Adds multiple caches per build

* Adds an Entry::Caches to handle multiple caches
* Updates Build#cache
* Updates Entry::Root, Entry::Job, Entry::Default to use Entry::Caches
* Updates Seed::Build and Cache to accomodate multiple caches
* Updates specs to handle multiple cache
* Adds docs and a changelog

app/models/ci/build.rb

@@ -812,14 +812,15 @@ module Ci
     end
 
     def cache
-      cache = options[:cache]
+      cache = Array.wrap(options[:cache])
 
-      if cache && project.jobs_cache_index
-        cache = cache.merge(
-          key: "#{cache[:key]}-#{project.jobs_cache_index}")
+      if project.jobs_cache_index
+        cache = cache.map do |single_cache|
+          single_cache.merge(key: "#{single_cache[:key]}-#{project.jobs_cache_index}")
+        end
       end
 
-      [cache]
+      cache
     end
 
     def credentials

changelogs/unreleased/lm-multiple-cache-per-file.yml

+---
+title: Adds ability to have multiple cache per job
+merge_request: 53410
+author:
+type: changed

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: false

doc/ci/yaml/README.md

@@ -2754,7 +2754,62 @@ URI-encoded `%2F`. A value made only of dots (`.`, `%2E`) is also forbidden.
 
 You can specify a [fallback cache key](#fallback-cache-key) to use if the specified `cache:key` is not found.
 
-##### Fallback cache key
+##### Multiple caches
+
+> - [Introduced](https://gitlab.com/gitlab-org/gitlab/-/issues/32814) in GitLab 13.10.
+> - It's [deployed behind a feature flag](../../user/feature_flags.md), disabled by default.
+> - It's disabled on GitLab.com.
+> - It's not recommended for production use.
+> - To use it in GitLab self-managed instances, ask a GitLab administrator to [enable it](#enable-or-disable-multiple-caches). **(FREE SELF)**
+
+WARNING:
+This feature might not be available to you. Check the **version history** note above for details.
+
+You can have a maximum of four caches:
+
+```yaml
+test-job:
+  stage: build
+  cache:
+    - key:
+        files:
+          - Gemfile.lock
+      paths:
+        - vendor/ruby
+    - key:
+        files:
+          - yarn.lock
+      paths:
+        - .yarn-cache/
+  script:
+    - bundle install --path=vendor
+    - yarn install --cache-folder .yarn-cache
+    - echo Run tests...
+```
+
+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 and not ready for production use.
+It is deployed behind a feature flag that is **disabled by default**.
+[GitLab administrators with access to the GitLab Rails console](../../administration/feature_flags.md)
+can enable 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/config/entry/cache.rb

@@ -7,52 +7,90 @@ module Gitlab
         ##
         # Entry that represents a cache configuration
         #
-        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'
-                  }
+        class Cache < ::Gitlab::Config::Entry::Simplifiable
+          strategy :Caches, if: -> (config) { Feature.enabled?(:multiple_cache_per_job) }
+          strategy :Cache, if: -> (config) { Feature.disabled?(:multiple_cache_per_job) }
+
+          class Caches < ::Gitlab::Config::Entry::ComposableArray
+            include ::Gitlab::Config::Entry::Validatable
+
+            MULTIPLE_CACHE_LIMIT = 4
+
+            validations do
+              validates :config, presence: true
+
+              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
             end
           end
 
-          entry :key, Entry::Key,
-            description: 'Cache key used to define a cache affinity.'
+          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
 
-          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
+          end
 
-            result
+          class UnknownStrategy < ::Gitlab::Config::Entry::Node
           end
         end
       end

lib/gitlab/ci/features.rb

@@ -67,6 +67,10 @@ module Gitlab
       def self.display_codequality_backend_comparison?(project)
         ::Feature.enabled?(:codequality_backend_comparison, project, default_enabled: :yaml)
       end
+
+      def self.multiple_cache_per_job?
+        ::Feature.enabled?(:multiple_cache_per_job, default_enabled: :yaml)
+      end
     end
   end
 end

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

@@ -28,8 +28,16 @@ module Gitlab
               .fabricate(attributes.delete(:except))
             @rules = Gitlab::Ci::Build::Rules
               .new(attributes.delete(:rules), default_when: 'on_success')
-            @cache = Seed::Build::Cache
-              .new(pipeline, attributes.delete(:cache))
+
+            if multiple_cache_per_job?
+              cache = Array.wrap(attributes.delete(:cache))
+              @cache = cache.map do |cache|
+                Seed::Build::Cache.new(pipeline, cache)
+              end
+            else
+              @cache = Seed::Build::Cache
+                .new(pipeline, attributes.delete(:cache))
+            end
           end
 
           def name
@@ -197,7 +205,21 @@ module Gitlab
 
           def cache_attributes
             strong_memoize(:cache_attributes) do
-              @cache.build_attributes
+              if multiple_cache_per_job?
+                if @cache.empty?
+                  {}
+                else
+                  { options: { cache: @cache.map(&:attributes) } }
+                end
+              else
+                @cache.build_attributes
+              end
+            end
+          end
+
+          def multiple_cache_per_job?
+            strong_memoize(:multiple_cache_per_job) do
+              ::Gitlab::Ci::Features.multiple_cache_per_job?
             end
           end
 

lib/gitlab/ci/pipeline/seed/build/cache.rb

@@ -18,18 +18,18 @@ module Gitlab
               raise ArgumentError, "unknown cache keys: #{local_cache.keys}" if local_cache.any?
             end
 
-            def build_attributes
+            def attributes
               {
-                options: {
-                  cache: {
-                    key: key_string,
-                    paths: @paths,
-                    policy: @policy,
-                    untracked: @untracked,
-                    when: @when
-                  }.compact.presence
-                }.compact
-              }
+                key: key_string,
+                paths: @paths,
+                policy: @policy,
+                untracked: @untracked,
+                when: @when
+              }.compact
+            end
+
+            def build_attributes
+              { options: { cache: attributes.presence }.compact }
             end
 
             private

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

@@ -7,225 +7,285 @@ RSpec.describe Gitlab::Ci::Config::Entry::Cache do
 
   subject(:entry) { described_class.new(config) }
 
-  describe 'validations' do
+  context 'with multiple caches' 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 }
-
-      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
+    describe '#valid?' do
+      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
 
