1 files changed, 146 insertions, 65 deletions

diff --git a/spec/lib/gitlab/ci/config/normalizer_spec.rb b/spec/lib/gitlab/ci/config/normalizer_spec.rb
index d3d165ba00f..949af8cdc4c 100644
--- a/spec/lib/gitlab/ci/config/normalizer_spec.rb
+++ b/spec/lib/gitlab/ci/config/normalizer_spec.rb
@@ -4,66 +4,13 @@ require 'fast_spec_helper'
 
 RSpec.describe Gitlab::Ci::Config::Normalizer do
   let(:job_name) { :rspec }
-  let(:job_config) { { script: 'rspec', parallel: 5, name: 'rspec' } }
+  let(:job_config) { { script: 'rspec', parallel: parallel_config, name: 'rspec', variables: variables_config } }
   let(:config) { { job_name => job_config } }
 
-  let(:expanded_job_names) do
-    [
-      "rspec 1/5",
-      "rspec 2/5",
-      "rspec 3/5",
-      "rspec 4/5",
-      "rspec 5/5"
-    ]
-  end
-
   describe '.normalize_jobs' do
     subject { described_class.new(config).normalize_jobs }
 
-    it 'does not have original job' do
-      is_expected.not_to include(job_name)
-    end
-
-    it 'has parallelized jobs' do
-      is_expected.to include(*expanded_job_names.map(&:to_sym))
-    end
-
-    it 'sets job instance in options' do
-      expect(subject.values).to all(include(:instance))
-    end
-
-    it 'parallelizes jobs with original config' do
-      original_config = config[job_name].except(:name)
-      configs = subject.values.map { |config| config.except(:name, :instance) }
-
-      expect(configs).to all(eq(original_config))
-    end
-
-    context 'when the job is not parallelized' do
-      let(:job_config) { { script: 'rspec', name: 'rspec' } }
-
-      it 'returns the same hash' do
-        is_expected.to eq(config)
-      end
-    end
-
-    context 'when there is a job with a slash in it' do
-      let(:job_name) { :"rspec 35/2" }
-
-      it 'properly parallelizes job names' do
-        job_names = [
-          :"rspec 35/2 1/5",
-          :"rspec 35/2 2/5",
-          :"rspec 35/2 3/5",
-          :"rspec 35/2 4/5",
-          :"rspec 35/2 5/5"
-        ]
-
-        is_expected.to include(*job_names)
-      end
-    end
-
-    context 'for dependencies' do
+    shared_examples 'parallel dependencies' do
       context "when job has dependencies on parallelized jobs" do
         let(:config) do
           {
@@ -91,9 +38,7 @@ RSpec.describe Gitlab::Ci::Config::Normalizer do
         end
 
         it "parallelizes dependencies" do
-          job_names = ["rspec 1/5", "rspec 2/5", "rspec 3/5", "rspec 4/5", "rspec 5/5"]
-
-          expect(subject[:final_job][:dependencies]).to include(*job_names)
+          expect(subject[:final_job][:dependencies]).to include(*expanded_job_names)
         end
 
         it "includes the regular job in dependencies" do
@@ -102,14 +47,14 @@ RSpec.describe Gitlab::Ci::Config::Normalizer do
       end
     end
 
-    context 'for needs' do
+    shared_examples 'parallel needs' do
       let(:expanded_job_attributes) do
         expanded_job_names.map do |job_name|
           { name: job_name, extra: :key }
         end
       end
 
-      context "when job has needs on parallelized jobs" do
+      context 'when job has needs on parallelized jobs' do
         let(:config) do
           {
             job_name => job_config,
@@ -124,12 +69,12 @@ RSpec.describe Gitlab::Ci::Config::Normalizer do
           }
         end
 
-        it "parallelizes needs" do
+        it 'parallelizes needs' do
           expect(subject.dig(:other_job, :needs, :job)).to eq(expanded_job_attributes)
         end
       end
 
-      context "when there are dependencies which are both parallelized and not" do
+      context 'when there are dependencies which are both parallelized and not' do
         let(:config) do
           {
             job_name => job_config,
@@ -141,21 +86,157 @@ RSpec.describe Gitlab::Ci::Config::Normalizer do
               needs: {
                 job: [
                   { name: job_name.to_s, extra: :key },
-                  { name: "other_job", extra: :key }
+                  { name: 'other_job', extra: :key }
                 ]
               }
             }
           }
         end
 
