From 78b2f65cb5320a6a28c1e26bb6ee792a54e1b674 Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Thu, 1 Jun 2017 12:00:37 +0200
Subject: Rename `Ci::Stage` class to `Ci::LegacyStage`

---
 app/models/ci/legacy_stage.rb       |  64 +++++++++
 app/models/ci/pipeline.rb           |   4 +-
 app/models/ci/stage.rb              |  64 ---------
 spec/factories/ci/stages.rb         |   6 +-
 spec/models/ci/legacy_stage_spec.rb | 262 ++++++++++++++++++++++++++++++++++++
 spec/models/ci/pipeline_spec.rb     |   2 +-
 spec/models/ci/stage_spec.rb        | 262 ------------------------------------
 7 files changed, 333 insertions(+), 331 deletions(-)
 create mode 100644 app/models/ci/legacy_stage.rb
 delete mode 100644 app/models/ci/stage.rb
 create mode 100644 spec/models/ci/legacy_stage_spec.rb
 delete mode 100644 spec/models/ci/stage_spec.rb

diff --git a/app/models/ci/legacy_stage.rb b/app/models/ci/legacy_stage.rb
new file mode 100644
index 00000000000..9b536af672b
--- /dev/null
+++ b/app/models/ci/legacy_stage.rb
@@ -0,0 +1,64 @@
+module Ci
+  # Currently this is artificial object, constructed dynamically
+  # We should migrate this object to actual database record in the future
+  class LegacyStage
+    include StaticModel
+
+    attr_reader :pipeline, :name
+
+    delegate :project, to: :pipeline
+
+    def initialize(pipeline, name:, status: nil, warnings: nil)
+      @pipeline = pipeline
+      @name = name
+      @status = status
+      @warnings = warnings
+    end
+
+    def groups
+      @groups ||= statuses.ordered.latest
+        .sort_by(&:sortable_name).group_by(&:group_name)
+        .map do |group_name, grouped_statuses|
+          Ci::Group.new(self, name: group_name, jobs: grouped_statuses)
+        end
+    end
+
+    def to_param
+      name
+    end
+
+    def statuses_count
+      @statuses_count ||= statuses.count
+    end
+
+    def status
+      @status ||= statuses.latest.status
+    end
+
+    def detailed_status(current_user)
+      Gitlab::Ci::Status::Stage::Factory
+        .new(self, current_user)
+        .fabricate!
+    end
+
+    def statuses
+      @statuses ||= pipeline.statuses.where(stage: name)
+    end
+
+    def builds
+      @builds ||= pipeline.builds.where(stage: name)
+    end
+
+    def success?
+      status.to_s == 'success'
+    end
+
+    def has_warnings?
+      if @warnings.is_a?(Integer)
+        @warnings > 0
+      else
+        statuses.latest.failed_but_allowed.any?
+      end
+    end
+  end
+end
diff --git a/app/models/ci/pipeline.rb b/app/models/ci/pipeline.rb
index 8e687fd5c08..e64e16657fe 100644
--- a/app/models/ci/pipeline.rb
+++ b/app/models/ci/pipeline.rb
@@ -161,7 +161,7 @@ module Ci
     end
 
     def legacy_stage(name)
-      stage = Ci::Stage.new(self, name: name)
+      stage = Ci::LegacyStage.new(self, name: name)
       stage unless stage.statuses_count.zero?
     end
 
@@ -180,7 +180,7 @@ module Ci
         .pluck('sg.stage', status_sql, "(#{warnings_sql})")
 
       stages_with_statuses.map do |stage|
-        Ci::Stage.new(self, Hash[%i[name status warnings].zip(stage)])
+        Ci::LegacyStage.new(self, Hash[%i[name status warnings].zip(stage)])
       end
     end
 
