15 files changed, 479 insertions, 105 deletions

diff --git a/spec/models/application_setting_spec.rb b/spec/models/application_setting_spec.rb
index 0b7e16cc33c..ef480e7a80a 100644
--- a/spec/models/application_setting_spec.rb
+++ b/spec/models/application_setting_spec.rb
@@ -115,9 +115,8 @@ describe ApplicationSetting do
     end
 
     context 'circuitbreaker settings' do
-      [:circuitbreaker_backoff_threshold,
-       :circuitbreaker_failure_count_threshold,
-       :circuitbreaker_failure_wait_time,
+      [:circuitbreaker_failure_count_threshold,
+       :circuitbreaker_check_interval,
        :circuitbreaker_failure_reset_time,
        :circuitbreaker_storage_timeout].each do |field|
         it "Validates #{field} as number" do
@@ -126,16 +125,6 @@ describe ApplicationSetting do
                            .is_greater_than_or_equal_to(0)
         end
       end
-
-      it 'requires the `backoff_threshold` to be lower than the `failure_count_threshold`' do
-        setting.circuitbreaker_failure_count_threshold = 10
-        setting.circuitbreaker_backoff_threshold = 15
-        failure_message = "The circuitbreaker backoff threshold should be lower "\
-                          "than the failure count threshold"
-
-        expect(setting).not_to be_valid
-        expect(setting.errors[:circuitbreaker_backoff_threshold]).to include(failure_message)
-      end
     end
 
     context 'repository storages' do
diff --git a/spec/models/ci/build_spec.rb b/spec/models/ci/build_spec.rb
index a6258676767..871e8b47650 100644
--- a/spec/models/ci/build_spec.rb
+++ b/spec/models/ci/build_spec.rb
@@ -132,11 +132,9 @@ describe Ci::Build do
   end
 
   describe '#artifacts?' do
-    context 'when new artifacts are used' do
-      let(:build) { create(:ci_build, :artifacts) }
-
-      subject { build.artifacts? }
+    subject { build.artifacts? }
 
+    context 'when new artifacts are used' do
       context 'artifacts archive does not exist' do
         let(:build) { create(:ci_build) }
 
@@ -144,25 +142,19 @@ describe Ci::Build do
       end
 
       context 'artifacts archive exists' do
+        let(:build) { create(:ci_build, :artifacts) }
+
         it { is_expected.to be_truthy }
 
         context 'is expired' do
-          let!(:build) { create(:ci_build, :artifacts, :expired) }
+          let(:build) { create(:ci_build, :artifacts, :expired) }
 
           it { is_expected.to be_falsy }
         end
-
-        context 'is not expired' do
-          it { is_expected.to be_truthy }
-        end
       end
     end
 
     context 'when legacy artifacts are used' do
-      let(:build) { create(:ci_build, :legacy_artifacts) }
-
-      subject { build.artifacts? }
-
       context 'artifacts archive does not exist' do
         let(:build) { create(:ci_build) }
 
@@ -170,17 +162,15 @@ describe Ci::Build do
       end
 
       context 'artifacts archive exists' do
+        let(:build) { create(:ci_build, :legacy_artifacts) }
+
         it { is_expected.to be_truthy }
 
         context 'is expired' do
-          let!(:build) { create(:ci_build, :legacy_artifacts, :expired) }
+          let(:build) { create(:ci_build, :legacy_artifacts, :expired) }
 
           it { is_expected.to be_falsy }
         end
-
-        context 'is not expired' do
-          it { is_expected.to be_truthy }
-        end
       end
     end
   end
@@ -1871,9 +1861,9 @@ describe Ci::Build do
   describe 'state transition: any => [:running]' do
     shared_examples 'validation is active' do
       context 'when depended job has not been completed yet' do
-        let!(:pre_stage_job) { create(:ci_build, :running, pipeline: pipeline, name: 'test', stage_idx: 0) }
+        let!(:pre_stage_job) { create(:ci_build, :manual, pipeline: pipeline, name: 'test', stage_idx: 0) }
 
-        it { expect { job.run! }.to raise_error(Ci::Build::MissingDependenciesError) }
+        it { expect { job.run! }.not_to raise_error(Ci::Build::MissingDependenciesError) }
       end
 
       context 'when artifacts of depended job has been expired' do
@@ -1895,11 +1885,10 @@ describe Ci::Build do
 
     shared_examples 'validation is not active' do
       context 'when depended job has not been completed yet' do
-        let!(:pre_stage_job) { create(:ci_build, :running, pipeline: pipeline, name: 'test', stage_idx: 0) }
+        let!(:pre_stage_job) { create(:ci_build, :manual, pipeline: pipeline, name: 'test', stage_idx: 0) }
 
         it { expect { job.run! }.not_to raise_error }
       end
-
       context 'when artifacts of depended job has been expired' do
         let!(:pre_stage_job) { create(:ci_build, :success, :expired, pipeline: pipeline, name: 'test', stage_idx: 0) }
 
diff --git a/spec/models/ci/pipeline_spec.rb b/spec/models/ci/pipeline_spec.rb
index bb89e093890..a1f63a2534b 100644
--- a/spec/models/ci/pipeline_spec.rb
+++ b/spec/models/ci/pipeline_spec.rb
@@ -116,7 +116,7 @@ describe Ci::Pipeline, :mailer do
     end
 
     it "calculates average when there is one build without coverage" do
-      FactoryGirl.create(:ci_build, pipeline: pipeline)
+      FactoryBot.create(:ci_build, pipeline: pipeline)
       expect(pipeline.coverage).to be_nil
     end
   end
@@ -435,7 +435,7 @@ describe Ci::Pipeline, :mailer do
 
     describe 'merge request metrics' do
       let(:project) { create(:project, :repository) }
-      let(:pipeline) { FactoryGirl.create(:ci_empty_pipeline, status: 'created', project: project, ref: 'master', sha: project.repository.commit('master').id) }
+      let(:pipeline) { FactoryBot.create(:ci_empty_pipeline, status: 'created', project: project, ref: 'master', sha: project.repository.commit('master').id) }
       let!(:merge_request) { create(:merge_request, source_project: project, source_branch: pipeline.ref) }
 
       before do
@@ -1530,4 +1530,16 @@ describe Ci::Pipeline, :mailer do
       expect(query_count).to eq(1)
     end
   end
+
+  describe '#total_size' do
+    let!(:build_job1) { create(:ci_build, pipeline: pipeline, stage_idx: 0) }
+    let!(:build_job2) { create(:ci_build, pipeline: pipeline, stage_idx: 0) }
+    let!(:test_job_failed_and_retried) { create(:ci_build, :failed, :retried, pipeline: pipeline, stage_idx: 1) }
+    let!(:second_test_job) { create(:ci_build, pipeline: pipeline, stage_idx: 1) }
+    let!(:deploy_job) { create(:ci_build, pipeline: pipeline, stage_idx: 2) }
+
+    it 'returns all jobs (including failed and retried)' do
+      expect(pipeline.total_size).to eq(5)
+    end
+  end
 end
diff --git a/spec/models/ci/runner_spec.rb b/spec/models/ci/runner_spec.rb
index a93e7e233a8..b2b64e6ff48 100644
--- a/spec/models/ci/runner_spec.rb
+++ b/spec/models/ci/runner_spec.rb
@@ -51,24 +51,24 @@ describe Ci::Runner do
 
   describe '#display_name' do
     it 'returns the description if it has a value' do
-      runner = FactoryGirl.build(:ci_runner, description: 'Linux/Ruby-1.9.3-p448')
+      runner = FactoryBot.build(:ci_runner, description: 'Linux/Ruby-1.9.3-p448')
       expect(runner.display_name).to eq 'Linux/Ruby-1.9.3-p448'
     end
 
     it 'returns the token if it does not have a description' do
-      runner = FactoryGirl.create(:ci_runner)
+      runner = FactoryBot.create(:ci_runner)
       expect(runner.display_name).to eq runner.description
     end
 
     it 'returns the token if the description is an empty string' do
-      runner = FactoryGirl.build(:ci_runner, description: '', token: 'token')
+      runner = FactoryBot.build(:ci_runner, description: '', token: 'token')
       expect(runner.display_name).to eq runner.token
     end
   end
 
   describe '#assign_to' do
-    let!(:project) { FactoryGirl.create :project }
-    let!(:shared_runner) { FactoryGirl.create(:ci_runner, :shared) }
+    let!(:project) { FactoryBot.create :project }
+    let!(:shared_runner) { FactoryBot.create(:ci_runner, :shared) }
 
     before do
       shared_runner.assign_to(project)
@@ -83,15 +83,15 @@ describe Ci::Runner do
     subject { described_class.online }
 
     before do
-      @runner1 = FactoryGirl.create(:ci_runner, :shared, contacted_at: 1.year.ago)
-      @runner2 = FactoryGirl.create(:ci_runner, :shared, contacted_at: 1.second.ago)
+      @runner1 = FactoryBot.create(:ci_runner, :shared, contacted_at: 1.year.ago)
+      @runner2 = FactoryBot.create(:ci_runner, :shared, contacted_at: 1.second.ago)
     end
 
     it { is_expected.to eq([@runner2])}
   end
 
   describe '#online?' do
-    let(:runner) { FactoryGirl.create(:ci_runner, :shared) }
+    let(:runner) { FactoryBot.create(:ci_runner, :shared) }
 
     subject { runner.online? }
 
@@ -268,7 +268,7 @@ describe Ci::Runner do
   end
 
   describe '#status' do
-    let(:runner) { FactoryGirl.create(:ci_runner, :shared, contacted_at: 1.second.ago) }
+    let(:runner) { FactoryBot.create(:ci_runner, :shared, contacted_at: 1.second.ago) }
 
     subject { runner.status }
 
@@ -442,9 +442,9 @@ describe Ci::Runner do
 
   describe "belongs_to_one_project?" do
     it "returns false if there are two projects runner assigned to" do
-      runner = FactoryGirl.create(:ci_runner)
-      project = FactoryGirl.create(:project)
-      project1 = FactoryGirl.create(:project)
+      runner = FactoryBot.create(:ci_runner)
+      project = FactoryBot.create(:project)
+      project1 = FactoryBot.create(:project)
       project.runners << runner
       project1.runners << runner
 
@@ -452,8 +452,8 @@ describe Ci::Runner do
     end
 
     it "returns true" do
-      runner = FactoryGirl.create(:ci_runner)
-      project = FactoryGirl.create(:project)
+      runner = FactoryBot.create(:ci_runner)
+      project = FactoryBot.create(:project)
       project.runners << runner
 
       expect(runner.belongs_to_one_project?).to be_truthy
diff --git a/spec/models/concerns/cache_markdown_field_spec.rb b/spec/models/concerns/cache_markdown_field_spec.rb
index 129dfa07f15..3c7f578975b 100644
--- a/spec/models/concerns/cache_markdown_field_spec.rb
+++ b/spec/models/concerns/cache_markdown_field_spec.rb
@@ -102,6 +102,26 @@ describe CacheMarkdownField do
     it { expect(thing.cached_markdown_version).to eq(CacheMarkdownField::CACHE_VERSION) }
   end
 
+  context 'when a markdown field is set repeatedly to an empty string' do
+    it do
+      expect(thing).to receive(:refresh_markdown_cache).once
+      thing.foo = ''
+      thing.save
+      thing.foo = ''
+      thing.save
+    end
+  end
+
+  context 'when a markdown field is set repeatedly to a string which renders as empty html' do
+    it do
+      expect(thing).to receive(:refresh_markdown_cache).once
+      thing.foo = '[//]: # (This is also a comment.)'
+      thing.save
+      thing.foo = '[//]: # (This is also a comment.)'
+      thing.save
+    end
+  end
+
   context 'a non-markdown field changed' do
     before do
       thing.bar = 'OK'
diff --git a/spec/models/deployment_spec.rb b/spec/models/deployment_spec.rb
index c5708e70ef9..ba8aa13d5ad 100644
--- a/spec/models/deployment_spec.rb
+++ b/spec/models/deployment_spec.rb
@@ -126,7 +126,7 @@ describe Deployment do
     subject { deployment.stop_action }
 
     context 'when no other actions' do
-      let(:deployment) { FactoryGirl.build(:deployment, deployable: build) }
+      let(:deployment) { FactoryBot.build(:deployment, deployable: build) }
 
       it { is_expected.to be_nil }
     end
@@ -135,13 +135,13 @@ describe Deployment do
       let!(:close_action) { create(:ci_build, :manual, pipeline: build.pipeline, name: 'close_app') }
 
       context 'when matching action is defined' do
-        let(:deployment) { FactoryGirl.build(:deployment, deployable: build, on_stop: 'close_other_app') }
+        let(:deployment) { FactoryBot.build(:deployment, deployable: build, on_stop: 'close_other_app') }
 
         it { is_expected.to be_nil }
       end
 
       context 'when no matching action is defined' do
-        let(:deployment) { FactoryGirl.build(:deployment, deployable: build, on_stop: 'close_app') }
+        let(:deployment) { FactoryBot.build(:deployment, deployable: build, on_stop: 'close_app') }
 
         it { is_expected.to eq(close_action) }
       end
@@ -159,7 +159,7 @@ describe Deployment do
 
     context 'when matching action is defined' do
       let(:build) { create(:ci_build) }
-      let(:deployment) { FactoryGirl.build(:deployment, deployable: build, on_stop: 'close_app') }
+      let(:deployment) { FactoryBot.build(:deployment, deployable: build, on_stop: 'close_app') }
       let!(:close_action) { create(:ci_build, :manual, pipeline: build.pipeline, name: 'close_app') }
 
       it { is_expected.to be_truthy }
diff --git a/spec/models/merge_request_spec.rb b/spec/models/merge_request_spec.rb
index 30a5a3bbff7..bb63abd167b 100644
--- a/spec/models/merge_request_spec.rb
+++ b/spec/models/merge_request_spec.rb
@@ -124,6 +124,7 @@ describe MergeRequest do
     context 'when the target branch does not exist' do
       before do
         project.repository.rm_branch(subject.author, subject.target_branch)
+        subject.clear_memoized_shas
       end
 
       it 'returns nil' do
@@ -600,30 +601,30 @@ describe MergeRequest do
   end
 
   describe '#can_remove_source_branch?' do
-    let(:user) { create(:user) }
-    let(:user2) { create(:user) }
+    set(:user) { create(:user) }
+    set(:merge_request) { create(:merge_request, :simple) }
 
-    before do
-      subject.source_project.team << [user, :master]
+    subject { merge_request }
 
-      subject.source_branch = "feature"
-      subject.target_branch = "master"
-      subject.save!
+    before do
+      subject.source_project.add_master(user)
     end
 
     it "can't be removed when its a protected branch" do
       allow(ProtectedBranch).to receive(:protected?).and_return(true)
+
       expect(subject.can_remove_source_branch?(user)).to be_falsey
     end
 
     it "can't remove a root ref" do
-      subject.source_branch = "master"
-      subject.target_branch = "feature"
+      subject.update(source_branch: 'master', target_branch: 'feature')
 
       expect(subject.can_remove_source_branch?(user)).to be_falsey
     end
 
     it "is unable to remove the source branch for a project the user cannot push to" do
+      user2 = create(:user)
+
       expect(subject.can_remove_source_branch?(user2)).to be_falsey
     end
 
@@ -634,6 +635,7 @@ describe MergeRequest do
     end
 
     it "cannot be removed if the last commit is not also the head of the source branch" do
+      subject.clear_memoized_shas
       subject.source_branch = "lfs"
 
       expect(subject.can_remove_source_branch?(user)).to be_falsey
@@ -733,7 +735,7 @@ describe MergeRequest do
 
       before do
         project.repository.raw_repository.delete_branch(subject.target_branch)
-        subject.reload
+        subject.clear_memoized_shas
       end
 
       it 'does not crash' do
@@ -1404,6 +1406,16 @@ describe MergeRequest do
 
       subject.reload_diff
     end
+
+    context 'when using the after_update hook to update' do
+      context 'when the branches are updated' do
+        it 'uses the new heads to generate the diff' do
+          expect { subject.update!(source_branch: subject.target_branch, target_branch: subject.source_branch) }
+            .to change { subject.merge_request_diff.start_commit_sha }
+            .and change { subject.merge_request_diff.head_commit_sha }
+        end
+      end
+    end
   end
 
   describe '#update_diff_discussion_positions' do
@@ -1468,6 +1480,7 @@ describe MergeRequest do
     context 'when the target branch does not exist' do
       before do
         subject.project.repository.rm_branch(subject.author, subject.target_branch)
+        subject.clear_memoized_shas
       end
 
       it 'returns nil' do
@@ -1855,4 +1868,20 @@ describe MergeRequest do
   it_behaves_like 'throttled touch' do
     subject { create(:merge_request, updated_at: 1.hour.ago) }
   end
+
+  context 'state machine transitions' do
+    describe '#unlock_mr' do
+      subject { create(:merge_request, state: 'locked', merge_jid: 123) }
+
+      it 'updates merge request head pipeline and sets merge_jid to nil' do
+        pipeline = create(:ci_empty_pipeline, project: subject.project, ref: subject.source_branch, sha: subject.source_branch_sha)
+
+        subject.unlock_mr
+
+        subject.reload
+        expect(subject.head_pipeline).to eq(pipeline)
+        expect(subject.merge_jid).to be_nil
+      end
+    end
+  end
 end
diff --git a/spec/models/namespace_spec.rb b/spec/models/namespace_spec.rb
index 3817f20bfe7..b7c6286fd83 100644
--- a/spec/models/namespace_spec.rb
+++ b/spec/models/namespace_spec.rb
@@ -559,4 +559,34 @@ describe Namespace do
       end
     end
   end
+
+  describe "#allowed_path_by_redirects" do
+    let(:namespace1) { create(:namespace, path: 'foo') }
+
+    context "when the path has been taken before" do
+      before do
+        namespace1.path = 'bar'
+        namespace1.save!
+      end
+
+      it 'should be invalid' do
+        namespace2 = build(:group, path: 'foo')
+        expect(namespace2).to be_invalid
+      end
+
+      it 'should return an error on path' do
+        namespace2 = build(:group, path: 'foo')
+        namespace2.valid?
+        expect(namespace2.errors.messages[:path].first).to eq('foo has been taken before. Please use another one')
+      end
+    end
+
+    context "when the path has not been taken before" do
+      it 'should be valid' do
+        expect(RedirectRoute.count).to eq(0)
+        namespace = build(:namespace)
+        expect(namespace).to be_valid
+      end
+    end
+  end
 end
diff --git a/spec/models/note_spec.rb b/spec/models/note_spec.rb
index e1a0c55b6a6..cefbf60b28c 100644
--- a/spec/models/note_spec.rb
+++ b/spec/models/note_spec.rb
@@ -756,6 +756,28 @@ describe Note do
     end
   end
 
+  describe '#references' do
+    context 'when part of a discussion' do
+      it 'references all earlier notes in the discussion' do
+        first_note = create(:discussion_note_on_issue)
+        second_note = create(:discussion_note_on_issue, in_reply_to: first_note)
+        third_note = create(:discussion_note_on_issue, in_reply_to: second_note)
+        create(:discussion_note_on_issue, in_reply_to: third_note)
+
+        expect(third_note.references).to eq([first_note.noteable, first_note, second_note])
+      end
+    end
+
+    context 'when not part of a discussion' do
+      subject { create(:note) }
+      let(:note) { create(:note, in_reply_to: subject) }
+
+      it 'returns the noteable' do
+        expect(note.references).to eq([note.noteable])
+      end
+    end
+  end
+
   describe 'expiring ETag cache' do
     let(:note) { build(:note_on_issue) }
 
diff --git a/spec/models/personal_access_token_spec.rb b/spec/models/personal_access_token_spec.rb
index 01440b15674..2bb1c49b740 100644
--- a/spec/models/personal_access_token_spec.rb
+++ b/spec/models/personal_access_token_spec.rb
@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe PersonalAccessToken do
+  subject { described_class }
+
   describe '.build' do
     let(:personal_access_token) { build(:personal_access_token) }
     let(:invalid_personal_access_token) { build(:personal_access_token, :invalid) }
@@ -45,6 +47,29 @@ describe PersonalAccessToken do
     end
   end
 
+  describe 'Redis storage' do
+    let(:user_id) { 123 }
+    let(:token) { 'abc000foo' }
+
+    before do
+      subject.redis_store!(user_id, token)
+    end
+
+    it 'returns stored data' do
+      expect(subject.redis_getdel(user_id)).to eq(token)
+    end
+
+    context 'after deletion' do
+      before do
+        expect(subject.redis_getdel(user_id)).to eq(token)
+      end
+
+      it 'token is removed' do
+        expect(subject.redis_getdel(user_id)).to be_nil
+      end
+    end
+  end
+
   context "validations" do
     let(:personal_access_token) { build(:personal_access_token) }
 
diff --git a/spec/models/project_services/jira_service_spec.rb b/spec/models/project_services/jira_service_spec.rb
index ad22fb2a386..c9b3c6cf602 100644
--- a/spec/models/project_services/jira_service_spec.rb
+++ b/spec/models/project_services/jira_service_spec.rb
@@ -395,6 +395,26 @@ describe JiraService do
     end
   end
 
+  describe 'additional cookies' do
+    let(:project) { create(:project) }
+
+    context 'provides additional cookies to allow basic auth with oracle webgate' do
+      before do
+        @service = project.create_jira_service(
+          active: true, properties: { url: 'http://jira.com' })
+      end
+
+      after do
+        @service.destroy!
+      end
+
+      it 'is initialized' do
+        expect(@service.options[:use_cookies]).to eq(true)
+        expect(@service.options[:additional_cookies]).to eq(["OBBasicAuth=fromDialog"])
+      end
+    end
+  end
+
   describe 'project and issue urls' do
     let(:project) { create(:project) }
 
diff --git a/spec/models/project_spec.rb b/spec/models/project_spec.rb
index f4699fd243d..f805f2dcddb 100644
--- a/spec/models/project_spec.rb
+++ b/spec/models/project_spec.rb
@@ -289,12 +289,12 @@ describe Project do
 
   describe 'project token' do
     it 'sets an random token if none provided' do
-      project = FactoryGirl.create :project, runners_token: ''
+      project = FactoryBot.create :project, runners_token: ''
       expect(project.runners_token).not_to eq('')
     end
 
     it 'does not set an random token if one provided' do
-      project = FactoryGirl.create :project, runners_token: 'my-token'
+      project = FactoryBot.create :project, runners_token: 'my-token'
       expect(project.runners_token).to eq('my-token')
     end
   end
@@ -1863,10 +1863,11 @@ describe Project do
       project.change_head(project.default_branch)
     end
 
-    it 'creates the new reference with rugged' do
-      expect(project.repository.rugged.references).to receive(:create).with('HEAD',
+    it 'creates the new reference' do
+      expect(project.repository.raw_repository).to receive(:write_ref).with('HEAD',
                                                                             "refs/heads/#{project.default_branch}",
                                                                             force: true)
+
       project.change_head(project.default_branch)
     end
 
diff --git a/spec/models/repository_spec.rb b/spec/models/repository_spec.rb
index 82ed1ecee33..799d99c0369 100644
--- a/spec/models/repository_spec.rb
+++ b/spec/models/repository_spec.rb
@@ -29,7 +29,9 @@ describe Repository do
   def expect_to_raise_storage_error
     expect { yield }.to raise_error do |exception|
       storage_exceptions = [Gitlab::Git::Storage::Inaccessible, Gitlab::Git::CommandError, GRPC::Unavailable]
-      expect(exception.class).to be_in(storage_exceptions)
+      known_exception = storage_exceptions.select { |e| exception.is_a?(e) }
+
+      expect(known_exception).not_to be_nil
     end
   end
 
@@ -57,12 +59,18 @@ describe Repository do
   end
 
   describe 'tags_sorted_by' do
-    context 'name' do
-      subject { repository.tags_sorted_by('name').map(&:name) }
+    context 'name_desc' do
+      subject { repository.tags_sorted_by('name_desc').map(&:name) }
 
       it { is_expected.to eq(['v1.1.0', 'v1.0.0']) }
     end
 
+    context 'name_asc' do
+      subject { repository.tags_sorted_by('name_asc').map(&:name) }
+
+      it { is_expected.to eq(['v1.0.0', 'v1.1.0']) }
+    end
+
     context 'updated' do
       let(:tag_a) { repository.find_tag('v1.0.0') }
       let(:tag_b) { repository.find_tag('v1.1.0') }
@@ -634,9 +642,7 @@ describe Repository do
   end
 
   describe '#fetch_ref' do
-    # Setting the var here, sidesteps the stub that makes gitaly raise an error
-    # before the actual test call
-    set(:broken_repository) { create(:project, :broken_storage).repository }
+    let(:broken_repository) { create(:project, :broken_storage).repository }
 
     describe 'when storage is broken', :broken_storage  do
       it 'should raise a storage error' do
@@ -1007,7 +1013,7 @@ describe Repository do
 
       it 'runs without errors' do
         # old_rev is an ancestor of new_rev
-        expect(repository.rugged.merge_base(old_rev, new_rev)).to eq(old_rev)
+        expect(repository.merge_base(old_rev, new_rev)).to eq(old_rev)
 
         # old_rev is not a direct ancestor (parent) of new_rev
         expect(repository.rugged.lookup(new_rev).parent_ids).not_to include(old_rev)
@@ -1029,7 +1035,7 @@ describe Repository do
 
       it 'raises an exception' do
         # The 'master' branch is NOT an ancestor of new_rev.
-        expect(repository.rugged.merge_base(old_rev, new_rev)).not_to eq(old_rev)
+        expect(repository.merge_base(old_rev, new_rev)).not_to eq(old_rev)
 
         # Updating 'master' to new_rev would lose the commits on 'master' that
         # are not contained in new_rev. This should not be allowed.
@@ -1916,6 +1922,23 @@ describe Repository do
 
       File.delete(path)
     end
+
+    it "attempting to call keep_around when exists a lock does not fail" do
+      ref = repository.send(:keep_around_ref_name, sample_commit.id)
+      path = File.join(repository.path, ref)
+      lock_path = "#{path}.lock"
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(lock_path, 'w') { |f| f.write('') }
+
+      begin
+        expect { repository.keep_around(sample_commit.id) }.not_to raise_error(Gitlab::Git::Repository::GitError)
+
+        expect(File.exist?(lock_path)).to be_falsey
+      ensure
+        File.delete(path)
+      end
+    end
   end
 
   describe '#update_ref' do
@@ -2343,4 +2366,111 @@ describe Repository do
       end
     end
   end
+
+  describe '#contributors' do
+    let(:author_a) { build(:author, email: 'tiagonbotelho@hotmail.com', name: 'tiagonbotelho') }
+    let(:author_b) { build(:author, email: 'gitlab@winniehell.de', name: 'Winnie') }
+    let(:author_c) { build(:author, email: 'douwe@gitlab.com', name: 'Douwe Maan') }
+    let(:stubbed_commits) do
+      [build(:commit, author: author_a),
+       build(:commit, author: author_a),
+       build(:commit, author: author_b),
+       build(:commit, author: author_c),
+       build(:commit, author: author_c),
+       build(:commit, author: author_c)]
+    end
+    let(:order_by) { nil }
+    let(:sort) { nil }
+
+    before do
+      allow(repository).to receive(:commits).with(nil, limit: 2000, offset: 0, skip_merges: true).and_return(stubbed_commits)
+    end
+
+    subject { repository.contributors(order_by: order_by, sort: sort) }
+
+    def expect_contributors(*contributors)
+      expect(subject.map(&:email)).to eq(contributors.map(&:email))
+    end
+
+    it 'returns the array of Gitlab::Contributor for the repository' do
+      expect_contributors(author_a, author_b, author_c)
+    end
+
+    context 'order_by email' do
+      let(:order_by) { 'email' }
+
+      context 'asc' do
+        let(:sort) { 'asc' }
+
+        it 'returns all the contributors ordered by email asc case insensitive' do
+          expect_contributors(author_c, author_b, author_a)
+        end
+      end
+
+      context 'desc' do
+        let(:sort) { 'desc' }
+
+        it 'returns all the contributors ordered by email desc case insensitive' do
+          expect_contributors(author_a, author_b, author_c)
+        end
+      end
+    end
+
+    context 'order_by name' do
+      let(:order_by) { 'name' }
+
+      context 'asc' do
+        let(:sort) { 'asc' }
+
+        it 'returns all the contributors ordered by name asc case insensitive' do
+          expect_contributors(author_c, author_a, author_b)
+        end
+      end
+
+      context 'desc' do
+        let(:sort) { 'desc' }
+
+        it 'returns all the contributors ordered by name desc case insensitive' do
+          expect_contributors(author_b, author_a, author_c)
+        end
+      end
+    end
+
+    context 'order_by commits' do
+      let(:order_by) { 'commits' }
+
+      context 'asc' do
+        let(:sort) { 'asc' }
+
+        it 'returns all the contributors ordered by commits asc' do
+          expect_contributors(author_b, author_a, author_c)
+        end
+      end
+
+      context 'desc' do
+        let(:sort) { 'desc' }
+
+        it 'returns all the contributors ordered by commits desc' do
+          expect_contributors(author_c, author_a, author_b)
+        end
+      end
+    end
+
+    context 'invalid ordering' do
+      let(:order_by) { 'unknown' }
+
+      it 'returns the contributors unsorted' do
+        expect_contributors(author_a, author_b, author_c)
+      end
+    end
+
+    context 'invalid sorting' do
+      let(:order_by) { 'name' }
+      let(:sort) { 'unknown' }
+
+      it 'returns the contributors unsorted' do
+        expect_contributors(author_a, author_b, author_c)
+      end
+    end
+  end
 end
diff --git a/spec/models/route_spec.rb b/spec/models/route_spec.rb
index fece370c03f..ddad6862a63 100644
--- a/spec/models/route_spec.rb
+++ b/spec/models/route_spec.rb
@@ -87,6 +87,7 @@ describe Route do
       end
 
       context 'when conflicting redirects exist' do
+        let(:route) { create(:project).route }
         let!(:conflicting_redirect1) { route.create_redirect('bar/test') }
         let!(:conflicting_redirect2) { route.create_redirect('bar/test/foo') }
         let!(:conflicting_redirect3) { route.create_redirect('gitlab-org') }
@@ -141,11 +142,50 @@ describe Route do
       expect(redirect_route.source).to eq(route.source)
       expect(redirect_route.path).to eq('foo')
     end
+
+    context 'when the source is a Project' do
+      it 'creates a temporal RedirectRoute' do
+        project = create(:project)
+        route = project.route
+        redirect_route = route.create_redirect('foo')
+        expect(redirect_route.permanent?).to be_falsy
+      end
+    end
+
+    context 'when the source is not a project' do
+      it 'creates a permanent RedirectRoute' do
+        redirect_route = route.create_redirect('foo', permanent: true)
+        expect(redirect_route.permanent?).to be_truthy
+      end
+    end
   end
 
   describe '#delete_conflicting_redirects' do
+    context 'with permanent redirect' do
+      it 'does not delete the redirect' do
+        route.create_redirect("#{route.path}/foo", permanent: true)
+
+        expect do
+          route.delete_conflicting_redirects
+        end.not_to change { RedirectRoute.count }
+      end
+    end
+
+    context 'with temporal redirect' do
+      let(:route) { create(:project).route }
+
+      it 'deletes the redirect' do
+        route.create_redirect("#{route.path}/foo")
+
+        expect do
+          route.delete_conflicting_redirects
+        end.to change { RedirectRoute.count }.by(-1)
+      end
+    end
+
     context 'when a redirect route with the same path exists' do
       context 'when the redirect route has matching case' do
+        let(:route) { create(:project).route }
         let!(:redirect1) { route.create_redirect(route.path) }
 
         it 'deletes the redirect' do
@@ -169,6 +209,7 @@ describe Route do
       end
 
       context 'when the redirect route is differently cased' do
+        let(:route) { create(:project).route }
         let!(:redirect1) { route.create_redirect(route.path.upcase) }
 
         it 'deletes the redirect' do
@@ -185,7 +226,32 @@ describe Route do
       expect(route.conflicting_redirects).to be_an(ActiveRecord::Relation)
     end
 
+    context 'with permanent redirects' do
+      it 'does not return anything' do
+        route.create_redirect("#{route.path}/foo", permanent: true)
+        route.create_redirect("#{route.path}/foo/bar", permanent: true)
+        route.create_redirect("#{route.path}/baz/quz", permanent: true)
+
+        expect(route.conflicting_redirects).to be_empty
+      end
+    end
+
+    context 'with temporal redirects' do
+      let(:route) { create(:project).route }
+
+      it 'returns the redirect routes' do
+        route = create(:project).route
+        redirect1 = route.create_redirect("#{route.path}/foo")
+        redirect2 = route.create_redirect("#{route.path}/foo/bar")
+        redirect3 = route.create_redirect("#{route.path}/baz/quz")
+
+        expect(route.conflicting_redirects).to match_array([redirect1, redirect2, redirect3])
+      end
+    end
+
     context 'when a redirect route with the same path exists' do
+      let(:route) { create(:project).route }
+
       context 'when the redirect route has matching case' do
         let!(:redirect1) { route.create_redirect(route.path) }
 
@@ -214,4 +280,42 @@ describe Route do
       end
     end
   end
+
+  describe "#conflicting_redirect_exists?" do
+    context 'when a conflicting redirect exists' do
+      let(:group1) { create(:group, path: 'foo') }
+      let(:group2) { create(:group, path: 'baz') }
+
+      it 'should not be saved' do
+        group1.path = 'bar'
+        group1.save
+
+        group2.path = 'foo'
+
+        expect(group2.save).to be_falsy
+      end
+
+      it 'should return an error on path' do
+        group1.path = 'bar'
+        group1.save
+
+        group2.path = 'foo'
+        group2.valid?
+        expect(group2.errors["route.path"].first).to eq('foo has been taken before. Please use another one')
+      end
+    end
+
+    context 'when a conflicting redirect does not exist' do
+      let(:project1) { create(:project, path: 'foo') }
+      let(:project2) { create(:project, path: 'baz') }
+
+      it 'should be saved' do
+        project1.path = 'bar'
+        project1.save
+
+        project2.path = 'foo'
+        expect(project2.save).to be_truthy
+      end
+    end
+  end
 end
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index 03c96a8f5aa..4687d9dfa00 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -913,11 +913,11 @@ describe User do
 
     describe 'email matching' do
       it 'returns users with a matching Email' do
-        expect(described_class.search(user.email)).to eq([user, user2])
+        expect(described_class.search(user.email)).to eq([user])
       end
 
-      it 'returns users with a partially matching Email' do
-        expect(described_class.search(user.email[0..2])).to eq([user, user2])
+      it 'does not return users with a partially matching Email' do
+        expect(described_class.search(user.email[0..2])).not_to include(user, user2)
       end
 
       it 'returns users with a matching Email regardless of the casing' do
@@ -973,8 +973,8 @@ describe User do
       expect(search_with_secondary_emails(user.email)).to eq([user])
     end
 
-    it 'returns users with a partially matching email' do
-      expect(search_with_secondary_emails(user.email[0..2])).to eq([user])
+    it 'does not return users with a partially matching email' do
+      expect(search_with_secondary_emails(user.email[0..2])).not_to include([user])
     end
 
     it 'returns users with a matching email regardless of the casing' do
@@ -997,29 +997,8 @@ describe User do
       expect(search_with_secondary_emails(email.email)).to eq([email.user])
     end
 
-    it 'returns users with a matching part of secondary email' do
-      expect(search_with_secondary_emails(email.email[1..4])).to eq([email.user])
-    end
-
-    it 'return users with a matching part of secondary email regardless of case' do
-      expect(search_with_secondary_emails(email.email[1..4].upcase)).to eq([email.user])
-      expect(search_with_secondary_emails(email.email[1..4].downcase)).to eq([email.user])
-      expect(search_with_secondary_emails(email.email[1..4].capitalize)).to eq([email.user])
-    end
-
-    it 'returns multiple users with matching secondary emails' do
-      email1 = create(:email, email: '1_testemail@example.com')
-      email2 = create(:email, email: '2_testemail@example.com')
-      email3 = create(:email, email: 'other@email.com')
-      email3.user.update_attributes!(email: 'another@mail.com')
-
-      expect(
-        search_with_secondary_emails('testemail@example.com').map(&:id)
-      ).to include(email1.user.id, email2.user.id)
-
-      expect(
-        search_with_secondary_emails('testemail@example.com').map(&:id)
-      ).not_to include(email3.user.id)
+    it 'does not return users with a matching part of secondary email' do
+      expect(search_with_secondary_emails(email.email[1..4])).not_to include([email.user])
     end
   end
 
@@ -2592,4 +2571,28 @@ describe User do
       include_examples 'max member access for groups'
     end
   end
+
+  describe "#username_previously_taken?" do
+    let(:user1) { create(:user, username: 'foo') }
+
+    context 'when the username has been taken before' do
+      before do
+        user1.username = 'bar'
+        user1.save!
+      end
+
+      it 'should raise an ActiveRecord::RecordInvalid exception' do
+        user2 = build(:user, username: 'foo')
+        expect { user2.save! }.to raise_error(ActiveRecord::RecordInvalid, /Path foo has been taken before/)
+      end
+    end
+
+    context 'when the username has not been taken before' do
+      it 'should be valid' do
+        expect(RedirectRoute.count).to eq(0)
+        user2 = build(:user, username: 'baz')
+        expect(user2).to be_valid
+      end
+    end
+  end
 end