-        it "parallelizes dependencies" do
+        it 'parallelizes dependencies' do
           expect(subject.dig(:final_job, :needs, :job)).to include(*expanded_job_attributes)
         end
 
-        it "includes the regular job in dependencies" do
+        it 'includes the regular job in dependencies' do
           expect(subject.dig(:final_job, :needs, :job)).to include(name: 'other_job', extra: :key)
         end
       end
     end
+
+    context 'with parallel config as integer' do
+      let(:variables_config) { {} }
+      let(:parallel_config) { 5 }
+
+      let(:expanded_job_names) do
+        [
+          'rspec 1/5',
+          'rspec 2/5',
+          'rspec 3/5',
+          'rspec 4/5',
+          'rspec 5/5'
+        ]
+      end
+
+      it 'does not have original job' do
+        is_expected.not_to include(job_name)
+      end
+
+      it 'has parallelized jobs' do
+        is_expected.to include(*expanded_job_names.map(&:to_sym))
+      end
+
+      it 'sets job instance in options' do
+        expect(subject.values).to all(include(:instance))
+      end
+
+      it 'parallelizes jobs with original config' do
+        original_config = config[job_name]
+          .except(:name)
+          .deep_merge(parallel: { total: parallel_config })
+
+        configs = subject.values.map { |config| config.except(:name, :instance) }
+
+        expect(configs).to all(eq(original_config))
+      end
+
+      context 'when the job is not parallelized' do
+        let(:job_config) { { script: 'rspec', name: 'rspec' } }
+
+        it 'returns the same hash' do
+          is_expected.to eq(config)
+        end
+      end
+
+      context 'when there is a job with a slash in it' do
+        let(:job_name) { :"rspec 35/2" }
+
+        it 'properly parallelizes job names' do
+          job_names = [
+            :"rspec 35/2 1/5",
+            :"rspec 35/2 2/5",
+            :"rspec 35/2 3/5",
+            :"rspec 35/2 4/5",
+            :"rspec 35/2 5/5"
+          ]
+
+          is_expected.to include(*job_names)
+        end
+      end
+
+      it_behaves_like 'parallel dependencies'
+      it_behaves_like 'parallel needs'
+    end
+
+    context 'with parallel matrix config' do
+      let(:variables_config) do
+        {
+          USER_VARIABLE: 'user value'
+        }
+      end
+
+      let(:parallel_config) do
+        {
+          matrix: [
+            {
+              VAR_1: [1],
+              VAR_2: [2, 3]
+            }
+          ]
+        }
+      end
+
+      let(:expanded_job_names) do
+        [
+          'rspec 1/2',
+          'rspec 2/2'
+        ]
+      end
+
+      it 'does not have original job' do
+        is_expected.not_to include(job_name)
+      end
+
+      it 'has parallelized jobs' do
+        is_expected.to include(*expanded_job_names.map(&:to_sym))
+      end
+
+      it 'sets job instance in options' do
+        expect(subject.values).to all(include(:instance))
+      end
+
+      it 'sets job variables', :aggregate_failures do
+        expect(subject.values[0]).to match(
+          a_hash_including(variables: { VAR_1: 1, VAR_2: 2, USER_VARIABLE: 'user value' })
+        )
+
+        expect(subject.values[1]).to match(
+          a_hash_including(variables: { VAR_1: 1, VAR_2: 3, USER_VARIABLE: 'user value' })
+        )
+      end
+
+      it 'parallelizes jobs with original config' do
+        configs = subject.values.map do |config|
+          config.except(:name, :instance, :variables)
+        end
+
+        original_config = config[job_name]
+          .except(:name, :variables)
+          .deep_merge(parallel: { total: 2 })
+
+        expect(configs).to all(match(a_hash_including(original_config)))
+      end
+
+      it_behaves_like 'parallel dependencies'
+      it_behaves_like 'parallel needs'
+    end
+
+    context 'when parallel config does not matches a factory' do
+      let(:variables_config) { {} }
+      let(:parallel_config) { }
+
+      it 'does not alter the job config' do
+        is_expected.to match(config)
+      end
+    end
   end
 end