Merge branch 'master' into fix-git-hooks-when-creating-file

* master: (1031 commits)
  Add changelog entry for renaming API param [ci skip]
  Add missing milestone parameter
  Refactor issues filter in API
  Fix project hooks params
  Gitlab::LDAP::Person uses LDAP attributes configuration
  Don't delete files from spec/fixtures
  Copy, don't move uploaded avatar files
  Minor improvements to changelog docs
  Rename logo, apply for Slack too
  Fix Gemfile.lock for the octokit update
  Fix cross-project references copy to include the project reference
  Add logo in public files
  Use stable icon for Mattermost integration
  rewrite the item.respond_to?(:x?) && item.x? to item.try(:x?)
  API: extern_uid is a string
  Increases pipeline graph drowdown width in order to prevent strange position on chrome on ubuntu
  Removed bottom padding from merge manually from CLI because of repositioning award emoji's
  Make haml_lint happy
  Improve spec
  Add feature tests for Cycle Analytics
  ...

43 files changed, 1607 insertions, 673 deletions

diff --git a/spec/models/build_spec.rb b/spec/models/build_spec.rb
index d4970e38f7c..cd3b6d51545 100644
--- a/spec/models/build_spec.rb
+++ b/spec/models/build_spec.rb
@@ -87,6 +87,26 @@ describe Ci::Build, models: true do
     end
   end
 
+  describe '#persisted_environment' do
+    before do
+      @environment = create(:environment, project: project, name: "foo-#{project.default_branch}")
+    end
+
+    subject { build.persisted_environment }
+
+    context 'referenced literally' do
+      let(:build) { create(:ci_build, pipeline: pipeline, environment: "foo-#{project.default_branch}") }
+
+      it { is_expected.to eq(@environment) }
+    end
+
+    context 'referenced with a variable' do
+      let(:build) { create(:ci_build, pipeline: pipeline, environment: "foo-$CI_BUILD_REF_NAME") }
+
+      it { is_expected.to eq(@environment) }
+    end
+  end
+
   describe '#trace' do
     it { expect(build.trace).to be_nil }
 
@@ -254,6 +274,24 @@ describe Ci::Build, models: true do
     end
   end
 
+  describe '#ref_slug' do
+    {
+      'master'    => 'master',
+      '1-foo'     => '1-foo',
+      'fix/1-foo' => 'fix-1-foo',
+      'fix-1-foo' => 'fix-1-foo',
+      'a' * 63    => 'a' * 63,
+      'a' * 64    => 'a' * 63,
+      'FOO'       => 'foo',
+    }.each do |ref, slug|
+      it "transforms #{ref} to #{slug}" do
+        build.ref = ref
+
+        expect(build.ref_slug).to eq(slug)
+      end
+    end
+  end
+
   describe '#variables' do
     let(:container_registry_enabled) { false }
     let(:predefined_variables) do
@@ -265,6 +303,7 @@ describe Ci::Build, models: true do
         { key: 'CI_BUILD_REF', value: build.sha, public: true },
         { key: 'CI_BUILD_BEFORE_SHA', value: build.before_sha, public: true },
         { key: 'CI_BUILD_REF_NAME', value: 'master', public: true },
+        { key: 'CI_BUILD_REF_SLUG', value: 'master', public: true },
         { key: 'CI_BUILD_NAME', value: 'test', public: true },
         { key: 'CI_BUILD_STAGE', value: 'test', public: true },
         { key: 'CI_SERVER_NAME', value: 'GitLab', public: true },
@@ -309,6 +348,22 @@ describe Ci::Build, models: true do
       it { user_variables.each { |v| is_expected.to include(v) } }
     end
 
+    context 'when build has an environment' do
+      before do
+        build.update(environment: 'production')
+        create(:environment, project: build.project, name: 'production', slug: 'prod-slug')
+      end
+
+      let(:environment_variables) do
+        [
+          { key: 'CI_ENVIRONMENT_NAME', value: 'production', public: true },
+          { key: 'CI_ENVIRONMENT_SLUG', value: 'prod-slug',  public: true }
+        ]
+      end
+
+      it { environment_variables.each { |v| is_expected.to include(v) } }
+    end
+
     context 'when build started manually' do
       before do
         build.update_attributes(when: :manual)
@@ -403,7 +458,7 @@ describe Ci::Build, models: true do
             })
           end
           let(:variables) do
-            [{ key: :KEY, value: 'value', public: true }]
+            [{ key: 'KEY', value: 'value', public: true }]
           end
 
           it { is_expected.to eq(predefined_variables + variables) }
@@ -451,6 +506,17 @@ describe Ci::Build, models: true do
       it { is_expected.to include({ key: 'CI_RUNNER_TAGS', value: 'docker, linux', public: true }) }
     end
 
+    context 'when build is for a deployment' do
+      let(:deployment_variable) { { key: 'KUBERNETES_TOKEN', value: 'TOKEN', public: false } }
+
+      before do
+        build.environment = 'production'
+        allow(project).to receive(:deployment_variables).and_return([deployment_variable])
+      end
+
+      it { is_expected.to include(deployment_variable) }
+    end
+
     context 'returns variables in valid order' do
       before do
         allow(build).to receive(:predefined_variables) { ['predefined'] }
@@ -899,21 +965,87 @@ describe Ci::Build, models: true do
     end
   end
 
+  describe '#cancelable?' do
+    subject { build }
+
+    context 'when build is cancelable' do
+      context 'when build is pending' do
+        it { is_expected.to be_cancelable }
+      end
+
+      context 'when build is running' do
+        before do
+          build.run!
+        end
+
+        it { is_expected.to be_cancelable }
+      end
+    end
+
+    context 'when build is not cancelable' do
+      context 'when build is successful' do
+        before do
+          build.success!
+        end
+
+        it { is_expected.not_to be_cancelable }
+      end
+
+      context 'when build is failed' do
+        before do
+          build.drop!
+        end
+
+        it { is_expected.not_to be_cancelable }
+      end
+    end
+  end
+
   describe '#retryable?' do
-    context 'when build is running' do
-      before do
-        build.run!
+    subject { build }
+
+    context 'when build is retryable' do
+      context 'when build is successful' do
+        before do
+          build.success!
+        end
+
+        it { is_expected.to be_retryable }
       end
 
-      it { expect(build).not_to be_retryable }
+      context 'when build is failed' do
+        before do
+          build.drop!
+        end
+
+        it { is_expected.to be_retryable }
+      end
+
+      context 'when build is canceled' do
+        before do
+          build.cancel!
+        end
+
+        it { is_expected.to be_retryable }
+      end
     end
 
-    context 'when build is finished' do
-      before do
-        build.success!
+    context 'when build is not retryable' do
+      context 'when build is running' do
+        before do
+          build.run!
+        end
+
+        it { is_expected.not_to be_retryable }
       end
 
-      it { expect(build).to be_retryable }
+      context 'when build is skipped' do
+        before do
+          build.skip!
+        end
+
+        it { is_expected.not_to be_retryable }
+      end
     end
   end
 
@@ -1174,10 +1306,33 @@ describe Ci::Build, models: true do
   describe '#expanded_environment_name' do
     subject { build.expanded_environment_name }
 
-    context 'when environment uses variables' do
-      let(:build) { create(:ci_build, ref: 'master', environment: 'review/$CI_BUILD_REF_NAME') }
+    context 'when environment uses $CI_BUILD_REF_NAME' do
+      let(:build) do
+        create(:ci_build,
+               ref: 'master',
+               environment: 'review/$CI_BUILD_REF_NAME')
+      end
 
       it { is_expected.to eq('review/master') }
     end
+
+    context 'when environment uses yaml_variables containing symbol keys' do
+      let(:build) do
+        create(:ci_build,
+               yaml_variables: [{ key: :APP_HOST, value: 'host' }],
+               environment: 'review/$APP_HOST')
+      end
+
+      it { is_expected.to eq('review/host') }
+    end
+  end
+
+  describe '#detailed_status' do
+    let(:user) { create(:user) }
+
+    it 'returns a detailed status' do
+      expect(build.detailed_status(user))
+        .to be_a Gitlab::Ci::Status::Build::Cancelable
+    end
   end
 end
diff --git a/spec/models/ci/build_spec.rb b/spec/models/ci/build_spec.rb
index a7e90c8a381..7e1d1126b97 100644
--- a/spec/models/ci/build_spec.rb
+++ b/spec/models/ci/build_spec.rb
@@ -85,4 +85,30 @@ describe Ci::Build, models: true do
       it { expect(build.trace_file_path).to eq(build.old_path_to_trace) }
     end
   end
+
+  describe '#update_project_statistics' do
+    let!(:build) { create(:ci_build, artifacts_size: 23) }
+
+    it 'updates project statistics when the artifact size changes' do
+      expect(ProjectCacheWorker).to receive(:perform_async)
+        .with(build.project_id, [], [:build_artifacts_size])
+
+      build.artifacts_size = 42
+      build.save!
+    end
+
+    it 'does not update project statistics when the artifact size stays the same' do
+      expect(ProjectCacheWorker).not_to receive(:perform_async)
+
+      build.name = 'changed'
+      build.save!
+    end
+
+    it 'updates project statistics when the build is destroyed' do
+      expect(ProjectCacheWorker).to receive(:perform_async)
+        .with(build.project_id, [], [:build_artifacts_size])
+
+      build.destroy
+    end
+  end
 end
diff --git a/spec/models/ci/pipeline_spec.rb b/spec/models/ci/pipeline_spec.rb
index 8158e71dd55..cebaa157ef3 100644
--- a/spec/models/ci/pipeline_spec.rb
+++ b/spec/models/ci/pipeline_spec.rb
@@ -175,6 +175,30 @@ describe Ci::Pipeline, models: true do
     end
   end
 
+  describe '#stage' do
+    subject { pipeline.stage('test') }
+
+    context 'with status in stage' do
+      before do
+        create(:commit_status, pipeline: pipeline, stage: 'test')
+      end
+
+      it { expect(subject).to be_a Ci::Stage }
+      it { expect(subject.name).to eq 'test' }
+      it { expect(subject.statuses).not_to be_empty }
+    end
+
+    context 'without status in stage' do
+      before do
+        create(:commit_status, pipeline: pipeline, stage: 'build')
+      end
+
+      it 'return stage object' do
+        is_expected.to be_nil
+      end
+    end
+  end
+
   describe 'state machine' do
     let(:current) { Time.now.change(usec: 0) }
     let(:build) { create_build('build1', 0) }
@@ -381,6 +405,78 @@ describe Ci::Pipeline, models: true do
     end
   end
 
+  shared_context 'with some outdated pipelines' do
+    before do
+      create_pipeline(:canceled, 'ref', 'A')
+      create_pipeline(:success, 'ref', 'A')
+      create_pipeline(:failed, 'ref', 'B')
+      create_pipeline(:skipped, 'feature', 'C')
+    end
+
+    def create_pipeline(status, ref, sha)
+      create(:ci_empty_pipeline, status: status, ref: ref, sha: sha)
+    end
+  end
+
+  describe '.latest' do
+    include_context 'with some outdated pipelines'
+
+    context 'when no ref is specified' do
+      let(:pipelines) { described_class.latest.all }
+
+      it 'returns the latest pipeline for the same ref and different sha' do
+        expect(pipelines.map(&:sha)).to contain_exactly('A', 'B', 'C')
+        expect(pipelines.map(&:status)).
+          to contain_exactly('success', 'failed', 'skipped')
+      end
+    end
+
+    context 'when ref is specified' do
+      let(:pipelines) { described_class.latest('ref').all }
+
+      it 'returns the latest pipeline for ref and different sha' do
+        expect(pipelines.map(&:sha)).to contain_exactly('A', 'B')
+        expect(pipelines.map(&:status)).
+          to contain_exactly('success', 'failed')
+      end
+    end
+  end
+
+  describe '.latest_status' do
+    include_context 'with some outdated pipelines'
+
+    context 'when no ref is specified' do
+      let(:latest_status) { described_class.latest_status }
+
+      it 'returns the latest status for the same ref and different sha' do
+        expect(latest_status).to eq(described_class.latest.status)
+        expect(latest_status).to eq('failed')
+      end
+    end
+
+    context 'when ref is specified' do
+      let(:latest_status) { described_class.latest_status('ref') }
+
+      it 'returns the latest status for ref and different sha' do
+        expect(latest_status).to eq(described_class.latest_status('ref'))
+        expect(latest_status).to eq('failed')
+      end
+    end
+  end
+
+  describe '.latest_successful_for' do
+    include_context 'with some outdated pipelines'
+
+    let!(:latest_successful_pipeline) do
+      create_pipeline(:success, 'ref', 'D')
+    end
+
+    it 'returns the latest successful pipeline' do
+      expect(described_class.latest_successful_for('ref')).
+        to eq(latest_successful_pipeline)
+    end
+  end
+
   describe '#status' do
     let!(:build) { create(:ci_build, :created, pipeline: pipeline, name: 'test') }
 
@@ -442,11 +538,15 @@ describe Ci::Pipeline, models: true do
   end
 
   describe '#detailed_status' do
+    let(:user) { create(:user) }
+
+    subject { pipeline.detailed_status(user) }
+
     context 'when pipeline is created' do
       let(:pipeline) { create(:ci_pipeline, status: :created) }
 
       it 'returns detailed status for created pipeline' do
-        expect(pipeline.detailed_status.text).to eq 'created'
+        expect(subject.text).to eq 'created'
       end
     end
 
@@ -454,7 +554,7 @@ describe Ci::Pipeline, models: true do
       let(:pipeline) { create(:ci_pipeline, status: :pending) }
 
       it 'returns detailed status for pending pipeline' do
-        expect(pipeline.detailed_status.text).to eq 'pending'
+        expect(subject.text).to eq 'pending'
       end
     end
 
