Merge branch 'pipeline-stage' into 'master'

Refine pipeline stages

## What does this MR do?

Introduces a concept of `Ci::Stage` to make it easier to have detailed statuses.

## Why was this MR needed?

This is needed to simplify the handling of `Ci::Statuses` and make the `Stage` actual concept in code:
https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/7889

See merge request !7927

2 files changed, 179 insertions, 9 deletions

diff --git a/spec/models/ci/pipeline_spec.rb b/spec/models/ci/pipeline_spec.rb
index 3f93d9ddf19..8158e71dd55 100644
--- a/spec/models/ci/pipeline_spec.rb
+++ b/spec/models/ci/pipeline_spec.rb
@@ -20,8 +20,6 @@ describe Ci::Pipeline, models: true do
   it { is_expected.to respond_to :git_author_email }
   it { is_expected.to respond_to :short_sha }
 
-  it { is_expected.to delegate_method(:stages).to(:statuses) }
-
   describe '#valid_commit_sha' do
     context 'commit.sha can not start with 00000000' do
       before do
@@ -125,16 +123,55 @@ describe Ci::Pipeline, models: true do
   end
 
   describe '#stages' do
-    let(:pipeline2) { FactoryGirl.create :ci_pipeline, project: project }
-    subject { CommitStatus.where(pipeline: [pipeline, pipeline2]).stages }
-
     before do
-      FactoryGirl.create :ci_build, pipeline: pipeline2, stage: 'test', stage_idx: 1
-      FactoryGirl.create :ci_build, pipeline: pipeline, stage: 'build', stage_idx: 0
+      create(:commit_status, pipeline: pipeline, stage: 'build', name: 'linux', stage_idx: 0, status: 'success')
+      create(:commit_status, pipeline: pipeline, stage: 'build', name: 'mac', stage_idx: 0, status: 'failed')
+      create(:commit_status, pipeline: pipeline, stage: 'deploy', name: 'staging', stage_idx: 2, status: 'running')
+      create(:commit_status, pipeline: pipeline, stage: 'test', name: 'rspec', stage_idx: 1, status: 'success')
+    end
+
+    subject { pipeline.stages }
+
+    context 'stages list' do
+      it 'returns ordered list of stages' do
+        expect(subject.map(&:name)).to eq(%w[build test deploy])
+      end
+    end
+
+    it 'returns a valid number of stages' do
+      expect(pipeline.stages_count).to eq(3)
+    end
+
+    it 'returns a valid names of stages' do
+      expect(pipeline.stages_name).to eq(['build', 'test', 'deploy'])
     end
 
-    it 'return all stages' do
-      is_expected.to eq(%w(build test))
+    context 'stages with statuses' do
+      let(:statuses) do
+        subject.map do |stage|
+          [stage.name, stage.status]
+        end
+      end
+
+      it 'returns list of stages with statuses' do
+        expect(statuses).to eq([['build', 'failed'],
+                                ['test', 'success'],
+                                ['deploy', 'running']
+                               ])
+      end
+
+      context 'when build is retried' do
+        before do
+          create(:commit_status, pipeline: pipeline, stage: 'build', name: 'mac', stage_idx: 0, status: 'success')
+        end
+
+        it 'ignores the previous state' do
+          expect(statuses).to eq([['build', 'success'],
+                                  ['test', 'success'],
+                                  ['deploy', 'running']
+                                 ])
+        end
+      end
     end
   end
 
diff --git a/spec/models/ci/stage_spec.rb b/spec/models/ci/stage_spec.rb
new file mode 100644
index 00000000000..f232761dba2
--- /dev/null
+++ b/spec/models/ci/stage_spec.rb
@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Ci::Stage, models: true do
+  let(:stage) { build(:ci_stage) }
+  let(:pipeline) { stage.pipeline }
+  let(:stage_name) { stage.name }
+
+  describe '#expectations' do
+    subject { stage }
+
+    it { is_expected.to include_module(StaticModel) }
+
+    it { is_expected.to respond_to(:pipeline) }
+    it { is_expected.to respond_to(:name) }
+
+    it { is_expected.to delegate_method(:project).to(:pipeline) }
+  end
+
+  describe '#statuses' do
+    let!(:stage_build) { create_job(:ci_build) }
+    let!(:commit_status) { create_job(:commit_status) }
+    let!(:other_build) { create_job(:ci_build, stage: 'other stage') }
+
+    subject { stage.statuses }
+
+    it "returns only matching statuses" do
+      is_expected.to contain_exactly(stage_build, commit_status)
+    end
+  end
+
+  describe '#builds' do
+    let!(:stage_build) { create_job(:ci_build) }
+    let!(:commit_status) { create_job(:commit_status) }
+
+    subject { stage.builds }
+
+    it "returns only builds" do
+      is_expected.to contain_exactly(stage_build)
+    end
+  end
+
+  describe '#status' do
+    subject { stage.status }
+
+    context 'if status is already defined' do
+      let(:stage) { build(:ci_stage, status: 'success') }
+
+      it "returns defined status" do
+        is_expected.to eq('success')
+      end
+    end
+
+    context 'if status has to be calculated' do
+      let!(:stage_build) { create_job(:ci_build, status: :failed) }
+
+      it "returns status of a build" do
+        is_expected.to eq('failed')
+      end
+
+      context 'and builds are retried' do
+        let!(:new_build) { create_job(:ci_build, status: :success) }
+
+        it "returns status of latest build" do
+          is_expected.to eq('success')
+        end
+      end
+    end
+  end
+
+  describe '#detailed_status' do
+    subject { stage.detailed_status }
+
+    context 'when build is created' do
+      let!(:stage_build) { create_job(:ci_build, status: :created) }
+
+      it 'returns detailed status for created stage' do
+        expect(subject.text).to eq 'created'
+      end
+    end
+
+    context 'when build is pending' do
+      let!(:stage_build) { create_job(:ci_build, status: :pending) }
+
+      it 'returns detailed status for pending stage' do
+        expect(subject.text).to eq 'pending'
+      end
+    end
+
+    context 'when build is running' do
+      let!(:stage_build) { create_job(:ci_build, status: :running) }
+
+      it 'returns detailed status for running stage' do
+        expect(subject.text).to eq 'running'
+      end
+    end
+
+    context 'when build is successful' do
+      let!(:stage_build) { create_job(:ci_build, status: :success) }
+
+      it 'returns detailed status for successful stage' do
+        expect(subject.text).to eq 'passed'
+      end
+    end
+
+    context 'when build is failed' do
+      let!(:stage_build) { create_job(:ci_build, status: :failed) }
+
+      it 'returns detailed status for failed stage' do
+        expect(subject.text).to eq 'failed'
+      end
+    end
+
+    context 'when build is canceled' do
+      let!(:stage_build) { create_job(:ci_build, status: :canceled) }
+
+      it 'returns detailed status for canceled stage' do
+        expect(subject.text).to eq 'canceled'
+      end
+    end
+
+    context 'when build is skipped' do
+      let!(:stage_build) { create_job(:ci_build, status: :skipped) }
+
+      it 'returns detailed status for skipped stage' do
+        expect(subject.text).to eq 'skipped'
+      end
+    end
+  end
+
+  def create_job(type, status: 'success', stage: stage_name)
+    create(type, pipeline: pipeline, stage: stage, status: status)
+  end
+end