diff --git a/app/models/ci/stage.rb b/app/models/ci/stage.rb
deleted file mode 100644
index 9bda3186c30..00000000000
--- a/app/models/ci/stage.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-module Ci
-  # Currently this is artificial object, constructed dynamically
-  # We should migrate this object to actual database record in the future
-  class Stage
-    include StaticModel
-
-    attr_reader :pipeline, :name
-
-    delegate :project, to: :pipeline
-
-    def initialize(pipeline, name:, status: nil, warnings: nil)
-      @pipeline = pipeline
-      @name = name
-      @status = status
-      @warnings = warnings
-    end
-
-    def groups
-      @groups ||= statuses.ordered.latest
-        .sort_by(&:sortable_name).group_by(&:group_name)
-        .map do |group_name, grouped_statuses|
-          Ci::Group.new(self, name: group_name, jobs: grouped_statuses)
-        end
-    end
-
-    def to_param
-      name
-    end
-
-    def statuses_count
-      @statuses_count ||= statuses.count
-    end
-
-    def status
-      @status ||= statuses.latest.status
-    end
-
-    def detailed_status(current_user)
-      Gitlab::Ci::Status::Stage::Factory
-        .new(self, current_user)
-        .fabricate!
-    end
-
-    def statuses
-      @statuses ||= pipeline.statuses.where(stage: name)
-    end
-
-    def builds
-      @builds ||= pipeline.builds.where(stage: name)
-    end
-
-    def success?
-      status.to_s == 'success'
-    end
-
-    def has_warnings?
-      if @warnings.is_a?(Integer)
-        @warnings > 0
-      else
-        statuses.latest.failed_but_allowed.any?
-      end
-    end
-  end
-end
diff --git a/spec/factories/ci/stages.rb b/spec/factories/ci/stages.rb
index 7f557b25ccb..884661e1030 100644
--- a/spec/factories/ci/stages.rb
+++ b/spec/factories/ci/stages.rb
@@ -1,5 +1,5 @@
 FactoryGirl.define do
-  factory :ci_stage, class: Ci::Stage do
+  factory :ci_stage, class: Ci::LegacyStage do
     transient do
       name 'test'
       status nil
@@ -8,7 +8,9 @@ FactoryGirl.define do
     end
 
     initialize_with do
-      Ci::Stage.new(pipeline, name: name, status: status, warnings: warnings)
+      Ci::LegacyStage.new(pipeline, name: name,
+                                    status: status,
+                                    warnings: warnings)
     end
   end
 end