@@ -462,7 +562,7 @@ describe Ci::Pipeline, models: true do
       let(:pipeline) { create(:ci_pipeline, status: :running) }
 
       it 'returns detailed status for running pipeline' do
-        expect(pipeline.detailed_status.text).to eq 'running'
+        expect(subject.text).to eq 'running'
       end
     end
 
@@ -470,7 +570,7 @@ describe Ci::Pipeline, models: true do
       let(:pipeline) { create(:ci_pipeline, status: :success) }
 
       it 'returns detailed status for successful pipeline' do
-        expect(pipeline.detailed_status.text).to eq 'passed'
+        expect(subject.text).to eq 'passed'
       end
     end
 
@@ -478,7 +578,7 @@ describe Ci::Pipeline, models: true do
       let(:pipeline) { create(:ci_pipeline, status: :failed) }
 
       it 'returns detailed status for failed pipeline' do
-        expect(pipeline.detailed_status.text).to eq 'failed'
+        expect(subject.text).to eq 'failed'
       end
     end
 
@@ -486,7 +586,7 @@ describe Ci::Pipeline, models: true do
       let(:pipeline) { create(:ci_pipeline, status: :canceled) }
 
       it 'returns detailed status for canceled pipeline' do
-        expect(pipeline.detailed_status.text).to eq 'canceled'
+        expect(subject.text).to eq 'canceled'
       end
     end
 
@@ -494,7 +594,7 @@ describe Ci::Pipeline, models: true do
       let(:pipeline) { create(:ci_pipeline, status: :skipped) }
 
       it 'returns detailed status for skipped pipeline' do
-        expect(pipeline.detailed_status.text).to eq 'skipped'
+        expect(subject.text).to eq 'skipped'
       end
     end
 
@@ -506,7 +606,7 @@ describe Ci::Pipeline, models: true do
       end
 
       it 'retruns detailed status for successful pipeline with warnings' do
-        expect(pipeline.detailed_status.label).to eq 'passed with warnings'
+        expect(subject.label).to eq 'passed with warnings'
       end
     end
   end
diff --git a/spec/models/ci/stage_spec.rb b/spec/models/ci/stage_spec.rb
index f232761dba2..742bedb37e4 100644
--- a/spec/models/ci/stage_spec.rb
+++ b/spec/models/ci/stage_spec.rb
@@ -28,6 +28,19 @@ describe Ci::Stage, models: true do
     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) }
@@ -68,7 +81,9 @@ describe Ci::Stage, models: true do
   end
 
   describe '#detailed_status' do
-    subject { stage.detailed_status }
+    let(:user) { create(:user) }
+
+    subject { stage.detailed_status(user) }
 
     context 'when build is created' do
       let!(:stage_build) { create_job(:ci_build, status: :created) }
diff --git a/spec/models/commit_spec.rb b/spec/models/commit_spec.rb
index 0935fc0561c..74b50d2908d 100644
--- a/spec/models/commit_spec.rb
+++ b/spec/models/commit_spec.rb
@@ -213,23 +213,19 @@ eos
   end
 
   describe '#status' do
-    context 'without arguments for compound status' do
-      shared_examples 'giving the status from pipeline' do
-        it do
-          expect(commit.status).to eq(Ci::Pipeline.status)
-        end
-      end
-
-      context 'with pipelines' do
-        let!(:pipeline) do
-          create(:ci_empty_pipeline, project: project, sha: commit.sha)
+    context 'without ref argument' do
+      before do
+        %w[success failed created pending].each do |status|
+          create(:ci_empty_pipeline,
+                 project: project,
+                 sha: commit.sha,
+                 status: status)
         end
-
-        it_behaves_like 'giving the status from pipeline'
       end
 
-      context 'without pipelines' do
-        it_behaves_like 'giving the status from pipeline'
+      it 'gives compound status from latest pipelines' do
+        expect(commit.status).to eq(Ci::Pipeline.latest_status)
+        expect(commit.status).to eq('pending')
       end
     end
 
@@ -255,8 +251,9 @@ eos
         expect(commit.status('fix')).to eq(pipeline_from_fix.status)
       end
 
-      it 'gives compound status if ref is nil' do
-        expect(commit.status(nil)).to eq(commit.status)
+      it 'gives compound status from latest pipelines if ref is nil' do
+        expect(commit.status(nil)).to eq(Ci::Pipeline.latest_status)
+        expect(commit.status(nil)).to eq('failed')
       end
     end
   end
diff --git a/spec/models/commit_status_spec.rb b/spec/models/commit_status_spec.rb
index 1ec08c2a9d0..701f3323c0f 100644
--- a/spec/models/commit_status_spec.rb
+++ b/spec/models/commit_status_spec.rb
@@ -234,4 +234,13 @@ describe CommitStatus, models: true do
       end
     end
   end
+
+  describe '#detailed_status' do
+    let(:user) { create(:user) }
+
+    it 'returns a detailed status' do
+      expect(commit_status.detailed_status(user))
+        .to be_a Gitlab::Ci::Status::Success
+    end
+  end
 end
diff --git a/spec/models/concerns/issuable_spec.rb b/spec/models/concerns/issuable_spec.rb
index 4fa06a8c60a..1078c959419 100644
--- a/spec/models/concerns/issuable_spec.rb
+++ b/spec/models/concerns/issuable_spec.rb
@@ -44,6 +44,45 @@ describe Issue, "Issuable" do
     it { expect(described_class).to respond_to(:assigned) }
   end
 
+  describe "before_save" do
+    describe "#update_cache_counts" do
+      context "when previous assignee exists" do
+        before do
+          assignee = create(:user)
+          issue.project.team << [assignee, :developer]
+          issue.update(assignee: assignee)
+        end
+
+        it "updates cache counts for new assignee" do
+          user = create(:user)
+
+          expect(user).to receive(:update_cache_counts)
+
+          issue.update(assignee: user)
+        end
+
+        it "updates cache counts for previous assignee" do
+          old_assignee = issue.assignee
+          allow(User).to receive(:find_by_id).with(old_assignee.id).and_return(old_assignee)
+
+          expect(old_assignee).to receive(:update_cache_counts)
+
+          issue.update(assignee: nil)
+        end
+      end
+
+      context "when previous assignee does not exist" do
+        before{ issue.update(assignee: nil) }
+
+        it "updates cache count for the new assignee" do
+          expect_any_instance_of(User).to receive(:update_cache_counts)
+
+          issue.update(assignee: user)
+        end
+      end
+    end
+  end
+
   describe ".search" do
     let!(:searchable_issue) { create(:issue, title: "Searchable issue") }
 
diff --git a/spec/models/concerns/reactive_caching_spec.rb b/spec/models/concerns/reactive_caching_spec.rb
new file mode 100644
index 00000000000..a0765a264cf
--- /dev/null
+++ b/spec/models/concerns/reactive_caching_spec.rb
@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe ReactiveCaching, caching: true do
+  include ReactiveCachingHelpers
+
+  class CacheTest
+    include ReactiveCaching
+
+    self.reactive_cache_key = ->(thing) { ["foo", thing.id] }
+
+    self.reactive_cache_lifetime = 5.minutes
+    self.reactive_cache_refresh_interval = 15.seconds
+
+    attr_reader :id
+
+    def initialize(id, &blk)
+      @id = id
+      @calculator = blk
+    end
+
+    def calculate_reactive_cache
+      @calculator.call
+    end
+
+    def result
+      with_reactive_cache do |data|
+        data / 2
+      end
+    end
+  end
+
+  let(:now) { Time.now.utc }
+
+  around(:each) do |example|
+    Timecop.freeze(now) { example.run }
+  end
+
+  let(:calculation) { -> { 2 + 2 } }
+  let(:cache_key) { "foo:666" }
+  let(:instance) { CacheTest.new(666, &calculation) }
+
+  describe '#with_reactive_cache' do
+    before { stub_reactive_cache }
+    subject(:go!) { instance.result }
+
+    context 'when cache is empty' do
+      it { is_expected.to be_nil }
+
+      it 'queues a background worker' do
+        expect(ReactiveCachingWorker).to receive(:perform_async).with(CacheTest, 666)
+
+        go!
+      end
+
+      it 'updates the cache lifespan' do
+        go!
+
+        expect(reactive_cache_alive?(instance)).to be_truthy
+      end
+    end
+
+    context 'when the cache is full' do
+      before { stub_reactive_cache(instance, 4) }
+
+      it { is_expected.to eq(2) }
+
+      context 'and expired' do
+        before { invalidate_reactive_cache(instance) }
+        it { is_expected.to be_nil }
+      end
+    end
+  end
+
+  describe '#clear_reactive_cache!' do
+    before do
+      stub_reactive_cache(instance, 4)
+      instance.clear_reactive_cache!
+    end
+
+    it { expect(instance.result).to be_nil }
+  end
+
+  describe '#exclusively_update_reactive_cache!' do
+    subject(:go!) { instance.exclusively_update_reactive_cache! }
+
+    context 'when the lease is free and lifetime is not exceeded' do
+      before { stub_reactive_cache(instance, "preexisting") }
+
+      it 'takes and releases the lease' do
+        expect_any_instance_of(Gitlab::ExclusiveLease).to receive(:try_obtain).and_return("000000")
+        expect(Gitlab::ExclusiveLease).to receive(:cancel).with(cache_key, "000000")
+
+        go!
+      end
+
+      it 'caches the result of #calculate_reactive_cache' do
+        go!
+
+        expect(read_reactive_cache(instance)).to eq(calculation.call)
+      end
+
+      it "enqueues a repeat worker" do
+        expect_reactive_cache_update_queued(instance)
+
+        go!
+      end
+
+      context 'and #calculate_reactive_cache raises an exception' do
+        before { stub_reactive_cache(instance, "preexisting") }
+        let(:calculation) { -> { raise "foo"} }
+
+        it 'leaves the cache untouched' do
+          expect { go! }.to raise_error("foo")
+          expect(read_reactive_cache(instance)).to eq("preexisting")
+        end
+
+        it 'enqueues a repeat worker' do
+          expect_reactive_cache_update_queued(instance)
+
+          expect { go! }.to raise_error("foo")
+        end
+      end
+    end
+
+    context 'when lifetime is exceeded' do
+      it 'skips the calculation' do
+        expect(instance).to receive(:calculate_reactive_cache).never
+
+        go!
+      end
+    end
+
+    context 'when the lease is already taken' do
+      before do
+        expect_any_instance_of(Gitlab::ExclusiveLease).to receive(:try_obtain).and_return(nil)
+      end
+
+      it 'skips the calculation' do
+        expect(instance).to receive(:calculate_reactive_cache).never
+
+        go!
+      end
+    end
+  end
+end
diff --git a/spec/models/concerns/routable_spec.rb b/spec/models/concerns/routable_spec.rb
index 0acefc0c1d5..b556135532f 100644
--- a/spec/models/concerns/routable_spec.rb
+++ b/spec/models/concerns/routable_spec.rb
@@ -3,6 +3,10 @@ require 'spec_helper'
 describe Group, 'Routable' do
   let!(:group) { create(:group) }
 
+  describe 'Validations' do
+    it { is_expected.to validate_presence_of(:route) }
+  end
+
   describe 'Associations' do
     it { is_expected.to have_one(:route).dependent(:destroy) }
   end
@@ -35,16 +39,16 @@ describe Group, 'Routable' do
     it { expect(described_class.find_by_full_path('unknown')).to eq(nil) }
   end
 
-  describe '.where_paths_in' do
+  describe '.where_full_path_in' do
     context 'without any paths' do
       it 'returns an empty relation' do
-        expect(described_class.where_paths_in([])).to eq([])
+        expect(described_class.where_full_path_in([])).to eq([])
       end
     end
 
     context 'without any valid paths' do
       it 'returns an empty relation' do
-        expect(described_class.where_paths_in(%w[unknown])).to eq([])
+        expect(described_class.where_full_path_in(%w[unknown])).to eq([])
       end
     end
 
@@ -52,13 +56,13 @@ describe Group, 'Routable' do
       let!(:nested_group) { create(:group, parent: group) }
 
       it 'returns the projects matching the paths' do
-        result = described_class.where_paths_in([group.to_param, nested_group.to_param])
+        result = described_class.where_full_path_in([group.to_param, nested_group.to_param])
 
         expect(result).to contain_exactly(group, nested_group)
       end
 
       it 'returns projects regardless of the casing of paths' do
-        result = described_class.where_paths_in([group.to_param.upcase, nested_group.to_param.upcase])
+        result = described_class.where_full_path_in([group.to_param.upcase, nested_group.to_param.upcase])
 
         expect(result).to contain_exactly(group, nested_group)
       end
diff --git a/spec/models/concerns/token_authenticatable_spec.rb b/spec/models/concerns/token_authenticatable_spec.rb
index eb64f3d0c83..4b0bfa43abf 100644
--- a/spec/models/concerns/token_authenticatable_spec.rb
+++ b/spec/models/concerns/token_authenticatable_spec.rb
@@ -6,6 +6,7 @@ shared_examples 'TokenAuthenticatable' do
     it { expect(described_class).to be_private_method_defined(:write_new_token) }
     it { expect(described_class).to respond_to("find_by_#{token_field}") }
     it { is_expected.to respond_to("ensure_#{token_field}") }
+    it { is_expected.to respond_to("set_#{token_field}") }
     it { is_expected.to respond_to("reset_#{token_field}!") }
   end
 end
@@ -55,6 +56,12 @@ describe ApplicationSetting, 'TokenAuthenticatable' do
     end
   end
 
+  describe 'setting new token' do
+    subject { described_class.new.send("set_#{token_field}", '0123456789') }
+
+    it { is_expected.to eq '0123456789' }
+  end
+
   describe 'multiple token fields' do
     before do
       described_class.send(:add_authentication_token_field, :yet_another_token)
