Merge branch 'lm-remove-multiple-cache-ff' into 'master'

Cleans up multiple_cache_per_job FF and associated code [RUN ALL RSPEC] [RUN AS-IF-FOSS]

See merge request gitlab-org/gitlab!60131

changelogs/unreleased/lm-remove-multiple-cache-ff.yml

+---
+title: Removes multiple_cache_per_job feature flag and associated code
+merge_request:
+author: Laura Montemayor
+type: removed

config/feature_flags/development/multiple_cache_per_job.yml

----
-name: multiple_cache_per_job
-introduced_by_url: https://gitlab.com/gitlab-org/gitlab/-/merge_requests/53410
-rollout_issue_url: https://gitlab.com/gitlab-org/gitlab/-/issues/321877
-milestone: '13.10'
-type: development
-group: group::pipeline authoring
-default_enabled: true

doc/ci/yaml/README.md

@@ -2970,11 +2970,7 @@ You can specify a [fallback cache key](#fallback-cache-key) to use if the specif
 ##### Multiple caches
 
 > - [Introduced](https://gitlab.com/gitlab-org/gitlab/-/issues/32814) in GitLab 13.10.
-> - [Deployed behind a feature flag](../../user/feature_flags.md), disabled by default.
-> - [Enabled by default](https://gitlab.com/gitlab-org/gitlab/-/issues/321877) in GitLab 13.11.
-> - Enabled on GitLab.com.
-> - Recommended for production use.
-> - For GitLab self-managed instances, GitLab administrators can opt to [disable it](#enable-or-disable-multiple-caches). **(FREE SELF)**
+> - [Feature Flag removed](https://gitlab.com/gitlab-org/gitlab/-/issues/321877), in GitLab 13.12.
 
 You can have a maximum of four caches:
 
@@ -3001,25 +2997,6 @@ test-job:
 If multiple caches are combined with a [Fallback cache key](#fallback-cache-key),
 the fallback is fetched multiple times if multiple caches are not found.
 
-##### Enable or disable multiple caches **(FREE SELF)**
-
-The multiple caches feature is under development but ready for production use.
-It is deployed behind a feature flag that is **enabled by default**.
-[GitLab administrators with access to the GitLab Rails console](../../administration/feature_flags.md)
-can opt to disable it.
-
-To enable it:
-
-```ruby
-Feature.enable(:multiple_cache_per_job)
-```
-
-To disable it:
-
-```ruby
-Feature.disable(:multiple_cache_per_job)
-```
-
 #### Fallback cache key
 
 > [Introduced](https://gitlab.com/gitlab-org/gitlab-runner/-/merge_requests/1534) in GitLab Runner 13.4.

lib/gitlab/ci/build/cache.rb

@@ -7,39 +7,22 @@ module Gitlab
         include ::Gitlab::Utils::StrongMemoize
 
         def initialize(cache, pipeline)
-          if multiple_cache_per_job?
-            cache = Array.wrap(cache)
-            @cache = cache.map do |cache|
-              Gitlab::Ci::Pipeline::Seed::Build::Cache
-              .new(pipeline, cache)
-            end
-          else
-            @cache = Gitlab::Ci::Pipeline::Seed::Build::Cache
-              .new(pipeline, cache)
+          cache = Array.wrap(cache)
+          @cache = cache.map do |cache|
+            Gitlab::Ci::Pipeline::Seed::Build::Cache
+            .new(pipeline, cache)
           end
         end
 
         def cache_attributes
           strong_memoize(:cache_attributes) do
-            if multiple_cache_per_job?
-              if @cache.empty?
-                {}
-              else
-                { options: { cache: @cache.map(&:attributes) } }
-              end
+            if @cache.empty?
+              {}
             else
-              @cache.build_attributes
+              { options: { cache: @cache.map(&:attributes) } }
             end
           end
         end
-
-        private
-
-        def multiple_cache_per_job?
-          strong_memoize(:multiple_cache_per_job) do
-            ::Gitlab::Ci::Features.multiple_cache_per_job?
-          end
-        end
       end
     end
   end

lib/gitlab/ci/config/entry/cache.rb

@@ -4,88 +4,52 @@ module Gitlab
   module Ci
     class Config
       module Entry
-        ##
-        # Entry that represents a cache configuration
-        #
-        class Cache < ::Gitlab::Config::Entry::Simplifiable
-          strategy :Caches, if: -> (config) { Feature.enabled?(:multiple_cache_per_job, default_enabled: :yaml) }
-          strategy :Cache, if: -> (config) { Feature.disabled?(:multiple_cache_per_job, default_enabled: :yaml) }
-
-          class Caches < ::Gitlab::Config::Entry::ComposableArray
-            include ::Gitlab::Config::Entry::Validatable
-
-            MULTIPLE_CACHE_LIMIT = 4
-
-            validations do
-              validate do
-                unless config.is_a?(Hash) || config.is_a?(Array)
-                  errors.add(:config, 'can only be a Hash or an Array')
-                end
-
-                if config.is_a?(Array) && config.count > MULTIPLE_CACHE_LIMIT
-                  errors.add(:config, "no more than #{MULTIPLE_CACHE_LIMIT} caches can be created")
-                end
-              end
-            end
-
-            def initialize(*args)
-              super
-
-              @key = nil
-            end
-
-            def composable_class
-              Entry::Cache::Cache
+        class Cache < ::Gitlab::Config::Entry::Node
+          include ::Gitlab::Config::Entry::Configurable
+          include ::Gitlab::Config::Entry::Validatable
+          include ::Gitlab::Config::Entry::Attributable
+
+          ALLOWED_KEYS = %i[key untracked paths when policy].freeze
+          ALLOWED_POLICY = %w[pull-push push pull].freeze
+          DEFAULT_POLICY = 'pull-push'
+          ALLOWED_WHEN = %w[on_success on_failure always].freeze
+          DEFAULT_WHEN = 'on_success'
+
+          validations do
+            validates :config, type: Hash, allowed_keys: ALLOWED_KEYS
+            validates :policy,
+              inclusion: { in: ALLOWED_POLICY, message: 'should be pull-push, push, or pull' },
+              allow_blank: true
+
+            with_options allow_nil: true do
+              validates :when,
+                  inclusion: {
+                    in: ALLOWED_WHEN,
+                    message: 'should be on_success, on_failure or always'
+                  }
             end
           end
 
-          class Cache < ::Gitlab::Config::Entry::Node
-            include ::Gitlab::Config::Entry::Configurable
-            include ::Gitlab::Config::Entry::Validatable
-            include ::Gitlab::Config::Entry::Attributable
-
-            ALLOWED_KEYS = %i[key untracked paths when policy].freeze
-            ALLOWED_POLICY = %w[pull-push push pull].freeze
-            DEFAULT_POLICY = 'pull-push'
-            ALLOWED_WHEN = %w[on_success on_failure always].freeze
-            DEFAULT_WHEN = 'on_success'
+          entry :key, Entry::Key,
+            description: 'Cache key used to define a cache affinity.'
 
-            validations do
-              validates :config, type: Hash, allowed_keys: ALLOWED_KEYS
-              validates :policy,
-                inclusion: { in: ALLOWED_POLICY, message: 'should be pull-push, push, or pull' },
-                allow_blank: true
-
-              with_options allow_nil: true do
-                validates :when,
-                    inclusion: {
-                      in: ALLOWED_WHEN,
-                      message: 'should be on_success, on_failure or always'
-                    }
-              end
-            end
+          entry :untracked, ::Gitlab::Config::Entry::Boolean,
+            description: 'Cache all untracked files.'
 
-            entry :key, Entry::Key,
-              description: 'Cache key used to define a cache affinity.'
+          entry :paths, Entry::Paths,
+            description: 'Specify which paths should be cached across builds.'
 
-            entry :untracked, ::Gitlab::Config::Entry::Boolean,
-              description: 'Cache all untracked files.'
+          attributes :policy, :when
 
-            entry :paths, Entry::Paths,
-              description: 'Specify which paths should be cached across builds.'
+          def value
+            result = super
 
-            attributes :policy, :when
+            result[:key] = key_value
+            result[:policy] = policy || DEFAULT_POLICY
+            # Use self.when to avoid conflict with reserved word
+            result[:when] = self.when || DEFAULT_WHEN
 
-            def value
-              result = super
-
-              result[:key] = key_value
-              result[:policy] = policy || DEFAULT_POLICY
-              # Use self.when to avoid conflict with reserved word
-              result[:when] = self.when || DEFAULT_WHEN
-
-              result
-            end
+            result
           end
 
           class UnknownStrategy < ::Gitlab::Config::Entry::Node

lib/gitlab/ci/config/entry/caches.rb

+# frozen_string_literal: true
+
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # Entry that represents caches configuration
+        #
+        class Caches < ::Gitlab::Config::Entry::ComposableArray
+          include ::Gitlab::Config::Entry::Validatable
+
+          MULTIPLE_CACHE_LIMIT = 4
+
+          validations do
+            validate do
+              unless config.is_a?(Hash) || config.is_a?(Array)
+                errors.add(:config, 'can only be a Hash or an Array')
+              end
+
+              if config.is_a?(Array) && config.count > MULTIPLE_CACHE_LIMIT
+                errors.add(:config, "no more than #{MULTIPLE_CACHE_LIMIT} caches can be created")
+              end
+            end
+          end
+
+          def initialize(*args)
+            super
+
+            @key = nil
+          end
+
+          def composable_class
+            Entry::Cache
+          end
+        end
+      end
+    end
+  end
+end

lib/gitlab/ci/config/entry/default.rb

@@ -37,7 +37,7 @@ module Gitlab
             description: 'Script that will be executed after each job.',
             inherit: true
 
-          entry :cache, Entry::Cache,
+          entry :cache, Entry::Caches,
             description: 'Configure caching between build jobs.',
             inherit: true
 

lib/gitlab/ci/config/entry/job.rb

@@ -64,7 +64,7 @@ module Gitlab
             description: 'Commands that will be executed when finishing job.',
             inherit: true
 
-          entry :cache, Entry::Cache,
+          entry :cache, Entry::Caches,
             description: 'Cache definition for this job.',
             inherit: true
 

lib/gitlab/ci/config/entry/root.rb

@@ -61,7 +61,7 @@ module Gitlab
             description: 'Deprecated: stages for this pipeline.',
             reserved: true
 
-          entry :cache, Entry::Cache,
+          entry :cache, Entry::Caches,
             description: 'Configure caching between build jobs.',
             reserved: true
 

lib/gitlab/ci/features.rb

@@ -56,8 +56,8 @@ module Gitlab
         ::Feature.enabled?(:codequality_mr_diff, project, default_enabled: false)
       end
 
-      def self.multiple_cache_per_job?
-        ::Feature.enabled?(:multiple_cache_per_job, default_enabled: :yaml)
+      def self.gldropdown_tags_enabled?
+        ::Feature.enabled?(:gldropdown_tags, default_enabled: :yaml)
       end
     end
   end

spec/lib/gitlab/ci/build/cache_spec.rb

@@ -4,11 +4,23 @@ require 'spec_helper'
 
 RSpec.describe Gitlab::Ci::Build::Cache do
   describe '.initialize' do
-    context 'when the multiple cache feature flag is disabled' do
-      before do
-        stub_feature_flags(multiple_cache_per_job: false)
+    context 'when the cache is an array' do
+      it 'instantiates an array of cache seeds' do
+        cache_config = [{ key: 'key-a' }, { key: 'key-b' }]
+        pipeline = double(::Ci::Pipeline)
+        cache_seed_a = double(Gitlab::Ci::Pipeline::Seed::Build::Cache)
+        cache_seed_b = double(Gitlab::Ci::Pipeline::Seed::Build::Cache)
+        allow(Gitlab::Ci::Pipeline::Seed::Build::Cache).to receive(:new).and_return(cache_seed_a, cache_seed_b)
+
+        cache = described_class.new(cache_config, pipeline)
+
+        expect(Gitlab::Ci::Pipeline::Seed::Build::Cache).to have_received(:new).with(pipeline, { key: 'key-a' })
+        expect(Gitlab::Ci::Pipeline::Seed::Build::Cache).to have_received(:new).with(pipeline, { key: 'key-b' })
+        expect(cache.instance_variable_get(:@cache)).to eq([cache_seed_a, cache_seed_b])
       end
+    end
 
+    context 'when the cache is a hash' do
       it 'instantiates a cache seed' do
         cache_config = { key: 'key-a' }
         pipeline = double(::Ci::Pipeline)
@@ -18,87 +30,35 @@ RSpec.describe Gitlab::Ci::Build::Cache do
         cache = described_class.new(cache_config, pipeline)
 
         expect(Gitlab::Ci::Pipeline::Seed::Build::Cache).to have_received(:new).with(pipeline, cache_config)
-        expect(cache.instance_variable_get(:@cache)).to eq(cache_seed)
-      end
-    end
-
-    context 'when the multiple cache feature flag is enabled' do
-      context 'when the cache is an array' do
-        it 'instantiates an array of cache seeds' do
-          cache_config = [{ key: 'key-a' }, { key: 'key-b' }]
-          pipeline = double(::Ci::Pipeline)
-          cache_seed_a = double(Gitlab::Ci::Pipeline::Seed::Build::Cache)
-          cache_seed_b = double(Gitlab::Ci::Pipeline::Seed::Build::Cache)
-          allow(Gitlab::Ci::Pipeline::Seed::Build::Cache).to receive(:new).and_return(cache_seed_a, cache_seed_b)
-
-          cache = described_class.new(cache_config, pipeline)
-
-          expect(Gitlab::Ci::Pipeline::Seed::Build::Cache).to have_received(:new).with(pipeline, { key: 'key-a' })
-          expect(Gitlab::Ci::Pipeline::Seed::Build::Cache).to have_received(:new).with(pipeline, { key: 'key-b' })
-          expect(cache.instance_variable_get(:@cache)).to eq([cache_seed_a, cache_seed_b])
-        end
-      end
-
-      context 'when the cache is a hash' do
-        it 'instantiates a cache seed' do
-          cache_config = { key: 'key-a' }
-          pipeline = double(::Ci::Pipeline)
-          cache_seed = double(Gitlab::Ci::Pipeline::Seed::Build::Cache)
-          allow(Gitlab::Ci::Pipeline::Seed::Build::Cache).to receive(:new).and_return(cache_seed)
-
-          cache = described_class.new(cache_config, pipeline)
-
-          expect(Gitlab::Ci::Pipeline::Seed::Build::Cache).to have_received(:new).with(pipeline, cache_config)
-          expect(cache.instance_variable_get(:@cache)).to eq([cache_seed])
-        end
+        expect(cache.instance_variable_get(:@cache)).to eq([cache_seed])
       end
     end
   end
 
   describe '#cache_attributes' do
-    context 'when the multiple cache feature flag is disabled' do
-      before do
-        stub_feature_flags(multiple_cache_per_job: false)
-      end
-
-      it "returns the cache seed's build attributes" do
-        cache_config = { key: 'key-a' }
+    context 'when there are no caches' do
+      it 'returns an empty hash' do
+        cache_config = []
         pipeline = double(::Ci::Pipeline)
         cache = described_class.new(cache_config, pipeline)
 
         attributes = cache.cache_attributes
 
-        expect(attributes).to eq({
-          options: { cache: { key: 'key-a' } }
-        })
+        expect(attributes).to eq({})
       end
     end
 
-    context 'when the multiple cache feature flag is enabled' do
-      context 'when there are no caches' do
-        it 'returns an empty hash' do
-          cache_config = []
-          pipeline = double(::Ci::Pipeline)
-          cache = described_class.new(cache_config, pipeline)
-
-          attributes = cache.cache_attributes
-
-          expect(attributes).to eq({})
-        end
-      end
-
-      context 'when there are caches' do
-        it 'returns the structured attributes for the caches' do
-          cache_config = [{ key: 'key-a' }, { key: 'key-b' }]
-          pipeline = double(::Ci::Pipeline)
-          cache = described_class.new(cache_config, pipeline)
+    context 'when there are caches' do
+      it 'returns the structured attributes for the caches' do
+        cache_config = [{ key: 'key-a' }, { key: 'key-b' }]
+        pipeline = double(::Ci::Pipeline)
+        cache = described_class.new(cache_config, pipeline)
 
-          attributes = cache.cache_attributes
+        attributes = cache.cache_attributes
 
-          expect(attributes).to eq({
-            options: { cache: cache_config }
-          })
-        end
+        expect(attributes).to eq({
+          options: { cache: cache_config }
+        })
       end
     end
   end

spec/lib/gitlab/ci/config/entry/cache_spec.rb

@@ -7,295 +7,227 @@ RSpec.describe Gitlab::Ci::Config::Entry::Cache do
 
   subject(:entry) { described_class.new(config) }
 
-  context 'with multiple caches' do
+  describe 'validations' do
     before do
       entry.compose!
     end
 
-    describe '#valid?' do
-      context 'with an empty hash as cache' do
-        let(:config) { {} }
-
-        it 'is valid' do
-          expect(entry).to be_valid
-        end
-      end
-
-      context 'when configuration is valid with a single cache' do
-        let(:config)  { { key: 'key', paths: ["logs/"], untracked: true } }
-
-        it 'is valid' do
-          expect(entry).to be_valid
+    context 'when entry config value is correct' do
+      let(:policy) { nil }
+      let(:key) { 'some key' }
+      let(:when_config) { nil }
+
+      let(:config) do
+        {
+          key: key,
+          untracked: true,
+          paths: ['some/path/']
+        }.tap do |config|
+          config[:policy] = policy if policy
+          config[:when] = when_config if when_config
         end
       end
 
-      context 'when configuration is valid with multiple caches' do
-        let(:config) do
-          [
-            { key: 'key', paths: ["logs/"], untracked: true },
-            { key: 'key2', paths: ["logs/"], untracked: true },
-            { key: 'key3', paths: ["logs/"], untracked: true }
-          ]
+      describe '#value' do
+        shared_examples 'hash key value' do
+          it 'returns hash value' do
+            expect(entry.value).to eq(key: key, untracked: true, paths: ['some/path/'], policy: 'pull-push', when: 'on_success')
+          end
         end
 
-        it 'is valid' do
-          expect(entry).to be_valid
-        end
-      end
+        it_behaves_like 'hash key value'
 
-      context 'when configuration is not a Hash or Array' do
-        let(:config) { 'invalid' }
+        context 'with files' do
+          let(:key) { { files: %w[a-file other-file] } }
 
-        it 'is invalid' do
-          expect(entry).not_to be_valid
+          it_behaves_like 'hash key value'
         end
-      end
 
-      context 'when entry values contain more than four caches' do
-        let(:config) do
-          [
-            { key: 'key', paths: ["logs/"], untracked: true },
-            { key: 'key2', paths: ["logs/"], untracked: true },
-            { key: 'key3', paths: ["logs/"], untracked: true },
-            { key: 'key4', paths: ["logs/"], untracked: true },
-            { key: 'key5', paths: ["logs/"], untracked: true }
-          ]
-        end
+        context 'with files and prefix' do
+          let(:key) { { files: %w[a-file other-file], prefix: 'prefix-value' } }
 
-        it 'is invalid' do
-          expect(entry.errors).to eq(["caches config no more than 4 caches can be created"])
-          expect(entry).not_to be_valid
+          it_behaves_like 'hash key value'
         end
-      end
-    end
-  end
 
-  context 'with a single cache' do
-    before do
-      stub_feature_flags(multiple_cache_per_job: false)
-    end
-    describe 'validations' do
-      before do
-        entry.compose!
-      end
-
-      context 'when entry config value is correct' do
-        let(:policy) { nil }
-        let(:key) { 'some key' }
-        let(:when_config) { nil }
+        context 'with prefix' do
+          let(:key) { { prefix: 'prefix-value' } }
 
-        let(:config) do
-          {
-            key: key,
-            untracked: true,
-            paths: ['some/path/']
-          }.tap do |config|
-            config[:policy] = policy if policy
-            config[:when] = when_config if when_config
+          it 'key is nil' do
+            expect(entry.value).to match(a_hash_including(key: nil))
           end
         end
 
-        describe '#value' do
-          shared_examples 'hash key value' do
-            it 'returns hash value' do
-              expect(entry.value).to eq(key: key, untracked: true, paths: ['some/path/'], policy: 'pull-push', when: 'on_success')
-            end
-          end
-
-          it_behaves_like 'hash key value'
-
-          context 'with files' do
-            let(:key) { { files: %w[a-file other-file] } }
-
-            it_behaves_like 'hash key value'
-          end
-
-          context 'with files and prefix' do
-            let(:key) { { files: %w[a-file other-file], prefix: 'prefix-value' } }
-
-            it_behaves_like 'hash key value'
+        context 'with `policy`' do
+          where(:policy, :result) do
+            'pull-push' | 'pull-push'
+            'push'      | 'push'
+            'pull'      | 'pull'
+            'unknown'   | 'unknown' # invalid
           end
 
-          context 'with prefix' do
-            let(:key) { { prefix: 'prefix-value' } }
-
-            it 'key is nil' do
-              expect(entry.value).to match(a_hash_including(key: nil))
-            end
+          with_them do
+            it { expect(entry.value).to include(policy: result) }
           end
+        end
 
-          context 'with `policy`' do
-            where(:policy, :result) do
-              'pull-push' | 'pull-push'
-              'push'      | 'push'
-              'pull'      | 'pull'
-              'unknown'   | 'unknown' # invalid
-            end
-
-            with_them do
-              it { expect(entry.value).to include(policy: result) }
-            end
+        context 'without `policy`' do
+          it 'assigns policy to default' do
+            expect(entry.value).to include(policy: 'pull-push')
           end
+        end
 
-          context 'without `policy`' do
-            it 'assigns policy to default' do
-              expect(entry.value).to include(policy: 'pull-push')
-            end
+        context 'with `when`' do
+          where(:when_config, :result) do
+            'on_success' | 'on_success'
+            'on_failure' | 'on_failure'
+            'always'     | 'always'
+            'unknown'    | 'unknown' # invalid
           end
 
-          context 'with `when`' do
-            where(:when_config, :result) do
-              'on_success' | 'on_success'
-              'on_failure' | 'on_failure'
-              'always'     | 'always'
-              'unknown'    | 'unknown' # invalid
-            end
-
-            with_them do
-              it { expect(entry.value).to include(when: result) }
-            end
+          with_them do
+            it { expect(entry.value).to include(when: result) }
           end
+        end
 
-          context 'without `when`' do
-            it 'assigns when to default' do
-              expect(entry.value).to include(when: 'on_success')
-            end
+        context 'without `when`' do
+          it 'assigns when to default' do
+            expect(entry.value).to include(when: 'on_success')
           end
         end
+      end
 
-        describe '#valid?' do
-          it { is_expected.to be_valid }
+      describe '#valid?' do
+        it { is_expected.to be_valid }
 
-          context 'with files' do
-            let(:key) { { files: %w[a-file other-file] } }
+        context 'with files' do
+          let(:key) { { files: %w[a-file other-file] } }
 
-            it { is_expected.to be_valid }
-          end
+          it { is_expected.to be_valid }
         end
+      end
 
-        context 'with `policy`' do
-          where(:policy, :valid) do
-            'pull-push' | true
-            'push'      | true
-            'pull'      | true
-            'unknown'   | false
-          end
+      context 'with `policy`' do
+        where(:policy, :valid) do
+          'pull-push' | true
+          'push'      | true
+          'pull'      | true
+          'unknown'   | false
+        end
 
-          with_them do
-            it 'returns expected validity' do
-              expect(entry.valid?).to eq(valid)
-            end
+        with_them do
+          it 'returns expected validity' do
+            expect(entry.valid?).to eq(valid)
           end
         end
+      end
 
-        context 'with `when`' do
-          where(:when_config, :valid) do
-            'on_success' | true
-            'on_failure' | true
-            'always'     | true
-            'unknown'    | false
-          end
+      context 'with `when`' do
+        where(:when_config, :valid) do
+          'on_success' | true
+          'on_failure' | true
+          'always'     | true
+          'unknown'    | false
+        end
 
-          with_them do
-            it 'returns expected validity' do
-              expect(entry.valid?).to eq(valid)
-            end
+        with_them do
+          it 'returns expected validity' do
+            expect(entry.valid?).to eq(valid)
           end
         end
+      end
 
-        context 'with key missing' do
-          let(:config) do
-            { untracked: true,
-              paths: ['some/path/'] }
-          end
+      context 'with key missing' do
+        let(:config) do
+          { untracked: true,
+            paths: ['some/path/'] }
+        end
 
-          describe '#value' do
-            it 'sets key with the default' do
-              expect(entry.value[:key])
-                .to eq(Gitlab::Ci::Config::Entry::Key.default)
-            end
+        describe '#value' do
+          it 'sets key with the default' do
+            expect(entry.value[:key])
+              .to eq(Gitlab::Ci::Config::Entry::Key.default)
           end
         end
       end
+    end
 
-      context 'when entry value is not correct' do
-        describe '#errors' do
-          subject { entry.errors }
+    context 'when entry value is not correct' do
+      describe '#errors' do
+        subject { entry.errors }
 
-          context 'when is not a hash' do
-            let(:config) { 'ls' }
+        context 'when is not a hash' do
+          let(:config) { 'ls' }
 
-            it 'reports errors with config value' do
-              is_expected.to include 'cache config should be a hash'
-            end
+          it 'reports errors with config value' do
+            is_expected.to include 'cache config should be a hash'
           end
+        end
 
-          context 'when policy is unknown' do
-            let(:config) { { policy: 'unknown' } }
+        context 'when policy is unknown' do
+          let(:config) { { policy: 'unknown' } }
 
-            it 'reports error' do
-              is_expected.to include('cache policy should be pull-push, push, or pull')
-            end
+          it 'reports error' do
+            is_expected.to include('cache policy should be pull-push, push, or pull')
           end
+        end
 
-          context 'when `when` is unknown' do
-            let(:config) { { when: 'unknown' } }
+        context 'when `when` is unknown' do
+          let(:config) { { when: 'unknown' } }
 
-            it 'reports error' do
-              is_expected.to include('cache when should be on_success, on_failure or always')
-            end
+          it 'reports error' do
+            is_expected.to include('cache when should be on_success, on_failure or always')
           end
+        end
 
-          context 'when descendants are invalid' do
-            context 'with invalid keys' do
-              let(:config) { { key: 1 } }
-
-              it 'reports error with descendants' do
-                is_expected.to include 'key should be a hash, a string or a symbol'
-              end
-            end
-
-            context 'with empty key' do
-              let(:config) { { key: {} } }
+        context 'when descendants are invalid' do
+          context 'with invalid keys' do
+            let(:config) { { key: 1 } }
 
-              it 'reports error with descendants' do
-                is_expected.to include 'key config missing required keys: files'
-              end
+            it 'reports error with descendants' do
+              is_expected.to include 'key should be a hash, a string or a symbol'
             end
+          end
 
-            context 'with invalid files' do
-              let(:config) { { key: { files: 'a-file' } } }
+          context 'with empty key' do
+            let(:config) { { key: {} } }
 
-              it 'reports error with descendants' do
-                is_expected.to include 'key:files config should be an array of strings'
-              end
+            it 'reports error with descendants' do
+              is_expected.to include 'key config missing required keys: files'
             end
+          end
 
-            context 'with prefix without files' do
-              let(:config) { { key: { prefix: 'a-prefix' } } }
+          context 'with invalid files' do
+            let(:config) { { key: { files: 'a-file' } } }
 
-              it 'reports error with descendants' do
-                is_expected.to include 'key config missing required keys: files'
-              end
+            it 'reports error with descendants' do
+              is_expected.to include 'key:files config should be an array of strings'
             end
+          end
 
-            context 'when there is an unknown key present' do
-              let(:config) { { key: { unknown: 'a-file' } } }
+          context 'with prefix without files' do
+            let(:config) { { key: { prefix: 'a-prefix' } } }
 
-              it 'reports error with descendants' do
-                is_expected.to include 'key config contains unknown keys: unknown'
-              end
+            it 'reports error with descendants' do
+              is_expected.to include 'key config missing required keys: files'
             end
           end
 
           context 'when there is an unknown key present' do
-            let(:config) { { invalid: true } }
+            let(:config) { { key: { unknown: 'a-file' } } }
 
             it 'reports error with descendants' do
-              is_expected.to include 'cache config contains unknown keys: invalid'
+              is_expected.to include 'key config contains unknown keys: unknown'
             end
           end
         end
+
+        context 'when there is an unknown key present' do
+          let(:config) { { invalid: true } }
+
+          it 'reports error with descendants' do
+            is_expected.to include 'cache config contains unknown keys: invalid'
+          end
+        end
       end
     end
   end

spec/lib/gitlab/ci/config/entry/caches_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Gitlab::Ci::Config::Entry::Caches do
+  using RSpec::Parameterized::TableSyntax
+
+  subject(:entry) { described_class.new(config) }
+
+  before do
+    entry.compose!
+  end
+
+  describe '#valid?' do
+    context 'with an empty hash as cache' do
+      let(:config) { {} }
+
+      it 'is valid' do
+        expect(entry).to be_valid
+      end
+    end
+
+    context 'when configuration is valid with a single cache' do
+      let(:config)  { { key: 'key', paths: ["logs/"], untracked: true } }
+
+      it 'is valid' do
+        expect(entry).to be_valid
+      end
+    end
+
+    context 'when configuration is valid with multiple caches' do
+      let(:config) do
+        [
+          { key: 'key', paths: ["logs/"], untracked: true },
+          { key: 'key2', paths: ["logs/"], untracked: true },
+          { key: 'key3', paths: ["logs/"], untracked: true }
+        ]
+      end
+
+      it 'is valid' do
+        expect(entry).to be_valid
+      end
+    end
+
+    context 'when configuration is not a Hash or Array' do
+      let(:config) { 'invalid' }
+
+      it 'is invalid' do
+        expect(entry).not_to be_valid
+      end
+    end
+
+    context 'when entry values contain more than four caches' do
+      let(:config) do
+        [
+          { key: 'key', paths: ["logs/"], untracked: true },
+          { key: 'key2', paths: ["logs/"], untracked: true },
+          { key: 'key3', paths: ["logs/"], untracked: true },
+          { key: 'key4', paths: ["logs/"], untracked: true },
+          { key: 'key5', paths: ["logs/"], untracked: true }
+        ]
+      end
+
+      it 'is invalid' do
+        expect(entry.errors).to eq(["caches config no more than 4 caches can be created"])
+        expect(entry).not_to be_valid
+      end
+    end
+  end
+end

spec/lib/gitlab/ci/config/entry/job_spec.rb

@@ -556,42 +556,6 @@ RSpec.describe Gitlab::Ci::Config::Entry::Job do
       end
     end
 
-    context 'with multiple_cache_per_job FF disabled' do
-      before do
-        stub_feature_flags(multiple_cache_per_job: false)
-      end
-
-      context 'when job config overrides default config' do
-        before do
-          entry.compose!(deps)
-        end
-
-        let(:config) do
-          { script: 'rspec', image: 'some_image', cache: { key: 'test' } }
-        end
-
-        it 'overrides default config' do
-          expect(entry[:image].value).to eq(name: 'some_image')
-          expect(entry[:cache].value).to eq(key: 'test', policy: 'pull-push', when: 'on_success')
-        end
-      end
-
-      context 'when job config does not override default config' do
-        before do
-          allow(default).to receive('[]').with(:image).and_return(specified)
-
-          entry.compose!(deps)
-        end
-
-        let(:config) { { script: 'ls', cache: { key: 'test' } } }
-
-        it 'uses config from default entry' do
-          expect(entry[:image].value).to eq 'specified'
-          expect(entry[:cache].value).to eq(key: 'test', policy: 'pull-push', when: 'on_success')
-        end
-      end
-    end
-
     context 'with workflow rules' do
       using RSpec::Parameterized::TableSyntax
 

spec/lib/gitlab/ci/config/entry/root_spec.rb

@@ -175,68 +175,6 @@ RSpec.describe Gitlab::Ci::Config::Entry::Root do
             )
           end
         end
-
-        context 'with multuple_cache_per_job FF disabled' do
-          before do
-            stub_feature_flags(multiple_cache_per_job: false)
-            root.compose!
-          end
-
-          describe '#jobs_value' do
-            it 'returns jobs configuration' do
-              expect(root.jobs_value.keys).to eq([:rspec, :spinach, :release])
-              expect(root.jobs_value[:rspec]).to eq(
-                { name: :rspec,
-                        script: %w[rspec ls],
-                        before_script: %w(ls pwd),
-                        image: { name: 'ruby:2.7' },
-                        services: [{ name: 'postgres:9.1' }, { name: 'mysql:5.5' }],
-                        stage: 'test',
-                        cache: { key: 'k', untracked: true, paths: ['public/'], policy: 'pull-push', when: 'on_success' },
-                        variables: { 'VAR' => 'root', 'VAR2' => 'val 2' },
-                        job_variables: {},
-                        root_variables_inheritance: true,
-                        ignore: false,
-                        after_script: ['make clean'],
-                        only: { refs: %w[branches tags] },
-                        scheduling_type: :stage }
-              )
-              expect(root.jobs_value[:spinach]).to eq(
-                { name: :spinach,
-                          before_script: [],
-                          script: %w[spinach],
-                          image: { name: 'ruby:2.7' },
-                          services: [{ name: 'postgres:9.1' }, { name: 'mysql:5.5' }],
-                          stage: 'test',
-                          cache: { key: 'k', untracked: true, paths: ['public/'], policy: 'pull-push', when: 'on_success' },
-                          variables: { 'VAR' => 'root', 'VAR2' => 'val 2' },
-                          job_variables: {},
-                          root_variables_inheritance: true,
-                          ignore: false,
-                          after_script: ['make clean'],
-                          only: { refs: %w[branches tags] },
-                          scheduling_type: :stage }
-              )
-              expect(root.jobs_value[:release]).to eq(
-                { name: :release,
-                          stage: 'release',
-                          before_script: [],
-                          script: ["make changelog | tee release_changelog.txt"],
-                          release: { name: "Release $CI_TAG_NAME", tag_name: 'v0.06', description: "./release_changelog.txt" },
-                          image: { name: "ruby:2.7" },
-                          services: [{ name: "postgres:9.1" }, { name: "mysql:5.5" }],
-                          cache: { key: "k", untracked: true, paths: ["public/"], policy: "pull-push", when: 'on_success' },
-                          only: { refs: %w(branches tags) },
-                          variables: { 'VAR' => 'job', 'VAR2' => 'val 2' },
-                          job_variables: { 'VAR' => 'job' },
-                          root_variables_inheritance: true,
-                          after_script: [],
-                          ignore: false,
-                          scheduling_type: :stage }
-              )
-            end
-          end
-        end
       end
     end
 
@@ -255,56 +193,6 @@ RSpec.describe Gitlab::Ci::Config::Entry::Root do
           spinach: { before_script: [], variables: { VAR: 'job' }, script: 'spinach' } }
       end
 
-      context 'with multiple_cache_per_job FF disabled' do
-        context 'when composed' do
-          before do
-            stub_feature_flags(multiple_cache_per_job: false)
-            root.compose!
-          end
-
-          describe '#errors' do
-            it 'has no errors' do
-              expect(root.errors).to be_empty
-            end
-          end
-
-          describe '#jobs_value' do
-            it 'returns jobs configuration' do
-              expect(root.jobs_value).to eq(
-                rspec: { name: :rspec,
-                        script: %w[rspec ls],
-                        before_script: %w(ls pwd),
-                        image: { name: 'ruby:2.7' },
-                        services: [{ name: 'postgres:9.1' }, { name: 'mysql:5.5' }],
-                        stage: 'test',
-                        cache: { key: 'k', untracked: true, paths: ['public/'], policy: 'pull-push', when: 'on_success' },
-                        variables: { 'VAR' => 'root' },
-                        job_variables: {},
-                        root_variables_inheritance: true,
-                        ignore: false,
-                        after_script: ['make clean'],
-                        only: { refs: %w[branches tags] },
-                        scheduling_type: :stage },
-                spinach: { name: :spinach,
-                          before_script: [],
-                          script: %w[spinach],
-                          image: { name: 'ruby:2.7' },
-                          services: [{ name: 'postgres:9.1' }, { name: 'mysql:5.5' }],
-                          stage: 'test',
-                          cache: { key: 'k', untracked: true, paths: ['public/'], policy: 'pull-push', when: 'on_success' },
-                          variables: { 'VAR' => 'job' },
-                          job_variables: { 'VAR' => 'job' },
-                          root_variables_inheritance: true,
-                          ignore: false,
-                          after_script: ['make clean'],
-                          only: { refs: %w[branches tags] },
-                          scheduling_type: :stage }
-              )
-            end
-          end
-        end
-      end
-
       context 'when composed' do
         before do
           root.compose!
@@ -390,19 +278,6 @@ RSpec.describe Gitlab::Ci::Config::Entry::Root do
           expect(root.cache_value).to eq([key: 'a', policy: 'pull-push', when: 'on_success'])
         end
       end
-
-      context 'with multiple_cache_per_job FF disabled' do
-        before do
-          stub_feature_flags(multiple_cache_per_job: false)
-          root.compose!
-        end
-
-        describe '#cache_value' do
-          it 'returns correct cache definition' do
-            expect(root.cache_value).to eq(key: 'a', policy: 'pull-push', when: 'on_success')
-          end
-        end
-      end
     end
 
     context 'when variables resembles script-type job' do
@@ -525,7 +400,7 @@ RSpec.describe Gitlab::Ci::Config::Entry::Root do
     context 'when entry exists' do
       it 'returns correct entry' do
         expect(root[:cache])
-          .to be_an_instance_of Gitlab::Ci::Config::Entry::Cache
+          .to be_an_instance_of Gitlab::Ci::Config::Entry::Caches
         expect(root[:jobs][:rspec][:script].value).to eq ['ls']
       end
     end

spec/lib/gitlab/ci/pipeline/seed/build/cache_spec.rb

@@ -9,253 +9,6 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build::Cache do
 
   let(:processor) { described_class.new(pipeline, config) }
 
-  context 'with multiple_cache_per_job ff disabled' do
-    before do
-      stub_feature_flags(multiple_cache_per_job: false)
-    end
-
-    describe '#build_attributes' do
-      subject { processor.build_attributes }
-
-      context 'with cache:key' do
-        let(:config) do
-          {
-            key: 'a-key',
-            paths: ['vendor/ruby']
-          }
-        end
-
-        it { is_expected.to include(options: { cache: config }) }
-      end
-
-      context 'with cache:key as a symbol' do
-        let(:config) do
-          {
-            key: :a_key,
-            paths: ['vendor/ruby']
-          }
-        end
-
-        it { is_expected.to include(options: { cache: config.merge(key: "a_key") }) }
-      end
-
-      context 'with cache:key:files' do
-        shared_examples 'default key' do
-          let(:config) do
-            { key: { files: files } }
-          end
-
-          it 'uses default key' do
-            expected = { options: { cache: { key: 'default' } } }
-
-            is_expected.to include(expected)
-          end
-        end
-
-        shared_examples 'version and gemfile files' do
-          let(:config) do
-            {
-              key: {
-                files: files
-              },
-              paths: ['vendor/ruby']
-            }
-          end
-
-          it 'builds a string key' do
-            expected = {
-              options: {
-                cache: {
-                  key: '703ecc8fef1635427a1f86a8a1a308831c122392',
-                  paths: ['vendor/ruby']
-                }
-              }
-            }
-
-            is_expected.to include(expected)
-          end
-        end
-
-        context 'with existing files' do
-          let(:files) { ['VERSION', 'Gemfile.zip'] }
-
-          it_behaves_like 'version and gemfile files'
-        end
-
-        context 'with files starting with ./' do
-          let(:files) { ['Gemfile.zip', './VERSION'] }
-
-          it_behaves_like 'version and gemfile files'
-        end
-
-        context 'with files ending with /' do
-          let(:files) { ['Gemfile.zip/'] }
-
-          it_behaves_like 'default key'
-        end
-
-        context 'with new line in filenames' do
-          let(:files) { ["Gemfile.zip\nVERSION"] }
-
-          it_behaves_like 'default key'
-        end
-
-        context 'with missing files' do
-          let(:files) { ['project-gemfile.lock', ''] }
-
-          it_behaves_like 'default key'
-        end
-
-        context 'with directories' do
-          shared_examples 'foo/bar directory key' do
-            let(:config) do
-              {
-                key: {
-                  files: files
-                }
-              }
-            end
-
-            it 'builds a string key' do
-              expected = {
-                options: {
-                  cache: { key: '74bf43fb1090f161bdd4e265802775dbda2f03d1' }
-                }
-              }
-
-              is_expected.to include(expected)
-            end
-          end
-
-          context 'with directory' do
-            let(:files) { ['foo/bar'] }
-
-            it_behaves_like 'foo/bar directory key'
-          end
-
-          context 'with directory ending in slash' do
-            let(:files) { ['foo/bar/'] }
-
-            it_behaves_like 'foo/bar directory key'
-          end
-
-          context 'with directories ending in slash star' do
-            let(:files) { ['foo/bar/*'] }
-
-            it_behaves_like 'foo/bar directory key'
-          end
-        end
-      end
-
-      context 'with cache:key:prefix' do
-        context 'without files' do
-          let(:config) do
-            {
-              key: {
-                prefix: 'a-prefix'
-              },
-              paths: ['vendor/ruby']
-            }
-          end
-
-          it 'adds prefix to default key' do
-            expected = {
-              options: {
-                cache: {
-                  key: 'a-prefix-default',
-                  paths: ['vendor/ruby']
-                }
-              }
-            }
-
-            is_expected.to include(expected)
-          end
-        end
-
-        context 'with existing files' do
-          let(:config) do
-            {
-              key: {
-                files: ['VERSION', 'Gemfile.zip'],
-                prefix: 'a-prefix'
-              },
-              paths: ['vendor/ruby']
-            }
-          end
-
-          it 'adds prefix key' do
-            expected = {
-              options: {
-                cache: {
-                  key: 'a-prefix-703ecc8fef1635427a1f86a8a1a308831c122392',
-                  paths: ['vendor/ruby']
-                }
-              }
-            }
-
-            is_expected.to include(expected)
-          end
-        end
-
-        context 'with missing files' do
-          let(:config) do
-            {
-              key: {
-                files: ['project-gemfile.lock', ''],
-                prefix: 'a-prefix'
-              },
-              paths: ['vendor/ruby']
-            }
-          end
-
-          it 'adds prefix to default key' do
-            expected = {
-              options: {
-                cache: {
-                  key: 'a-prefix-default',
-                  paths: ['vendor/ruby']
-                }
-              }
-            }
-
-            is_expected.to include(expected)
-          end
-        end
-      end
-
-      context 'with all cache option keys' do
-        let(:config) do
-          {
-            key: 'a-key',
-            paths: ['vendor/ruby'],
-            untracked: true,
-            policy: 'push',
-            when: 'on_success'
-          }
-        end
-
-        it { is_expected.to include(options: { cache: config }) }
-      end
-
-      context 'with unknown cache option keys' do
-        let(:config) do
-          {
-            key: 'a-key',
-            unknown_key: true
-          }
-        end
-
-        it { expect { subject }.to raise_error(ArgumentError, /unknown_key/) }
-      end
-
-      context 'with empty config' do
-        let(:config) { {} }
-
-        it { is_expected.to include(options: {}) }
-      end
-    end
-  end
-
   describe '#attributes' do
     subject { processor.attributes }
 

spec/lib/gitlab/ci/pipeline/seed/build_spec.rb

@@ -90,91 +90,6 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build do
       end
     end
 
-    context 'with multiple_cache_per_job FF disabled' do
-      before do
-        stub_feature_flags(multiple_cache_per_job: false)
-      end
-
-      context 'with cache:key' do
-        let(:attributes) do
-          {
-            name: 'rspec',
-            ref: 'master',
-            cache: {
-              key: 'a-value'
-            }
-          }
-        end
-
-        it { is_expected.to include(options: { cache: { key: 'a-value' } }) }
-      end
-
-      context 'with cache:key:files' do
-        let(:attributes) do
-          {
-            name: 'rspec',
-            ref: 'master',
-            cache: {
-              key: {
-                files: ['VERSION']
-              }
-            }
-          }
-        end
-
-        it 'includes cache options' do
-          cache_options = {
-            options: {
-              cache: { key: 'f155568ad0933d8358f66b846133614f76dd0ca4' }
-            }
-          }
-
-          is_expected.to include(cache_options)
-        end
-      end
-
-      context 'with cache:key:prefix' do
-        let(:attributes) do
-          {
-            name: 'rspec',
-            ref: 'master',
-            cache: {
-              key: {
-                prefix: 'something'
-              }
-            }
-          }
-        end
-
-        it { is_expected.to include(options: { cache: { key: 'something-default' } }) }
-      end
-
-      context 'with cache:key:files and prefix' do
-        let(:attributes) do
-          {
-            name: 'rspec',
-            ref: 'master',
-            cache: {
-              key: {
-                files: ['VERSION'],
-                prefix: 'something'
-              }
-            }
-          }
-        end
-
-        it 'includes cache options' do
-          cache_options = {
-            options: {
-              cache: { key: 'something-f155568ad0933d8358f66b846133614f76dd0ca4' }
-            }
-          }
-
-          is_expected.to include(cache_options)
-        end
-      end
-    end
-
     context 'with cache:key' do
       let(:attributes) do
         {

spec/lib/gitlab/ci/yaml_processor_spec.rb

@@ -1419,155 +1419,6 @@ module Gitlab
         end
       end
 
-      context 'with multiple_cache_per_job FF disabled' do
-        before do
-          stub_feature_flags(multiple_cache_per_job: false)
-        end
-        describe 'cache' do
-          context 'when cache definition has unknown keys' do
-            let(:config) do
-              YAML.dump(
-                { cache: { untracked: true, invalid: 'key' },
-                  rspec: { script: 'rspec' } })
-            end
-
-            it_behaves_like 'returns errors', 'cache config contains unknown keys: invalid'
-          end
-
-          it "returns cache when defined globally" do
-            config = YAML.dump({
-                                cache: { paths: ["logs/", "binaries/"], untracked: true, key: 'key' },
-                                rspec: {
-                                  script: "rspec"
-                                }
-                              })
-
-            config_processor = Gitlab::Ci::YamlProcessor.new(config).execute
-
-            expect(config_processor.stage_builds_attributes("test").size).to eq(1)
-            expect(config_processor.stage_builds_attributes("test").first[:cache]).to eq(
-              paths: ["logs/", "binaries/"],
-              untracked: true,
-              key: 'key',
-              policy: 'pull-push',
-              when: 'on_success'
-            )
-          end
-
-          it "returns cache when defined in default context" do
-            config = YAML.dump(
-              {
-                default: {
-                  cache: { paths: ["logs/", "binaries/"], untracked: true, key: { files: ['file'] } }
-                },
-                rspec: {
-                  script: "rspec"
-                }
-              })
-
-            config_processor = Gitlab::Ci::YamlProcessor.new(config).execute
-
-            expect(config_processor.stage_builds_attributes("test").size).to eq(1)
-            expect(config_processor.stage_builds_attributes("test").first[:cache]).to eq(
-              paths: ["logs/", "binaries/"],
-              untracked: true,
-              key: { files: ['file'] },
-              policy: 'pull-push',
-              when: 'on_success'
-            )
-          end
-
-          it 'returns cache key when defined in a job' do
-            config = YAML.dump({
-                                rspec: {
-                                  cache: { paths: ['logs/', 'binaries/'], untracked: true, key: 'key' },
-                                  script: 'rspec'
-                                }
-                              })
-
-            config_processor = Gitlab::Ci::YamlProcessor.new(config).execute
-
-            expect(config_processor.stage_builds_attributes('test').size).to eq(1)
-            expect(config_processor.stage_builds_attributes('test').first[:cache]).to eq(
-              paths: ['logs/', 'binaries/'],
-              untracked: true,
-              key: 'key',
-              policy: 'pull-push',
-              when: 'on_success'
-            )
-          end
-
-          it 'returns cache files' do
-            config = YAML.dump(
-              rspec: {
-                cache: {
-                  paths: ['logs/', 'binaries/'],
-                  untracked: true,
-                  key: { files: ['file'] }
-                },
-                script: 'rspec'
-              }
-            )
-
-            config_processor = Gitlab::Ci::YamlProcessor.new(config).execute
-
-            expect(config_processor.stage_builds_attributes('test').size).to eq(1)
-            expect(config_processor.stage_builds_attributes('test').first[:cache]).to eq(
-              paths: ['logs/', 'binaries/'],
-              untracked: true,
-              key: { files: ['file'] },
-              policy: 'pull-push',
-              when: 'on_success'
-            )
-          end
-
-          it 'returns cache files with prefix' do
-            config = YAML.dump(
-              rspec: {
-                cache: {
-                  paths: ['logs/', 'binaries/'],
-                  untracked: true,
-                  key: { files: ['file'], prefix: 'prefix' }
-                },
-                script: 'rspec'
-              }
-            )
-
-            config_processor = Gitlab::Ci::YamlProcessor.new(config).execute
-
-            expect(config_processor.stage_builds_attributes('test').size).to eq(1)
-            expect(config_processor.stage_builds_attributes('test').first[:cache]).to eq(
-              paths: ['logs/', 'binaries/'],
-              untracked: true,
-              key: { files: ['file'], prefix: 'prefix' },
-              policy: 'pull-push',
-              when: 'on_success'
-            )
-          end
-
-          it "overwrite cache when defined for a job and globally" do
-            config = YAML.dump({
-                                cache: { paths: ["logs/", "binaries/"], untracked: true, key: 'global' },
-                                rspec: {
-                                  script: "rspec",
-                                  cache: { paths: ["test/"], untracked: false, key: 'local' }
-                                }
-                              })
-
-            config_processor = Gitlab::Ci::YamlProcessor.new(config).execute
-
-            expect(config_processor.stage_builds_attributes("test").size).to eq(1)
-            expect(config_processor.stage_builds_attributes("test").first[:cache]).to eq(
-              paths: ["test/"],
-              untracked: false,
-              key: 'local',
-              policy: 'pull-push',
-              when: 'on_success'
-            )
-          end
-        end
-      end
-
       describe 'cache' do
         context 'when cache definition has unknown keys' do
           let(:config) do