diff --git a/spec/models/ci/legacy_stage_spec.rb b/spec/models/ci/legacy_stage_spec.rb
new file mode 100644
index 00000000000..48116c7e701
--- /dev/null
+++ b/spec/models/ci/legacy_stage_spec.rb
@@ -0,0 +1,262 @@
+require 'spec_helper'
+
+describe Ci::LegacyStage, :models 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 '#groups' do
+    before do
+      create_job(:ci_build, name: 'rspec 0 2')
+      create_job(:ci_build, name: 'rspec 0 1')
+      create_job(:ci_build, name: 'spinach 0 1')
+      create_job(:commit_status, name: 'aaaaa')
+    end
+
+    it 'returns an array of three groups' do
+      expect(stage.groups).to be_a Array
+      expect(stage.groups).to all(be_a Ci::Group)
+      expect(stage.groups.size).to eq 3
+    end
+
+    it 'returns groups with correctly ordered statuses' do
+      expect(stage.groups.first.jobs.map(&:name))
+        .to eq ['aaaaa']
+      expect(stage.groups.second.jobs.map(&:name))
+        .to eq ['rspec 0 1', 'rspec 0 2']
+      expect(stage.groups.third.jobs.map(&:name))
+        .to eq ['spinach 0 1']
+    end
+
+    it 'returns groups with correct names' do
+      expect(stage.groups.map(&:name))
+        .to eq %w[aaaaa rspec spinach]
+    end
+  end
+
+  describe '#statuses_count' do
+    before do
+      create_job(:ci_build)
+      create_job(:ci_build, stage: 'other stage')
+    end
+
+    subject { stage.statuses_count }
+
+    it "counts statuses only from current stage" do
+      is_expected.to eq(1)
+    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) }
+
+        before do
+          stage_build.update(retried: true)
+        end
+
+        it "returns status of latest build" do
+          is_expected.to eq('success')
+        end
+      end
+    end
+  end
+
+  describe '#detailed_status' do
+    let(:user) { create(:user) }
+
+    subject { stage.detailed_status(user) }
+
+    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
+
+  describe '#success?' do
+    context 'when stage is successful' do
+      before do
+        create_job(:ci_build, status: :success)
+        create_job(:generic_commit_status, status: :success)
+      end
+
+      it 'is successful' do
+        expect(stage).to be_success
+      end
+    end
+
+    context 'when stage is not successful' do
+      before do
+        create_job(:ci_build, status: :failed)
+        create_job(:generic_commit_status, status: :success)
+      end
+
+      it 'is not successful' do
+        expect(stage).not_to be_success
+      end
+    end
+  end
+
+  describe '#has_warnings?' do
+    context 'when stage has warnings' do
+      context 'when using memoized warnings flag' do
+        context 'when there are warnings' do
+          let(:stage) { build(:ci_stage, warnings: 2) }
+
+          it 'returns true using memoized value' do
+            expect(stage).not_to receive(:statuses)
+            expect(stage).to have_warnings
+          end
+        end
+
+        context 'when there are no warnings' do
+          let(:stage) { build(:ci_stage, warnings: 0) }
+
+          it 'returns false using memoized value' do
+            expect(stage).not_to receive(:statuses)
+            expect(stage).not_to have_warnings
+          end
+        end
+
+        context 'when number of warnings is not a valid value' do
+          let(:stage) { build(:ci_stage, warnings: true) }
+
+          it 'calculates statuses using database queries' do
+            expect(stage).to receive(:statuses).and_call_original
+            expect(stage).not_to have_warnings
+          end
+        end
+      end
+
+      context 'when calculating warnings from statuses' do
+        before do
+          create(:ci_build, :failed, :allowed_to_fail,
+                 stage: stage_name, pipeline: pipeline)
+        end
+
+        it 'has warnings calculated from statuses' do
+          expect(stage).to receive(:statuses).and_call_original
+          expect(stage).to have_warnings
+        end
+      end
+    end
+
+    context 'when stage does not have warnings' do
+      before do
+        create(:ci_build, :success, stage: stage_name,
+                                    pipeline: pipeline)
+      end
+
+      it 'does not have warnings calculated from statuses' do
+        expect(stage).to receive(:statuses).and_call_original
+        expect(stage).not_to have_warnings
+      end
+    end
+  end
+
+  def create_job(type, status: 'success', stage: stage_name, **opts)
+    create(type, pipeline: pipeline, stage: stage, status: status, **opts)
+  end
+end
diff --git a/spec/models/ci/pipeline_spec.rb b/spec/models/ci/pipeline_spec.rb
index 46dfa90218d..17e10a5322e 100644
--- a/spec/models/ci/pipeline_spec.rb
+++ b/spec/models/ci/pipeline_spec.rb
@@ -292,7 +292,7 @@ describe Ci::Pipeline, models: true do
         create(:commit_status, pipeline: pipeline, stage: 'test')
       end
 
-      it { expect(subject).to be_a Ci::Stage }
+      it { expect(subject).to be_a Ci::LegacyStage }
       it { expect(subject.name).to eq 'test' }
       it { expect(subject.statuses).not_to be_empty }
     end