diff --git a/spec/models/deploy_key_spec.rb b/spec/models/deploy_key_spec.rb
index 93623e8e99b..8ef8218cf74 100644
--- a/spec/models/deploy_key_spec.rb
+++ b/spec/models/deploy_key_spec.rb
@@ -1,8 +1,22 @@
 require 'spec_helper'
 
 describe DeployKey, models: true do
+  include EmailHelpers
+
   describe "Associations" do
     it { is_expected.to have_many(:deploy_keys_projects) }
     it { is_expected.to have_many(:projects) }
   end
+
+  describe 'notification' do
+    let(:user) { create(:user) }
+
+    it 'does not send a notification' do
+      perform_enqueued_jobs do
+        create(:deploy_key, user: user)
+      end
+
+      should_not_email(user)
+    end
+  end
 end
diff --git a/spec/models/environment_spec.rb b/spec/models/environment_spec.rb
index c8170164898..93eb402e060 100644
--- a/spec/models/environment_spec.rb
+++ b/spec/models/environment_spec.rb
@@ -1,7 +1,8 @@
 require 'spec_helper'
 
 describe Environment, models: true do
-  let(:environment) { create(:environment) }
+  let(:project) { create(:empty_project) }
+  subject(:environment) { create(:environment, project: project) }
 
   it { is_expected.to belong_to(:project) }
   it { is_expected.to have_many(:deployments) }
@@ -15,15 +16,11 @@ describe Environment, models: true do
   it { is_expected.to validate_uniqueness_of(:name).scoped_to(:project_id) }
   it { is_expected.to validate_length_of(:name).is_at_most(255) }
 
-  it { is_expected.to validate_length_of(:external_url).is_at_most(255) }
-
-  # To circumvent a not null violation of the name column:
-  # https://github.com/thoughtbot/shoulda-matchers/issues/336
-  it 'validates uniqueness of :external_url' do
-    create(:environment)
+  it { is_expected.to validate_uniqueness_of(:slug).scoped_to(:project_id) }
+  it { is_expected.to validate_length_of(:slug).is_at_most(24) }
 
-    is_expected.to validate_uniqueness_of(:external_url).scoped_to(:project_id)
-  end
+  it { is_expected.to validate_length_of(:external_url).is_at_most(255) }
+  it { is_expected.to validate_uniqueness_of(:external_url).scoped_to(:project_id) }
 
   describe '#nullify_external_url' do
     it 'replaces a blank url with nil' do
@@ -35,6 +32,8 @@ describe Environment, models: true do
   end
 
   describe '#includes_commit?' do
+    let(:project) { create(:project) }
+
     context 'without a last deployment' do
       it "returns false" do
         expect(environment.includes_commit?('HEAD')).to be false
@@ -42,9 +41,6 @@ describe Environment, models: true do
     end
 
     context 'with a last deployment' do
-      let(:project)     { create(:project) }
-      let(:environment) { create(:environment, project: project) }
-
       let!(:deployment) do
         create(:deployment, environment: environment, sha: project.commit('master').id)
       end
@@ -69,7 +65,6 @@ describe Environment, models: true do
 
   describe '#first_deployment_for' do
     let(:project)       { create(:project) }
-    let!(:environment)  { create(:environment, project: project) }
     let!(:deployment)   { create(:deployment, environment: environment, ref: commit.parent.id) }
     let!(:deployment1)  { create(:deployment, environment: environment, ref: commit.id) }
     let(:head_commit)   { project.commit }
@@ -199,4 +194,89 @@ describe Environment, models: true do
       expect(environment.actions_for('review/master')).to contain_exactly(review_action)
     end
   end