-      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
+      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_behaves_like 'hash key value'
+        it 'is valid' do
+          expect(entry).to be_valid
+        end
+      end
 
-        context 'with files' do
-          let(:key) { { files: %w[a-file other-file] } }
+      context 'when configuration is not a Hash or Array' do
+        let(:config) { 'invalid' }
 
-          it_behaves_like 'hash key value'
+        it 'is invalid' do
+          expect(entry).not_to be_valid
         end
+      end
 
-        context 'with files and prefix' do
-          let(:key) { { files: %w[a-file other-file], prefix: 'prefix-value' } }
+      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_behaves_like 'hash key 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
         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 'with prefix' do
-          let(:key) { { prefix: 'prefix-value' } }
+      context 'when entry config value is correct' do
+        let(:policy) { nil }
+        let(:key) { 'some key' }
+        let(:when_config) { nil }
 
-          it 'key is nil' do
-            expect(entry.value).to match(a_hash_including(key: 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 'with `policy`' do
-          where(:policy, :result) do
-            'pull-push' | 'pull-push'
-            'push'      | 'push'
-            'pull'      | 'pull'
-            'unknown'   | 'unknown' # invalid
+        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
 
-          with_them do
-            it { expect(entry.value).to include(policy: result) }
+          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
-        end
 
-        context 'without `policy`' do
-          it 'assigns policy to default' do
-            expect(entry.value).to include(policy: 'pull-push')
+          context 'with files and prefix' do
+            let(:key) { { files: %w[a-file other-file], prefix: 'prefix-value' } }
+
+            it_behaves_like 'hash key value'
           end
-        end
 
-        context 'with `when`' do
-          where(:when_config, :result) do
-            'on_success' | 'on_success'
-            'on_failure' | 'on_failure'
-            'always'     | 'always'
-            'unknown'    | 'unknown' # invalid
+          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
           end
 
-          with_them do
-            it { expect(entry.value).to include(when: result) }
+          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
           end
-        end
 
-        context 'without `when`' do
-          it 'assigns when to default' do
-            expect(entry.value).to include(when: 'on_success')
+          context 'without `policy`' do
+            it 'assigns policy to default' do
+              expect(entry.value).to include(policy: 'pull-push')
+            end
           end
-        end
-      end
 
-      describe '#valid?' do
-        it { is_expected.to be_valid }
+          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 files' do
-          let(:key) { { files: %w[a-file other-file] } }
+            with_them do
+              it { expect(entry.value).to include(when: result) }
+            end
+          end
 
-          it { is_expected.to be_valid }
+          context 'without `when`' do
+            it 'assigns when to default' do
+              expect(entry.value).to include(when: 'on_success')
+            end
+          end
         end
-      end
 
-      context 'with `policy`' do
-        where(:policy, :valid) do
-          'pull-push' | true
-          'push'      | true
-          'pull'      | true
-          'unknown'   | false
-        end
+        describe '#valid?' do
+          it { is_expected.to be_valid }
+
+          context 'with files' do
+            let(:key) { { files: %w[a-file other-file] } }
 
-        with_them do
-          it 'returns expected validity' do
-            expect(entry.valid?).to eq(valid)
+            it { is_expected.to be_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 `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)
+          with_them do
+            it 'returns expected validity' do
+              expect(entry.valid?).to eq(valid)
+            end
           end
         end
-      end
 
-      context 'with key missing' do
-        let(:config) do
-          { untracked: true,
-            paths: ['some/path/'] }
+        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
+          end
         end
 
-        describe '#value' do
-          it 'sets key with the default' do
-            expect(entry.value[:key])
-              .to eq(Gitlab::Ci::Config::Entry::Key.default)
+        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
           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'
+            it 'reports errors with config value' do
+              is_expected.to include 'cache config should be a hash'
+            end
           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')
+            it 'reports error' do
+              is_expected.to include('cache policy should be pull-push, push, or pull')
+            end
           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')
+            it 'reports error' do
+              is_expected.to include('cache when should be on_success, on_failure or always')
+            end
           end
-        end
 
-        context 'when descendants are invalid' do
-          context 'with invalid keys' do
-            let(:config) { { key: 1 } }
+          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'
+              it 'reports error with descendants' do
+                is_expected.to include 'key should be a hash, a string or a symbol'
+              end
             end
-          end
 
-          context 'with empty key' do
-            let(:config) { { key: {} } }
+            context 'with empty key' do
+              let(:config) { { key: {} } }
 
-            it 'reports error with descendants' do
-              is_expected.to include 'key config missing required keys: files'
+              it 'reports error with descendants' do
+                is_expected.to include 'key config missing required keys: files'
+              end
             end
-          end
 
-          context 'with invalid files' do
-            let(:config) { { key: { files: 'a-file' } } }
+            context 'with invalid files' do
+              let(:config) { { key: { files: 'a-file' } } }
 
-            it 'reports error with descendants' do
-              is_expected.to include 'key:files config should be an array of strings'
+              it 'reports error with descendants' do
+                is_expected.to include 'key:files config should be an array of strings'
+              end
             end
-          end
 
-          context 'with prefix without files' do
-            let(:config) { { key: { prefix: 'a-prefix' } } }
+            context 'with prefix without files' do
+              let(:config) { { key: { prefix: 'a-prefix' } } }
 
-            it 'reports error with descendants' do
-              is_expected.to include 'key config missing required keys: files'
+              it 'reports error with descendants' do
+                is_expected.to include 'key config missing required keys: files'
+              end
             end
-          end
 
-          context 'when there is an unknown key present' do
-            let(:config) { { key: { unknown: 'a-file' } } }
+            context 'when there is an unknown key present' do
+              let(:config) { { key: { unknown: 'a-file' } } }
 
-            it 'reports error with descendants' do
-              is_expected.to include 'key config contains unknown keys: unknown'
+              it 'reports error with descendants' do
+                is_expected.to include 'key config contains unknown keys: unknown'
+              end
             end
           end
-        end
 
-        context 'when there is an unknown key present' do
-          let(:config) { { invalid: true } }
+          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'
+            it 'reports error with descendants' do
+              is_expected.to include 'cache config contains unknown keys: invalid'
+            end
           end
         end
       end

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

@@ -537,7 +537,7 @@ RSpec.describe Gitlab::Ci::Config::Entry::Job do
 
       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')
+        expect(entry[:cache].value).to eq([key: 'test', policy: 'pull-push', when: 'on_success'])
       end
     end
 
@@ -552,7 +552,43 @@ RSpec.describe Gitlab::Ci::Config::Entry::Job do
 
       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')
+        expect(entry[:cache].value).to eq([key: 'test', 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)
+      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
 

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

@@ -126,49 +126,105 @@ RSpec.describe Gitlab::Ci::Config::Entry::Root 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' },
-                       ignore: false,
-                       after_script: ['make clean'],
-                       only: { refs: %w[branches tags] },
-                       scheduling_type: :stage }
+                      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' },
+                      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' },
-                         ignore: false,
-                         after_script: ['make clean'],
-                         only: { refs: %w[branches tags] },
-                         scheduling_type: :stage }
+                        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' },
+                        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' },
-                         after_script: [],
-                         ignore: false,
-                         scheduling_type: :stage }
+                        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' },
+                        after_script: [],
+                        ignore: false,
+                        scheduling_type: :stage }
             )
           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' },
+                        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' },
+                          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' },
+                          after_script: [],
+                          ignore: false,
+                          scheduling_type: :stage }
+              )
+            end
+          end
+        end
       end
     end
 
@@ -187,6 +243,52 @@ 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' },
+                        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' },
+                          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!
@@ -202,29 +304,29 @@ RSpec.describe Gitlab::Ci::Config::Entry::Root 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' },
-                       ignore: false,
-                       after_script: ['make clean'],
-                       only: { refs: %w[branches tags] },
-                       scheduling_type: :stage },
+                      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' },
+                      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' },
-                         ignore: false,
-                         after_script: ['make clean'],
-                         only: { refs: %w[branches tags] },
-                         scheduling_type: :stage }
+                        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' },
+                        ignore: false,
+                        after_script: ['make clean'],
+                        only: { refs: %w[branches tags] },
+                        scheduling_type: :stage }
             )
           end
         end
@@ -265,7 +367,20 @@ RSpec.describe Gitlab::Ci::Config::Entry::Root do
 
       describe '#cache_value' do
         it 'returns correct cache definition' do
-          expect(root.cache_value).to eq(key: 'a', policy: 'pull-push', when: 'on_success')
+          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

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

@@ -9,8 +9,255 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build::Cache do
 
   let(:processor) { described_class.new(pipeline, config) }
 
-  describe '#build_attributes' do
-    subject { processor.build_attributes }
+  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 }
 
     context 'with cache:key' do
       let(:config) do
@@ -20,7 +267,7 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build::Cache do
         }
       end
 
-      it { is_expected.to include(options: { cache: config }) }
+      it { is_expected.to include(config) }
     end
 
     context 'with cache:key as a symbol' do
@@ -31,7 +278,7 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build::Cache do
         }
       end
 
-      it { is_expected.to include(options: { cache: config.merge(key: "a_key") }) }
+      it { is_expected.to include(config.merge(key: "a_key")) }
     end
 
     context 'with cache:key:files' do
@@ -41,7 +288,7 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build::Cache do
         end
 
         it 'uses default key' do
-          expected = { options: { cache: { key: 'default' } } }
+          expected = { key: 'default' }
 
           is_expected.to include(expected)
         end
@@ -59,13 +306,9 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build::Cache do
 
         it 'builds a string key' do
           expected = {
-            options: {
-              cache: {
                 key: '703ecc8fef1635427a1f86a8a1a308831c122392',
                 paths: ['vendor/ruby']
-              }
             }
-          }
 
           is_expected.to include(expected)
         end
@@ -112,11 +355,7 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build::Cache do
           end
 
           it 'builds a string key' do
-            expected = {
-              options: {
-                cache: { key: '74bf43fb1090f161bdd4e265802775dbda2f03d1' }
-              }
-            }
+            expected = { key: '74bf43fb1090f161bdd4e265802775dbda2f03d1' }
 
             is_expected.to include(expected)
           end
@@ -155,13 +394,9 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build::Cache do
 
         it 'adds prefix to default key' do
           expected = {
-            options: {
-              cache: {
                 key: 'a-prefix-default',
                 paths: ['vendor/ruby']
               }
-            }
-          }
 
           is_expected.to include(expected)
         end
@@ -180,13 +415,9 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build::Cache do
 
         it 'adds prefix key' do
           expected = {
-            options: {
-              cache: {
                 key: 'a-prefix-703ecc8fef1635427a1f86a8a1a308831c122392',
                 paths: ['vendor/ruby']
               }
-            }
-          }
 
           is_expected.to include(expected)
         end
@@ -205,13 +436,9 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build::Cache do
 
         it 'adds prefix to default key' do
           expected = {
-            options: {
-              cache: {
                 key: 'a-prefix-default',
                 paths: ['vendor/ruby']
               }
-            }
-          }
 
           is_expected.to include(expected)
         end
@@ -229,7 +456,7 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build::Cache do
         }
       end
 
-      it { is_expected.to include(options: { cache: config }) }
+      it { is_expected.to include(config) }
     end
 
     context 'with unknown cache option keys' do
@@ -242,11 +469,5 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build::Cache do
 
       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

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

@@ -87,86 +87,167 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build do
       end
     end
 
-    context 'with cache:key' do
-      let(:attributes) do
-        {
-          name: 'rspec',
-          ref: 'master',
-          cache: {
-            key: 'a-value'
+    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
 
-      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
 
-    context 'with cache:key:files' do
-      let(:attributes) do
-        {
-          name: 'rspec',
-          ref: 'master',
-          cache: {
-            key: {
-              files: ['VERSION']
+        it 'includes cache options' do
+          cache_options = {
+            options: {
+              cache: { key: 'f155568ad0933d8358f66b846133614f76dd0ca4' }
             }
           }
-        }
+
+          is_expected.to include(cache_options)
+        end
       end
 
-      it 'includes cache options' do
-        cache_options = {
-          options: {
+      context 'with cache:key:prefix' do
+        let(:attributes) do
+          {
+            name: 'rspec',
+            ref: 'master',
             cache: {
-              key: 'f155568ad0933d8358f66b846133614f76dd0ca4'
+              key: {
+                prefix: 'something'
+              }
             }
           }
-        }
+        end
 
-        is_expected.to include(cache_options)
+        it { is_expected.to include(options: { cache: { key: 'something-default' } }) }
       end
-    end
 
-    context 'with cache:key:prefix' do
-      let(:attributes) do
-        {
-          name: 'rspec',
-          ref: 'master',
-          cache: {
-            key: {
-              prefix: 'something'
+      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' }
             }
           }
-        }
-      end
 
-      it { is_expected.to include(options: { cache: { key: 'something-default' } }) }
+          is_expected.to include(cache_options)
+        end
+      end
     end
 
-    context 'with cache:key:files and prefix' do
+    context 'with cache:key' do
       let(:attributes) do
         {
           name: 'rspec',
           ref: 'master',
-          cache: {
-            key: {
-              files: ['VERSION'],
-              prefix: 'something'
+          cache: [{
+            key: 'a-value'
+          }]
+        }
+      end
+
+      it { is_expected.to include(options: { cache: [a_hash_including(key: 'a-value')] }) }
+
+      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: [a_hash_including(key: 'f155568ad0933d8358f66b846133614f76dd0ca4')]
             }
           }
-        }
+
+          is_expected.to include(cache_options)
+        end
       end
 
-      it 'includes cache options' do
-        cache_options = {
-          options: {
-            cache: {
-              key: 'something-f155568ad0933d8358f66b846133614f76dd0ca4'
+      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: [a_hash_including( 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: [a_hash_including(key: 'something-f155568ad0933d8358f66b846133614f76dd0ca4')]
             }
           }
-        }
 
-        is_expected.to include(cache_options)
+          is_expected.to include(cache_options)
+        end
       end
     end
 
@@ -179,7 +260,7 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build do
         }
       end
 
-      it { is_expected.to include(options: {}) }
+      it { is_expected.to include({}) }
     end
 
     context 'with allow_failure' do
@@ -296,7 +377,7 @@ RSpec.describe Gitlab::Ci::Pipeline::Seed::Build do
         it 'does not have environment' do
           expect(subject).not_to be_has_environment
           expect(subject.environment).to be_nil
-          expect(subject.metadata.expanded_environment_name).to be_nil
+          expect(subject.metadata).to be_nil
           expect(Environment.exists?(name: expected_environment_name)).to eq(false)
         end
       end

spec/lib/gitlab/ci/yaml_processor_spec.rb

@@ -1368,6 +1368,155 @@ 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
@@ -1381,22 +1530,22 @@ module Gitlab
 
         it "returns cache when defined globally" do
           config = YAML.dump({
-                               cache: { paths: ["logs/", "binaries/"], untracked: true, key: 'key' },
-                               rspec: {
-                                 script: "rspec"
-                               }
-                             })
+                              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(
+          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
@@ -1413,32 +1562,46 @@ module Gitlab
           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(
+          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
+        it 'returns cache key/s when defined in a job' do
           config = YAML.dump({
-                               rspec: {
-                                 cache: { paths: ['logs/', 'binaries/'], untracked: true, key: 'key' },
-                                 script: 'rspec'
-                               }
-                             })
+                              rspec: {
+                                cache: [
+                                  { paths: ['binaries/'], untracked: true, key: 'keya' },
+                                  { 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'
+            [
+              {
+                paths: ['binaries/'],
+                untracked: true,
+                key: 'keya',
+                policy: 'pull-push',
+                when: 'on_success'
+              },
+              {
+                paths: ['logs/', 'binaries/'],
+                untracked: true,
+                key: 'key',
+                policy: 'pull-push',
+                when: 'on_success'
+              }
+            ]
           )
         end
 
@@ -1446,10 +1609,10 @@ module Gitlab
           config = YAML.dump(
             rspec: {
               cache: {
-                paths: ['logs/', 'binaries/'],
-                untracked: true,
-                key: { files: ['file'] }
-              },
+                  paths: ['binaries/'],
+                  untracked: true,
+                  key: { files: ['file'] }
+                },
               script: 'rspec'
             }
           )
@@ -1457,13 +1620,13 @@ module Gitlab
           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/'],
+          expect(config_processor.stage_builds_attributes('test').first[:cache]).to eq([
+            paths: ['binaries/'],
             untracked: true,
             key: { files: ['file'] },
             policy: 'pull-push',
             when: 'on_success'
-          )
+          ])
         end
 
         it 'returns cache files with prefix' do
@@ -1481,34 +1644,34 @@ module Gitlab
           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(
+          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' }
-                               }
-                             })
+                              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(
+          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
 

spec/models/ci/build_spec.rb

@@ -817,7 +817,48 @@ RSpec.describe Ci::Build do
   end
 
   describe '#cache' do
-    let(:options) { { cache: { key: "key", paths: ["public"], policy: "pull-push" } } }
+    let(:options) do
+      { cache: [{ key: "key", paths: ["public"], policy: "pull-push" }] }
+    end
+
+    context 'with multiple_cache_per_job FF disabled' do
+      before do
+        stub_feature_flags(multiple_cache_per_job: false)
+      end
+      let(:options) { { cache: { key: "key", paths: ["public"], policy: "pull-push" } } }
+
+      subject { build.cache }
+
+      context 'when build has cache' do
+        before do
+          allow(build).to receive(:options).and_return(options)
+        end
+
+        context 'when project has jobs_cache_index' do
+          before do
+            allow_any_instance_of(Project).to receive(:jobs_cache_index).and_return(1)
+          end
+
+          it { is_expected.to be_an(Array).and all(include(key: "key-1")) }
+        end
+
+        context 'when project does not have jobs_cache_index' do
+          before do
+            allow_any_instance_of(Project).to receive(:jobs_cache_index).and_return(nil)
+          end
+
+          it { is_expected.to eq([options[:cache]]) }
+        end
+      end
+
+      context 'when build does not have cache' do
+        before do
+          allow(build).to receive(:options).and_return({})
+        end
+
+        it { is_expected.to eq([]) }
+      end
+    end
 
     subject { build.cache }
 
@@ -826,6 +867,21 @@ RSpec.describe Ci::Build do
         allow(build).to receive(:options).and_return(options)
       end
 
+      context 'when build has multiple caches' do
+        let(:options) do
+          { cache: [
+            { key: "key", paths: ["public"], policy: "pull-push" },
+            { key: "key2", paths: ["public"], policy: "pull-push" }
+          ] }
+        end
+
+        before do
+          allow_any_instance_of(Project).to receive(:jobs_cache_index).and_return(1)
+        end
+
+        it { is_expected.to match([a_hash_including(key: "key-1"), a_hash_including(key: "key2-1")]) }
+      end
+
       context 'when project has jobs_cache_index' do
         before do
           allow_any_instance_of(Project).to receive(:jobs_cache_index).and_return(1)
@@ -839,7 +895,7 @@ RSpec.describe Ci::Build do
           allow_any_instance_of(Project).to receive(:jobs_cache_index).and_return(nil)
         end
 
-        it { is_expected.to eq([options[:cache]]) }
+        it { is_expected.to eq(options[:cache]) }
       end
     end
 
@@ -848,7 +904,7 @@ RSpec.describe Ci::Build do
         allow(build).to receive(:options).and_return({})
       end
 
-      it { is_expected.to eq([nil]) }
+      it { is_expected.to be_empty }
     end
   end