diff --git a/spec/models/ci/stage_spec.rb b/spec/models/ci/stage_spec.rb
deleted file mode 100644
index 8f6ab908987..00000000000
--- a/spec/models/ci/stage_spec.rb
+++ /dev/null
@@ -1,262 +0,0 @@
-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 '#groups' do
-    before do
-      create_job(:ci_build, name: 'rspec 0 2')
-      create_job(:ci_build, name: 'rspec 0 1')
-      create_job(:ci_build, name: 'spinach 0 1')
-      create_job(:commit_status, name: 'aaaaa')
-    end
-
-    it 'returns an array of three groups' do
-      expect(stage.groups).to be_a Array
-      expect(stage.groups).to all(be_a Ci::Group)
-      expect(stage.groups.size).to eq 3
-    end
-
-    it 'returns groups with correctly ordered statuses' do
-      expect(stage.groups.first.jobs.map(&:name))
-        .to eq ['aaaaa']
-      expect(stage.groups.second.jobs.map(&:name))
-        .to eq ['rspec 0 1', 'rspec 0 2']
-      expect(stage.groups.third.jobs.map(&:name))
-        .to eq ['spinach 0 1']
-    end
-
-    it 'returns groups with correct names' do
-      expect(stage.groups.map(&:name))
-        .to eq %w[aaaaa rspec spinach]
-    end
-  end
-
-  describe '#statuses_count' do
-    before do
-      create_job(:ci_build)
-      create_job(:ci_build, stage: 'other stage')
-    end
-
-    subject { stage.statuses_count }
-
-    it "counts statuses only from current stage" do
-      is_expected.to eq(1)
-    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) }
-
-        before do
-          stage_build.update(retried: true)
-        end
-
-        it "returns status of latest build" do
-          is_expected.to eq('success')
-        end
-      end
-    end
-  end
-
-  describe '#detailed_status' do
-    let(:user) { create(:user) }
-
-    subject { stage.detailed_status(user) }
-
-    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
-
-  describe '#success?' do
-    context 'when stage is successful' do
-      before do
-        create_job(:ci_build, status: :success)
-        create_job(:generic_commit_status, status: :success)
-      end
-
-      it 'is successful' do
-        expect(stage).to be_success
-      end
-    end
-
-    context 'when stage is not successful' do
-      before do
-        create_job(:ci_build, status: :failed)
-        create_job(:generic_commit_status, status: :success)
-      end
-
-      it 'is not successful' do
-        expect(stage).not_to be_success
-      end
-    end
-  end
-
-  describe '#has_warnings?' do
-    context 'when stage has warnings' do
-      context 'when using memoized warnings flag' do
-        context 'when there are warnings' do
-          let(:stage) { build(:ci_stage, warnings: 2) }
-
-          it 'returns true using memoized value' do
-            expect(stage).not_to receive(:statuses)
-            expect(stage).to have_warnings
-          end
-        end
-
-        context 'when there are no warnings' do
-          let(:stage) { build(:ci_stage, warnings: 0) }
-
-          it 'returns false using memoized value' do
-            expect(stage).not_to receive(:statuses)
-            expect(stage).not_to have_warnings
-          end
-        end
-
-        context 'when number of warnings is not a valid value' do
-          let(:stage) { build(:ci_stage, warnings: true) }
-
-          it 'calculates statuses using database queries' do
-            expect(stage).to receive(:statuses).and_call_original
-            expect(stage).not_to have_warnings
-          end
-        end
-      end
-
-      context 'when calculating warnings from statuses' do
-        before do
-          create(:ci_build, :failed, :allowed_to_fail,
-                 stage: stage_name, pipeline: pipeline)
-        end
-
-        it 'has warnings calculated from statuses' do
-          expect(stage).to receive(:statuses).and_call_original
-          expect(stage).to have_warnings
-        end
-      end
-    end
-
-    context 'when stage does not have warnings' do
-      before do
-        create(:ci_build, :success, stage: stage_name,
-                                    pipeline: pipeline)
-      end
-
-      it 'does not have warnings calculated from statuses' do
-        expect(stage).to receive(:statuses).and_call_original
-        expect(stage).not_to have_warnings
-      end
-    end
-  end
-
-  def create_job(type, status: 'success', stage: stage_name, **opts)
-    create(type, pipeline: pipeline, stage: stage, status: status, **opts)
-  end
-end
-- 
cgit v1.2.1