+
+  describe '#has_terminals?' do
+    subject { environment.has_terminals? }
+
+    context 'when the enviroment is available' do
+      context 'with a deployment service' do
+        let(:project) { create(:kubernetes_project) }
+
+        context 'and a deployment' do
+          let!(:deployment) { create(:deployment, environment: environment) }
+          it { is_expected.to be_truthy }
+        end
+
+        context 'but no deployments' do
+          it { is_expected.to be_falsy }
+        end
+      end
+
+      context 'without a deployment service' do
+        it { is_expected.to be_falsy }
+      end
+    end
+
+    context 'when the environment is unavailable' do
+      let(:project) { create(:kubernetes_project) }
+      before { environment.stop }
+      it { is_expected.to be_falsy }
+    end
+  end
+
+  describe '#terminals' do
+    let(:project) { create(:kubernetes_project) }
+    subject { environment.terminals }
+
+    context 'when the environment has terminals' do
+      before { allow(environment).to receive(:has_terminals?).and_return(true) }
+
+      it 'returns the terminals from the deployment service' do
+        expect(project.deployment_service).
+          to receive(:terminals).with(environment).
+          and_return(:fake_terminals)
+
+        is_expected.to eq(:fake_terminals)
+      end
+    end
+
+    context 'when the environment does not have terminals' do
+      before { allow(environment).to receive(:has_terminals?).and_return(false) }
+      it { is_expected.to eq(nil) }
+    end
+  end
+
+  describe '#slug' do
+    it "is automatically generated" do
+      expect(environment.slug).not_to be_nil
+    end
+
+    it "is not regenerated if name changes" do
+      original_slug = environment.slug
+      environment.update_attributes!(name: environment.name.reverse)
+
+      expect(environment.slug).to eq(original_slug)
+    end
+  end
+
+  describe '#generate_slug' do
+    SUFFIX = "-[a-z0-9]{6}"
+    {
+      "staging-12345678901234567" => "staging-123456789" + SUFFIX,
+      "9-staging-123456789012345" => "env-9-staging-123" + SUFFIX,
+      "staging-1234567890123456"  => "staging-1234567890123456",
+      "production"                => "production",
+      "PRODUCTION"                => "production" + SUFFIX,
+      "review/1-foo"              => "review-1-foo" + SUFFIX,
+      "1-foo"                     => "env-1-foo" + SUFFIX,
+      "1/foo"                     => "env-1-foo" + SUFFIX,
+      "foo-"                      => "foo" + SUFFIX,
+    }.each do |name, matcher|
+      it "returns a slug matching #{matcher}, given #{name}" do
+        slug = described_class.new(name: name).generate_slug
+
+        expect(slug).to match(/\A#{matcher}\z/)
+      end
+    end
+  end
 end
diff --git a/spec/models/generic_commit_status_spec.rb b/spec/models/generic_commit_status_spec.rb
index 615cfe3142b..6004bfdb7b7 100644
--- a/spec/models/generic_commit_status_spec.rb
+++ b/spec/models/generic_commit_status_spec.rb
@@ -1,8 +1,11 @@
 require 'spec_helper'
 
 describe GenericCommitStatus, models: true do
-  let(:pipeline) { FactoryGirl.create :ci_pipeline }
-  let(:generic_commit_status) { FactoryGirl.create :generic_commit_status, pipeline: pipeline }
+  let(:pipeline) { create(:ci_pipeline) }
+
+  let(:generic_commit_status) do
+    create(:generic_commit_status, pipeline: pipeline)
+  end
 
   describe '#context' do
     subject { generic_commit_status.context }
@@ -17,6 +20,15 @@ describe GenericCommitStatus, models: true do
     it { is_expected.to eq([:external]) }
   end
 
+  describe '#detailed_status' do
+    let(:user) { create(:user) }
+
+    it 'returns detailed status object' do
+      expect(generic_commit_status.detailed_status(user))
+        .to be_a Gitlab::Ci::Status::Success
+    end
+  end
+
   describe 'set_default_values' do
     before do
       generic_commit_status.context = nil
diff --git a/spec/models/group_label_spec.rb b/spec/models/group_label_spec.rb
index 668aa6fb357..555a876daeb 100644
--- a/spec/models/group_label_spec.rb
+++ b/spec/models/group_label_spec.rb
@@ -43,7 +43,7 @@ describe GroupLabel, models: true do
       let(:target_project) { build_stubbed(:empty_project, name: 'project-2', namespace: namespace) }
 
       it 'returns a String reference to the object' do
-        expect(label.to_reference(source_project, target_project)).to eq %(project-1~#{label.id})
+        expect(label.to_reference(source_project, target_project: target_project)).to eq %(project-1~#{label.id})
       end
     end
 
diff --git a/spec/models/group_spec.rb b/spec/models/group_spec.rb
index 1613a586a2c..45fe927202b 100644
--- a/spec/models/group_spec.rb
+++ b/spec/models/group_spec.rb
@@ -50,9 +50,8 @@ describe Group, models: true do
 
   describe 'validations' do
     it { is_expected.to validate_presence_of :name }
-    it { is_expected.to validate_uniqueness_of(:name) }
+    it { is_expected.to validate_uniqueness_of(:name).scoped_to(:parent_id) }
     it { is_expected.to validate_presence_of :path }
-    it { is_expected.to validate_uniqueness_of(:path) }
     it { is_expected.not_to validate_presence_of :owner }
   end
 
@@ -271,4 +270,22 @@ describe Group, models: true do
       expect(group.web_url).to include("groups/#{group.name}")
     end
   end
+
+  describe 'nested group' do
+    subject { build(:group, :nested) }
+
+    it { is_expected.to be_valid }
+    it { expect(subject.parent).to be_kind_of(Group) }
+  end
+
+  describe '#members_with_parents' do
+    let!(:group) { create(:group, :nested) }
+    let!(:master) { group.parent.add_user(create(:user), GroupMember::MASTER) }
+    let!(:developer) { group.add_user(create(:user), GroupMember::DEVELOPER) }
+
+    it 'returns parents members' do
+      expect(group.members_with_parents).to include(developer)
+      expect(group.members_with_parents).to include(master)
+    end
+  end
 end
diff --git a/spec/models/issue_spec.rb b/spec/models/issue_spec.rb
index 24e216329a9..bfa36d92ac3 100644
--- a/spec/models/issue_spec.rb
+++ b/spec/models/issue_spec.rb
@@ -22,26 +22,6 @@ describe Issue, models: true do
     it { is_expected.to have_db_index(:deleted_at) }
   end
 
-  describe '.visible_to_user' do
-    let(:user) { create(:user) }
-    let(:authorized_user) { create(:user) }
-    let(:project) { create(:project, namespace: authorized_user.namespace) }
-    let!(:public_issue) { create(:issue, project: project) }
-    let!(:confidential_issue) { create(:issue, project: project, confidential: true) }
-
-    it 'returns non confidential issues for nil user' do
-      expect(Issue.visible_to_user(nil).count).to be(1)
-    end
-
-    it 'returns non confidential issues for user not authorized for the issues projects' do
-      expect(Issue.visible_to_user(user).count).to be(1)
-    end
-
-    it 'returns all issues for user authorized for the issues projects' do
-      expect(Issue.visible_to_user(authorized_user).count).to be(2)
-    end
-  end
-
   describe '#to_reference' do
     let(:project) { build(:empty_project, name: 'sample-project') }
     let(:issue) { build(:issue, iid: 1, project: project) }
@@ -50,6 +30,10 @@ describe Issue, models: true do
       expect(issue.to_reference).to eq "#1"
     end
 
+    it 'returns a String reference with the full path' do
+      expect(issue.to_reference(full: true)).to eq(project.path_with_namespace + '#1')
+    end
+
     it 'supports a cross-project reference' do
       another_project = build(:project, name: 'another-project', namespace: project.namespace)
       expect(issue.to_reference(another_project)).to eq "sample-project#1"
diff --git a/spec/models/key_spec.rb b/spec/models/key_spec.rb
index 2a33d819138..7758b7ffa97 100644
--- a/spec/models/key_spec.rb
+++ b/spec/models/key_spec.rb
@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Key, models: true do
+  include EmailHelpers
+
   describe "Associations" do
     it { is_expected.to belong_to(:user) }
   end
@@ -96,4 +98,16 @@ describe Key, models: true do
       expect(described_class.new(key: " #{valid_key} ").key).to eq(valid_key)
     end
   end
+
+  describe 'notification' do
+    let(:user) { create(:user) }
+
+    it 'sends a notification' do
+      perform_enqueued_jobs do
+        create(:key, user: user)
+      end
+
+      should_email(user)
+    end
+  end
 end
diff --git a/spec/models/lfs_objects_project_spec.rb b/spec/models/lfs_objects_project_spec.rb
new file mode 100644
index 00000000000..7bc278e350f
--- /dev/null
+++ b/spec/models/lfs_objects_project_spec.rb
@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe LfsObjectsProject, models: true do
+  subject { create(:lfs_objects_project, project: project) }
+  let(:project) { create(:empty_project) }
+
+  describe 'associations' do
+    it { is_expected.to belong_to(:project) }
+    it { is_expected.to belong_to(:lfs_object) }
+  end
+
+  describe 'validation' do
+    it { is_expected.to validate_presence_of(:lfs_object_id) }
+    it { is_expected.to validate_uniqueness_of(:lfs_object_id).scoped_to(:project_id).with_message("already exists in project") }
+
+    it { is_expected.to validate_presence_of(:project_id) }
+  end
+
+  describe '#update_project_statistics' do
+    it 'updates project statistics when the object is added' do
+      expect(ProjectCacheWorker).to receive(:perform_async)
+        .with(project.id, [], [:lfs_objects_size])
+
+      subject.save!
+    end
+
+    it 'updates project statistics when the object is removed' do
+      subject.save!
+
+      expect(ProjectCacheWorker).to receive(:perform_async)
+        .with(project.id, [], [:lfs_objects_size])
+
+      subject.destroy
+    end
+  end
+end
diff --git a/spec/models/merge_request_spec.rb b/spec/models/merge_request_spec.rb
index 8b730be91fd..8d1385016fd 100644
--- a/spec/models/merge_request_spec.rb
+++ b/spec/models/merge_request_spec.rb
@@ -153,6 +153,10 @@ describe MergeRequest, models: true do
       another_project = build(:project, name: 'another-project', namespace: project.namespace)
       expect(merge_request.to_reference(another_project)).to eq "sample-project!1"
     end
+
+    it 'returns a String reference with the full path' do
+      expect(merge_request.to_reference(full: true)).to eq(project.path_with_namespace + '!1')
+    end
   end
 
   describe '#raw_diffs' do
@@ -205,7 +209,7 @@ describe MergeRequest, models: true do
     end
   end
 
-  describe "#mr_and_commit_notes" do
+  describe "#related_notes" do
     let!(:merge_request) { create(:merge_request) }
 
     before do
@@ -217,7 +221,7 @@ describe MergeRequest, models: true do
 
     it "includes notes for commits" do
       expect(merge_request.commits).not_to be_empty
-      expect(merge_request.mr_and_commit_notes.count).to eq(2)
+      expect(merge_request.related_notes.count).to eq(2)
     end
 
     it "includes notes for commits from target project as well" do
@@ -225,7 +229,7 @@ describe MergeRequest, models: true do
                               project: merge_request.target_project)
 
       expect(merge_request.commits).not_to be_empty
-      expect(merge_request.mr_and_commit_notes.count).to eq(3)
+      expect(merge_request.related_notes.count).to eq(3)
     end
   end
 
@@ -252,7 +256,7 @@ describe MergeRequest, models: true do
     end
   end
 
-  describe 'detection of issues to be closed' do
+  describe '#closes_issues' do
     let(:issue0) { create :issue, project: subject.project }
     let(:issue1) { create :issue, project: subject.project }
 
@@ -280,14 +284,23 @@ describe MergeRequest, models: true do
 
       expect(subject.closes_issues).to be_empty
     end
+  end
+
+  describe '#issues_mentioned_but_not_closing' do
+    let(:closing_issue) { create :issue, project: subject.project }
+    let(:mentioned_issue) { create :issue, project: subject.project }
+
+    let(:commit) { double('commit', safe_message: "Fixes #{closing_issue.to_reference}") }
+
+    it 'detects issues mentioned in description but not closed' do
+      subject.project.team << [subject.author, :developer]
+      subject.description = "Is related to #{mentioned_issue.to_reference} and #{closing_issue.to_reference}"
 
-    it 'detects issues mentioned in the description' do
-      issue2 = create(:issue, project: subject.project)
-      subject.description = "Closes #{issue2.to_reference}"
+      allow(subject).to receive(:commits).and_return([commit])
       allow(subject.project).to receive(:default_branch).
         and_return(subject.target_branch)
 
-      expect(subject.closes_issues).to include(issue2)
+      expect(subject.issues_mentioned_but_not_closing).to match_array([mentioned_issue])
     end
   end
 
@@ -410,11 +423,17 @@ describe MergeRequest, models: true do
         .to match("Remove all technical debt\n\n")
     end
 
-    it 'includes its description in the body' do
-      request = build(:merge_request, description: 'By removing all code')
+    it 'includes its closed issues in the body' do
+      issue = create(:issue, project: subject.project)
 
-      expect(request.merge_commit_message)
-        .to match("By removing all code\n\n")
+      subject.project.team << [subject.author, :developer]
+      subject.description = "This issue Closes #{issue.to_reference}"
+
+      allow(subject.project).to receive(:default_branch).
+        and_return(subject.target_branch)
+
+      expect(subject.merge_commit_message)
+        .to match("Closes #{issue.to_reference}")
     end
 
     it 'includes its reference in the body' do
@@ -429,6 +448,20 @@ describe MergeRequest, models: true do
 
       expect(request.merge_commit_message).not_to match("Title\n\n\n\n")
     end
+
+    it 'includes its description in the body' do
+      request = build(:merge_request, description: 'By removing all code')
+
+      expect(request.merge_commit_message(include_description: true))
+        .to match("By removing all code\n\n")
+    end
+
+    it 'does not includes its description in the body' do
+      request = build(:merge_request, description: 'By removing all code')
+
+      expect(request.merge_commit_message)
+        .not_to match("By removing all code\n\n")
+    end
   end
 
   describe "#reset_merge_when_build_succeeds" do
diff --git a/spec/models/milestone_spec.rb b/spec/models/milestone_spec.rb
index 0cc2efae5f9..064f29d2d66 100644
--- a/spec/models/milestone_spec.rb
+++ b/spec/models/milestone_spec.rb
@@ -24,8 +24,9 @@ describe Milestone, models: true do
     it { is_expected.to have_many(:issues) }
   end
 
-  let(:milestone) { create(:milestone) }
-  let(:issue) { create(:issue) }
+  let(:project) { create(:project, :public) }
+  let(:milestone) { create(:milestone, project: project) }
+  let(:issue) { create(:issue, project: project) }
   let(:user) { create(:user) }
 
   describe "#title" do
@@ -110,8 +111,8 @@ describe Milestone, models: true do
 
   describe :items_count do
     before do
-      milestone.issues << create(:issue)
-      milestone.issues << create(:closed_issue)
+      milestone.issues << create(:issue, project: project)
+      milestone.issues << create(:closed_issue, project: project)
       milestone.merge_requests << create(:merge_request)
     end
 
@@ -126,7 +127,7 @@ describe Milestone, models: true do
 
   describe '#total_items_count' do
     before do
-      create :closed_issue, milestone: milestone
+      create :closed_issue, milestone: milestone, project: project
       create :merge_request, milestone: milestone
     end
 
diff --git a/spec/models/namespace_spec.rb b/spec/models/namespace_spec.rb
index 7f82e85563b..600538ff5f4 100644
--- a/spec/models/namespace_spec.rb
+++ b/spec/models/namespace_spec.rb
@@ -4,22 +4,19 @@ describe Namespace, models: true do
   let!(:namespace) { create(:namespace) }
 
   it { is_expected.to have_many :projects }
+  it { is_expected.to have_many :project_statistics }
 
   it { is_expected.to validate_presence_of(:name) }
-  it { is_expected.to validate_uniqueness_of(:name) }
+  it { is_expected.to validate_uniqueness_of(:name).scoped_to(:parent_id) }
   it { is_expected.to validate_length_of(:name).is_at_most(255) }
 
   it { is_expected.to validate_length_of(:description).is_at_most(255) }
 
   it { is_expected.to validate_presence_of(:path) }
-  it { is_expected.to validate_uniqueness_of(:path) }
   it { is_expected.to validate_length_of(:path).is_at_most(255) }
 
   it { is_expected.to validate_presence_of(:owner) }
 
-  describe "Mass assignment" do
-  end
-
   describe "Respond to" do
     it { is_expected.to respond_to(:human_name) }
     it { is_expected.to respond_to(:to_param) }
@@ -61,6 +58,50 @@ describe Namespace, models: true do
     end
   end
 
+  describe '.with_statistics' do
+    let(:namespace) { create :namespace }
+
+    let(:project1) do
+      create(:empty_project,
+             namespace: namespace,
+             statistics: build(:project_statistics,
+                               storage_size:         606,
+                               repository_size:      101,
+                               lfs_objects_size:     202,
+                               build_artifacts_size: 303))
+    end
+
+    let(:project2) do
+      create(:empty_project,
+             namespace: namespace,
+             statistics: build(:project_statistics,
+                               storage_size:         60,
+                               repository_size:      10,
+                               lfs_objects_size:     20,
+                               build_artifacts_size: 30))
+    end
+
+    it "sums all project storage counters in the namespace" do
+      project1
+      project2
+      statistics = Namespace.with_statistics.find(namespace.id)
+
+      expect(statistics.storage_size).to eq 666
+      expect(statistics.repository_size).to eq 111
+      expect(statistics.lfs_objects_size).to eq 222
+      expect(statistics.build_artifacts_size).to eq 333
+    end
+
+    it "correctly handles namespaces without projects" do
+      statistics = Namespace.with_statistics.find(namespace.id)
+
+      expect(statistics.storage_size).to eq 0
+      expect(statistics.repository_size).to eq 0
+      expect(statistics.lfs_objects_size).to eq 0
+      expect(statistics.build_artifacts_size).to eq 0
+    end
+  end
+
   describe '#move_dir' do
     before do
       @namespace = create :namespace
@@ -132,4 +173,26 @@ describe Namespace, models: true do
     it { expect(group.full_path).to eq(group.path) }
     it { expect(nested_group.full_path).to eq("#{group.path}/#{nested_group.path}") }
   end
+
+  describe '#full_name' do
+    let(:group) { create(:group) }
+    let(:nested_group) { create(:group, parent: group) }
+
+    it { expect(group.full_name).to eq(group.name) }
+    it { expect(nested_group.full_name).to eq("#{group.name} / #{nested_group.name}") }
+  end
+
+  describe '#parents' do
+    let(:group) { create(:group) }
+    let(:nested_group) { create(:group, parent: group) }
+    let(:deep_nested_group) { create(:group, parent: nested_group) }
+    let(:very_deep_nested_group) { create(:group, parent: deep_nested_group) }
+
+    it 'returns the correct parents' do
+      expect(very_deep_nested_group.parents).to eq([group, nested_group, deep_nested_group])
+      expect(deep_nested_group.parents).to eq([group, nested_group])
+      expect(nested_group.parents).to eq([group])
+      expect(group.parents).to eq([])
+    end
+  end
 end
diff --git a/spec/models/note_spec.rb b/spec/models/note_spec.rb
index 17a15b12dcb..310fecd8a5c 100644
--- a/spec/models/note_spec.rb
+++ b/spec/models/note_spec.rb
@@ -162,44 +162,6 @@ describe Note, models: true do
     end
   end
 
-  describe '.search' do
-    let(:note) { create(:note_on_issue, note: 'WoW') }
-
-    it 'returns notes with matching content' do
-      expect(described_class.search(note.note)).to eq([note])
-    end
-
-    it 'returns notes with matching content regardless of the casing' do
-      expect(described_class.search('WOW')).to eq([note])
-    end
-
-    context "confidential issues" do
-      let(:user) { create(:user) }
-      let(:project) { create(:project) }
-      let(:confidential_issue) { create(:issue, :confidential, project: project, author: user) }
-      let(:confidential_note) { create(:note, note: "Random", noteable: confidential_issue, project: confidential_issue.project) }
-
-      it "returns notes with matching content if user can see the issue" do
-        expect(described_class.search(confidential_note.note, as_user: user)).to eq([confidential_note])
-      end
-
-      it "does not return notes with matching content if user can not see the issue" do
-        user = create(:user)
-        expect(described_class.search(confidential_note.note, as_user: user)).to be_empty
-      end
-
-      it "does not return notes with matching content for project members with guest role" do
-        user = create(:user)
-        project.team << [user, :guest]
-        expect(described_class.search(confidential_note.note, as_user: user)).to be_empty
-      end
-
-      it "does not return notes with matching content for unauthenticated users" do
-        expect(described_class.search(confidential_note.note)).to be_empty
-      end
-    end
-  end
-
   describe "editable?" do
     it "returns true" do
       note = build(:note)
diff --git a/spec/models/project_authorization_spec.rb b/spec/models/project_authorization_spec.rb
new file mode 100644
index 00000000000..33ef67f97a7
--- /dev/null
+++ b/spec/models/project_authorization_spec.rb
@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe ProjectAuthorization do
+  let(:user) { create(:user) }
+  let(:project1) { create(:empty_project) }
+  let(:project2) { create(:empty_project) }
+
+  describe '.insert_authorizations' do
+    it 'inserts the authorizations' do
+      described_class.
+        insert_authorizations([[user.id, project1.id, Gitlab::Access::MASTER]])
+
+      expect(user.project_authorizations.count).to eq(1)
+    end
+
+    it 'inserts rows in batches' do
+      described_class.insert_authorizations([
+        [user.id, project1.id, Gitlab::Access::MASTER],
+        [user.id, project2.id, Gitlab::Access::MASTER],
+      ], 1)
+
+      expect(user.project_authorizations.count).to eq(2)
+    end
+  end
+end
diff --git a/spec/models/project_services/slack_service/build_message_spec.rb b/spec/models/project_services/chat_message/build_message_spec.rb
index 452f4e2782c..50ad5013df9 100644
--- a/spec/models/project_services/slack_service/build_message_spec.rb
+++ b/spec/models/project_services/chat_message/build_message_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe SlackService::BuildMessage do
-  subject { SlackService::BuildMessage.new(args) }
+describe ChatMessage::BuildMessage do
+  subject { described_class.new(args) }
 
   let(:args) do
     {
@@ -10,7 +10,7 @@ describe SlackService::BuildMessage do
       tag: false,
 
       project_name: 'project_name',
-      project_url: 'example.gitlab.com',
+      project_url: 'http://example.gitlab.com',
 
       commit: {
         status: status,
@@ -48,10 +48,10 @@ describe SlackService::BuildMessage do
   end
 
   def build_message(status_text = status)
-    "<example.gitlab.com|project_name>:" \
-    " Commit <example.gitlab.com/commit/" \
+    "<http://example.gitlab.com|project_name>:" \
+    " Commit <http://example.gitlab.com/commit/" \
     "97de212e80737a608d939f648d959671fb0a0142/builds|97de212e>" \
-    " of <example.gitlab.com/commits/develop|develop> branch" \
+    " of <http://example.gitlab.com/commits/develop|develop> branch" \
     " by hacker #{status_text} in #{duration} #{'second'.pluralize(duration)}"
   end
 end
diff --git a/spec/models/project_services/slack_service/issue_message_spec.rb b/spec/models/project_services/chat_message/issue_message_spec.rb
index 98c36ec088d..190ff4c535d 100644
--- a/spec/models/project_services/slack_service/issue_message_spec.rb
+++ b/spec/models/project_services/chat_message/issue_message_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe SlackService::IssueMessage, models: true do
-  subject { SlackService::IssueMessage.new(args) }
+describe ChatMessage::IssueMessage, models: true do
+  subject { described_class.new(args) }
 
   let(:args) do
     {
@@ -10,14 +10,14 @@ describe SlackService::IssueMessage, models: true do
         username: 'test.user'
       },
       project_name: 'project_name',
-      project_url: 'somewhere.com',
+      project_url: 'http://somewhere.com',
 
       object_attributes: {
         title: 'Issue title',
         id: 10,
         iid: 100,
         assignee_id: 1,
-        url: 'url',
+        url: 'http://url.com',
         action: 'open',
         state: 'opened',
         description: 'issue description'
@@ -40,11 +40,11 @@ describe SlackService::IssueMessage, models: true do
   context 'open' do
     it 'returns a message regarding opening of issues' do
       expect(subject.pretext).to eq(
-        '<somewhere.com|[project_name>] Issue opened by test.user')
+        '[<http://somewhere.com|project_name>] Issue opened by test.user')
       expect(subject.attachments).to eq([
         {
           title: "#100 Issue title",
-          title_link: "url",
+          title_link: "http://url.com",
           text: "issue description",
           color: color,
         }
@@ -60,7 +60,7 @@ describe SlackService::IssueMessage, models: true do
 
     it 'returns a message regarding closing of issues' do
       expect(subject.pretext). to eq(
-        '<somewhere.com|[project_name>] Issue <url|#100 Issue title> closed by test.user')
+        '[<http://somewhere.com|project_name>] Issue <http://url.com|#100 Issue title> closed by test.user')
       expect(subject.attachments).to be_empty
     end
   end
diff --git a/spec/models/project_services/slack_service/merge_message_spec.rb b/spec/models/project_services/chat_message/merge_message_spec.rb
index c5c052d9af1..cc154112e90 100644
--- a/spec/models/project_services/slack_service/merge_message_spec.rb
+++ b/spec/models/project_services/chat_message/merge_message_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe SlackService::MergeMessage, models: true do
-  subject { SlackService::MergeMessage.new(args) }
+describe ChatMessage::MergeMessage, models: true do
+  subject { described_class.new(args) }
 
   let(:args) do
     {
@@ -10,14 +10,14 @@ describe SlackService::MergeMessage, models: true do
           username: 'test.user'
       },
       project_name: 'project_name',
-      project_url: 'somewhere.com',
+      project_url: 'http://somewhere.com',
 
       object_attributes: {
         title: "Issue title\nSecond line",
         id: 10,
         iid: 100,
         assignee_id: 1,
-        url: 'url',
+        url: 'http://url.com',
         state: 'opened',
         description: 'issue description',
         source_branch: 'source_branch',
@@ -31,8 +31,8 @@ describe SlackService::MergeMessage, models: true do
   context 'open' do
     it 'returns a message regarding opening of merge requests' do
       expect(subject.pretext).to eq(
-        'test.user opened <somewhere.com/merge_requests/100|merge request !100> '\
-        'in <somewhere.com|project_name>: *Issue title*')
+        'test.user opened <http://somewhere.com/merge_requests/100|merge request !100> '\
+        'in <http://somewhere.com|project_name>: *Issue title*')
       expect(subject.attachments).to be_empty
     end
   end
@@ -43,8 +43,8 @@ describe SlackService::MergeMessage, models: true do
     end
     it 'returns a message regarding closing of merge requests' do
       expect(subject.pretext).to eq(
-        'test.user closed <somewhere.com/merge_requests/100|merge request !100> '\
-        'in <somewhere.com|project_name>: *Issue title*')
+        'test.user closed <http://somewhere.com/merge_requests/100|merge request !100> '\
+        'in <http://somewhere.com|project_name>: *Issue title*')
       expect(subject.attachments).to be_empty
     end
   end
diff --git a/spec/models/project_services/slack_service/note_message_spec.rb b/spec/models/project_services/chat_message/note_message_spec.rb
index 97f818125d3..da700a08e57 100644
--- a/spec/models/project_services/slack_service/note_message_spec.rb
+++ b/spec/models/project_services/chat_message/note_message_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe SlackService::NoteMessage, models: true do
+describe ChatMessage::NoteMessage, models: true do
   let(:color) { '#345' }
 
   before do
@@ -11,15 +11,15 @@ describe SlackService::NoteMessage, models: true do
             avatar_url: 'http://fakeavatar'
         },
         project_name: 'project_name',
-        project_url: 'somewhere.com',
+        project_url: 'http://somewhere.com',
         repository: {
             name: 'project_name',
-            url: 'somewhere.com',
+            url: 'http://somewhere.com',
         },
         object_attributes: {
             id: 10,
             note: 'comment on a commit',
-            url: 'url',
+            url: 'http://url.com',
             noteable_type: 'Commit'
         }
     }
@@ -36,9 +36,9 @@ describe SlackService::NoteMessage, models: true do
     end
 
     it 'returns a message regarding notes on commits' do
-      message = SlackService::NoteMessage.new(@args)
-      expect(message.pretext).to eq("test.user <url|commented on " \
-      "commit 5f163b2b> in <somewhere.com|project_name>: " \
+      message = described_class.new(@args)
+      expect(message.pretext).to eq("test.user <http://url.com|commented on " \
+      "commit 5f163b2b> in <http://somewhere.com|project_name>: " \
       "*Added a commit message*")
       expected_attachments = [
           {
@@ -62,9 +62,9 @@ describe SlackService::NoteMessage, models: true do
     end
 
     it 'returns a message regarding notes on a merge request' do
-      message = SlackService::NoteMessage.new(@args)
-      expect(message.pretext).to eq("test.user <url|commented on " \
-      "merge request !30> in <somewhere.com|project_name>: " \
+      message = described_class.new(@args)
+      expect(message.pretext).to eq("test.user <http://url.com|commented on " \
+      "merge request !30> in <http://somewhere.com|project_name>: " \
       "*merge request title*")
       expected_attachments = [
           {
@@ -88,10 +88,10 @@ describe SlackService::NoteMessage, models: true do
     end
 
     it 'returns a message regarding notes on an issue' do
-      message = SlackService::NoteMessage.new(@args)
+      message = described_class.new(@args)
       expect(message.pretext).to eq(
-        "test.user <url|commented on " \
-        "issue #20> in <somewhere.com|project_name>: " \
+        "test.user <http://url.com|commented on " \
+        "issue #20> in <http://somewhere.com|project_name>: " \
         "*issue title*")
       expected_attachments = [
           {
@@ -114,9 +114,9 @@ describe SlackService::NoteMessage, models: true do
     end
 
     it 'returns a message regarding notes on a project snippet' do
-      message = SlackService::NoteMessage.new(@args)
-      expect(message.pretext).to eq("test.user <url|commented on " \
-      "snippet #5> in <somewhere.com|project_name>: " \
+      message = described_class.new(@args)
+      expect(message.pretext).to eq("test.user <http://url.com|commented on " \
+      "snippet #5> in <http://somewhere.com|project_name>: " \
       "*snippet title*")
       expected_attachments = [
           {
diff --git a/spec/models/project_services/chat_message/pipeline_message_spec.rb b/spec/models/project_services/chat_message/pipeline_message_spec.rb
new file mode 100644
index 00000000000..bf2a9616455
--- /dev/null
+++ b/spec/models/project_services/chat_message/pipeline_message_spec.rb
@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe ChatMessage::PipelineMessage do
+  subject { described_class.new(args) }
+  let(:user) { { name: 'hacker' } }
+
+  let(:args) do
+    {
+      object_attributes: {
+        id: 123,
+        sha: '97de212e80737a608d939f648d959671fb0a0142',
+        tag: false,
+        ref: 'develop',
+        status: status,
+        duration: duration
+      },
+      project: { path_with_namespace: 'project_name',
+                 web_url: 'http://example.gitlab.com' },
+      user: user
+    }
+  end
+
+  let(:message) { build_message }
+
+  context 'pipeline succeeded' do
+    let(:status) { 'success' }
+    let(:color) { 'good' }
+    let(:duration) { 10 }
+    let(:message) { build_message('passed') }
+
+    it 'returns a message with information about succeeded build' do
+      verify_message
+    end
+  end
+
+  context 'pipeline failed' do
+    let(:status) { 'failed' }
+    let(:color) { 'danger' }
+    let(:duration) { 10 }
+
+    it 'returns a message with information about failed build' do
+      verify_message
+    end
+
+    context 'when triggered by API therefore lacking user' do
+      let(:user) { nil }
+      let(:message) { build_message(status, 'API') }
+
+      it 'returns a message stating it is by API' do
+        verify_message
+      end
+    end
+  end
+
+  def verify_message
+    expect(subject.pretext).to be_empty
+    expect(subject.fallback).to eq(message)
+    expect(subject.attachments).to eq([text: message, color: color])
+  end
+
+  def build_message(status_text = status, name = user[:name])
+    "<http://example.gitlab.com|project_name>:" \
+    " Pipeline <http://example.gitlab.com/pipelines/123|#123>" \
+    " of <http://example.gitlab.com/commits/develop|develop> branch" \
+    " by #{name} #{status_text} in #{duration} #{'second'.pluralize(duration)}"
+  end
+end
diff --git a/spec/models/project_services/slack_service/push_message_spec.rb b/spec/models/project_services/chat_message/push_message_spec.rb
index 17cd05e24f1..24928873bad 100644
--- a/spec/models/project_services/slack_service/push_message_spec.rb
+++ b/spec/models/project_services/chat_message/push_message_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe SlackService::PushMessage, models: true do
-  subject { SlackService::PushMessage.new(args) }
+describe ChatMessage::PushMessage, models: true do
+  subject { described_class.new(args) }
 
   let(:args) do
     {
@@ -10,7 +10,7 @@ describe SlackService::PushMessage, models: true do
       project_name: 'project_name',
       ref: 'refs/heads/master',
       user_name: 'test.user',
-      project_url: 'url'
+      project_url: 'http://url.com'
     }
   end
 
@@ -19,20 +19,20 @@ describe SlackService::PushMessage, models: true do
   context 'push' do
     before do
       args[:commits] = [
-        { message: 'message1', url: 'url1', id: 'abcdefghijkl', author: { name: 'author1' } },
-        { message: 'message2', url: 'url2', id: '123456789012', author: { name: 'author2' } },
+        { message: 'message1', url: 'http://url1.com', id: 'abcdefghijkl', author: { name: 'author1' } },
+        { message: 'message2', url: 'http://url2.com', id: '123456789012', author: { name: 'author2' } },
       ]
     end
 
     it 'returns a message regarding pushes' do
       expect(subject.pretext).to eq(
-        'test.user pushed to branch <url/commits/master|master> of '\
-        '<url|project_name> (<url/compare/before...after|Compare changes>)'
+        'test.user pushed to branch <http://url.com/commits/master|master> of '\
+        '<http://url.com|project_name> (<http://url.com/compare/before...after|Compare changes>)'
       )
       expect(subject.attachments).to eq([
         {
-          text: "<url1|abcdefgh>: message1 - author1\n"\
-                "<url2|12345678>: message2 - author2",
+          text: "<http://url1.com|abcdefgh>: message1 - author1\n"\
+                "<http://url2.com|12345678>: message2 - author2",
           color: color,
         }
       ])
@@ -47,14 +47,14 @@ describe SlackService::PushMessage, models: true do
         project_name: 'project_name',
         ref: 'refs/tags/new_tag',
         user_name: 'test.user',
-        project_url: 'url'
+        project_url: 'http://url.com'
       }
     end
 
     it 'returns a message regarding pushes' do
       expect(subject.pretext).to eq('test.user pushed new tag ' \
-       '<url/commits/new_tag|new_tag> to ' \
-       '<url|project_name>')
+                                    '<http://url.com/commits/new_tag|new_tag> to ' \
+                                    '<http://url.com|project_name>')
       expect(subject.attachments).to be_empty
     end
   end
@@ -66,8 +66,8 @@ describe SlackService::PushMessage, models: true do
 
     it 'returns a message regarding a new branch' do
       expect(subject.pretext).to eq(
-        'test.user pushed new branch <url/commits/master|master> to '\
-        '<url|project_name>'
+        'test.user pushed new branch <http://url.com/commits/master|master> to '\
+        '<http://url.com|project_name>'
       )
       expect(subject.attachments).to be_empty
     end
@@ -80,7 +80,7 @@ describe SlackService::PushMessage, models: true do
 
     it 'returns a message regarding a removed branch' do
       expect(subject.pretext).to eq(
-        'test.user removed branch master from <url|project_name>'
+        'test.user removed branch master from <http://url.com|project_name>'
       )
       expect(subject.attachments).to be_empty
     end
diff --git a/spec/models/project_services/slack_service/wiki_page_message_spec.rb b/spec/models/project_services/chat_message/wiki_page_message_spec.rb
index 093911598b0..a2ad61e38e7 100644
--- a/spec/models/project_services/slack_service/wiki_page_message_spec.rb
+++ b/spec/models/project_services/chat_message/wiki_page_message_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe SlackService::WikiPageMessage, models: true do
+describe ChatMessage::WikiPageMessage, models: true do
   subject { described_class.new(args) }
 
   let(:args) do
@@ -10,10 +10,10 @@ describe SlackService::WikiPageMessage, models: true do
         username: 'test.user'
       },
       project_name: 'project_name',
-      project_url: 'somewhere.com',
+      project_url: 'http://somewhere.com',
       object_attributes: {
         title: 'Wiki page title',
-        url: 'url',
+        url: 'http://url.com',
         content: 'Wiki page description'
       }
     }
@@ -25,7 +25,7 @@ describe SlackService::WikiPageMessage, models: true do
 
       it 'returns a message that a new wiki page was created' do
         expect(subject.pretext).to eq(
-          'test.user created <url|wiki page> in <somewhere.com|project_name>: '\
+          'test.user created <http://url.com|wiki page> in <http://somewhere.com|project_name>: '\
           '*Wiki page title*')
       end
     end
@@ -35,7 +35,7 @@ describe SlackService::WikiPageMessage, models: true do
 
       it 'returns a message that a wiki page was updated' do
         expect(subject.pretext).to eq(
-          'test.user edited <url|wiki page> in <somewhere.com|project_name>: '\
+          'test.user edited <http://url.com|wiki page> in <http://somewhere.com|project_name>: '\
           '*Wiki page title*')
       end
     end
diff --git a/spec/models/project_services/chat_notification_service_spec.rb b/spec/models/project_services/chat_notification_service_spec.rb
new file mode 100644
index 00000000000..c98e7ee14fd
--- /dev/null
+++ b/spec/models/project_services/chat_notification_service_spec.rb
@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe ChatNotificationService, models: true do
+  describe "Associations" do
+    before do
+      allow(subject).to receive(:activated?).and_return(true)
+    end
+
+    it { is_expected.to validate_presence_of :webhook }
+  end
+end
diff --git a/spec/models/project_services/chat_service_spec.rb b/spec/models/project_services/chat_service_spec.rb
deleted file mode 100644
index c6a45a3e1be..00000000000
--- a/spec/models/project_services/chat_service_spec.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe ChatService, models: true do
-  describe "Associations" do
-    it { is_expected.to have_many :chat_names }
-  end
-
-  describe '#valid_token?' do
-    subject { described_class.new }
-
-    it 'is false as it has no token' do
-      expect(subject.valid_token?('wer')).to be_falsey
-    end
-  end
-end
diff --git a/spec/models/project_services/kubernetes_service_spec.rb b/spec/models/project_services/kubernetes_service_spec.rb
new file mode 100644
index 00000000000..4f3cd14e941
--- /dev/null
+++ b/spec/models/project_services/kubernetes_service_spec.rb
@@ -0,0 +1,218 @@
+require 'spec_helper'
+
+describe KubernetesService, models: true, caching: true do
+  include KubernetesHelpers
+  include ReactiveCachingHelpers
+
+  let(:project) { create(:kubernetes_project) }
+  let(:service) { project.kubernetes_service }
+
+  # We use Kubeclient to interactive with the Kubernetes API. It will
+  # GET /api/v1 for a list of resources the API supports. This must be stubbed
+  # in addition to any other HTTP requests we expect it to perform.
+  let(:discovery_url) { service.api_url + '/api/v1' }
+  let(:discovery_response) { { body: kube_discovery_body.to_json } }
+
+  let(:pods_url) { service.api_url + "/api/v1/namespaces/#{service.namespace}/pods" }
+  let(:pods_response) { { body: kube_pods_body(kube_pod).to_json } }
+
+  def stub_kubeclient_discover
+    WebMock.stub_request(:get, discovery_url).to_return(discovery_response)
+  end
+
+  def stub_kubeclient_pods
+    stub_kubeclient_discover
+    WebMock.stub_request(:get, pods_url).to_return(pods_response)
+  end
+
+  describe "Associations" do
+    it { is_expected.to belong_to :project }
+  end
+
+  describe 'Validations' do
+    context 'when service is active' do
+      before { subject.active = true }
+      it { is_expected.to validate_presence_of(:namespace) }
+      it { is_expected.to validate_presence_of(:api_url) }
+      it { is_expected.to validate_presence_of(:token) }
+
+      context 'namespace format' do
+        before do
+          subject.project = project
+          subject.api_url = "http://example.com"
+          subject.token = "test"
+        end
+
+        {
+          'foo'  => true,
+          '1foo' => true,
+          'foo1' => true,
+          'foo-bar' => true,
+          '-foo' => false,
+          'foo-' => false,
+          'a' * 63 => true,
+          'a' * 64 => false,
+          'a.b' => false,
+          'a*b' => false,
+        }.each do |namespace, validity|
+          it "should validate #{namespace} as #{validity ? 'valid' : 'invalid'}" do
+            subject.namespace = namespace
+
+            expect(subject.valid?).to eq(validity)
+          end
+        end
+      end
+    end
+
+    context 'when service is inactive' do
+      before { subject.active = false }
+      it { is_expected.not_to validate_presence_of(:namespace) }
+      it { is_expected.not_to validate_presence_of(:api_url) }
+      it { is_expected.not_to validate_presence_of(:token) }
+    end
+  end
+
+  describe '#initialize_properties' do
+    context 'with a project' do
+      it 'defaults to the project name' do
+        expect(described_class.new(project: project).namespace).to eq(project.name)
+      end
+    end
+
+    context 'without a project' do
+      it 'leaves the namespace unset' do
+        expect(described_class.new.namespace).to be_nil
+      end
+    end
+  end
+
+  describe '#test' do
+    before do
+      stub_kubeclient_discover
+    end
+
+    context 'with path prefix in api_url' do
+      let(:discovery_url) { 'https://kubernetes.example.com/prefix/api/v1' }
+
+      it 'tests with the prefix' do
+        service.api_url = 'https://kubernetes.example.com/prefix/'
+
+        expect(service.test[:success]).to be_truthy
+        expect(WebMock).to have_requested(:get, discovery_url).once
+      end
+    end
+
+    context 'with custom CA certificate' do
+      it 'is added to the certificate store' do
+        service.ca_pem = "CA PEM DATA"
+
+        cert = double("certificate")
+        expect(OpenSSL::X509::Certificate).to receive(:new).with(service.ca_pem).and_return(cert)
+        expect_any_instance_of(OpenSSL::X509::Store).to receive(:add_cert).with(cert)
+
+        expect(service.test[:success]).to be_truthy
+        expect(WebMock).to have_requested(:get, discovery_url).once
+      end
+    end
+
+    context 'success' do
+      it 'reads the discovery endpoint' do
+        expect(service.test[:success]).to be_truthy
+        expect(WebMock).to have_requested(:get, discovery_url).once
+      end
+    end
+
+    context 'failure' do
+      let(:discovery_response) { { status: 404 } }
+
+      it 'fails to read the discovery endpoint' do
+        expect(service.test[:success]).to be_falsy
+        expect(WebMock).to have_requested(:get, discovery_url).once
+      end
+    end
+  end
+
+  describe '#predefined_variables' do
+    before do
+      subject.api_url = 'https://kube.domain.com'
+      subject.token = 'token'
+      subject.namespace = 'my-project'
+      subject.ca_pem = 'CA PEM DATA'
+    end
+
+    it 'sets KUBE_URL' do
+      expect(subject.predefined_variables).to include(
+        { key: 'KUBE_URL', value: 'https://kube.domain.com', public: true }
+      )
+    end
+
+    it 'sets KUBE_TOKEN' do
+      expect(subject.predefined_variables).to include(
+        { key: 'KUBE_TOKEN', value: 'token', public: false }
+      )
+    end
+
+    it 'sets KUBE_NAMESPACE' do
+      expect(subject.predefined_variables).to include(
+        { key: 'KUBE_NAMESPACE', value: 'my-project', public: true }
+      )
+    end
+
+    it 'sets KUBE_CA_PEM' do
+      expect(subject.predefined_variables).to include(
+        { key: 'KUBE_CA_PEM', value: 'CA PEM DATA', public: true }
+      )
+    end
+  end
+
+  describe '#terminals' do
+    let(:environment) { build(:environment, project: project, name: "env", slug: "env-000000") }
+    subject { service.terminals(environment) }
+
+    context 'with invalid pods' do
+      it 'returns no terminals' do
+        stub_reactive_cache(service, pods: [ { "bad" => "pod" } ])
+
+        is_expected.to be_empty
+      end
+    end
+
+    context 'with valid pods' do
+      let(:pod) { kube_pod(app: environment.slug) }
+      let(:terminals) { kube_terminals(service, pod) }
+
+      it 'returns terminals' do
+        stub_reactive_cache(service, pods: [ pod, pod, kube_pod(app: "should-be-filtered-out") ])
+
+        is_expected.to eq(terminals + terminals)
+      end
+    end
+  end
+
+  describe '#calculate_reactive_cache' do
+    before { stub_kubeclient_pods }
+    subject { service.calculate_reactive_cache }
+
+    context 'when service is inactive' do
+      before { service.active = false }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when kubernetes responds with valid pods' do
+      it { is_expected.to eq(pods: [kube_pod]) }
+    end
+
+    context 'when kubernetes responds with 500' do
+      let(:pods_response) { { status: 500 } }
+
+      it { expect { subject }.to raise_error(KubeException) }
+    end
+
+    context 'when kubernetes responds with 404' do
+      let(:pods_response) { { status: 404 } }
+
+      it { is_expected.to eq(pods: []) }
+    end
+  end
+end
diff --git a/spec/models/project_services/mattermost_service_spec.rb b/spec/models/project_services/mattermost_service_spec.rb
new file mode 100644
index 00000000000..490d6aedffc
--- /dev/null
+++ b/spec/models/project_services/mattermost_service_spec.rb
@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe MattermostService, models: true do
+  it_behaves_like "slack or mattermost notifications"
+end
diff --git a/spec/models/project_services/mattermost_slash_commands_service_spec.rb b/spec/models/project_services/mattermost_slash_commands_service_spec.rb
index 4a1037e950b..c879edddfdd 100644
--- a/spec/models/project_services/mattermost_slash_commands_service_spec.rb
+++ b/spec/models/project_services/mattermost_slash_commands_service_spec.rb
@@ -1,97 +1,122 @@
 require 'spec_helper'
 
-describe MattermostSlashCommandsService, models: true do
-  describe "Associations" do
-    it { is_expected.to respond_to :token }
-  end
+describe MattermostSlashCommandsService, :models do
+  it_behaves_like "chat slash commands service"
 
-  describe '#valid_token?' do
-    subject { described_class.new }
+  context 'Mattermost API' do
+    let(:project) { create(:empty_project) }
+    let(:service) { project.build_mattermost_slash_commands_service }
+    let(:user) { create(:user) }
 
-    context 'when the token is empty' do
-      it 'is false' do
-        expect(subject.valid_token?('wer')).to be_falsey
-      end
+    before do
+      Mattermost::Session.base_uri("http://mattermost.example.com")
+
+      allow_any_instance_of(Mattermost::Client).to receive(:with_session).
+        and_yield(Mattermost::Session.new(nil))
     end
 
-    context 'when there is a token' do
-      before do
-        subject.token = '123'
+    describe '#configure' do
+      subject do
+        service.configure(user, team_id: 'abc',
+                                trigger: 'gitlab', url: 'http://trigger.url',
+                                icon_url: 'http://icon.url/icon.png')
       end
 
-      it 'accepts equal tokens' do
-        expect(subject.valid_token?('123')).to be_truthy
-      end
-    end
-  end
+      context 'the requests succeeds' do
+        before do
+          stub_request(:post, 'http://mattermost.example.com/api/v3/teams/abc/commands/create').
+            with(body: {
+              team_id: 'abc',
+              trigger: 'gitlab',
+              url: 'http://trigger.url',
+              icon_url: 'http://icon.url/icon.png',
+              auto_complete: true,
+              auto_complete_desc: "Perform common operations on: #{project.name_with_namespace}",
+              auto_complete_hint: '[help]',
+              description: "Perform common operations on: #{project.name_with_namespace}",
+              display_name: "GitLab / #{project.name_with_namespace}",
+              method: 'P',
+              username: 'GitLab' }.to_json).
+            to_return(
+              status: 200,
+              headers: { 'Content-Type' => 'application/json' },
+              body: { token: 'token' }.to_json
+            )
+        end
 
-  describe '#trigger' do
-    subject { described_class.new }
+        it 'saves the service' do
+          expect { subject }.to change { project.services.count }.by(1)
+        end
 
-    context 'no token is passed' do
-      let(:params) { Hash.new }
+        it 'saves the token' do
+          subject
 
-      it 'returns nil' do
-        expect(subject.trigger(params)).to be_nil
+          expect(service.reload.token).to eq('token')
+        end
       end
-    end
 
-    context 'with a token passed' do
-      let(:project) { create(:empty_project) }
-      let(:params) { { token: 'token' } }
-
-      before do
-        allow(subject).to receive(:token).and_return('token')
-      end
+      context 'an error is received' do
+        before do
+          stub_request(:post, 'http://mattermost.example.com/api/v3/teams/abc/commands/create').
+            to_return(
+              status: 500,
+              headers: { 'Content-Type' => 'application/json' },
+              body: {
+                id: 'api.command.duplicate_trigger.app_error',
+                message: 'This trigger word is already in use. Please choose another word.',
+                detailed_error: '',
+                request_id: 'obc374man7bx5r3dbc1q5qhf3r',
+                status_code: 500
+              }.to_json
+            )
+        end
 
-      context 'no user can be found' do
-        context 'when no url can be generated' do
-          it 'responds with the authorize url' do
-            response = subject.trigger(params)
+        it 'shows error messages' do
+          succeeded, message = subject
 
-            expect(response[:response_type]).to eq :ephemeral
-            expect(response[:text]).to start_with ":sweat_smile: Couldn't identify you"
-          end
+          expect(succeeded).to be(false)
+          expect(message).to eq('This trigger word is already in use. Please choose another word.')
         end
+      end
+    end
 
-        context 'when an auth url can be generated' do
-          let(:params) do
-            {
-              team_domain: 'http://domain.tld',
-              team_id: 'T3423423',
-              user_id: 'U234234',
-              user_name: 'mepmep',
-              token: 'token'
-            }
-          end
-
-          let(:service) do
-            project.create_mattermost_slash_commands_service(
-              properties: { token: 'token' }
-            )
-          end
+    describe '#list_teams' do
+      subject do
+        service.list_teams(user)
+      end
 
-          it 'generates the url' do
-            response = service.trigger(params)
+      context 'the requests succeeds' do
+        before do
+          stub_request(:get, 'http://mattermost.example.com/api/v3/teams/all').
+            to_return(
+              status: 200,
+              headers: { 'Content-Type' => 'application/json' },
+              body: ['list'].to_json
+            )
+        end
 
-            expect(response[:text]).to start_with(':wave: Hi there!')
-          end
+        it 'returns a list of teams' do
+          expect(subject).not_to be_empty
         end
       end
 
-      context 'when the user is authenticated' do
-        let!(:chat_name) { create(:chat_name, service: service) }
-        let(:service) do
-          project.create_mattermost_slash_commands_service(
-            properties: { token: 'token' }
-          )
+      context 'an error is received' do
+        before do
+          stub_request(:get, 'http://mattermost.example.com/api/v3/teams/all').
+            to_return(
+              status: 500,
+              headers: { 'Content-Type' => 'application/json' },
+              body: {
+                message: 'Failed to get team list.'
+              }.to_json
+            )
         end
-        let(:params) { { token: 'token', team_id: chat_name.team_id, user_id: chat_name.chat_id } }
 
-        it 'triggers the command' do
-          expect_any_instance_of(Gitlab::ChatCommands::Command).to receive(:execute)
+        it 'shows error messages' do
+          teams, message = subject
 
-          service.trigger(params)
+          expect(teams).to be_empty
+          expect(message).to eq('Failed to get team list.')
         end
       end
     end
diff --git a/spec/models/project_services/slack_service/pipeline_message_spec.rb b/spec/models/project_services/slack_service/pipeline_message_spec.rb
deleted file mode 100644
index 363138a9454..00000000000
--- a/spec/models/project_services/slack_service/pipeline_message_spec.rb
+++ /dev/null
@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe SlackService::PipelineMessage do
-  subject { SlackService::PipelineMessage.new(args) }
-
-  let(:args) do
-    {
-      object_attributes: {
-        id: 123,
-        sha: '97de212e80737a608d939f648d959671fb0a0142',
-        tag: false,
-        ref: 'develop',
-        status: status,
-        duration: duration
-      },
-      project: { path_with_namespace: 'project_name',
-                 web_url: 'example.gitlab.com' },
-      user: { name: 'hacker' }
-    }
-  end
-
-  let(:message) { build_message }
-
-  context 'pipeline succeeded' do
-    let(:status) { 'success' }
-    let(:color) { 'good' }
-    let(:duration) { 10 }
-    let(:message) { build_message('passed') }
-
-    it 'returns a message with information about succeeded build' do
-      expect(subject.pretext).to be_empty
-      expect(subject.fallback).to eq(message)
-      expect(subject.attachments).to eq([text: message, color: color])
-    end
-  end
-
-  context 'pipeline failed' do
-    let(:status) { 'failed' }
-    let(:color) { 'danger' }
-    let(:duration) { 10 }
-
-    it 'returns a message with information about failed build' do
-      expect(subject.pretext).to be_empty
-      expect(subject.fallback).to eq(message)
-      expect(subject.attachments).to eq([text: message, color: color])
-    end
-  end
-
-  def build_message(status_text = status)
-    "<example.gitlab.com|project_name>:" \
-    " Pipeline <example.gitlab.com/pipelines/123|#123>" \
-    " of <example.gitlab.com/commits/develop|develop> branch" \
-    " by hacker #{status_text} in #{duration} #{'second'.pluralize(duration)}"
-  end
-end
diff --git a/spec/models/project_services/slack_service_spec.rb b/spec/models/project_services/slack_service_spec.rb
index c07a70a8069..9a3ecc66d83 100644
--- a/spec/models/project_services/slack_service_spec.rb
+++ b/spec/models/project_services/slack_service_spec.rb
@@ -1,327 +1,5 @@
 require 'spec_helper'
 
 describe SlackService, models: true do
-  let(:slack) { SlackService.new }
-  let(:webhook_url) { 'https://example.gitlab.com/' }
-
-  describe "Associations" do
-    it { is_expected.to belong_to :project }
-    it { is_expected.to have_one :service_hook }
-  end
-
-  describe 'Validations' do
-    context 'when service is active' do
-      before { subject.active = true }
-
-      it { is_expected.to validate_presence_of(:webhook) }
-      it_behaves_like 'issue tracker service URL attribute', :webhook
-    end
-
-    context 'when service is inactive' do
-      before { subject.active = false }
-
-      it { is_expected.not_to validate_presence_of(:webhook) }
-    end
-  end
-
-  describe "Execute" do
-    let(:user)    { create(:user) }
-    let(:project) { create(:project) }
-    let(:username) { 'slack_username' }
-    let(:channel)  { 'slack_channel' }
-
-    let(:push_sample_data) do
-      Gitlab::DataBuilder::Push.build_sample(project, user)
-    end
-
-    before do
-      allow(slack).to receive_messages(
-        project: project,
-        project_id: project.id,
-        service_hook: true,
-        webhook: webhook_url
-      )
-
-      WebMock.stub_request(:post, webhook_url)
-
-      opts = {
-        title: 'Awesome issue',
-        description: 'please fix'
-      }
-
-      issue_service = Issues::CreateService.new(project, user, opts)
-      @issue = issue_service.execute
-      @issues_sample_data = issue_service.hook_data(@issue, 'open')
-
-      opts = {
-        title: 'Awesome merge_request',
-        description: 'please fix',
-        source_branch: 'feature',
-        target_branch: 'master'
-      }
-      merge_service = MergeRequests::CreateService.new(project,
-                                                       user, opts)
-      @merge_request = merge_service.execute
-      @merge_sample_data = merge_service.hook_data(@merge_request,
-                                                   'open')
-
-      opts = {
-        title: "Awesome wiki_page",
-        content: "Some text describing some thing or another",
-        format: "md",
-        message: "user created page: Awesome wiki_page"
-      }
-
-      wiki_page_service = WikiPages::CreateService.new(project, user, opts)
-      @wiki_page = wiki_page_service.execute
-      @wiki_page_sample_data = wiki_page_service.hook_data(@wiki_page, 'create')
-    end
-
-    it "calls Slack API for push events" do
-      slack.execute(push_sample_data)
-
-      expect(WebMock).to have_requested(:post, webhook_url).once
-    end
-
-    it "calls Slack API for issue events" do
-      slack.execute(@issues_sample_data)
-
-      expect(WebMock).to have_requested(:post, webhook_url).once
-    end
-
-    it "calls Slack API for merge requests events" do
-      slack.execute(@merge_sample_data)
-
-      expect(WebMock).to have_requested(:post, webhook_url).once
-    end
-
-    it "calls Slack API for wiki page events" do
-      slack.execute(@wiki_page_sample_data)
-
-      expect(WebMock).to have_requested(:post, webhook_url).once
-    end
-
-    it 'uses the username as an option for slack when configured' do
-      allow(slack).to receive(:username).and_return(username)
-      expect(Slack::Notifier).to receive(:new).
-       with(webhook_url, username: username).
-       and_return(
-         double(:slack_service).as_null_object
-       )
-
-      slack.execute(push_sample_data)
-    end
-
-    it 'uses the channel as an option when it is configured' do
-      allow(slack).to receive(:channel).and_return(channel)
-      expect(Slack::Notifier).to receive(:new).
-        with(webhook_url, channel: channel).
-        and_return(
-          double(:slack_service).as_null_object
-        )
-      slack.execute(push_sample_data)
-    end
-
-    context "event channels" do
-      it "uses the right channel for push event" do
-        slack.update_attributes(push_channel: "random")
-
-        expect(Slack::Notifier).to receive(:new).
-         with(webhook_url, channel: "random").
-         and_return(
-           double(:slack_service).as_null_object
-         )
-
-        slack.execute(push_sample_data)
-      end
-
-      it "uses the right channel for merge request event" do
-        slack.update_attributes(merge_request_channel: "random")
-
-        expect(Slack::Notifier).to receive(:new).
-         with(webhook_url, channel: "random").
-         and_return(
-           double(:slack_service).as_null_object
-         )
-
-        slack.execute(@merge_sample_data)
-      end
-
-      it "uses the right channel for issue event" do
-        slack.update_attributes(issue_channel: "random")
-
-        expect(Slack::Notifier).to receive(:new).
-         with(webhook_url, channel: "random").
-         and_return(
-           double(:slack_service).as_null_object
-         )
-
-        slack.execute(@issues_sample_data)
-      end
-
-      it "uses the right channel for wiki event" do
-        slack.update_attributes(wiki_page_channel: "random")
-
-        expect(Slack::Notifier).to receive(:new).
-         with(webhook_url, channel: "random").
-         and_return(
-           double(:slack_service).as_null_object
-         )
-
-        slack.execute(@wiki_page_sample_data)
-      end
-
-      context "note event" do
-        let(:issue_note) do
-          create(:note_on_issue, project: project, note: "issue note")
-        end
-
-        it "uses the right channel" do
-          slack.update_attributes(note_channel: "random")
-
-          note_data = Gitlab::DataBuilder::Note.build(issue_note, user)
-
-          expect(Slack::Notifier).to receive(:new).
-           with(webhook_url, channel: "random").
-           and_return(
-             double(:slack_service).as_null_object
-           )
-
-          slack.execute(note_data)
-        end
-      end
-    end
-  end
-
-  describe "Note events" do
-    let(:user) { create(:user) }
-    let(:project) { create(:project, creator_id: user.id) }
-
-    before do
-      allow(slack).to receive_messages(
-        project: project,
-        project_id: project.id,
-        service_hook: true,
-        webhook: webhook_url
-      )
-
-      WebMock.stub_request(:post, webhook_url)
-    end
-
-    context 'when commit comment event executed' do
-      let(:commit_note) do
-        create(:note_on_commit, author: user,
-                                project: project,
-                                commit_id: project.repository.commit.id,
-                                note: 'a comment on a commit')
-      end
-
-      it "calls Slack API for commit comment events" do
-        data = Gitlab::DataBuilder::Note.build(commit_note, user)
-        slack.execute(data)
-
-        expect(WebMock).to have_requested(:post, webhook_url).once
-      end
-    end
-
-    context 'when merge request comment event executed' do
-      let(:merge_request_note) do
-        create(:note_on_merge_request, project: project,
-                                       note: "merge request note")
-      end
-
-      it "calls Slack API for merge request comment events" do
-        data = Gitlab::DataBuilder::Note.build(merge_request_note, user)
-        slack.execute(data)
-
-        expect(WebMock).to have_requested(:post, webhook_url).once
-      end
-    end
-
-    context 'when issue comment event executed' do
-      let(:issue_note) do
-        create(:note_on_issue, project: project, note: "issue note")
-      end
-
-      it "calls Slack API for issue comment events" do
-        data = Gitlab::DataBuilder::Note.build(issue_note, user)
-        slack.execute(data)
-
-        expect(WebMock).to have_requested(:post, webhook_url).once
-      end
-    end
-
-    context 'when snippet comment event executed' do
-      let(:snippet_note) do
-        create(:note_on_project_snippet, project: project,
-                                         note: "snippet note")
-      end
-
-      it "calls Slack API for snippet comment events" do
-        data = Gitlab::DataBuilder::Note.build(snippet_note, user)
-        slack.execute(data)
-
-        expect(WebMock).to have_requested(:post, webhook_url).once
-      end
-    end
-  end
-
-  describe 'Pipeline events' do
-    let(:user) { create(:user) }
-    let(:project) { create(:project) }
-
-    let(:pipeline) do
-      create(:ci_pipeline,
-             project: project, status: status,
-             sha: project.commit.sha, ref: project.default_branch)
-    end
-
-    before do
-      allow(slack).to receive_messages(
-        project: project,
-        service_hook: true,
-        webhook: webhook_url
-      )
-    end
-
-    shared_examples 'call Slack API' do
-      before do
-        WebMock.stub_request(:post, webhook_url)
-      end
-
-      it 'calls Slack API for pipeline events' do
-        data = Gitlab::DataBuilder::Pipeline.build(pipeline)
-        slack.execute(data)
-
-        expect(WebMock).to have_requested(:post, webhook_url).once
-      end
-    end
-
-    context 'with failed pipeline' do
-      let(:status) { 'failed' }
-
-      it_behaves_like 'call Slack API'
-    end
-
-    context 'with succeeded pipeline' do
-      let(:status) { 'success' }
-
-      context 'with default to notify_only_broken_pipelines' do
-        it 'does not call Slack API for pipeline events' do
-          data = Gitlab::DataBuilder::Pipeline.build(pipeline)
-          result = slack.execute(data)
-
-          expect(result).to be_falsy
-        end
-      end
-
-      context 'with setting notify_only_broken_pipelines to false' do
-        before do
-          slack.notify_only_broken_pipelines = false
-        end
-
-        it_behaves_like 'call Slack API'
-      end
-    end
-  end
+  it_behaves_like "slack or mattermost notifications"
 end
diff --git a/spec/models/project_services/slack_slash_commands_service_spec.rb b/spec/models/project_services/slack_slash_commands_service_spec.rb
new file mode 100644
index 00000000000..5766aa340e2
--- /dev/null
+++ b/spec/models/project_services/slack_slash_commands_service_spec.rb
@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe SlackSlashCommandsService, :models do
+  it_behaves_like "chat slash commands service"
+
+  describe '#trigger' do
+    context 'when an auth url is generated' do
+      let(:project) { create(:empty_project) }
+      let(:params) do
+        {
+          team_domain: 'http://domain.tld',
+          team_id: 'T3423423',
+          user_id: 'U234234',
+          user_name: 'mepmep',
+          token: 'token'
+        }
+      end
+
+      let(:service) do
+        project.create_slack_slash_commands_service(
+          properties: { token: 'token' },
+          active: true
+        )
+      end
+
+      let(:authorize_url) do
+        'http://authorize.example.com/'
+      end
+
+      before do
+        allow(service).to receive(:authorize_chat_name_url).and_return(authorize_url)
+      end
+
+      it 'uses slack compatible links' do
+        response = service.trigger(params)
+
+        expect(response[:text]).to include("<#{authorize_url}|connect your GitLab account>")
+      end
+    end
+  end
+end
diff --git a/spec/models/project_spec.rb b/spec/models/project_spec.rb
index 21ff238841e..fb225eb7625 100644
--- a/spec/models/project_spec.rb
+++ b/spec/models/project_spec.rb
@@ -20,9 +20,9 @@ describe Project, models: true do
     it { is_expected.to have_many(:deploy_keys) }
     it { is_expected.to have_many(:hooks).dependent(:destroy) }
     it { is_expected.to have_many(:protected_branches).dependent(:destroy) }
-    it { is_expected.to have_many(:chat_services) }
     it { is_expected.to have_one(:forked_project_link).dependent(:destroy) }
     it { is_expected.to have_one(:slack_service).dependent(:destroy) }
+    it { is_expected.to have_one(:mattermost_service).dependent(:destroy) }
     it { is_expected.to have_one(:pushover_service).dependent(:destroy) }
     it { is_expected.to have_one(:asana_service).dependent(:destroy) }
     it { is_expected.to have_many(:boards).dependent(:destroy) }
@@ -36,6 +36,7 @@ describe Project, models: true do
     it { is_expected.to have_one(:hipchat_service).dependent(:destroy) }
     it { is_expected.to have_one(:flowdock_service).dependent(:destroy) }
     it { is_expected.to have_one(:assembla_service).dependent(:destroy) }
+    it { is_expected.to have_one(:slack_slash_commands_service).dependent(:destroy) }
     it { is_expected.to have_one(:mattermost_slash_commands_service).dependent(:destroy) }
     it { is_expected.to have_one(:gemnasium_service).dependent(:destroy) }
     it { is_expected.to have_one(:buildkite_service).dependent(:destroy) }
@@ -48,6 +49,7 @@ describe Project, models: true do
     it { is_expected.to have_one(:gitlab_issue_tracker_service).dependent(:destroy) }
     it { is_expected.to have_one(:external_wiki_service).dependent(:destroy) }
     it { is_expected.to have_one(:project_feature).dependent(:destroy) }
+    it { is_expected.to have_one(:statistics).class_name('ProjectStatistics').dependent(:delete) }
     it { is_expected.to have_one(:import_data).class_name('ProjectImportData').dependent(:destroy) }
     it { is_expected.to have_one(:last_event).class_name('Event') }
     it { is_expected.to have_one(:forked_from_project).through(:forked_project_link) }
@@ -1457,6 +1459,18 @@ describe Project, models: true do
     end
   end
 
+  describe '#gitlab_project_import?' do
+    subject(:project) { build(:project, import_type: 'gitlab_project') }
+
+    it { expect(project.gitlab_project_import?).to be true }
+  end
+
+  describe '#gitea_import?' do
+    subject(:project) { build(:project, import_type: 'gitea') }
+
+    it { expect(project.gitea_import?).to be true }
+  end
+
   describe '#lfs_enabled?' do
     let(:project) { create(:project) }
 
@@ -1696,6 +1710,46 @@ describe Project, models: true do
     end
   end
 
+  describe '#deployment_variables' do
+    context 'when project has no deployment service' do
+      let(:project) { create(:empty_project) }
+
+      it 'returns an empty array' do
+        expect(project.deployment_variables).to eq []
+      end
+    end
+
+    context 'when project has a deployment service' do
+      let(:project) { create(:kubernetes_project) }
+
+      it 'returns variables from this service' do
+        expect(project.deployment_variables).to include(
+          { key: 'KUBE_TOKEN', value: project.kubernetes_service.token, public: false }
+        )
+      end
+    end
+  end
+
+  describe '#update_project_statistics' do
+    let(:project) { create(:empty_project) }
+
+    it "is called after creation" do
+      expect(project.statistics).to be_a ProjectStatistics
+      expect(project.statistics).to be_persisted
+    end
+
+    it "copies the namespace_id" do
+      expect(project.statistics.namespace_id).to eq project.namespace_id
+    end
+
+    it "updates the namespace_id when changed" do
+      namespace = create(:namespace)
+      project.update(namespace: namespace)
+
+      expect(project.statistics.namespace_id).to eq namespace.id
+    end
+  end
+
   def enable_lfs
     allow(Gitlab.config.lfs).to receive(:enabled).and_return(true)
   end
diff --git a/spec/models/project_statistics_spec.rb b/spec/models/project_statistics_spec.rb
new file mode 100644
index 00000000000..77403cc9eb0
--- /dev/null
+++ b/spec/models/project_statistics_spec.rb
@@ -0,0 +1,160 @@
+require 'rails_helper'
+
+describe ProjectStatistics, models: true do
+  let(:project) { create :empty_project }
+  let(:statistics) { project.statistics }
+
+  describe 'constants' do
+    describe 'STORAGE_COLUMNS' do
+      it 'is an array of symbols' do
+        expect(described_class::STORAGE_COLUMNS).to be_kind_of Array
+        expect(described_class::STORAGE_COLUMNS.map(&:class).uniq).to eq [Symbol]
+      end
+    end
+
+    describe 'STATISTICS_COLUMNS' do
+      it 'is an array of symbols' do
+        expect(described_class::STATISTICS_COLUMNS).to be_kind_of Array
+        expect(described_class::STATISTICS_COLUMNS.map(&:class).uniq).to eq [Symbol]
+      end
+
+      it 'includes all storage columns' do
+        expect(described_class::STATISTICS_COLUMNS & described_class::STORAGE_COLUMNS).to eq described_class::STORAGE_COLUMNS
+      end
+    end
+  end
+
+  describe 'associations' do
+    it { is_expected.to belong_to(:project) }
+    it { is_expected.to belong_to(:namespace) }
+  end
+
+  describe 'statistics columns' do
+    it "support values up to 8 exabytes" do
+      statistics.update!(
+        commit_count: 8.exabytes - 1,
+        repository_size: 2.exabytes,
+        lfs_objects_size: 2.exabytes,
+        build_artifacts_size: 4.exabytes - 1,
+      )
+
+      statistics.reload
+
+      expect(statistics.commit_count).to eq(8.exabytes - 1)
+      expect(statistics.repository_size).to eq(2.exabytes)
+      expect(statistics.lfs_objects_size).to eq(2.exabytes)
+      expect(statistics.build_artifacts_size).to eq(4.exabytes - 1)
+      expect(statistics.storage_size).to eq(8.exabytes - 1)
+    end
+  end
+
+  describe '#total_repository_size' do
+    it "sums repository and LFS object size" do
+      statistics.repository_size = 2
+      statistics.lfs_objects_size = 3
+      statistics.build_artifacts_size = 4
+
+      expect(statistics.total_repository_size).to eq 5
+    end
+  end
+
+  describe '#refresh!' do
+    before do
+      allow(statistics).to receive(:update_commit_count)
+      allow(statistics).to receive(:update_repository_size)
+      allow(statistics).to receive(:update_lfs_objects_size)
+      allow(statistics).to receive(:update_build_artifacts_size)
+      allow(statistics).to receive(:update_storage_size)
+    end
+
+    context "without arguments" do
+      before do
+        statistics.refresh!
+      end
+
+      it "sums all counters" do
+        expect(statistics).to have_received(:update_commit_count)
+        expect(statistics).to have_received(:update_repository_size)
+        expect(statistics).to have_received(:update_lfs_objects_size)
+        expect(statistics).to have_received(:update_build_artifacts_size)
+      end
+    end
+
+    context "when passing an only: argument" do
+      before do
+        statistics.refresh! only: [:lfs_objects_size]
+      end
+
+      it "only updates the given columns" do
+        expect(statistics).to have_received(:update_lfs_objects_size)
+        expect(statistics).not_to have_received(:update_commit_count)
+        expect(statistics).not_to have_received(:update_repository_size)
+        expect(statistics).not_to have_received(:update_build_artifacts_size)
+      end
+    end
+  end
+
+  describe '#update_commit_count' do
+    before do
+      allow(project.repository).to receive(:commit_count).and_return(23)
+      statistics.update_commit_count
+    end
+
+    it "stores the number of commits in the repository" do
+      expect(statistics.commit_count).to eq 23
+    end
+  end
+
+  describe '#update_repository_size' do
+    before do
+      allow(project.repository).to receive(:size).and_return(12.megabytes)
+      statistics.update_repository_size
+    end
+
+    it "stores the size of the repository" do
+      expect(statistics.repository_size).to eq 12.megabytes
+    end
+  end
+
+  describe '#update_lfs_objects_size' do
+    let!(:lfs_object1) { create(:lfs_object, size: 23.megabytes) }
+    let!(:lfs_object2) { create(:lfs_object, size: 34.megabytes) }
+    let!(:lfs_objects_project1) { create(:lfs_objects_project, project: project, lfs_object: lfs_object1) }
+    let!(:lfs_objects_project2) { create(:lfs_objects_project, project: project, lfs_object: lfs_object2) }
+
+    before do
+      statistics.update_lfs_objects_size
+    end
+
+    it "stores the size of related LFS objects" do
+      expect(statistics.lfs_objects_size).to eq 57.megabytes
+    end
+  end
+
+  describe '#update_build_artifacts_size' do
+    let!(:pipeline) { create(:ci_pipeline, project: project) }
+    let!(:build1) { create(:ci_build, pipeline: pipeline, artifacts_size: 45.megabytes) }
+    let!(:build2) { create(:ci_build, pipeline: pipeline, artifacts_size: 56.megabytes) }
+
+    before do
+      statistics.update_build_artifacts_size
+    end
+
+    it "stores the size of related build artifacts" do
+      expect(statistics.build_artifacts_size).to eq 101.megabytes
+    end
+  end
+
+  describe '#update_storage_size' do
+    it "sums all storage counters" do
+      statistics.update!(
+        repository_size: 2,
+        lfs_objects_size: 3,
+      )
+
+      statistics.reload
+
+      expect(statistics.storage_size).to eq 5
+    end
+  end
+end
diff --git a/spec/models/repository_spec.rb b/spec/models/repository_spec.rb
index 65e96351033..b1fee342b57 100644
--- a/spec/models/repository_spec.rb
+++ b/spec/models/repository_spec.rb
@@ -139,6 +139,22 @@ describe Repository, models: true do
     it { is_expected.to eq('c1acaa58bbcbc3eafe538cb8274ba387047b69f8') }
   end
 
+  describe '#last_commit_id_for_path' do
+    subject { repository.last_commit_id_for_path(sample_commit.id, '.gitignore') }
+
+    it "returns last commit id for a given path" do
+      is_expected.to eq('c1acaa58bbcbc3eafe538cb8274ba387047b69f8')
+    end
+
+    it "caches last commit id for a given path" do
+      cache = repository.send(:cache)
+      key = "last_commit_id_for_path:#{sample_commit.id}:#{Digest::SHA1.hexdigest('.gitignore')}"
+
+      expect(cache).to receive(:fetch).with(key).and_return('c1acaa5')
+      is_expected.to eq('c1acaa5')
+    end
+  end
+
   describe '#find_commits_by_message' do
     it 'returns commits with messages containing a given string' do
       commit_ids = repository.find_commits_by_message('submodule').map(&:id)
diff --git a/spec/models/route_spec.rb b/spec/models/route_spec.rb
index 6f491fdf9a0..8481a9bef16 100644
--- a/spec/models/route_spec.rb
+++ b/spec/models/route_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Route, models: true do
-  let!(:group) { create(:group) }
+  let!(:group) { create(:group, path: 'gitlab') }
   let!(:route) { group.route }
 
   describe 'relationships' do
@@ -17,13 +17,15 @@ describe Route, models: true do
   describe '#rename_children' do
     let!(:nested_group) { create(:group, path: "test", parent: group) }
     let!(:deep_nested_group) { create(:group, path: "foo", parent: nested_group) }
+    let!(:similar_group) { create(:group, path: 'gitlab-org') }
 
-    it "updates children routes with new path" do
-      route.update_attributes(path: 'bar')
+    before { route.update_attributes(path: 'bar') }
 
+    it "updates children routes with new path" do
       expect(described_class.exists?(path: 'bar')).to be_truthy
       expect(described_class.exists?(path: 'bar/test')).to be_truthy
       expect(described_class.exists?(path: 'bar/test/foo')).to be_truthy
+      expect(described_class.exists?(path: 'gitlab-org')).to be_truthy
     end
   end
 end
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index bad6ed9e146..8b20ee81614 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -727,17 +727,6 @@ describe User, models: true do
     end
   end
 
-  describe 'by_username_or_id' do
-    let(:user1) { create(:user, username: 'foo') }
-
-    it "gets the correct user" do
-      expect(User.by_username_or_id(user1.id)).to eq(user1)
-      expect(User.by_username_or_id('foo')).to eq(user1)
-      expect(User.by_username_or_id(-1)).to be_nil
-      expect(User.by_username_or_id('bar')).to be_nil
-    end
-  end
-
   describe '.find_by_ssh_key_id' do
     context 'using an existing SSH key ID' do
       let(:user) { create(:user) }