Merge remote-tracking branch 'upstream/master' into fix-git-hooks-when-creating-file

* upstream/master: (1122 commits)
  Update CHANGELOG.md for 8.16.2
  Display project ID in project settings (!8572)
  fixed points from comments to improve code quality
  Update CHANGELOG.md for 8.14.8
  Statisfy eslint
  Add CHANGELOG entry
  Fix access to the wiki code via HTTP when repository feature disabled
  Display fullscreen button on small screens (!5302)
  Prevent removing fields from dropdowns on input elements
  fix for all themes
  Return struct instead of multiple values
  Fix race conditions for AuthorizedProjectsWorker
  Add User#nested_groups and User#nested_projects methods
  Fix spec failure due to timestamp ordering issue in mySQL
  Fixed error with filter keyboard tests
  `can?` already includes the `feature_available?` check
  Test there is no Merge Request button when MRs are disabled
  Ensure the correct Merge Request button is found
  Add 409 conflict tests
  Add CHANGELOG
  ...

82 files changed, 5246 insertions, 334 deletions

diff --git a/spec/lib/api/helpers/pagination_spec.rb b/spec/lib/api/helpers/pagination_spec.rb
new file mode 100644
index 00000000000..267318faed4
--- /dev/null
+++ b/spec/lib/api/helpers/pagination_spec.rb
@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe API::Helpers::Pagination do
+  let(:resource) { Project.all }
+
+  subject do
+    Class.new.include(described_class).new
+  end
+
+  describe '#paginate' do
+    let(:value) { spy('return value') }
+
+    before do
+      allow(value).to receive(:to_query).and_return(value)
+
+      allow(subject).to receive(:header).and_return(value)
+      allow(subject).to receive(:params).and_return(value)
+      allow(subject).to receive(:request).and_return(value)
+    end
+
+    describe 'required instance methods' do
+      let(:return_spy) { spy }
+
+      it 'requires some instance methods' do
+        expect_message(:header)
+        expect_message(:params)
+        expect_message(:request)
+
+        subject.paginate(resource)
+      end
+    end
+
+    context 'when resource can be paginated' do
+      before do
+        create_list(:empty_project, 3)
+      end
+
+      describe 'first page' do
+        before do
+          allow(subject).to receive(:params)
+            .and_return({ page: 1, per_page: 2 })
+        end
+
+        it 'returns appropriate amount of resources' do
+          expect(subject.paginate(resource).count).to eq 2
+        end
+
+        it 'adds appropriate headers' do
+          expect_header('X-Total', '3')
+          expect_header('X-Total-Pages', '2')
+          expect_header('X-Per-Page', '2')
+          expect_header('X-Page', '1')
+          expect_header('X-Next-Page', '2')
+          expect_header('X-Prev-Page', '')
+          expect_header('Link', any_args)
+
+          subject.paginate(resource)
+        end
+      end
+
+      describe 'second page' do
+        before do
+          allow(subject).to receive(:params)
+            .and_return({ page: 2, per_page: 2 })
+        end
+
+        it 'returns appropriate amount of resources' do
+          expect(subject.paginate(resource).count).to eq 1
+        end
+
+        it 'adds appropriate headers' do
+          expect_header('X-Total', '3')
+          expect_header('X-Total-Pages', '2')
+          expect_header('X-Per-Page', '2')
+          expect_header('X-Page', '2')
+          expect_header('X-Next-Page', '')
+          expect_header('X-Prev-Page', '1')
+          expect_header('Link', any_args)
+
+          subject.paginate(resource)
+        end
+      end
+    end
+
+    def expect_header(name, value)
+      expect(subject).to receive(:header).with(name, value)
+    end
+
+    def expect_message(method)
+      expect(subject).to receive(method)
+        .at_least(:once).and_return(value)
+    end
+  end
+end
diff --git a/spec/lib/banzai/filter/syntax_highlight_filter_spec.rb b/spec/lib/banzai/filter/syntax_highlight_filter_spec.rb
index d265d29ee86..69e3c52b35a 100644
--- a/spec/lib/banzai/filter/syntax_highlight_filter_spec.rb
+++ b/spec/lib/banzai/filter/syntax_highlight_filter_spec.rb
@@ -6,21 +6,21 @@ describe Banzai::Filter::SyntaxHighlightFilter, lib: true do
   context "when no language is specified" do
     it "highlights as plaintext" do
       result = filter('<pre><code>def fun end</code></pre>')
-      expect(result.to_html).to eq('<pre class="code highlight js-syntax-highlight plaintext" v-pre="true"><code>def fun end</code></pre>')
+      expect(result.to_html).to eq('<pre class="code highlight js-syntax-highlight plaintext" lang="plaintext" v-pre="true"><code>def fun end</code></pre>')
     end
   end
 
   context "when a valid language is specified" do
     it "highlights as that language" do
       result = filter('<pre><code class="ruby">def fun end</code></pre>')
-      expect(result.to_html).to eq('<pre class="code highlight js-syntax-highlight ruby" v-pre="true"><code><span class="k">def</span> <span class="nf">fun</span> <span class="k">end</span></code></pre>')
+      expect(result.to_html).to eq('<pre class="code highlight js-syntax-highlight ruby" lang="ruby" v-pre="true"><code><span class="k">def</span> <span class="nf">fun</span> <span class="k">end</span></code></pre>')
     end
   end
 
   context "when an invalid language is specified" do
     it "highlights as plaintext" do
       result = filter('<pre><code class="gnuplot">This is a test</code></pre>')
-      expect(result.to_html).to eq('<pre class="code highlight js-syntax-highlight plaintext" v-pre="true"><code>This is a test</code></pre>')
+      expect(result.to_html).to eq('<pre class="code highlight js-syntax-highlight plaintext" lang="plaintext" v-pre="true"><code>This is a test</code></pre>')
     end
   end
 
@@ -31,7 +31,7 @@ describe Banzai::Filter::SyntaxHighlightFilter, lib: true do
 
     it "highlights as plaintext" do
       result = filter('<pre><code class="ruby">This is a test</code></pre>')
-      expect(result.to_html).to eq('<pre class="code highlight" v-pre="true"><code>This is a test</code></pre>')
+      expect(result.to_html).to eq('<pre class="code highlight" lang="" v-pre="true"><code>This is a test</code></pre>')
     end
   end
 end
diff --git a/spec/lib/banzai/filter/user_reference_filter_spec.rb b/spec/lib/banzai/filter/user_reference_filter_spec.rb
index 5bfeb82e738..3e1ac9fb2b2 100644
--- a/spec/lib/banzai/filter/user_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/user_reference_filter_spec.rb
@@ -152,6 +152,30 @@ describe Banzai::Filter::UserReferenceFilter, lib: true do
     end
   end
 
+  context 'when a project is not specified' do
+    let(:project) { nil }
+
+    it 'does not link a User' do
+      doc = reference_filter("Hey #{reference}")
+
+      expect(doc).not_to include('a')
+    end
+
+    context 'when skip_project_check set to true' do
+      it 'links to a User' do
+        doc = reference_filter("Hey #{reference}", skip_project_check: true)
+
+        expect(doc.css('a').first.attr('href')).to eq urls.user_url(user)
+      end
+
+      it 'does not link users using @all reference' do
+        doc = reference_filter("Hey #{User.reference_prefix}all", skip_project_check: true)
+
+        expect(doc).not_to include('a')
+      end
+    end
+  end
+
   describe '#namespaces' do
     it 'returns a Hash containing all Namespaces' do
       document = Nokogiri::HTML.fragment("<p>#{user.to_reference}</p>")
diff --git a/spec/lib/ci/ansi2html_spec.rb b/spec/lib/ci/ansi2html_spec.rb
index 898f1e84ab0..0762fd7e56a 100644
--- a/spec/lib/ci/ansi2html_spec.rb
+++ b/spec/lib/ci/ansi2html_spec.rb
@@ -136,6 +136,14 @@ describe Ci::Ansi2html, lib: true do
     expect(subject.convert("<")[:html]).to eq('&lt;')
   end
 
+  it "replaces newlines with line break tags" do
+    expect(subject.convert("\n")[:html]).to eq('<br>')
+  end
+
+  it "groups carriage returns with newlines" do
+    expect(subject.convert("\r\n")[:html]).to eq('<br>')
+  end
+
   describe "incremental update" do
     shared_examples 'stateable converter' do
       let(:pass1) { subject.convert(pre_text) }
diff --git a/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb b/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb
index 62d68721574..f824e2e1efe 100644
--- a/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb
+++ b/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb
@@ -769,6 +769,19 @@ module Ci
           expect(builds.first[:environment]).to eq(environment[:name])
           expect(builds.first[:options]).to include(environment: environment)
         end
+
+        context 'the url has a port as variable' do
+          let(:environment) do
+            { name: 'production',
+              url: 'http://production.gitlab.com:$PORT' }
+          end
+
+          it 'allows a variable for the port' do
+            expect(builds.size).to eq(1)
+            expect(builds.first[:environment]).to eq(environment[:name])
+            expect(builds.first[:options]).to include(environment: environment)
+          end
+        end
       end
 
       context 'when no environment is specified' do
diff --git a/spec/lib/gitlab/asciidoc_spec.rb b/spec/lib/gitlab/asciidoc_spec.rb
index f3843ca64ff..ba199917f5c 100644
--- a/spec/lib/gitlab/asciidoc_spec.rb
+++ b/spec/lib/gitlab/asciidoc_spec.rb
@@ -8,6 +8,10 @@ module Gitlab
     let(:html) { 'H<sub>2</sub>O' }
 
     context "without project" do
+      before do
+        allow_any_instance_of(ApplicationSetting).to receive(:current).and_return(::ApplicationSetting.create_from_defaults)
+      end
+
       it "converts the input using Asciidoctor and default options" do
         expected_asciidoc_opts = {
             safe: :secure,
diff --git a/spec/lib/gitlab/backup/manager_spec.rb b/spec/lib/gitlab/backup/manager_spec.rb
index 1b749d1bd39..f84782ab440 100644
--- a/spec/lib/gitlab/backup/manager_spec.rb
+++ b/spec/lib/gitlab/backup/manager_spec.rb
@@ -1,9 +1,27 @@
 require 'spec_helper'
 
 describe Backup::Manager, lib: true do
-  describe '#remove_old' do
-    let(:progress) { StringIO.new }
+  include StubENV
+
+  let(:progress) { StringIO.new }
+
+  before do
+    allow(progress).to receive(:puts)
+    allow(progress).to receive(:print)
+
+    allow_any_instance_of(String).to receive(:color) do |string, _color|
+      string
+    end
+
+    @old_progress = $progress # rubocop:disable Style/GlobalVars
+    $progress = progress # rubocop:disable Style/GlobalVars
+  end
+
+  after do
+    $progress = @old_progress # rubocop:disable Style/GlobalVars
+  end
 
+  describe '#remove_old' do
     let(:files) do
       [
         '1451606400_2016_01_01_gitlab_backup.tar',
@@ -20,20 +38,6 @@ describe Backup::Manager, lib: true do
       allow(Dir).to receive(:glob).and_return(files)
       allow(FileUtils).to receive(:rm)
       allow(Time).to receive(:now).and_return(Time.utc(2016))
-
-      allow(progress).to receive(:puts)
-      allow(progress).to receive(:print)
-
-      allow_any_instance_of(String).to receive(:color) do |string, _color|
-        string
-      end
-
-      @old_progress = $progress # rubocop:disable Style/GlobalVars
-      $progress = progress # rubocop:disable Style/GlobalVars
-    end
-
-    after do
-      $progress = @old_progress # rubocop:disable Style/GlobalVars
     end
 
     context 'when keep_time is zero' do
@@ -124,4 +128,82 @@ describe Backup::Manager, lib: true do
       end
     end
   end
+
+  describe '#unpack' do
+    before do
+      allow(Dir).to receive(:chdir)
+    end
+
+    context 'when there are no backup files in the directory' do
+      before do
+        allow(Dir).to receive(:glob).and_return([])
+      end
+
+      it 'fails the operation and prints an error' do
+        expect { subject.unpack }.to raise_error SystemExit
+        expect(progress).to have_received(:puts)
+          .with(a_string_matching('No backups found'))
+      end
+    end
+
+    context 'when there are two backup files in the directory and BACKUP variable is not set' do
+      before do
+        allow(Dir).to receive(:glob).and_return(
+          [
+            '1451606400_2016_01_01_gitlab_backup.tar',
+            '1451520000_2015_12_31_gitlab_backup.tar',
+          ]
+        )
+      end
+
+      it 'fails the operation and prints an error' do
+        expect { subject.unpack }.to raise_error SystemExit
+        expect(progress).to have_received(:puts)
+          .with(a_string_matching('Found more than one backup'))
+      end
+    end
+
+    context 'when BACKUP variable is set to a non-existing file' do
+      before do
+        allow(Dir).to receive(:glob).and_return(
+          [
+            '1451606400_2016_01_01_gitlab_backup.tar'
+          ]
+        )
+        allow(File).to receive(:exist?).and_return(false)
+
+        stub_env('BACKUP', 'wrong')
+      end
+
+      it 'fails the operation and prints an error' do
+        expect { subject.unpack }.to raise_error SystemExit
+        expect(File).to have_received(:exist?).with('wrong_gitlab_backup.tar')
+        expect(progress).to have_received(:puts)
+          .with(a_string_matching('The backup file wrong_gitlab_backup.tar does not exist'))
+      end
+    end
+
+    context 'when BACKUP variable is set to a correct file' do
+      before do
+        allow(Dir).to receive(:glob).and_return(
+          [
+            '1451606400_2016_01_01_gitlab_backup.tar'
+          ]
+        )
+        allow(File).to receive(:exist?).and_return(true)
+        allow(Kernel).to receive(:system).and_return(true)
+        allow(YAML).to receive(:load_file).and_return(gitlab_version: Gitlab::VERSION)
+
+        stub_env('BACKUP', '1451606400_2016_01_01')
+      end
+
+      it 'unpacks the file' do
+        subject.unpack
+
+        expect(Kernel).to have_received(:system)
+          .with("tar", "-xf", "1451606400_2016_01_01_gitlab_backup.tar")
+        expect(progress).to have_received(:puts).with(a_string_matching('done'))
+      end
+    end
+  end
 end
diff --git a/spec/lib/gitlab/checks/change_access_spec.rb b/spec/lib/gitlab/checks/change_access_spec.rb
index 39069b49978..98effecdbbc 100644
--- a/spec/lib/gitlab/checks/change_access_spec.rb
+++ b/spec/lib/gitlab/checks/change_access_spec.rb
@@ -56,7 +56,6 @@ describe Gitlab::Checks::ChangeAccess, lib: true do
 
       it 'returns an error if the user is not allowed to do forced pushes to protected branches' do
         expect(Gitlab::Checks::ForcePush).to receive(:force_push?).and_return(true)
-        expect(user_access).to receive(:can_do_action?).with(:force_push_code_to_protected_branches).and_return(false)
 
         expect(subject.status).to be(false)
         expect(subject.message).to eq('You are not allowed to force push code to a protected branch on this project.')
@@ -88,8 +87,6 @@ describe Gitlab::Checks::ChangeAccess, lib: true do
         end
 
         it 'returns an error if the user is not allowed to delete protected branches' do
-          expect(user_access).to receive(:can_do_action?).with(:remove_protected_branches).and_return(false)
-
           expect(subject.status).to be(false)
           expect(subject.message).to eq('You are not allowed to delete protected branches from this project.')
         end
diff --git a/spec/lib/gitlab/ci/config/entry/environment_spec.rb b/spec/lib/gitlab/ci/config/entry/environment_spec.rb
index d97806295fb..2adbed2154f 100644
--- a/spec/lib/gitlab/ci/config/entry/environment_spec.rb
+++ b/spec/lib/gitlab/ci/config/entry/environment_spec.rb
@@ -196,22 +196,5 @@ describe Gitlab::Ci::Config::Entry::Environment do
         end
       end
     end
-
-    context 'when invalid URL is used' do
-      let(:config) { { name: 'test', url: 'invalid-example.gitlab.com' } }
-
-      describe '#valid?' do
-        it 'is not valid' do
-          expect(entry).not_to be_valid
-        end
-      end
-
-      describe '#errors?' do
-        it 'contains error about invalid URL' do
-          expect(entry.errors)
-            .to include "environment url must be a valid url"
-        end
-      end
-    end
   end
 end
diff --git a/spec/lib/gitlab/ci/status/build/factory_spec.rb b/spec/lib/gitlab/ci/status/build/factory_spec.rb
index dccb29b5ef6..0c40fca0c1a 100644
--- a/spec/lib/gitlab/ci/status/build/factory_spec.rb
+++ b/spec/lib/gitlab/ci/status/build/factory_spec.rb
@@ -3,15 +3,23 @@ require 'spec_helper'
 describe Gitlab::Ci::Status::Build::Factory do
   let(:user) { create(:user) }
   let(:project) { build.project }
-
-  subject { described_class.new(build, user) }
-  let(:status) { subject.fabricate! }
+  let(:status) { factory.fabricate! }
+  let(:factory) { described_class.new(build, user) }
 
   before { project.team << [user, :developer] }
 
   context 'when build is successful' do
     let(:build) { create(:ci_build, :success) }
 
+    it 'matches correct core status' do
+      expect(factory.core_status).to be_a Gitlab::Ci::Status::Success
+    end
+
+    it 'matches correct extended statuses' do
+      expect(factory.extended_statuses)
+        .to eq [Gitlab::Ci::Status::Build::Retryable]
+    end
+
     it 'fabricates a retryable build status' do
       expect(status).to be_a Gitlab::Ci::Status::Build::Retryable
     end
@@ -26,24 +34,72 @@ describe Gitlab::Ci::Status::Build::Factory do
   end
 
   context 'when build is failed' do
-    let(:build) { create(:ci_build, :failed) }
+    context 'when build is not allowed to fail' do
+      let(:build) { create(:ci_build, :failed) }
 
-    it 'fabricates a retryable build status' do
-      expect(status).to be_a Gitlab::Ci::Status::Build::Retryable
+      it 'matches correct core status' do
+        expect(factory.core_status).to be_a Gitlab::Ci::Status::Failed
+      end
+
+      it 'matches correct extended statuses' do
+        expect(factory.extended_statuses)
+          .to eq [Gitlab::Ci::Status::Build::Retryable]
+      end
+
+      it 'fabricates a retryable build status' do
+        expect(status).to be_a Gitlab::Ci::Status::Build::Retryable
+      end
+
+      it 'fabricates status with correct details' do
+        expect(status.text).to eq 'failed'
+        expect(status.icon).to eq 'icon_status_failed'
+        expect(status.label).to eq 'failed'
+        expect(status).to have_details
+        expect(status).to have_action
+      end
     end
 
-    it 'fabricates status with correct details' do
-      expect(status.text).to eq 'failed'
-      expect(status.icon).to eq 'icon_status_failed'
-      expect(status.label).to eq 'failed'
-      expect(status).to have_details
-      expect(status).to have_action
+    context 'when build is allowed to fail' do
+      let(:build) { create(:ci_build, :failed, :allowed_to_fail) }
+
+      it 'matches correct core status' do
+        expect(factory.core_status).to be_a Gitlab::Ci::Status::Failed
+      end
+
+      it 'matches correct extended statuses' do
+        expect(factory.extended_statuses)
+          .to eq [Gitlab::Ci::Status::Build::Retryable,
+                  Gitlab::Ci::Status::Build::FailedAllowed]
+      end
+
+      it 'fabricates a failed but allowed build status' do
+        expect(status).to be_a Gitlab::Ci::Status::Build::FailedAllowed
+      end
+
+      it 'fabricates status with correct details' do
+        expect(status.text).to eq 'failed'
+        expect(status.icon).to eq 'icon_status_warning'
+        expect(status.label).to eq 'failed (allowed to fail)'
+        expect(status).to have_details
+        expect(status).to have_action
+        expect(status.action_title).to include 'Retry'
+        expect(status.action_path).to include 'retry'
+      end
     end
   end
 
   context 'when build is a canceled' do
     let(:build) { create(:ci_build, :canceled) }
 
+    it 'matches correct core status' do
+      expect(factory.core_status).to be_a Gitlab::Ci::Status::Canceled
+    end
+
+    it 'matches correct extended statuses' do
+      expect(factory.extended_statuses)
+        .to eq [Gitlab::Ci::Status::Build::Retryable]
+    end
+
     it 'fabricates a retryable build status' do
       expect(status).to be_a Gitlab::Ci::Status::Build::Retryable
     end
@@ -60,6 +116,15 @@ describe Gitlab::Ci::Status::Build::Factory do
   context 'when build is running' do
     let(:build) { create(:ci_build, :running) }
 
+    it 'matches correct core status' do
+      expect(factory.core_status).to be_a Gitlab::Ci::Status::Running
+    end
+
+    it 'matches correct extended statuses' do
+      expect(factory.extended_statuses)
+        .to eq [Gitlab::Ci::Status::Build::Cancelable]
+    end
+
     it 'fabricates a canceable build status' do
       expect(status).to be_a Gitlab::Ci::Status::Build::Cancelable
     end
@@ -76,6 +141,15 @@ describe Gitlab::Ci::Status::Build::Factory do
   context 'when build is pending' do
     let(:build) { create(:ci_build, :pending) }
 
+    it 'matches correct core status' do
+      expect(factory.core_status).to be_a Gitlab::Ci::Status::Pending
+    end
+
+    it 'matches correct extended statuses' do
+      expect(factory.extended_statuses)
+        .to eq [Gitlab::Ci::Status::Build::Cancelable]
+    end
+
     it 'fabricates a cancelable build status' do
       expect(status).to be_a Gitlab::Ci::Status::Build::Cancelable
     end
@@ -92,6 +166,14 @@ describe Gitlab::Ci::Status::Build::Factory do
   context 'when build is skipped' do
     let(:build) { create(:ci_build, :skipped) }
 
+    it 'matches correct core status' do
+      expect(factory.core_status).to be_a Gitlab::Ci::Status::Skipped
+    end
+
+    it 'does not match extended statuses' do
+      expect(factory.extended_statuses).to be_empty
+    end
+
     it 'fabricates a core skipped status' do
       expect(status).to be_a Gitlab::Ci::Status::Skipped
     end
@@ -109,6 +191,15 @@ describe Gitlab::Ci::Status::Build::Factory do
     context 'when build is a play action' do
       let(:build) { create(:ci_build, :playable) }
 
+      it 'matches correct core status' do
+        expect(factory.core_status).to be_a Gitlab::Ci::Status::Skipped
+      end
+
+      it 'matches correct extended statuses' do
+        expect(factory.extended_statuses)
+          .to eq [Gitlab::Ci::Status::Build::Play]
+      end
+
       it 'fabricates a core skipped status' do
         expect(status).to be_a Gitlab::Ci::Status::Build::Play
       end
@@ -119,12 +210,22 @@ describe Gitlab::Ci::Status::Build::Factory do
         expect(status.label).to eq 'manual play action'
         expect(status).to have_details
         expect(status).to have_action
+        expect(status.action_path).to include 'play'
       end
     end
 
     context 'when build is an environment stop action' do
       let(:build) { create(:ci_build, :playable, :teardown_environment) }
 
+      it 'matches correct core status' do
+        expect(factory.core_status).to be_a Gitlab::Ci::Status::Skipped
+      end
+
+      it 'matches correct extended statuses' do
+        expect(factory.extended_statuses)
+          .to eq [Gitlab::Ci::Status::Build::Stop]
+      end
+
       it 'fabricates a core skipped status' do
         expect(status).to be_a Gitlab::Ci::Status::Build::Stop
       end
diff --git a/spec/lib/gitlab/ci/status/build/failed_allowed_spec.rb b/spec/lib/gitlab/ci/status/build/failed_allowed_spec.rb
new file mode 100644
index 00000000000..20f71459738
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/build/failed_allowed_spec.rb
@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Build::FailedAllowed do
+  let(:status) { double('core status') }
+  let(:user) { double('user') }
+
+  subject do
+    described_class.new(status)
+  end
+
+  describe '#text' do
+    it 'does not override status text' do
+      expect(status).to receive(:text)
+
+      subject.text
+    end
+  end
+
+  describe '#icon' do
+    it 'returns a warning icon' do
+      expect(subject.icon).to eq 'icon_status_warning'
+    end
+  end
+
+  describe '#label' do
+    it 'returns information about failed but allowed to fail status' do
+      expect(subject.label).to eq 'failed (allowed to fail)'
+    end
+  end
+
+  describe '#group' do
+    it 'returns status failed with warnings status group' do
+      expect(subject.group).to eq 'failed_with_warnings'
+    end
+  end
+
+  describe 'action details' do
+    describe '#has_action?' do
+      it 'does not decorate action details' do
+        expect(status).to receive(:has_action?)
+
+        subject.has_action?
+      end
+    end
+
+    describe '#action_path' do
+      it 'does not decorate action path' do
+        expect(status).to receive(:action_path)
+
+        subject.action_path
+      end
+    end
+
+    describe '#action_icon' do
+      it 'does not decorate action icon' do
+        expect(status).to receive(:action_icon)
+
+        subject.action_icon
+      end
+    end
+
+    describe '#action_title' do
+      it 'does not decorate action title' do
+        expect(status).to receive(:action_title)
+
+        subject.action_title
+      end
+    end
+  end
+
+  describe '.matches?' do
+    subject { described_class.matches?(build, user) }
+
+    context 'when build is failed' do
+      context 'when build is allowed to fail' do
+        let(:build) { create(:ci_build, :failed, :allowed_to_fail) }
+
+        it 'is a correct match' do
+          expect(subject).to be true
+        end
+      end
+
+      context 'when build is not allowed to fail' do
+        let(:build) { create(:ci_build, :failed) }
+
+        it 'is not a correct match' do
+          expect(subject).not_to be true
+        end
+      end
+    end
+
+    context 'when build did not fail' do
+      context 'when build is allowed to fail' do
+        let(:build) { create(:ci_build, :success, :allowed_to_fail) }
+
+        it 'is not a correct match' do
+          expect(subject).not_to be true
+        end
+      end
+
+      context 'when build is not allowed to fail' do
+        let(:build) { create(:ci_build, :success) }
+
+        it 'is not a correct match' do
+          expect(subject).not_to be true
+        end
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/external/common_spec.rb b/spec/lib/gitlab/ci/status/external/common_spec.rb
new file mode 100644
index 00000000000..5a97d98b55f
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/external/common_spec.rb
@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::External::Common do
+  let(:user) { create(:user) }
+  let(:project) { external_status.project }
+  let(:external_target_url) { 'http://example.gitlab.com/status' }
+
+  let(:external_status) do
+    create(:generic_commit_status, target_url: external_target_url)
+  end
+
+  subject do
+    Gitlab::Ci::Status::Core
+      .new(external_status, user)
+      .extend(described_class)
+  end
+
+  describe '#has_action?' do
+    it { is_expected.not_to have_action }
+  end
+
+  describe '#has_details?' do
+    context 'when user has access to read commit status' do
+      before { project.team << [user, :developer] }
+
+      it { is_expected.to have_details }
+    end
+
+    context 'when user does not have access to read commit status' do
+      it { is_expected.not_to have_details }
+    end
+  end
+
+  describe '#details_path' do
+    it 'links to the external target URL' do
+      expect(subject.details_path).to eq external_target_url
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/external/factory_spec.rb b/spec/lib/gitlab/ci/status/external/factory_spec.rb
new file mode 100644
index 00000000000..c96fd53e730
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/external/factory_spec.rb
@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::External::Factory do
+  let(:user) { create(:user) }
+  let(:project) { resource.project }
+  let(:status) { factory.fabricate! }
+  let(:factory) { described_class.new(resource, user) }
+  let(:external_url) { 'http://gitlab.com/status' }
+
+  before do
+    project.team << [user, :developer]
+  end
+
+  context 'when external status has a simple core status' do
+    HasStatus::AVAILABLE_STATUSES.each do |simple_status|
+      context "when core status is #{simple_status}" do
+        let(:resource) do
+          create(:generic_commit_status, status: simple_status,
+                                         target_url: external_url)
+        end
+
+        let(:expected_status) do
+          Gitlab::Ci::Status.const_get(simple_status.capitalize)
+        end
+
+        it "fabricates a core status #{simple_status}" do
+          expect(status).to be_a expected_status
+        end
+
+        it 'extends core status with common methods' do
+          expect(status).to have_details
+          expect(status).not_to have_action
+          expect(status.details_path).to eq external_url
+        end
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/factory_spec.rb b/spec/lib/gitlab/ci/status/factory_spec.rb
index f92a1c149bf..bbf9c7c83a3 100644
--- a/spec/lib/gitlab/ci/status/factory_spec.rb
+++ b/spec/lib/gitlab/ci/status/factory_spec.rb
@@ -1,24 +1,135 @@
 require 'spec_helper'
 
 describe Gitlab::Ci::Status::Factory do
-  subject do
-    described_class.new(resource, user)
+  let(:user) { create(:user) }
+  let(:fabricated_status) { factory.fabricate! }
+  let(:factory) { described_class.new(resource, user) }
+
+  context 'when object has a core status' do
+    HasStatus::AVAILABLE_STATUSES.each do |simple_status|
+      context "when simple core status is #{simple_status}" do
+        let(:resource) { double('resource', status: simple_status) }
+
+        let(:expected_status) do
+          Gitlab::Ci::Status.const_get(simple_status.capitalize)
+        end
+
+        it "fabricates a core status #{simple_status}" do
+          expect(fabricated_status).to be_a expected_status
+        end
+
+        it "matches a valid core status for #{simple_status}" do
+          expect(factory.core_status).to be_a expected_status
+        end
+
+        it "does not match any extended statuses for #{simple_status}" do
+          expect(factory.extended_statuses).to be_empty
+        end
+      end
+    end
   end
 
-  let(:user) { create(:user) }
+  context 'when resource supports multiple extended statuses' do
+    let(:resource) { double('resource', status: :success) }
 
-  let(:status) { subject.fabricate! }
+    let(:first_extended_status) do
+      Class.new(SimpleDelegator) do
+        def first_method
+          'first return value'
+        end
 
-  context 'when object has a core status' do
-    HasStatus::AVAILABLE_STATUSES.each do |core_status|
-      context "when core status is #{core_status}" do
-        let(:resource) { double(status: core_status) }
+        def second_method
+          'second return value'
+        end
+
+        def self.matches?(*)
+          true
+        end
+      end
+    end
 
-        it "fabricates a core status #{core_status}" do
-          expect(status).to be_a(
-            Gitlab::Ci::Status.const_get(core_status.capitalize))
+    let(:second_extended_status) do
+      Class.new(SimpleDelegator) do
+        def first_method
+          'decorated return value'
         end
+
+        def third_method
+          'third return value'
+        end
+
+        def self.matches?(*)
+          true
+        end
+      end
+    end
+
+    shared_examples 'compound decorator factory' do
+      it 'fabricates compound decorator' do
+        expect(fabricated_status.first_method).to eq 'decorated return value'
+        expect(fabricated_status.second_method).to eq 'second return value'
+        expect(fabricated_status.third_method).to eq 'third return value'
       end
+
+      it 'delegates to core status' do
+        expect(fabricated_status.text).to eq 'passed'
+      end
+
+      it 'latest matches status becomes a status name' do
+        expect(fabricated_status.class).to eq second_extended_status
+      end
+
+      it 'matches correct core status' do
+        expect(factory.core_status).to be_a Gitlab::Ci::Status::Success
+      end
+
+      it 'matches correct extended statuses' do
+        expect(factory.extended_statuses)
+          .to eq [first_extended_status, second_extended_status]
+      end
+    end
+
+    context 'when exclusive statuses are matches' do
+      before do
+        allow(described_class).to receive(:extended_statuses)
+          .and_return([[first_extended_status, second_extended_status]])
+      end
+
+      it 'does not fabricate compound decorator' do
+        expect(fabricated_status.first_method).to eq 'first return value'
+        expect(fabricated_status.second_method).to eq 'second return value'
+        expect(fabricated_status).not_to respond_to(:third_method)
+      end
+
+      it 'delegates to core status' do
+        expect(fabricated_status.text).to eq 'passed'
+      end
+
+      it 'matches correct core status' do
+        expect(factory.core_status).to be_a Gitlab::Ci::Status::Success
+      end
+
+      it 'matches correct extended statuses' do
+        expect(factory.extended_statuses).to eq [first_extended_status]
+      end
+    end
+
+    context 'when exclusive statuses are not matched' do
+      before do
+        allow(described_class).to receive(:extended_statuses)
+          .and_return([[first_extended_status], [second_extended_status]])
+      end
+
+      it_behaves_like 'compound decorator factory'
+    end
+
+    context 'when using simplified status grouping' do
+      before do
+        allow(described_class).to receive(:extended_statuses)
+          .and_return([first_extended_status, second_extended_status])
+      end
+
+      it_behaves_like 'compound decorator factory'
     end
   end
 end
diff --git a/spec/lib/gitlab/ci/status/pipeline/factory_spec.rb b/spec/lib/gitlab/ci/status/pipeline/factory_spec.rb
index d4a2dc7fcc1..b10a447c27a 100644
--- a/spec/lib/gitlab/ci/status/pipeline/factory_spec.rb
+++ b/spec/lib/gitlab/ci/status/pipeline/factory_spec.rb
@@ -3,29 +3,32 @@ require 'spec_helper'
 describe Gitlab::Ci::Status::Pipeline::Factory do
   let(:user) { create(:user) }
   let(:project) { pipeline.project }
-
-  subject do
-    described_class.new(pipeline, user)
-  end
-
-  let(:status) do
-    subject.fabricate!
-  end
+  let(:status) { factory.fabricate! }
+  let(:factory) { described_class.new(pipeline, user) }
 
   before do
     project.team << [user, :developer]
   end
 
   context 'when pipeline has a core status' do
-    HasStatus::AVAILABLE_STATUSES.each do |core_status|
-      context "when core status is #{core_status}" do
-        let(:pipeline) do
-          create(:ci_pipeline, status: core_status)
+    HasStatus::AVAILABLE_STATUSES.each do |simple_status|
+      context "when core status is #{simple_status}" do
+        let(:pipeline) { create(:ci_pipeline, status: simple_status) }
+
+        let(:expected_status) do
+          Gitlab::Ci::Status.const_get(simple_status.capitalize)
+        end
+
+        it "matches correct core status for #{simple_status}" do
+          expect(factory.core_status).to be_a expected_status
         end
 
-        it "fabricates a core status #{core_status}" do
-          expect(status).to be_a(
-            Gitlab::Ci::Status.const_get(core_status.capitalize))
+        it 'does not matche extended statuses' do
+          expect(factory.extended_statuses).to be_empty
+        end
+
+        it "fabricates a core status #{simple_status}" do
+          expect(status).to be_a expected_status
         end
 
         it 'extends core status with common pipeline methods' do
@@ -47,13 +50,22 @@ describe Gitlab::Ci::Status::Pipeline::Factory do
       create(:ci_build, :allowed_to_fail, :failed, pipeline: pipeline)
     end
 
+    it 'matches correct core status' do
+      expect(factory.core_status).to be_a Gitlab::Ci::Status::Success
+    end
+
+    it 'matches correct extended statuses' do
+      expect(factory.extended_statuses)
+        .to eq [Gitlab::Ci::Status::SuccessWarning]
+    end
+
     it 'fabricates extended "success with warnings" status' do
-      expect(status)
-        .to be_a Gitlab::Ci::Status::Pipeline::SuccessWithWarnings
+      expect(status).to be_a Gitlab::Ci::Status::SuccessWarning
     end
 
-    it 'extends core status with common pipeline methods' do
+    it 'extends core status with common pipeline method' do
       expect(status).to have_details
+      expect(status.details_path).to include "pipelines/#{pipeline.id}"
     end
   end
 end
diff --git a/spec/lib/gitlab/ci/status/pipeline/success_with_warnings_spec.rb b/spec/lib/gitlab/ci/status/pipeline/success_with_warnings_spec.rb
deleted file mode 100644
index 979160eb9c4..00000000000
--- a/spec/lib/gitlab/ci/status/pipeline/success_with_warnings_spec.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Gitlab::Ci::Status::Pipeline::SuccessWithWarnings do
-  subject do
-    described_class.new(double('status'))
-  end
-
-  describe '#test' do
-    it { expect(subject.text).to eq 'passed' }
-  end
-
-  describe '#label' do
-    it { expect(subject.label).to eq 'passed with warnings' }
-  end
-
-  describe '#icon' do
-    it { expect(subject.icon).to eq 'icon_status_warning' }
-  end
-
-  describe '#group' do
-    it { expect(subject.group).to eq 'success_with_warnings' }
-  end
-
-  describe '.matches?' do
-    context 'when pipeline is successful' do
-      let(:pipeline) do
-        create(:ci_pipeline, status: :success)
-      end
-
-      context 'when pipeline has warnings' do
-        before do
-          allow(pipeline).to receive(:has_warnings?).and_return(true)
-        end
-
-        it 'is a correct match' do
-          expect(described_class.matches?(pipeline, double)).to eq true
-        end
-      end
-
-      context 'when pipeline does not have warnings' do
-        it 'does not match' do
-          expect(described_class.matches?(pipeline, double)).to eq false
-        end
-      end
-    end
-
-    context 'when pipeline is not successful' do
-      let(:pipeline) do
-        create(:ci_pipeline, status: :skipped)
-      end
-
-      context 'when pipeline has warnings' do
-        before do
-          allow(pipeline).to receive(:has_warnings?).and_return(true)
-        end
-
-        it 'does not match' do
-          expect(described_class.matches?(pipeline, double)).to eq false
-        end
-      end
-
-      context 'when pipeline does not have warnings' do
-        it 'does not match' do
-          expect(described_class.matches?(pipeline, double)).to eq false
-        end
-      end
-    end
-  end
-end
diff --git a/spec/lib/gitlab/ci/status/stage/factory_spec.rb b/spec/lib/gitlab/ci/status/stage/factory_spec.rb
index 6f8721d30c2..bbb40e2c1ab 100644
--- a/spec/lib/gitlab/ci/status/stage/factory_spec.rb
+++ b/spec/lib/gitlab/ci/status/stage/factory_spec.rb
@@ -43,4 +43,25 @@ describe Gitlab::Ci::Status::Stage::Factory do
       end
     end
   end
+
+  context 'when stage has warnings' do
+    let(:stage) do
+      build(:ci_stage, name: 'test', status: :success, pipeline: pipeline)
+    end
+
+    before do
+      create(:ci_build, :allowed_to_fail, :failed,
+             stage: 'test', pipeline: stage.pipeline)
+    end
+
+    it 'fabricates extended "success with warnings" status' do
+      expect(status)
+        .to be_a Gitlab::Ci::Status::SuccessWarning
+    end
+
+    it 'extends core status with common stage method' do
+      expect(status).to have_details
+      expect(status.details_path).to include "pipelines/#{pipeline.id}##{stage.name}"
+    end
+  end
 end
diff --git a/spec/lib/gitlab/ci/status/success_warning_spec.rb b/spec/lib/gitlab/ci/status/success_warning_spec.rb
new file mode 100644
index 00000000000..7e2269397c6
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/success_warning_spec.rb
@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::SuccessWarning do
+  subject do
+    described_class.new(double('status'))
+  end
+
+  describe '#test' do
+    it { expect(subject.text).to eq 'passed' }
+  end
+
+  describe '#label' do
+    it { expect(subject.label).to eq 'passed with warnings' }
+  end
+
+  describe '#icon' do
+    it { expect(subject.icon).to eq 'icon_status_warning' }
+  end
+
+  describe '#group' do
+    it { expect(subject.group).to eq 'success_with_warnings' }
+  end
+
+  describe '.matches?' do
+    let(:matchable) { double('matchable') }
+
+    context 'when matchable subject is successful' do
+      before do
+        allow(matchable).to receive(:success?).and_return(true)
+      end
+
+      context 'when matchable subject has warnings' do
+        before do
+          allow(matchable).to receive(:has_warnings?).and_return(true)
+        end
+
+        it 'is a correct match' do
+          expect(described_class.matches?(matchable, double)).to eq true
+        end
+      end
+
+      context 'when matchable subject does not have warnings' do
+        before do
+          allow(matchable).to receive(:has_warnings?).and_return(false)
+        end
+
+        it 'does not match' do
+          expect(described_class.matches?(matchable, double)).to eq false
+        end
+      end
+    end
+
+    context 'when matchable subject is not successful' do
+      before do
+        allow(matchable).to receive(:success?).and_return(false)
+      end
+
+      context 'when matchable subject has warnings' do
+        before do
+          allow(matchable).to receive(:has_warnings?).and_return(true)
+        end
+
+        it 'does not match' do
+          expect(described_class.matches?(matchable, double)).to eq false
+        end
+      end
+
+      context 'when matchable subject does not have warnings' do
+        it 'does not match' do
+          expect(described_class.matches?(matchable, double)).to eq false
+        end
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/current_settings_spec.rb b/spec/lib/gitlab/current_settings_spec.rb
index 004341ffd02..b01c4805a34 100644
--- a/spec/lib/gitlab/current_settings_spec.rb
+++ b/spec/lib/gitlab/current_settings_spec.rb
@@ -1,36 +1,64 @@
 require 'spec_helper'
 
 describe Gitlab::CurrentSettings do
+  include StubENV
+
+  before do
+    stub_env('IN_MEMORY_APPLICATION_SETTINGS', 'false')
+  end
+
   describe '#current_application_settings' do
-    it 'attempts to use cached values first' do
-      allow_any_instance_of(Gitlab::CurrentSettings).to receive(:connect_to_db?).and_return(true)
-      expect(ApplicationSetting).to receive(:current).and_return(::ApplicationSetting.create_from_defaults)
-      expect(ApplicationSetting).not_to receive(:last)
+    context 'with DB available' do
+      before do
+        allow_any_instance_of(Gitlab::CurrentSettings).to receive(:connect_to_db?).and_return(true)
+      end
 
-      expect(current_application_settings).to be_a(ApplicationSetting)
-    end
+      it 'attempts to use cached values first' do
+        expect(ApplicationSetting).to receive(:current)
+        expect(ApplicationSetting).not_to receive(:last)
+
+        expect(current_application_settings).to be_a(ApplicationSetting)
+      end
 
-    it 'does not attempt to connect to DB or Redis' do
-      allow_any_instance_of(Gitlab::CurrentSettings).to receive(:connect_to_db?).and_return(false)
-      expect(ApplicationSetting).not_to receive(:current)
-      expect(ApplicationSetting).not_to receive(:last)
+      it 'falls back to DB if Redis returns an empty value' do
+        expect(ApplicationSetting).to receive(:last).and_call_original
 
-      expect(current_application_settings).to eq fake_application_settings
+        expect(current_application_settings).to be_a(ApplicationSetting)
+      end
+
+      it 'falls back to DB if Redis fails' do
+        expect(ApplicationSetting).to receive(:current).and_raise(::Redis::BaseError)
+        expect(ApplicationSetting).to receive(:last).and_call_original
+
+        expect(current_application_settings).to be_a(ApplicationSetting)
+      end
     end
 
-    it 'falls back to DB if Redis returns an empty value' do
-      allow_any_instance_of(Gitlab::CurrentSettings).to receive(:connect_to_db?).and_return(true)
-      expect(ApplicationSetting).to receive(:last).and_call_original
+    context 'with DB unavailable' do
+      before do
+        allow_any_instance_of(Gitlab::CurrentSettings).to receive(:connect_to_db?).and_return(false)
+      end
 
-      expect(current_application_settings).to be_a(ApplicationSetting)
+      it 'returns an in-memory ApplicationSetting object' do
+        expect(ApplicationSetting).not_to receive(:current)
+        expect(ApplicationSetting).not_to receive(:last)
+
+        expect(current_application_settings).to be_a(OpenStruct)
+      end
     end
 
-    it 'falls back to DB if Redis fails' do
-      allow_any_instance_of(Gitlab::CurrentSettings).to receive(:connect_to_db?).and_return(true)
-      expect(ApplicationSetting).to receive(:current).and_raise(::Redis::BaseError)
-      expect(ApplicationSetting).to receive(:last).and_call_original
+    context 'when ENV["IN_MEMORY_APPLICATION_SETTINGS"] is true' do
+      before do
+        stub_env('IN_MEMORY_APPLICATION_SETTINGS', 'true')
+      end
+
+      it 'returns an in-memory ApplicationSetting object' do
+        expect(ApplicationSetting).not_to receive(:current)
+        expect(ApplicationSetting).not_to receive(:last)
 
-      expect(current_application_settings).to be_a(ApplicationSetting)
+        expect(current_application_settings).to be_a(ApplicationSetting)
+        expect(current_application_settings).not_to be_persisted
+      end
     end
   end
 end
diff --git a/spec/lib/gitlab/cycle_analytics/code_event_fetcher_spec.rb b/spec/lib/gitlab/cycle_analytics/code_event_fetcher_spec.rb
new file mode 100644
index 00000000000..0267e8c2f69
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/code_event_fetcher_spec.rb
@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_event_spec'
+
+describe Gitlab::CycleAnalytics::CodeEventFetcher do
+  let(:stage_name) { :code }
+
+  it_behaves_like 'default query config' do
+    it 'has a default order' do
+      expect(event.order).not_to be_nil
+    end
+  end
+end
diff --git a/spec/lib/gitlab/cycle_analytics/code_event_spec.rb b/spec/lib/gitlab/cycle_analytics/code_event_spec.rb
deleted file mode 100644
index 43f42d1bde8..00000000000
--- a/spec/lib/gitlab/cycle_analytics/code_event_spec.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-require 'spec_helper'
-require 'lib/gitlab/cycle_analytics/shared_event_spec'
-
-describe Gitlab::CycleAnalytics::CodeEvent do
-  it_behaves_like 'default query config' do
-    it 'does not have the default order' do
-      expect(event.order).not_to eq(event.start_time_attrs)
-    end
-  end
-end
diff --git a/spec/lib/gitlab/cycle_analytics/code_stage_spec.rb b/spec/lib/gitlab/cycle_analytics/code_stage_spec.rb
new file mode 100644
index 00000000000..e8fc67acf05
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/code_stage_spec.rb
@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_stage_spec'
+
+describe Gitlab::CycleAnalytics::CodeStage do
+  let(:stage_name) { :code }
+
+  it_behaves_like 'base stage'
+end
diff --git a/spec/lib/gitlab/cycle_analytics/events_spec.rb b/spec/lib/gitlab/cycle_analytics/events_spec.rb
index 6062e7af4f5..9d2ba481919 100644
--- a/spec/lib/gitlab/cycle_analytics/events_spec.rb
+++ b/spec/lib/gitlab/cycle_analytics/events_spec.rb
@@ -1,12 +1,14 @@
 require 'spec_helper'
 
-describe Gitlab::CycleAnalytics::Events do
+describe 'cycle analytics events' do
   let(:project) { create(:project) }
   let(:from_date) { 10.days.ago }
   let(:user) { create(:user, :admin) }
   let!(:context) { create(:issue, project: project, created_at: 2.days.ago) }
 
-  subject { described_class.new(project: project, options: { from: from_date, current_user: user }) }
+  let(:events) do
+    CycleAnalytics.new(project, { from: from_date, current_user: user })[stage].events
+  end
 
   before do
     allow_any_instance_of(Gitlab::ReferenceExtractor).to receive(:issues).and_return([context])
@@ -15,104 +17,112 @@ describe Gitlab::CycleAnalytics::Events do
   end
 
   describe '#issue_events' do
+    let(:stage) { :issue }
+
     it 'has the total time' do
-      expect(subject.issue_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
 
     it 'has a title' do
-      expect(subject.issue_events.first[:title]).to eq(context.title)
+      expect(events.first[:title]).to eq(context.title)
     end
 
     it 'has the URL' do
-      expect(subject.issue_events.first[:url]).not_to be_nil
+      expect(events.first[:url]).not_to be_nil
     end
 
     it 'has an iid' do
-      expect(subject.issue_events.first[:iid]).to eq(context.iid.to_s)
+      expect(events.first[:iid]).to eq(context.iid.to_s)
     end
 
     it 'has a created_at timestamp' do
-      expect(subject.issue_events.first[:created_at]).to end_with('ago')
+      expect(events.first[:created_at]).to end_with('ago')
     end
 
     it "has the author's URL" do
-      expect(subject.issue_events.first[:author][:web_url]).not_to be_nil
+      expect(events.first[:author][:web_url]).not_to be_nil
     end
 
     it "has the author's avatar URL" do
-      expect(subject.issue_events.first[:author][:avatar_url]).not_to be_nil
+      expect(events.first[:author][:avatar_url]).not_to be_nil
     end
 
     it "has the author's name" do
-      expect(subject.issue_events.first[:author][:name]).to eq(context.author.name)
+      expect(events.first[:author][:name]).to eq(context.author.name)
     end
   end
 
   describe '#plan_events' do
+    let(:stage) { :plan }
+
     it 'has a title' do
-      expect(subject.plan_events.first[:title]).not_to be_nil
+      expect(events.first[:title]).not_to be_nil
     end
 
     it 'has a sha short ID' do
-      expect(subject.plan_events.first[:short_sha]).not_to be_nil
+      expect(events.first[:short_sha]).not_to be_nil
     end
 
     it 'has the URL' do
-      expect(subject.plan_events.first[:commit_url]).not_to be_nil
+      expect(events.first[:commit_url]).not_to be_nil
     end
 
     it 'has the total time' do
-      expect(subject.plan_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
 
     it "has the author's URL" do
-      expect(subject.plan_events.first[:author][:web_url]).not_to be_nil
+      expect(events.first[:author][:web_url]).not_to be_nil
     end
 
     it "has the author's avatar URL" do
-      expect(subject.plan_events.first[:author][:avatar_url]).not_to be_nil
+      expect(events.first[:author][:avatar_url]).not_to be_nil
     end
 
     it "has the author's name" do
-      expect(subject.plan_events.first[:author][:name]).not_to be_nil
+      expect(events.first[:author][:name]).not_to be_nil
     end
   end
 
   describe '#code_events' do
+    let(:stage) { :code }
+
     before do
       create_commit_referencing_issue(context)
     end
 
     it 'has the total time' do
-      expect(subject.code_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
 
     it 'has a title' do
-      expect(subject.code_events.first[:title]).to eq('Awesome merge_request')
+      expect(events.first[:title]).to eq('Awesome merge_request')
     end
 
     it 'has an iid' do
-      expect(subject.code_events.first[:iid]).to eq(context.iid.to_s)
+      expect(events.first[:iid]).to eq(context.iid.to_s)
     end
 
     it 'has a created_at timestamp' do
-      expect(subject.code_events.first[:created_at]).to end_with('ago')
+      expect(events.first[:created_at]).to end_with('ago')
     end
 
     it "has the author's URL" do
-      expect(subject.code_events.first[:author][:web_url]).not_to be_nil
+      expect(events.first[:author][:web_url]).not_to be_nil
     end
 
     it "has the author's avatar URL" do
-      expect(subject.code_events.first[:author][:avatar_url]).not_to be_nil
+      expect(events.first[:author][:avatar_url]).not_to be_nil
     end
 
     it "has the author's name" do
-      expect(subject.code_events.first[:author][:name]).to eq(MergeRequest.first.author.name)
+      expect(events.first[:author][:name]).to eq(MergeRequest.first.author.name)
     end
   end
 
   describe '#test_events' do
+    let(:stage) { :test }
+
     let(:merge_request) { MergeRequest.first }
     let!(:pipeline) do
       create(:ci_pipeline,
@@ -130,83 +140,85 @@ describe Gitlab::CycleAnalytics::Events do
     end
 
     it 'has the name' do
-      expect(subject.test_events.first[:name]).not_to be_nil
+      expect(events.first[:name]).not_to be_nil
     end
 
     it 'has the ID' do
-      expect(subject.test_events.first[:id]).not_to be_nil
+      expect(events.first[:id]).not_to be_nil
     end
 
     it 'has the URL' do
-      expect(subject.test_events.first[:url]).not_to be_nil
+      expect(events.first[:url]).not_to be_nil
     end
 
     it 'has the branch name' do
-      expect(subject.test_events.first[:branch]).not_to be_nil
+      expect(events.first[:branch]).not_to be_nil
     end
 
     it 'has the branch URL' do
-      expect(subject.test_events.first[:branch][:url]).not_to be_nil
+      expect(events.first[:branch][:url]).not_to be_nil
     end
 
     it 'has the short SHA' do
-      expect(subject.test_events.first[:short_sha]).not_to be_nil
+      expect(events.first[:short_sha]).not_to be_nil
     end
 
     it 'has the commit URL' do
-      expect(subject.test_events.first[:commit_url]).not_to be_nil
+      expect(events.first[:commit_url]).not_to be_nil
     end
 
     it 'has the date' do
-      expect(subject.test_events.first[:date]).not_to be_nil
+      expect(events.first[:date]).not_to be_nil
     end
 
     it 'has the total time' do
-      expect(subject.test_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
   end
 
   describe '#review_events' do
+    let(:stage) { :review }
     let!(:context) { create(:issue, project: project, created_at: 2.days.ago) }
 
     it 'has the total time' do
-      expect(subject.review_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
 
     it 'has a title' do
-      expect(subject.review_events.first[:title]).to eq('Awesome merge_request')
+      expect(events.first[:title]).to eq('Awesome merge_request')
     end
 
     it 'has an iid' do
-      expect(subject.review_events.first[:iid]).to eq(context.iid.to_s)
+      expect(events.first[:iid]).to eq(context.iid.to_s)
     end
 
     it 'has the URL' do
-      expect(subject.review_events.first[:url]).not_to be_nil
+      expect(events.first[:url]).not_to be_nil
     end
 
     it 'has a state' do
-      expect(subject.review_events.first[:state]).not_to be_nil
+      expect(events.first[:state]).not_to be_nil
     end
 
     it 'has a created_at timestamp' do
-      expect(subject.review_events.first[:created_at]).not_to be_nil
+      expect(events.first[:created_at]).not_to be_nil
     end
 
     it "has the author's URL" do
-      expect(subject.review_events.first[:author][:web_url]).not_to be_nil
+      expect(events.first[:author][:web_url]).not_to be_nil
     end
 
     it "has the author's avatar URL" do
-      expect(subject.review_events.first[:author][:avatar_url]).not_to be_nil
+      expect(events.first[:author][:avatar_url]).not_to be_nil
     end
 
     it "has the author's name" do
-      expect(subject.review_events.first[:author][:name]).to eq(MergeRequest.first.author.name)
+      expect(events.first[:author][:name]).to eq(MergeRequest.first.author.name)
     end
   end
 
   describe '#staging_events' do
+    let(:stage) { :staging }
     let(:merge_request) { MergeRequest.first }
     let!(:pipeline) do
       create(:ci_pipeline,
@@ -227,55 +239,56 @@ describe Gitlab::CycleAnalytics::Events do
     end
 
     it 'has the name' do
-      expect(subject.staging_events.first[:name]).not_to be_nil
+      expect(events.first[:name]).not_to be_nil
     end
 
     it 'has the ID' do
-      expect(subject.staging_events.first[:id]).not_to be_nil
+      expect(events.first[:id]).not_to be_nil
     end
 
     it 'has the URL' do
-      expect(subject.staging_events.first[:url]).not_to be_nil
+      expect(events.first[:url]).not_to be_nil
     end
 
     it 'has the branch name' do
-      expect(subject.staging_events.first[:branch]).not_to be_nil
+      expect(events.first[:branch]).not_to be_nil
     end
 
     it 'has the branch URL' do
-      expect(subject.staging_events.first[:branch][:url]).not_to be_nil
+      expect(events.first[:branch][:url]).not_to be_nil
     end
 
     it 'has the short SHA' do
-      expect(subject.staging_events.first[:short_sha]).not_to be_nil
+      expect(events.first[:short_sha]).not_to be_nil
     end
 
     it 'has the commit URL' do
-      expect(subject.staging_events.first[:commit_url]).not_to be_nil
+      expect(events.first[:commit_url]).not_to be_nil
     end
 
     it 'has the date' do
-      expect(subject.staging_events.first[:date]).not_to be_nil
+      expect(events.first[:date]).not_to be_nil
     end
 
     it 'has the total time' do
-      expect(subject.staging_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
 
     it "has the author's URL" do
-      expect(subject.staging_events.first[:author][:web_url]).not_to be_nil
+      expect(events.first[:author][:web_url]).not_to be_nil
     end
 
     it "has the author's avatar URL" do
-      expect(subject.staging_events.first[:author][:avatar_url]).not_to be_nil
+      expect(events.first[:author][:avatar_url]).not_to be_nil
     end
 
     it "has the author's name" do
-      expect(subject.staging_events.first[:author][:name]).to eq(MergeRequest.first.author.name)
+      expect(events.first[:author][:name]).to eq(MergeRequest.first.author.name)
     end
   end
 
   describe '#production_events' do
+    let(:stage) { :production }
     let!(:context) { create(:issue, project: project, created_at: 2.days.ago) }
 
     before do
@@ -284,35 +297,35 @@ describe Gitlab::CycleAnalytics::Events do
     end
 
     it 'has the total time' do
-      expect(subject.production_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
 
     it 'has a title' do
-      expect(subject.production_events.first[:title]).to eq(context.title)
+      expect(events.first[:title]).to eq(context.title)
     end
 
     it 'has the URL' do
-      expect(subject.production_events.first[:url]).not_to be_nil
+      expect(events.first[:url]).not_to be_nil
     end
 
     it 'has an iid' do
-      expect(subject.production_events.first[:iid]).to eq(context.iid.to_s)
+      expect(events.first[:iid]).to eq(context.iid.to_s)
     end
 
     it 'has a created_at timestamp' do
-      expect(subject.production_events.first[:created_at]).to end_with('ago')
+      expect(events.first[:created_at]).to end_with('ago')
     end
 
     it "has the author's URL" do
-      expect(subject.production_events.first[:author][:web_url]).not_to be_nil
+      expect(events.first[:author][:web_url]).not_to be_nil
     end
 
     it "has the author's avatar URL" do
-      expect(subject.production_events.first[:author][:avatar_url]).not_to be_nil
+      expect(events.first[:author][:avatar_url]).not_to be_nil
     end
 
     it "has the author's name" do
-      expect(subject.production_events.first[:author][:name]).to eq(context.author.name)
+      expect(events.first[:author][:name]).to eq(context.author.name)
     end
   end
 
diff --git a/spec/lib/gitlab/cycle_analytics/issue_event_fetcher_spec.rb b/spec/lib/gitlab/cycle_analytics/issue_event_fetcher_spec.rb
new file mode 100644
index 00000000000..fd9fa2fee49
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/issue_event_fetcher_spec.rb
@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_event_spec'
+
+describe Gitlab::CycleAnalytics::IssueEventFetcher do
+  let(:stage_name) { :issue }
+
+  it_behaves_like 'default query config'
+end
diff --git a/spec/lib/gitlab/cycle_analytics/issue_event_spec.rb b/spec/lib/gitlab/cycle_analytics/issue_event_spec.rb
deleted file mode 100644
index 1c5c308da7d..00000000000
--- a/spec/lib/gitlab/cycle_analytics/issue_event_spec.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-require 'spec_helper'
-require 'lib/gitlab/cycle_analytics/shared_event_spec'
-
-describe Gitlab::CycleAnalytics::IssueEvent do
-  it_behaves_like 'default query config' do
-    it 'has the default order' do
-      expect(event.order).to eq(event.start_time_attrs)
-    end
-  end
-end
diff --git a/spec/lib/gitlab/cycle_analytics/issue_stage_spec.rb b/spec/lib/gitlab/cycle_analytics/issue_stage_spec.rb
new file mode 100644
index 00000000000..3127f01989d
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/issue_stage_spec.rb
@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_stage_spec'
+
+describe Gitlab::CycleAnalytics::IssueStage do
+  let(:stage_name) { :issue }
+
+  it_behaves_like 'base stage'
+end
diff --git a/spec/lib/gitlab/cycle_analytics/plan_event_spec.rb b/spec/lib/gitlab/cycle_analytics/plan_event_fetcher_spec.rb
index 4a5604115ec..2e5dc5b5547 100644
--- a/spec/lib/gitlab/cycle_analytics/plan_event_spec.rb
+++ b/spec/lib/gitlab/cycle_analytics/plan_event_fetcher_spec.rb
@@ -1,15 +1,13 @@
 require 'spec_helper'
 require 'lib/gitlab/cycle_analytics/shared_event_spec'
 
-describe Gitlab::CycleAnalytics::PlanEvent do
-  it_behaves_like 'default query config' do
-    it 'has the default order' do
-      expect(event.order).to eq(event.start_time_attrs)
-    end
+describe Gitlab::CycleAnalytics::PlanEventFetcher do
+  let(:stage_name) { :plan }
 
+  it_behaves_like 'default query config' do
     context 'no commits' do
       it 'does not blow up if there are no commits' do
-        allow_any_instance_of(Gitlab::CycleAnalytics::EventsQuery).to receive(:execute).and_return([{}])
+        allow(event).to receive(:event_result).and_return([{}])
 
         expect { event.fetch }.not_to raise_error
       end
diff --git a/spec/lib/gitlab/cycle_analytics/plan_stage_spec.rb b/spec/lib/gitlab/cycle_analytics/plan_stage_spec.rb
new file mode 100644
index 00000000000..4c715921ad6
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/plan_stage_spec.rb
@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_stage_spec'
+
+describe Gitlab::CycleAnalytics::PlanStage do
+  let(:stage_name) { :plan }
+
+  it_behaves_like 'base stage'
+end
diff --git a/spec/lib/gitlab/cycle_analytics/production_event_fetcher_spec.rb b/spec/lib/gitlab/cycle_analytics/production_event_fetcher_spec.rb
new file mode 100644
index 00000000000..74001181305
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/production_event_fetcher_spec.rb
@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_event_spec'
+
+describe Gitlab::CycleAnalytics::ProductionEventFetcher do
+  let(:stage_name) { :production }
+
+  it_behaves_like 'default query config'
+end
diff --git a/spec/lib/gitlab/cycle_analytics/production_event_spec.rb b/spec/lib/gitlab/cycle_analytics/production_event_spec.rb
deleted file mode 100644
index ac17e3b4287..00000000000
--- a/spec/lib/gitlab/cycle_analytics/production_event_spec.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-require 'spec_helper'
-require 'lib/gitlab/cycle_analytics/shared_event_spec'
-
-describe Gitlab::CycleAnalytics::ProductionEvent do
-  it_behaves_like 'default query config' do
-    it 'has the default order' do
-      expect(event.order).to eq(event.start_time_attrs)
-    end
-  end
-end
diff --git a/spec/lib/gitlab/cycle_analytics/production_stage_spec.rb b/spec/lib/gitlab/cycle_analytics/production_stage_spec.rb
new file mode 100644
index 00000000000..916684b81eb
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/production_stage_spec.rb
@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_stage_spec'
+
+describe Gitlab::CycleAnalytics::ProductionStage do
+  let(:stage_name) { :production }
+
+  it_behaves_like 'base stage'
+end
diff --git a/spec/lib/gitlab/cycle_analytics/review_event_fetcher_spec.rb b/spec/lib/gitlab/cycle_analytics/review_event_fetcher_spec.rb
new file mode 100644
index 00000000000..4f67c95ed4c
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/review_event_fetcher_spec.rb
@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_event_spec'
+
+describe Gitlab::CycleAnalytics::ReviewEventFetcher do
+  let(:stage_name) { :review }
+
+  it_behaves_like 'default query config'
+end
diff --git a/spec/lib/gitlab/cycle_analytics/review_event_spec.rb b/spec/lib/gitlab/cycle_analytics/review_event_spec.rb
deleted file mode 100644
index 1ff53aa0227..00000000000
--- a/spec/lib/gitlab/cycle_analytics/review_event_spec.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-require 'spec_helper'
-require 'lib/gitlab/cycle_analytics/shared_event_spec'
-
-describe Gitlab::CycleAnalytics::ReviewEvent do
-  it_behaves_like 'default query config' do
-    it 'has the default order' do
-      expect(event.order).to eq(event.start_time_attrs)
-    end
-  end
-end
diff --git a/spec/lib/gitlab/cycle_analytics/review_stage_spec.rb b/spec/lib/gitlab/cycle_analytics/review_stage_spec.rb
new file mode 100644
index 00000000000..1412c8dfa08
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/review_stage_spec.rb
@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_stage_spec'
+
+describe Gitlab::CycleAnalytics::ReviewStage do
+  let(:stage_name) { :review }
+
+  it_behaves_like 'base stage'
+end
diff --git a/spec/lib/gitlab/cycle_analytics/shared_event_spec.rb b/spec/lib/gitlab/cycle_analytics/shared_event_spec.rb
index 7019e4c3351..9c5e57342e9 100644
--- a/spec/lib/gitlab/cycle_analytics/shared_event_spec.rb
+++ b/spec/lib/gitlab/cycle_analytics/shared_event_spec.rb
@@ -1,20 +1,13 @@
 require 'spec_helper'
 
 shared_examples 'default query config' do
-  let(:event) { described_class.new(project: double, options: {}) }
-
-  it 'has the start attributes' do
-    expect(event.start_time_attrs).not_to be_nil
-  end
+  let(:project) { create(:empty_project) }
+  let(:event) { described_class.new(project: project, stage: stage_name, options: { from: 1.day.ago }) }
 
   it 'has the stage attribute' do
     expect(event.stage).not_to be_nil
   end
 
-  it 'has the end attributes' do
-    expect(event.end_time_attrs).not_to be_nil
-  end
-
   it 'has the projection attributes' do
     expect(event.projections).not_to be_nil
   end
diff --git a/spec/lib/gitlab/cycle_analytics/shared_stage_spec.rb b/spec/lib/gitlab/cycle_analytics/shared_stage_spec.rb
new file mode 100644
index 00000000000..08425acbfc8
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/shared_stage_spec.rb
@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+shared_examples 'base stage' do
+  let(:stage) { described_class.new(project: double, options: {}) }
+
+  before do
+    allow(stage).to receive(:median).and_return(1.12)
+    allow_any_instance_of(Gitlab::CycleAnalytics::BaseEventFetcher).to receive(:event_result).and_return({})
+  end
+
+  it 'has the median data value' do
+    expect(stage.as_json[:value]).not_to be_nil
+  end
+
+  it 'has the median data stage' do
+    expect(stage.as_json[:title]).not_to be_nil
+  end
+
+  it 'has the median data description' do
+    expect(stage.as_json[:description]).not_to be_nil
+  end
+
+  it 'has the title' do
+    expect(stage.title).to eq(stage_name.to_s.capitalize)
+  end
+
+  it 'has the events' do
+    expect(stage.events).not_to be_nil
+  end
+end
diff --git a/spec/lib/gitlab/cycle_analytics/stage_summary_spec.rb b/spec/lib/gitlab/cycle_analytics/stage_summary_spec.rb
new file mode 100644
index 00000000000..fb6b6c4a8d2
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/stage_summary_spec.rb
@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Gitlab::CycleAnalytics::StageSummary, models: true do
+  let(:project) { create(:project) }
+  let(:from) { 1.day.ago }
+  let(:user) { create(:user, :admin) }
+  subject { described_class.new(project, from: Time.now, current_user: user).data }
+
+  describe "#new_issues" do
+    it "finds the number of issues created after the 'from date'" do
+      Timecop.freeze(5.days.ago) { create(:issue, project: project) }
+      Timecop.freeze(5.days.from_now) { create(:issue, project: project) }
+
+      expect(subject.first[:value]).to eq(1)
+    end
+
+    it "doesn't find issues from other projects" do
+      Timecop.freeze(5.days.from_now) { create(:issue, project: create(:project)) }
+
+      expect(subject.first[:value]).to eq(0)
+    end
+  end
+
+  describe "#commits" do
+    it "finds the number of commits created after the 'from date'" do
+      Timecop.freeze(5.days.ago) { create_commit("Test message", project, user, 'master') }
+      Timecop.freeze(5.days.from_now) { create_commit("Test message", project, user, 'master') }
+
+      expect(subject.second[:value]).to eq(1)
+    end
+
+    it "doesn't find commits from other projects" do
+      Timecop.freeze(5.days.from_now) { create_commit("Test message", create(:project), user, 'master') }
+
+      expect(subject.second[:value]).to eq(0)
+    end
+
+    it "finds a large (> 100) snumber of commits if present" do
+      Timecop.freeze(5.days.from_now) { create_commit("Test message", project, user, 'master', count: 100) }
+
+      expect(subject.second[:value]).to eq(100)
+    end
+  end
+
+  describe "#deploys" do
+    it "finds the number of deploys made created after the 'from date'" do
+      Timecop.freeze(5.days.ago) { create(:deployment, project: project) }
+      Timecop.freeze(5.days.from_now) { create(:deployment, project: project) }
+
+      expect(subject.third[:value]).to eq(1)
+    end
+
+    it "doesn't find commits from other projects" do
+      Timecop.freeze(5.days.from_now) { create(:deployment, project: create(:project)) }
+
+      expect(subject.third[:value]).to eq(0)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/cycle_analytics/staging_event_fetcher_spec.rb b/spec/lib/gitlab/cycle_analytics/staging_event_fetcher_spec.rb
new file mode 100644
index 00000000000..bbc82496340
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/staging_event_fetcher_spec.rb
@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_event_spec'
+
+describe Gitlab::CycleAnalytics::StagingEventFetcher do
+  let(:stage_name) { :staging }
+
+  it_behaves_like 'default query config' do
+    it 'has a default order' do
+      expect(event.order).not_to be_nil
+    end
+  end
+end
diff --git a/spec/lib/gitlab/cycle_analytics/staging_event_spec.rb b/spec/lib/gitlab/cycle_analytics/staging_event_spec.rb
deleted file mode 100644
index 4862d4765f2..00000000000
--- a/spec/lib/gitlab/cycle_analytics/staging_event_spec.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-require 'spec_helper'
-require 'lib/gitlab/cycle_analytics/shared_event_spec'
-
-describe Gitlab::CycleAnalytics::StagingEvent do
-  it_behaves_like 'default query config' do
-    it 'does not have the default order' do
-      expect(event.order).not_to eq(event.start_time_attrs)
-    end
-  end
-end
diff --git a/spec/lib/gitlab/cycle_analytics/staging_stage_spec.rb b/spec/lib/gitlab/cycle_analytics/staging_stage_spec.rb
new file mode 100644
index 00000000000..8154b3ac701
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/staging_stage_spec.rb
@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_stage_spec'
+
+describe Gitlab::CycleAnalytics::StagingStage do
+  let(:stage_name) { :staging }
+
+  it_behaves_like 'base stage'
+end
diff --git a/spec/lib/gitlab/cycle_analytics/test_event_fetcher_spec.rb b/spec/lib/gitlab/cycle_analytics/test_event_fetcher_spec.rb
new file mode 100644
index 00000000000..6639fa54e0e
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/test_event_fetcher_spec.rb
@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_event_spec'
+
+describe Gitlab::CycleAnalytics::TestEventFetcher do
+  let(:stage_name) { :test }
+
+  it_behaves_like 'default query config' do
+    it 'has a default order' do
+      expect(event.order).not_to be_nil
+    end
+  end
+end
diff --git a/spec/lib/gitlab/cycle_analytics/test_event_spec.rb b/spec/lib/gitlab/cycle_analytics/test_event_spec.rb
deleted file mode 100644
index e249db69fc6..00000000000
--- a/spec/lib/gitlab/cycle_analytics/test_event_spec.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-require 'spec_helper'
-require 'lib/gitlab/cycle_analytics/shared_event_spec'
-
-describe Gitlab::CycleAnalytics::TestEvent do
-  it_behaves_like 'default query config' do
-    it 'does not have the default order' do
-      expect(event.order).not_to eq(event.start_time_attrs)
-    end
-  end
-end
diff --git a/spec/lib/gitlab/cycle_analytics/test_stage_spec.rb b/spec/lib/gitlab/cycle_analytics/test_stage_spec.rb
new file mode 100644
index 00000000000..eacde22cd56
--- /dev/null
+++ b/spec/lib/gitlab/cycle_analytics/test_stage_spec.rb
@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'lib/gitlab/cycle_analytics/shared_stage_spec'
+
+describe Gitlab::CycleAnalytics::TestStage do
+  let(:stage_name) { :test }
+
+  it_behaves_like 'base stage'
+end
diff --git a/spec/lib/gitlab/email/email_shared_blocks.rb b/spec/lib/gitlab/email/email_shared_blocks.rb
index 19298e261e3..9d806fc524d 100644
--- a/spec/lib/gitlab/email/email_shared_blocks.rb
+++ b/spec/lib/gitlab/email/email_shared_blocks.rb
@@ -18,7 +18,7 @@ shared_context :email_shared_context do
   end
 end
 
-shared_examples :email_shared_examples do
+shared_examples :reply_processing_shared_examples do
   context "when the user could not be found" do
     before do
       user.destroy
diff --git a/spec/lib/gitlab/email/handler/create_issue_handler_spec.rb b/spec/lib/gitlab/email/handler/create_issue_handler_spec.rb
index cb3651e3845..08897a4c310 100644
--- a/spec/lib/gitlab/email/handler/create_issue_handler_spec.rb
+++ b/spec/lib/gitlab/email/handler/create_issue_handler_spec.rb
@@ -3,7 +3,7 @@ require_relative '../email_shared_blocks'
 
 describe Gitlab::Email::Handler::CreateIssueHandler, lib: true do
   include_context :email_shared_context
-  it_behaves_like :email_shared_examples
+  it_behaves_like :reply_processing_shared_examples
 
   before do
     stub_incoming_email_setting(enabled: true, address: "incoming+%{key}@appmail.adventuretime.ooo")
diff --git a/spec/lib/gitlab/email/handler/create_note_handler_spec.rb b/spec/lib/gitlab/email/handler/create_note_handler_spec.rb
index 48660d1dd1b..cebbeff50cf 100644
--- a/spec/lib/gitlab/email/handler/create_note_handler_spec.rb
+++ b/spec/lib/gitlab/email/handler/create_note_handler_spec.rb
@@ -3,7 +3,7 @@ require_relative '../email_shared_blocks'
 
 describe Gitlab::Email::Handler::CreateNoteHandler, lib: true do
   include_context :email_shared_context
-  it_behaves_like :email_shared_examples
+  it_behaves_like :reply_processing_shared_examples
 
   before do
     stub_incoming_email_setting(enabled: true, address: "reply+%{key}@appmail.adventuretime.ooo")
diff --git a/spec/lib/gitlab/email/handler/unsubscribe_handler_spec.rb b/spec/lib/gitlab/email/handler/unsubscribe_handler_spec.rb
new file mode 100644
index 00000000000..a444257754b
--- /dev/null
+++ b/spec/lib/gitlab/email/handler/unsubscribe_handler_spec.rb
@@ -0,0 +1,61 @@
+require 'spec_helper'
+require_relative '../email_shared_blocks'
+
+describe Gitlab::Email::Handler::UnsubscribeHandler, lib: true do
+  include_context :email_shared_context
+
+  before do
+    stub_incoming_email_setting(enabled: true, address: 'reply+%{key}@appmail.adventuretime.ooo')
+    stub_config_setting(host: 'localhost')
+  end
+
+  let(:email_raw) { fixture_file('emails/valid_reply.eml').gsub(mail_key, "#{mail_key}+unsubscribe") }
+  let(:project) { create(:project, :public) }
+  let(:user) { create(:user) }
+  let(:noteable) { create(:issue, project: project) }
+
+  let!(:sent_notification) { SentNotification.record(noteable, user.id, mail_key) }
+
+  context 'when notification concerns a commit' do
+    let(:commit) { create(:commit, project: project) }
+    let!(:sent_notification) { SentNotification.record(commit, user.id, mail_key) }
+
+    it 'handler does not raise an error' do
+      expect { receiver.execute }.not_to raise_error
+    end
+  end
+
+  context 'user is unsubscribed' do
+    it 'leaves user unsubscribed' do
+      expect { receiver.execute }.not_to change { noteable.subscribed?(user) }.from(false)
+    end
+  end
+
+  context 'user is subscribed' do
+    before do
+      noteable.subscribe(user)
+    end
+
+    it 'unsubscribes user from notable' do
+      expect { receiver.execute }.to change { noteable.subscribed?(user) }.from(true).to(false)
+    end
+  end
+
+  context 'when the noteable could not be found' do
+    before do
+      noteable.destroy
+    end
+
+    it 'raises a NoteableNotFoundError' do
+      expect { receiver.execute }.to raise_error(Gitlab::Email::NoteableNotFoundError)
+    end
+  end
+
+  context 'when no sent notification for the mail key could be found' do
+    let(:email_raw) { fixture_file('emails/wrong_mail_key.eml') }
+
+    it 'raises a SentNotificationNotFoundError' do
+      expect { receiver.execute }.to raise_error(Gitlab::Email::SentNotificationNotFoundError)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/git/attributes_spec.rb b/spec/lib/gitlab/git/attributes_spec.rb
new file mode 100644
index 00000000000..9c011e34c11
--- /dev/null
+++ b/spec/lib/gitlab/git/attributes_spec.rb
@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe Gitlab::Git::Attributes, seed_helper: true do
+  let(:path) do
+    File.join(SEED_REPOSITORY_PATH, 'with-git-attributes.git')
+  end
+
+  subject { described_class.new(path) }
+
+  describe '#attributes' do
+    context 'using a path with attributes' do
+      it 'returns the attributes as a Hash' do
+        expect(subject.attributes('test.txt')).to eq({ 'text' => true })
+      end
+
+      it 'returns a Hash containing multiple attributes' do
+        expect(subject.attributes('test.sh')).
+          to eq({ 'eol' => 'lf', 'gitlab-language' => 'shell' })
+      end
+
+      it 'returns a Hash containing attributes for a file with multiple extensions' do
+        expect(subject.attributes('test.haml.html')).
+          to eq({ 'gitlab-language' => 'haml' })
+      end
+
+      it 'returns a Hash containing attributes for a file in a directory' do
+        expect(subject.attributes('foo/bar.txt')).to eq({ 'foo' => true })
+      end
+
+      it 'returns a Hash containing attributes with query string parameters' do
+        expect(subject.attributes('foo.cgi')).
+          to eq({ 'key' => 'value?p1=v1&p2=v2' })
+      end
+
+      it 'returns a Hash containing the attributes for an absolute path' do
+        expect(subject.attributes('/test.txt')).to eq({ 'text' => true })
+      end
+
+      it 'returns a Hash containing the attributes when a pattern is defined using an absolute path' do
+        # When a path is given without a leading slash it should still match
+        # patterns defined with a leading slash.
+        expect(subject.attributes('foo.png')).
+          to eq({ 'gitlab-language' => 'png' })
+
+        expect(subject.attributes('/foo.png')).
+          to eq({ 'gitlab-language' => 'png' })
+      end
+
+      it 'returns an empty Hash for a defined path without attributes' do
+        expect(subject.attributes('bla/bla.txt')).to eq({})
+      end
+
+      context 'when the "binary" option is set for a path' do
+        it 'returns true for the "binary" option' do
+          expect(subject.attributes('test.binary')['binary']).to eq(true)
+        end
+
+        it 'returns false for the "diff" option' do
+          expect(subject.attributes('test.binary')['diff']).to eq(false)
+        end
+      end
+    end
+
+    context 'using a path without any attributes' do
+      it 'returns an empty Hash' do
+        expect(subject.attributes('test.foo')).to eq({})
+      end
+    end
+  end
+
+  describe '#patterns' do
+    it 'parses a file with entries' do
+      expect(subject.patterns).to be_an_instance_of(Hash)
+    end
+
+    it 'parses an entry that uses a tab to separate the pattern and attributes' do
+      expect(subject.patterns[File.join(path, '*.md')]).
+        to eq({ 'gitlab-language' => 'markdown' })
+    end
+
+    it 'stores patterns in reverse order' do
+      first = subject.patterns.to_a[0]
+
+      expect(first[0]).to eq(File.join(path, 'bla/bla.txt'))
+    end
+
+    # It's a bit hard to test for something _not_ being processed. As such we'll
+    # just test the number of entries.
+    it 'ignores any comments and empty lines' do
+      expect(subject.patterns.length).to eq(10)
+    end
+
+    it 'does not parse anything when the attributes file does not exist' do
+      expect(File).to receive(:exist?).
+        with(File.join(path, 'info/attributes')).
+        and_return(false)
+
+      expect(subject.patterns).to eq({})
+    end
+  end
+
+  describe '#parse_attributes' do
+    it 'parses a boolean attribute' do
+      expect(subject.parse_attributes('text')).to eq({ 'text' => true })
+    end
+
+    it 'parses a negated boolean attribute' do
+      expect(subject.parse_attributes('-text')).to eq({ 'text' => false })
+    end
+
+    it 'parses a key-value pair' do
+      expect(subject.parse_attributes('foo=bar')).to eq({ 'foo' => 'bar' })
+    end
+
+    it 'parses multiple attributes' do
+      input = 'boolean key=value -negated'
+
+      expect(subject.parse_attributes(input)).
+        to eq({ 'boolean' => true, 'key' => 'value', 'negated' => false })
+    end
+
+    it 'parses attributes with query string parameters' do
+      expect(subject.parse_attributes('foo=bar?baz=1')).
+        to eq({ 'foo' => 'bar?baz=1' })
+    end
+  end
+
+  describe '#each_line' do
+    it 'iterates over every line in the attributes file' do
+      args = [String] * 14 # the number of lines in the file
+
+      expect { |b| subject.each_line(&b) }.to yield_successive_args(*args)
+    end
+
+    it 'does not yield when the attributes file does not exist' do
+      expect(File).to receive(:exist?).
+        with(File.join(path, 'info/attributes')).
+        and_return(false)
+
+      expect { |b| subject.each_line(&b) }.not_to yield_control
+    end
+
+    it 'does not yield when the attributes file has an unsupported encoding' do
+      path = File.join(SEED_REPOSITORY_PATH, 'with-invalid-git-attributes.git')
+      attrs = described_class.new(path)
+
+      expect { |b| attrs.each_line(&b) }.not_to yield_control
+    end
+  end
+end
diff --git a/spec/lib/gitlab/git/blame_spec.rb b/spec/lib/gitlab/git/blame_spec.rb
new file mode 100644
index 00000000000..e169f5af6b6
--- /dev/null
+++ b/spec/lib/gitlab/git/blame_spec.rb
@@ -0,0 +1,66 @@
+# coding: utf-8
+require "spec_helper"
+
+describe Gitlab::Git::Blame, seed_helper: true do
+  let(:repository) { Gitlab::Git::Repository.new(TEST_REPO_PATH) }
+  let(:blame) do
+    Gitlab::Git::Blame.new(repository, SeedRepo::Commit::ID, "CONTRIBUTING.md")
+  end
+
+  context "each count" do
+    it do
+      data = []
+      blame.each do |commit, line|
+        data << {
+          commit: commit,
+          line: line
+        }
+      end
+
+      expect(data.size).to eq(95)
+      expect(data.first[:commit]).to be_kind_of(Gitlab::Git::Commit)
+      expect(data.first[:line]).to eq("# Contribute to GitLab")
+    end
+  end
+
+  context "ISO-8859 encoding" do
+    let(:blame) do
+      Gitlab::Git::Blame.new(repository, SeedRepo::EncodingCommit::ID, "encoding/iso8859.txt")
+    end
+
+    it 'converts to UTF-8' do
+      data = []
+      blame.each do |commit, line|
+        data << {
+          commit: commit,
+          line: line
+        }
+      end
+
+      expect(data.size).to eq(1)
+      expect(data.first[:commit]).to be_kind_of(Gitlab::Git::Commit)
+      expect(data.first[:line]).to eq("Ä ü")
+    end
+  end
+
+  context "unknown encoding" do
+    let(:blame) do
+      Gitlab::Git::Blame.new(repository, SeedRepo::EncodingCommit::ID, "encoding/iso8859.txt")
+    end
+
+    it 'converts to UTF-8' do
+      expect(CharlockHolmes::EncodingDetector).to receive(:detect).and_return(nil)
+      data = []
+      blame.each do |commit, line|
+        data << {
+            commit: commit,
+            line: line
+        }
+      end
+
+      expect(data.size).to eq(1)
+      expect(data.first[:commit]).to be_kind_of(Gitlab::Git::Commit)
+      expect(data.first[:line]).to eq(" ")
+    end
+  end
+end
diff --git a/spec/lib/gitlab/git/blob_snippet_spec.rb b/spec/lib/gitlab/git/blob_snippet_spec.rb
new file mode 100644
index 00000000000..79b1311ac91
--- /dev/null
+++ b/spec/lib/gitlab/git/blob_snippet_spec.rb
@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+require "spec_helper"
+
+describe Gitlab::Git::BlobSnippet, seed_helper: true do
+  describe :data do
+    context 'empty lines' do
+      let(:snippet) { Gitlab::Git::BlobSnippet.new('master', nil, nil, nil) }
+
+      it { expect(snippet.data).to be_nil }
+    end
+
+    context 'present lines' do
+      let(:snippet) { Gitlab::Git::BlobSnippet.new('master', ['wow', 'much'], 1, 'wow.rb') }
+
+      it { expect(snippet.data).to eq("wow\nmuch") }
+    end
+  end
+end
diff --git a/spec/lib/gitlab/git/blob_spec.rb b/spec/lib/gitlab/git/blob_spec.rb
new file mode 100644
index 00000000000..84f79ec2391
--- /dev/null
+++ b/spec/lib/gitlab/git/blob_spec.rb
@@ -0,0 +1,489 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Gitlab::Git::Blob, seed_helper: true do
+  let(:repository) { Gitlab::Git::Repository.new(TEST_REPO_PATH) }
+
+  describe :initialize do
+    let(:blob) { Gitlab::Git::Blob.new(name: 'test') }
+
+    it 'handles nil data' do
+      expect(blob.name).to eq('test')
+      expect(blob.size).to eq(nil)
+      expect(blob.loaded_size).to eq(nil)
+    end
+  end
+
+  describe :find do
+    context 'file in subdir' do
+      let(:blob) { Gitlab::Git::Blob.find(repository, SeedRepo::Commit::ID, "files/ruby/popen.rb") }
+
+      it { expect(blob.id).to eq(SeedRepo::RubyBlob::ID) }
+      it { expect(blob.name).to eq(SeedRepo::RubyBlob::NAME) }
+      it { expect(blob.path).to eq("files/ruby/popen.rb") }
+      it { expect(blob.commit_id).to eq(SeedRepo::Commit::ID) }
+      it { expect(blob.data[0..10]).to eq(SeedRepo::RubyBlob::CONTENT[0..10]) }
+      it { expect(blob.size).to eq(669) }
+      it { expect(blob.mode).to eq("100644") }
+    end
+
+    context 'file in root' do
+      let(:blob) { Gitlab::Git::Blob.find(repository, SeedRepo::Commit::ID, ".gitignore") }
+
+      it { expect(blob.id).to eq("dfaa3f97ca337e20154a98ac9d0be76ddd1fcc82") }
+      it { expect(blob.name).to eq(".gitignore") }
+      it { expect(blob.path).to eq(".gitignore") }
+      it { expect(blob.commit_id).to eq(SeedRepo::Commit::ID) }
+      it { expect(blob.data[0..10]).to eq("*.rbc\n*.sas") }
+      it { expect(blob.size).to eq(241) }
+      it { expect(blob.mode).to eq("100644") }
+      it { expect(blob).not_to be_binary }
+    end
+
+    context 'file in root with leading slash' do
+      let(:blob) { Gitlab::Git::Blob.find(repository, SeedRepo::Commit::ID, "/.gitignore") }
+
+      it { expect(blob.id).to eq("dfaa3f97ca337e20154a98ac9d0be76ddd1fcc82") }
+      it { expect(blob.name).to eq(".gitignore") }
+      it { expect(blob.path).to eq(".gitignore") }
+      it { expect(blob.commit_id).to eq(SeedRepo::Commit::ID) }
+      it { expect(blob.data[0..10]).to eq("*.rbc\n*.sas") }
+      it { expect(blob.size).to eq(241) }
+      it { expect(blob.mode).to eq("100644") }
+    end
+
+    context 'non-exist file' do
+      let(:blob) { Gitlab::Git::Blob.find(repository, SeedRepo::Commit::ID, "missing.rb") }
+
+      it { expect(blob).to be_nil }
+    end
+
+    context 'six submodule' do
+      let(:blob) { Gitlab::Git::Blob.find(repository, SeedRepo::Commit::ID, 'six') }
+
+      it { expect(blob.id).to eq('409f37c4f05865e4fb208c771485f211a22c4c2d') }
+      it { expect(blob.data).to eq('') }
+
+      it 'does not get messed up by load_all_data!' do
+        blob.load_all_data!(repository)
+        expect(blob.data).to eq('')
+      end
+
+      it 'does not mark the blob as binary' do
+        expect(blob).not_to be_binary
+      end
+    end
+
+    context 'large file' do
+      let(:blob) { Gitlab::Git::Blob.find(repository, SeedRepo::Commit::ID, 'files/images/6049019_460s.jpg') }
+      let(:blob_size) { 111803 }
+
+      it { expect(blob.size).to eq(blob_size) }
+      it { expect(blob.data.length).to eq(blob_size) }
+
+      it 'check that this test is sane' do
+        expect(blob.size).to be <= Gitlab::Git::Blob::MAX_DATA_DISPLAY_SIZE
+      end
+
+      it 'can load all data' do
+        blob.load_all_data!(repository)
+        expect(blob.data.length).to eq(blob_size)
+      end
+
+      it 'marks the blob as binary' do
+        expect(Gitlab::Git::Blob).to receive(:new).
+          with(hash_including(binary: true)).
+          and_call_original
+
+        expect(blob).to be_binary
+      end
+    end
+  end
+
+  describe :raw do
+    let(:raw_blob) { Gitlab::Git::Blob.raw(repository, SeedRepo::RubyBlob::ID) }
+    it { expect(raw_blob.id).to eq(SeedRepo::RubyBlob::ID) }
+    it { expect(raw_blob.data[0..10]).to eq("require \'fi") }
+    it { expect(raw_blob.size).to eq(669) }
+    it { expect(raw_blob.truncated?).to be_falsey }
+
+    context 'large file' do
+      it 'limits the size of a large file' do
+        blob_size = Gitlab::Git::Blob::MAX_DATA_DISPLAY_SIZE + 1
+        buffer = Array.new(blob_size, 0)
+        rugged_blob = Rugged::Blob.from_buffer(repository.rugged, buffer.join(''))
+        blob = Gitlab::Git::Blob.raw(repository, rugged_blob)
+
+        expect(blob.size).to eq(blob_size)
+        expect(blob.loaded_size).to eq(Gitlab::Git::Blob::MAX_DATA_DISPLAY_SIZE)
+        expect(blob.data.length).to eq(Gitlab::Git::Blob::MAX_DATA_DISPLAY_SIZE)
+        expect(blob.truncated?).to be_truthy
+
+        blob.load_all_data!(repository)
+        expect(blob.loaded_size).to eq(blob_size)
+      end
+    end
+  end
+
+  describe 'encoding' do
+    context 'file with russian text' do
+      let(:blob) { Gitlab::Git::Blob.find(repository, SeedRepo::Commit::ID, "encoding/russian.rb") }
+
+      it { expect(blob.name).to eq("russian.rb") }
+      it { expect(blob.data.lines.first).to eq("Хороший файл") }
+      it { expect(blob.size).to eq(23) }
+      it { expect(blob.truncated?).to be_falsey }
+      # Run it twice since data is encoded after the first run
+      it { expect(blob.truncated?).to be_falsey }
+      it { expect(blob.mode).to eq("100755") }
+    end
+
+    context 'file with Chinese text' do
+      let(:blob) { Gitlab::Git::Blob.find(repository, SeedRepo::Commit::ID, "encoding/テスト.txt") }
+
+      it { expect(blob.name).to eq("テスト.txt") }
+      it { expect(blob.data).to include("これはテスト") }
+      it { expect(blob.size).to eq(340) }
+      it { expect(blob.mode).to eq("100755") }
+      it { expect(blob.truncated?).to be_falsey }
+    end
+
+    context 'file with ISO-8859 text' do
+      let(:blob) { Gitlab::Git::Blob.find(repository, SeedRepo::LastCommit::ID, "encoding/iso8859.txt") }
+
+      it { expect(blob.name).to eq("iso8859.txt") }
+      it { expect(blob.loaded_size).to eq(4) }
+      it { expect(blob.size).to eq(4) }
+      it { expect(blob.mode).to eq("100644") }
+      it { expect(blob.truncated?).to be_falsey }
+    end
+  end
+
+  describe 'mode' do
+    context 'file regular' do
+      let(:blob) do
+        Gitlab::Git::Blob.find(
+          repository,
+          'fa1b1e6c004a68b7d8763b86455da9e6b23e36d6',
+          'files/ruby/regex.rb'
+        )
+      end
+
+      it { expect(blob.name).to eq('regex.rb') }
+      it { expect(blob.path).to eq('files/ruby/regex.rb') }
+      it { expect(blob.size).to eq(1200) }
+      it { expect(blob.mode).to eq("100644") }
+    end
+
+    context 'file binary' do
+      let(:blob) do
+        Gitlab::Git::Blob.find(
+          repository,
+          'fa1b1e6c004a68b7d8763b86455da9e6b23e36d6',
+          'files/executables/ls'
+        )
+      end
+
+      it { expect(blob.name).to eq('ls') }
+      it { expect(blob.path).to eq('files/executables/ls') }
+      it { expect(blob.size).to eq(110080) }
+      it { expect(blob.mode).to eq("100755") }
+    end
+
+    context 'file symlink to regular' do
+      let(:blob) do
+        Gitlab::Git::Blob.find(
+          repository,
+          'fa1b1e6c004a68b7d8763b86455da9e6b23e36d6',
+          'files/links/ruby-style-guide.md'
+        )
+      end
+
+      it { expect(blob.name).to eq('ruby-style-guide.md') }
+      it { expect(blob.path).to eq('files/links/ruby-style-guide.md') }
+      it { expect(blob.size).to eq(31) }
+      it { expect(blob.mode).to eq("120000") }
+    end
+
+    context 'file symlink to binary' do
+      let(:blob) do
+        Gitlab::Git::Blob.find(
+          repository,
+          'fa1b1e6c004a68b7d8763b86455da9e6b23e36d6',
+          'files/links/touch'
+        )
+      end
+
+      it { expect(blob.name).to eq('touch') }
+      it { expect(blob.path).to eq('files/links/touch') }
+      it { expect(blob.size).to eq(20) }
+      it { expect(blob.mode).to eq("120000") }
+    end
+  end
+
+  describe :commit do
+    let(:repository) { Gitlab::Git::Repository.new(TEST_REPO_PATH) }
+
+    let(:commit_options) do
+      {
+         file: {
+           content: 'Lorem ipsum...',
+           path: 'documents/story.txt'
+         },
+         author: {
+           email: 'user@example.com',
+           name: 'Test User',
+           time: Time.now
+         },
+         committer: {
+           email: 'user@example.com',
+           name: 'Test User',
+           time: Time.now
+         },
+         commit: {
+           message: 'Wow such commit',
+           branch: 'fix-mode'
+         }
+      }
+    end
+
+    let(:commit_sha) { Gitlab::Git::Blob.commit(repository, commit_options) }
+    let(:commit) { repository.lookup(commit_sha) }
+
+    it 'should add file with commit' do
+      # Commit message valid
+      expect(commit.message).to eq('Wow such commit')
+
+      tree = commit.tree.to_a.find { |tree| tree[:name] == 'documents' }
+
+      # Directory was created
+      expect(tree[:type]).to eq(:tree)
+
+      # File was created
+      expect(repository.lookup(tree[:oid]).first[:name]).to eq('story.txt')
+    end
+
+    describe "ref updating" do
+      it 'creates a commit but does not udate a ref' do
+        commit_opts = commit_options.tap{ |opts| opts[:commit][:update_ref] = false}
+        commit_sha = Gitlab::Git::Blob.commit(repository, commit_opts)
+        commit = repository.lookup(commit_sha)
+
+        # Commit message valid
+        expect(commit.message).to eq('Wow such commit')
+
+        # Does not update any related ref
+        expect(repository.lookup("fix-mode").oid).not_to eq(commit.oid)
+        expect(repository.lookup("HEAD").oid).not_to eq(commit.oid)
+      end
+    end
+
+    describe 'reject updates' do
+      it 'should reject updates' do
+        commit_options[:file][:update] = false
+        commit_options[:file][:path] = 'files/executables/ls'
+
+        expect{ commit_sha }.to raise_error('Filename already exists; update not allowed')
+      end
+    end
+
+    describe 'file modes' do
+      it 'should preserve file modes with commit' do
+        commit_options[:file][:path] = 'files/executables/ls'
+
+        entry = Gitlab::Git::Blob::find_entry_by_path(repository, commit.tree.oid, commit_options[:file][:path])
+        expect(entry[:filemode]).to eq(0100755)
+      end
+    end
+  end
+
+  describe :rename do
+    let(:repository) { Gitlab::Git::Repository.new(TEST_NORMAL_REPO_PATH) }
+    let(:rename_options) do
+      {
+        file: {
+          path: 'NEWCONTRIBUTING.md',
+          previous_path: 'CONTRIBUTING.md',
+          content: 'Lorem ipsum...',
+          update: true
+        },
+        author: {
+          email: 'user@example.com',
+          name: 'Test User',
+          time: Time.now
+        },
+        committer: {
+          email: 'user@example.com',
+          name: 'Test User',
+          time: Time.now
+        },
+        commit: {
+          message: 'Rename readme',
+          branch: 'master'
+        }
+      }
+    end
+
+    let(:rename_options2) do
+      {
+         file: {
+           content: 'Lorem ipsum...',
+           path: 'bin/new_executable',
+           previous_path: 'bin/executable',
+         },
+         author: {
+           email: 'user@example.com',
+           name: 'Test User',
+           time: Time.now
+         },
+         committer: {
+           email: 'user@example.com',
+           name: 'Test User',
+           time: Time.now
+         },
+         commit: {
+           message: 'Updates toberenamed.txt',
+           branch: 'master',
+           update_ref: false
+         }
+      }
+    end
+
+    it 'maintains file permissions when renaming' do
+      mode = 0o100755
+
+      Gitlab::Git::Blob.rename(repository, rename_options2)
+
+      expect(repository.rugged.index.get(rename_options2[:file][:path])[:mode]).to eq(mode)
+    end
+
+    it 'renames the file with commit and not change file permissions' do
+      ref = rename_options[:commit][:branch]
+
+      expect(repository.rugged.index.get('CONTRIBUTING.md')).not_to be_nil
+      expect { Gitlab::Git::Blob.rename(repository, rename_options) }.to change { repository.commit_count(ref) }.by(1)
+
+      expect(repository.rugged.index.get('CONTRIBUTING.md')).to be_nil
+      expect(repository.rugged.index.get('NEWCONTRIBUTING.md')).not_to be_nil
+    end
+  end
+
+  describe :remove do
+    let(:repository) { Gitlab::Git::Repository.new(TEST_REPO_PATH) }
+
+    let(:commit_options) do
+      {
+         file: {
+           path: 'README.md'
+         },
+         author: {
+           email: 'user@example.com',
+           name: 'Test User',
+           time: Time.now
+         },
+         committer: {
+           email: 'user@example.com',
+           name: 'Test User',
+           time: Time.now
+         },
+         commit: {
+           message: 'Remove readme',
+           branch: 'feature'
+         }
+      }
+    end
+
+    let(:commit_sha) { Gitlab::Git::Blob.remove(repository, commit_options) }
+    let(:commit) { repository.lookup(commit_sha) }
+    let(:blob) { Gitlab::Git::Blob.find(repository, commit_sha, "README.md") }
+
+    it 'should remove file with commit' do
+      # Commit message valid
+      expect(commit.message).to eq('Remove readme')
+
+      # File was removed
+      expect(blob).to be_nil
+    end
+  end
+
+  describe :lfs_pointers do
+    context 'file a valid lfs pointer' do
+      let(:blob) do
+        Gitlab::Git::Blob.find(
+          repository,
+          '33bcff41c232a11727ac6d660bd4b0c2ba86d63d',
+          'files/lfs/image.jpg'
+        )
+      end
+
+      it { expect(blob.lfs_pointer?).to eq(true) }
+      it { expect(blob.lfs_oid).to eq("4206f951d2691c78aac4c0ce9f2b23580b2c92cdcc4336e1028742c0274938e0") }
+      it { expect(blob.lfs_size).to eq("19548") }
+      it { expect(blob.id).to eq("f4d76af13003d1106be7ac8c5a2a3d37ddf32c2a") }
+      it { expect(blob.name).to eq("image.jpg") }
+      it { expect(blob.path).to eq("files/lfs/image.jpg") }
+      it { expect(blob.size).to eq(130) }
+      it { expect(blob.mode).to eq("100644") }
+    end
+
+    describe 'file an invalid lfs pointer' do
+      context 'with correct version header but incorrect size and oid' do
+        let(:blob) do
+          Gitlab::Git::Blob.find(
+            repository,
+            '33bcff41c232a11727ac6d660bd4b0c2ba86d63d',
+            'files/lfs/archive-invalid.tar'
+          )
+        end
+
+        it { expect(blob.lfs_pointer?).to eq(false) }
+        it { expect(blob.lfs_oid).to eq(nil) }
+        it { expect(blob.lfs_size).to eq(nil) }
+        it { expect(blob.id).to eq("f8a898db217a5a85ed8b3d25b34c1df1d1094c46") }
+        it { expect(blob.name).to eq("archive-invalid.tar") }
+        it { expect(blob.path).to eq("files/lfs/archive-invalid.tar") }
+        it { expect(blob.size).to eq(43) }
+        it { expect(blob.mode).to eq("100644") }
+      end
+
+      context 'with correct version header and size but incorrect size and oid' do
+        let(:blob) do
+          Gitlab::Git::Blob.find(
+            repository,
+            '33bcff41c232a11727ac6d660bd4b0c2ba86d63d',
+            'files/lfs/picture-invalid.png'
+          )
+        end
+
+        it { expect(blob.lfs_pointer?).to eq(false) }
+        it { expect(blob.lfs_oid).to eq(nil) }
+        it { expect(blob.lfs_size).to eq("1575078") }
+        it { expect(blob.id).to eq("5ae35296e1f95c1ef9feda1241477ed29a448572") }
+        it { expect(blob.name).to eq("picture-invalid.png") }
+        it { expect(blob.path).to eq("files/lfs/picture-invalid.png") }
+        it { expect(blob.size).to eq(57) }
+        it { expect(blob.mode).to eq("100644") }
+      end
+
+      context 'with correct version header and size but invalid size and oid' do
+        let(:blob) do
+          Gitlab::Git::Blob.find(
+            repository,
+            '33bcff41c232a11727ac6d660bd4b0c2ba86d63d',
+            'files/lfs/file-invalid.zip'
+          )
+        end
+
+        it { expect(blob.lfs_pointer?).to eq(false) }
+        it { expect(blob.lfs_oid).to eq(nil) }
+        it { expect(blob.lfs_size).to eq(nil) }
+        it { expect(blob.id).to eq("d831981bd876732b85a1bcc6cc01210c9f36248f") }
+        it { expect(blob.name).to eq("file-invalid.zip") }
+        it { expect(blob.path).to eq("files/lfs/file-invalid.zip") }
+        it { expect(blob.size).to eq(60) }
+        it { expect(blob.mode).to eq("100644") }
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/git/branch_spec.rb b/spec/lib/gitlab/git/branch_spec.rb
new file mode 100644
index 00000000000..78234b396c5
--- /dev/null
+++ b/spec/lib/gitlab/git/branch_spec.rb
@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Gitlab::Git::Branch, seed_helper: true do
+  let(:repository) { Gitlab::Git::Repository.new(TEST_REPO_PATH) }
+
+  subject { repository.branches }
+
+  it { is_expected.to be_kind_of Array }
+
+  describe '#size' do
+    subject { super().size }
+    it { is_expected.to eq(SeedRepo::Repo::BRANCHES.size) }
+  end
+
+  describe 'first branch' do
+    let(:branch) { repository.branches.first }
+
+    it { expect(branch.name).to eq(SeedRepo::Repo::BRANCHES.first) }
+    it { expect(branch.dereferenced_target.sha).to eq("0b4bc9a49b562e85de7cc9e834518ea6828729b9") }
+  end
+
+  describe 'master branch' do
+    let(:branch) do
+      repository.branches.find { |branch| branch.name == 'master' }
+    end
+
+    it { expect(branch.dereferenced_target.sha).to eq(SeedRepo::LastCommit::ID) }
+  end
+
+  it { expect(repository.branches.size).to eq(SeedRepo::Repo::BRANCHES.size) }
+end
diff --git a/spec/lib/gitlab/git/commit_spec.rb b/spec/lib/gitlab/git/commit_spec.rb
new file mode 100644
index 00000000000..e1be6784c20
--- /dev/null
+++ b/spec/lib/gitlab/git/commit_spec.rb
@@ -0,0 +1,408 @@
+require "spec_helper"
+
+describe Gitlab::Git::Commit, seed_helper: true do
+  let(:repository) { Gitlab::Git::Repository.new(TEST_REPO_PATH) }
+  let(:commit) { Gitlab::Git::Commit.find(repository, SeedRepo::Commit::ID) }
+  let(:rugged_commit) do
+    repository.rugged.lookup(SeedRepo::Commit::ID)
+  end
+
+  describe "Commit info" do
+    before do
+      repo = Gitlab::Git::Repository.new(TEST_REPO_PATH).rugged
+
+      @committer = {
+        email: 'mike@smith.com',
+        name: "Mike Smith",
+        time: Time.now
+      }
+
+      @author = {
+        email: 'john@smith.com',
+        name: "John Smith",
+        time: Time.now
+      }
+
+      @parents = [repo.head.target]
+      @gitlab_parents = @parents.map { |c| Gitlab::Git::Commit.decorate(c) }
+      @tree = @parents.first.tree
+
+      sha = Rugged::Commit.create(
+        repo,
+        author: @author,
+        committer: @committer,
+        tree: @tree,
+        parents: @parents,
+        message: "Refactoring specs",
+        update_ref: "HEAD"
+      )
+
+      @raw_commit = repo.lookup(sha)
+      @commit = Gitlab::Git::Commit.new(@raw_commit)
+    end
+
+    it { expect(@commit.short_id).to eq(@raw_commit.oid[0..10]) }
+    it { expect(@commit.id).to eq(@raw_commit.oid) }
+    it { expect(@commit.sha).to eq(@raw_commit.oid) }
+    it { expect(@commit.safe_message).to eq(@raw_commit.message) }
+    it { expect(@commit.created_at).to eq(@raw_commit.author[:time]) }
+    it { expect(@commit.date).to eq(@raw_commit.committer[:time]) }
+    it { expect(@commit.author_email).to eq(@author[:email]) }
+    it { expect(@commit.author_name).to eq(@author[:name]) }
+    it { expect(@commit.committer_name).to eq(@committer[:name]) }
+    it { expect(@commit.committer_email).to eq(@committer[:email]) }
+    it { expect(@commit.different_committer?).to be_truthy }
+    it { expect(@commit.parents).to eq(@gitlab_parents) }
+    it { expect(@commit.parent_id).to eq(@parents.first.oid) }
+    it { expect(@commit.no_commit_message).to eq("--no commit message") }
+    it { expect(@commit.tree).to eq(@tree) }
+
+    after do
+      # Erase the new commit so other tests get the original repo
+      repo = Gitlab::Git::Repository.new(TEST_REPO_PATH).rugged
+      repo.references.update("refs/heads/master", SeedRepo::LastCommit::ID)
+    end
+  end
+
+  context 'Class methods' do
+    describe :find do
+      it "should return first head commit if without params" do
+        expect(Gitlab::Git::Commit.last(repository).id).to eq(
+          repository.raw.head.target.oid
+        )
+      end
+
+      it "should return valid commit" do
+        expect(Gitlab::Git::Commit.find(repository, SeedRepo::Commit::ID)).to be_valid_commit
+      end
+
+      it "should return valid commit for tag" do
+        expect(Gitlab::Git::Commit.find(repository, 'v1.0.0').id).to eq('6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9')
+      end
+
+      it "should return nil for non-commit ids" do
+        blob = Gitlab::Git::Blob.find(repository, SeedRepo::Commit::ID, "files/ruby/popen.rb")
+        expect(Gitlab::Git::Commit.find(repository, blob.id)).to be_nil
+      end
+
+      it "should return nil for parent of non-commit object" do
+        blob = Gitlab::Git::Blob.find(repository, SeedRepo::Commit::ID, "files/ruby/popen.rb")
+        expect(Gitlab::Git::Commit.find(repository, "#{blob.id}^")).to be_nil
+      end
+
+      it "should return nil for nonexisting ids" do
+        expect(Gitlab::Git::Commit.find(repository, "+123_4532530XYZ")).to be_nil
+      end
+
+      context 'with broken repo' do
+        let(:repository) { Gitlab::Git::Repository.new(TEST_BROKEN_REPO_PATH) }
+
+        it 'returns nil' do
+          expect(Gitlab::Git::Commit.find(repository, SeedRepo::Commit::ID)).to be_nil
+        end
+      end
+    end
+
+    describe :last_for_path do
+      context 'no path' do
+        subject { Gitlab::Git::Commit.last_for_path(repository, 'master') }
+
+        describe '#id' do
+          subject { super().id }
+          it { is_expected.to eq(SeedRepo::LastCommit::ID) }
+        end
+      end
+
+      context 'path' do
+        subject { Gitlab::Git::Commit.last_for_path(repository, 'master', 'files/ruby') }
+
+        describe '#id' do
+          subject { super().id }
+          it { is_expected.to eq(SeedRepo::Commit::ID) }
+        end
+      end
+
+      context 'ref + path' do
+        subject { Gitlab::Git::Commit.last_for_path(repository, SeedRepo::Commit::ID, 'encoding') }
+
+        describe '#id' do
+          subject { super().id }
+          it { is_expected.to eq(SeedRepo::BigCommit::ID) }
+        end
+      end
+    end
+
+    describe "where" do
+      context 'path is empty string' do
+        subject do
+          commits = Gitlab::Git::Commit.where(
+            repo: repository,
+            ref: 'master',
+            path: '',
+            limit: 10
+          )
+
+          commits.map { |c| c.id }
+        end
+
+        it 'has 10 elements' do
+          expect(subject.size).to eq(10)
+        end
+        it { is_expected.to include(SeedRepo::EmptyCommit::ID) }
+      end
+
+      context 'path is nil' do
+        subject do
+          commits = Gitlab::Git::Commit.where(
+            repo: repository,
+            ref: 'master',
+            path: nil,
+            limit: 10
+          )
+
+          commits.map { |c| c.id }
+        end
+
+        it 'has 10 elements' do
+          expect(subject.size).to eq(10)
+        end
+        it { is_expected.to include(SeedRepo::EmptyCommit::ID) }
+      end
+
+      context 'ref is branch name' do
+        subject do
+          commits = Gitlab::Git::Commit.where(
+            repo: repository,
+            ref: 'master',
+            path: 'files',
+            limit: 3,
+            offset: 1
+          )
+
+          commits.map { |c| c.id }
+        end
+
+        it 'has 3 elements' do
+          expect(subject.size).to eq(3)
+        end
+        it { is_expected.to include("d14d6c0abdd253381df51a723d58691b2ee1ab08") }
+        it { is_expected.not_to include("eb49186cfa5c4338011f5f590fac11bd66c5c631") }
+      end
+
+      context 'ref is commit id' do
+        subject do
+          commits = Gitlab::Git::Commit.where(
+            repo: repository,
+            ref: "874797c3a73b60d2187ed6e2fcabd289ff75171e",
+            path: 'files',
+            limit: 3,
+            offset: 1
+          )
+
+          commits.map { |c| c.id }
+        end
+
+        it 'has 3 elements' do
+          expect(subject.size).to eq(3)
+        end
+        it { is_expected.to include("2f63565e7aac07bcdadb654e253078b727143ec4") }
+        it { is_expected.not_to include(SeedRepo::Commit::ID) }
+      end
+
+      context 'ref is tag' do
+        subject do
+          commits = Gitlab::Git::Commit.where(
+            repo: repository,
+            ref: 'v1.0.0',
+            path: 'files',
+            limit: 3,
+            offset: 1
+          )
+
+          commits.map { |c| c.id }
+        end
+
+        it 'has 3 elements' do
+          expect(subject.size).to eq(3)
+        end
+        it { is_expected.to include("874797c3a73b60d2187ed6e2fcabd289ff75171e") }
+        it { is_expected.not_to include(SeedRepo::Commit::ID) }
+      end
+    end
+
+    describe :between do
+      subject do
+        commits = Gitlab::Git::Commit.between(repository, SeedRepo::Commit::PARENT_ID, SeedRepo::Commit::ID)
+        commits.map { |c| c.id }
+      end
+
+      it 'has 1 element' do
+        expect(subject.size).to eq(1)
+      end
+      it { is_expected.to include(SeedRepo::Commit::ID) }
+      it { is_expected.not_to include(SeedRepo::FirstCommit::ID) }
+    end
+
+    describe :find_all do
+      context 'max_count' do
+        subject do
+          commits = Gitlab::Git::Commit.find_all(
+            repository,
+            max_count: 50
+          )
+
+          commits.map { |c| c.id }
+        end
+
+        it 'has 31 elements' do
+          expect(subject.size).to eq(33)
+        end
+        it { is_expected.to include(SeedRepo::Commit::ID) }
+        it { is_expected.to include(SeedRepo::Commit::PARENT_ID) }
+        it { is_expected.to include(SeedRepo::FirstCommit::ID) }
+      end
+
+      context 'ref + max_count + skip' do
+        subject do
+          commits = Gitlab::Git::Commit.find_all(
+            repository,
+            ref: 'master',
+            max_count: 50,
+            skip: 1
+          )
+
+          commits.map { |c| c.id }
+        end
+
+        it 'has 23 elements' do
+          expect(subject.size).to eq(24)
+        end
+        it { is_expected.to include(SeedRepo::Commit::ID) }
+        it { is_expected.to include(SeedRepo::FirstCommit::ID) }
+        it { is_expected.not_to include(SeedRepo::LastCommit::ID) }
+      end
+
+      context 'contains feature + max_count' do
+        subject do
+          commits = Gitlab::Git::Commit.find_all(
+            repository,
+            contains: 'feature',
+            max_count: 7
+          )
+
+          commits.map { |c| c.id }
+        end
+
+        it 'has 7 elements' do
+          expect(subject.size).to eq(7)
+        end
+
+        it { is_expected.not_to include(SeedRepo::Commit::PARENT_ID) }
+        it { is_expected.not_to include(SeedRepo::Commit::ID) }
+        it { is_expected.to include(SeedRepo::BigCommit::ID) }
+      end
+    end
+  end
+
+  describe :init_from_rugged do
+    let(:gitlab_commit) { Gitlab::Git::Commit.new(rugged_commit) }
+    subject { gitlab_commit }
+
+    describe '#id' do
+      subject { super().id }
+      it { is_expected.to eq(SeedRepo::Commit::ID) }
+    end
+  end
+
+  describe :init_from_hash do
+    let(:commit) { Gitlab::Git::Commit.new(sample_commit_hash) }
+    subject { commit }
+
+    describe '#id' do
+      subject { super().id }
+      it { is_expected.to eq(sample_commit_hash[:id])}
+    end
+
+    describe '#message' do
+      subject { super().message }
+      it { is_expected.to eq(sample_commit_hash[:message])}
+    end
+  end
+
+  describe :stats do
+    subject { commit.stats }
+
+    describe '#additions' do
+      subject { super().additions }
+      it { is_expected.to eq(11) }
+    end
+
+    describe '#deletions' do
+      subject { super().deletions }
+      it { is_expected.to eq(6) }
+    end
+  end
+
+  describe :to_diff do
+    subject { commit.to_diff }
+
+    it { is_expected.not_to include "From #{SeedRepo::Commit::ID}" }
+    it { is_expected.to include 'diff --git a/files/ruby/popen.rb b/files/ruby/popen.rb'}
+  end
+
+  describe :has_zero_stats? do
+    it { expect(commit.has_zero_stats?).to eq(false) }
+  end
+
+  describe :to_patch do
+    subject { commit.to_patch }
+
+    it { is_expected.to include "From #{SeedRepo::Commit::ID}" }
+    it { is_expected.to include 'diff --git a/files/ruby/popen.rb b/files/ruby/popen.rb'}
+  end
+
+  describe :to_hash do
+    let(:hash) { commit.to_hash }
+    subject { hash }
+
+    it { is_expected.to be_kind_of Hash }
+
+    describe '#keys' do
+      subject { super().keys.sort }
+      it { is_expected.to match(sample_commit_hash.keys.sort) }
+    end
+  end
+
+  describe :diffs do
+    subject { commit.diffs }
+
+    it { is_expected.to be_kind_of Gitlab::Git::DiffCollection }
+    it { expect(subject.count).to eq(2) }
+    it { expect(subject.first).to be_kind_of Gitlab::Git::Diff }
+  end
+
+  describe :ref_names do
+    let(:commit) { Gitlab::Git::Commit.find(repository, 'master') }
+    subject { commit.ref_names(repository) }
+
+    it 'has 1 element' do
+      expect(subject.size).to eq(1)
+    end
+    it { is_expected.to include("master") }
+    it { is_expected.not_to include("feature") }
+  end
+
+  def sample_commit_hash
+    {
+      author_email: "dmitriy.zaporozhets@gmail.com",
+      author_name: "Dmitriy Zaporozhets",
+      authored_date: "2012-02-27 20:51:12 +0200",
+      committed_date: "2012-02-27 20:51:12 +0200",
+      committer_email: "dmitriy.zaporozhets@gmail.com",
+      committer_name: "Dmitriy Zaporozhets",
+      id: SeedRepo::Commit::ID,
+      message: "tree css fixes",
+      parent_ids: ["874797c3a73b60d2187ed6e2fcabd289ff75171e"]
+    }
+  end
+end
diff --git a/spec/lib/gitlab/git/compare_spec.rb b/spec/lib/gitlab/git/compare_spec.rb
new file mode 100644
index 00000000000..f66b68e4218
--- /dev/null
+++ b/spec/lib/gitlab/git/compare_spec.rb
@@ -0,0 +1,109 @@
+require "spec_helper"
+
+describe Gitlab::Git::Compare, seed_helper: true do
+  let(:repository) { Gitlab::Git::Repository.new(TEST_REPO_PATH) }
+  let(:compare) { Gitlab::Git::Compare.new(repository, SeedRepo::BigCommit::ID, SeedRepo::Commit::ID, false) }
+  let(:compare_straight) { Gitlab::Git::Compare.new(repository, SeedRepo::BigCommit::ID, SeedRepo::Commit::ID, true) }
+
+  describe :commits do
+    subject do
+      compare.commits.map(&:id)
+    end
+
+    it 'has 8 elements' do
+      expect(subject.size).to eq(8)
+    end
+
+    it { is_expected.to include(SeedRepo::Commit::PARENT_ID) }
+    it { is_expected.not_to include(SeedRepo::BigCommit::PARENT_ID) }
+
+    context 'non-existing base ref' do
+      let(:compare) { Gitlab::Git::Compare.new(repository, 'no-such-branch', SeedRepo::Commit::ID) }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'non-existing head ref' do
+      let(:compare) { Gitlab::Git::Compare.new(repository, SeedRepo::BigCommit::ID, '1234567890') }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'base ref is equal to head ref' do
+      let(:compare) { Gitlab::Git::Compare.new(repository, SeedRepo::BigCommit::ID, SeedRepo::BigCommit::ID) }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'providing nil as base ref or head ref' do
+      let(:compare) { Gitlab::Git::Compare.new(repository, nil, nil) }
+
+      it { is_expected.to be_empty }
+    end
+  end
+
+  describe :diffs do
+    subject do
+      compare.diffs.map(&:new_path)
+    end
+
+    it 'has 10 elements' do
+      expect(subject.size).to eq(10)
+    end
+
+    it { is_expected.to include('files/ruby/popen.rb') }
+    it { is_expected.not_to include('LICENSE') }
+
+    context 'non-existing base ref' do
+      let(:compare) { Gitlab::Git::Compare.new(repository, 'no-such-branch', SeedRepo::Commit::ID) }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'non-existing head ref' do
+      let(:compare) { Gitlab::Git::Compare.new(repository, SeedRepo::BigCommit::ID, '1234567890') }
+
+      it { is_expected.to be_empty }
+    end
+  end
+
+  describe :same  do
+    subject do
+      compare.same
+    end
+
+    it { is_expected.to eq(false) }
+
+    context 'base ref is equal to head ref' do
+      let(:compare) { Gitlab::Git::Compare.new(repository, SeedRepo::BigCommit::ID, SeedRepo::BigCommit::ID) }
+
+      it { is_expected.to eq(true) }
+    end
+  end
+
+  describe :commits_straight do
+    subject do
+      compare_straight.commits.map(&:id)
+    end
+
+    it 'has 8 elements' do
+      expect(subject.size).to eq(8)
+    end
+
+    it { is_expected.to include(SeedRepo::Commit::PARENT_ID) }
+    it { is_expected.not_to include(SeedRepo::BigCommit::PARENT_ID) }
+  end
+
+  describe :diffs_straight do
+    subject do
+      compare_straight.diffs.map(&:new_path)
+    end
+
+    it 'has 10 elements' do
+      expect(subject.size).to eq(10)
+    end
+
+    it { is_expected.to include('files/ruby/popen.rb') }
+    it { is_expected.not_to include('LICENSE') }
+  end
+end
diff --git a/spec/lib/gitlab/git/diff_collection_spec.rb b/spec/lib/gitlab/git/diff_collection_spec.rb
new file mode 100644
index 00000000000..4fa72c565ae
--- /dev/null
+++ b/spec/lib/gitlab/git/diff_collection_spec.rb
@@ -0,0 +1,460 @@
+require 'spec_helper'
+
+describe Gitlab::Git::DiffCollection, seed_helper: true do
+  subject do
+    Gitlab::Git::DiffCollection.new(
+      iterator,
+      max_files: max_files,
+      max_lines: max_lines,
+      all_diffs: all_diffs,
+      no_collapse: no_collapse
+    )
+  end
+  let(:iterator) { Array.new(file_count, fake_diff(line_length, line_count)) }
+  let(:file_count) { 0 }
+  let(:line_length) { 1 }
+  let(:line_count) { 1 }
+  let(:max_files) { 10 }
+  let(:max_lines) { 100 }
+  let(:all_diffs) { false }
+  let(:no_collapse) { true }
+
+  describe '#to_a' do
+    subject { super().to_a }
+    it { is_expected.to be_kind_of ::Array }
+  end
+
+  describe :decorate! do
+    let(:file_count) { 3 }
+
+    it 'modifies the array in place' do
+      count = 0
+      subject.decorate! { |d| !d.nil? && count += 1 }
+      expect(subject.to_a).to eq([1, 2, 3])
+      expect(count).to eq(3)
+    end
+
+    it 'avoids future iterator iterations' do
+      subject.decorate! { |d| d unless d.nil? }
+
+      expect(iterator).not_to receive(:each)
+
+      subject.overflow?
+    end
+  end
+
+  context 'overflow handling' do
+    context 'adding few enough files' do
+      let(:file_count) { 3 }
+
+      context 'and few enough lines' do
+        let(:line_count) { 10 }
+
+        describe '#overflow?' do
+          subject { super().overflow? }
+          it { is_expected.to be_falsey }
+        end
+
+        describe '#empty?' do
+          subject { super().empty? }
+          it { is_expected.to be_falsey }
+        end
+
+        describe '#real_size' do
+          subject { super().real_size }
+          it { is_expected.to eq('3') }
+        end
+        it { expect(subject.size).to eq(3) }
+
+        context 'when limiting is disabled' do
+          let(:all_diffs) { true }
+
+          describe '#overflow?' do
+            subject { super().overflow? }
+            it { is_expected.to be_falsey }
+          end
+
+          describe '#empty?' do
+            subject { super().empty? }
+            it { is_expected.to be_falsey }
+          end
+
+          describe '#real_size' do
+            subject { super().real_size }
+            it { is_expected.to eq('3') }
+          end
+          it { expect(subject.size).to eq(3) }
+        end
+      end
+
+      context 'and too many lines' do
+        let(:line_count) { 1000 }
+
+        describe '#overflow?' do
+          subject { super().overflow? }
+          it { is_expected.to be_truthy }
+        end
+
+        describe '#empty?' do
+          subject { super().empty? }
+          it { is_expected.to be_falsey }
+        end
+
+        describe '#real_size' do
+          subject { super().real_size }
+          it { is_expected.to eq('0+') }
+        end
+        it { expect(subject.size).to eq(0) }
+
+        context 'when limiting is disabled' do
+          let(:all_diffs) { true }
+
+          describe '#overflow?' do
+            subject { super().overflow? }
+            it { is_expected.to be_falsey }
+          end
+
+          describe '#empty?' do
+            subject { super().empty? }
+            it { is_expected.to be_falsey }
+          end
+
+          describe '#real_size' do
+            subject { super().real_size }
+            it { is_expected.to eq('3') }
+          end
+          it { expect(subject.size).to eq(3) }
+        end
+      end
+    end
+
+    context 'adding too many files' do
+      let(:file_count) { 11 }
+
+      context 'and few enough lines' do
+        let(:line_count) { 1 }
+
+        describe '#overflow?' do
+          subject { super().overflow? }
+          it { is_expected.to be_truthy }
+        end
+
+        describe '#empty?' do
+          subject { super().empty? }
+          it { is_expected.to be_falsey }
+        end
+
+        describe '#real_size' do
+          subject { super().real_size }
+          it { is_expected.to eq('10+') }
+        end
+        it { expect(subject.size).to eq(10) }
+
+        context 'when limiting is disabled' do
+          let(:all_diffs) { true }
+
+          describe '#overflow?' do
+            subject { super().overflow? }
+            it { is_expected.to be_falsey }
+          end
+
+          describe '#empty?' do
+            subject { super().empty? }
+            it { is_expected.to be_falsey }
+          end
+
+          describe '#real_size' do
+            subject { super().real_size }
+            it { is_expected.to eq('11') }
+          end
+          it { expect(subject.size).to eq(11) }
+        end
+      end
+
+      context 'and too many lines' do
+        let(:line_count) { 30 }
+
+        describe '#overflow?' do
+          subject { super().overflow? }
+          it { is_expected.to be_truthy }
+        end
+
+        describe '#empty?' do
+          subject { super().empty? }
+          it { is_expected.to be_falsey }
+        end
+
+        describe '#real_size' do
+          subject { super().real_size }
+          it { is_expected.to eq('3+') }
+        end
+        it { expect(subject.size).to eq(3) }
+
+        context 'when limiting is disabled' do
+          let(:all_diffs) { true }
+
+          describe '#overflow?' do
+            subject { super().overflow? }
+            it { is_expected.to be_falsey }
+          end
+
+          describe '#empty?' do
+            subject { super().empty? }
+            it { is_expected.to be_falsey }
+          end
+
+          describe '#real_size' do
+            subject { super().real_size }
+            it { is_expected.to eq('11') }
+          end
+          it { expect(subject.size).to eq(11) }
+        end
+      end
+    end
+
+    context 'adding exactly the maximum number of files' do
+      let(:file_count) { 10 }
+
+      context 'and few enough lines' do
+        let(:line_count) { 1 }
+
+        describe '#overflow?' do
+          subject { super().overflow? }
+          it { is_expected.to be_falsey }
+        end
+
+        describe '#empty?' do
+          subject { super().empty? }
+          it { is_expected.to be_falsey }
+        end
+
+        describe '#real_size' do
+          subject { super().real_size }
+          it { is_expected.to eq('10') }
+        end
+        it { expect(subject.size).to eq(10) }
+      end
+    end
+
+    context 'adding too many bytes' do
+      let(:file_count) { 10 }
+      let(:line_length) { 5200 }
+
+      describe '#overflow?' do
+        subject { super().overflow? }
+        it { is_expected.to be_truthy }
+      end
+
+      describe '#empty?' do
+        subject { super().empty? }
+        it { is_expected.to be_falsey }
+      end
+
+      describe '#real_size' do
+        subject { super().real_size }
+        it { is_expected.to eq('9+') }
+      end
+      it { expect(subject.size).to eq(9) }
+
+      context 'when limiting is disabled' do
+        let(:all_diffs) { true }
+
+        describe '#overflow?' do
+          subject { super().overflow? }
+          it { is_expected.to be_falsey }
+        end
+
+        describe '#empty?' do
+          subject { super().empty? }
+          it { is_expected.to be_falsey }
+        end
+
+        describe '#real_size' do
+          subject { super().real_size }
+          it { is_expected.to eq('10') }
+        end
+        it { expect(subject.size).to eq(10) }
+      end
+    end
+  end
+
+  describe 'empty collection' do
+    subject { Gitlab::Git::DiffCollection.new([]) }
+
+    describe '#overflow?' do
+      subject { super().overflow? }
+      it { is_expected.to be_falsey }
+    end
+
+    describe '#empty?' do
+      subject { super().empty? }
+      it { is_expected.to be_truthy }
+    end
+
+    describe '#size' do
+      subject { super().size }
+      it { is_expected.to eq(0) }
+    end
+
+    describe '#real_size' do
+      subject { super().real_size }
+      it { is_expected.to eq('0')}
+    end
+  end
+
+  describe :each do
+    context 'when diff are too large' do
+      let(:collection) do
+        Gitlab::Git::DiffCollection.new([{ diff: 'a' * 204800 }])
+      end
+
+      it 'yields Diff instances even when they are too large' do
+        expect { |b| collection.each(&b) }.
+          to yield_with_args(an_instance_of(Gitlab::Git::Diff))
+      end
+
+      it 'prunes diffs that are too large' do
+        diff = nil
+
+        collection.each do |d|
+          diff = d
+        end
+
+        expect(diff.diff).to eq('')
+      end
+    end
+
+    context 'when diff is quite large will collapse by default' do
+      let(:iterator) { [{ diff: 'a' * 20480 }] }
+
+      context 'when no collapse is set' do
+        let(:no_collapse) { true }
+
+        it 'yields Diff instances even when they are quite big' do
+          expect { |b| subject.each(&b) }.
+            to yield_with_args(an_instance_of(Gitlab::Git::Diff))
+        end
+
+        it 'does not prune diffs' do
+          diff = nil
+
+          subject.each do |d|
+            diff = d
+          end
+
+          expect(diff.diff).not_to eq('')
+        end
+      end
+
+      context 'when no collapse is unset' do
+        let(:no_collapse) { false }
+
+        it 'yields Diff instances even when they are quite big' do
+          expect { |b| subject.each(&b) }.
+            to yield_with_args(an_instance_of(Gitlab::Git::Diff))
+        end
+
+        it 'prunes diffs that are quite big' do
+          diff = nil
+
+          subject.each do |d|
+            diff = d
+          end
+
+          expect(diff.diff).to eq('')
+        end
+
+        context 'when go over safe limits on files' do
+          let(:iterator) { [ fake_diff(1, 1) ] * 4 }
+
+          before(:each) do
+            stub_const('Gitlab::Git::DiffCollection::DEFAULT_LIMITS', { max_files: 2, max_lines: max_lines })
+          end
+
+          it 'prunes diffs by default even little ones' do
+            subject.each_with_index do |d, i|
+              if i < 2
+                expect(d.diff).not_to eq('')
+              else # 90 lines
+                expect(d.diff).to eq('')
+              end
+            end
+          end
+        end
+
+        context 'when go over safe limits on lines' do
+          let(:iterator) do
+            [
+              fake_diff(1, 45),
+              fake_diff(1, 45),
+              fake_diff(1, 20480),
+              fake_diff(1, 1)
+            ]
+          end
+
+          before(:each) do
+            stub_const('Gitlab::Git::DiffCollection::DEFAULT_LIMITS', { max_files: max_files, max_lines: 80 })
+          end
+
+          it 'prunes diffs by default even little ones' do
+            subject.each_with_index do |d, i|
+              if i < 2
+                expect(d.diff).not_to eq('')
+              else # 90 lines
+                expect(d.diff).to eq('')
+              end
+            end
+          end
+        end
+
+        context 'when go over safe limits on bytes' do
+          let(:iterator) do
+            [
+              fake_diff(1, 45),
+              fake_diff(1, 45),
+              fake_diff(1, 20480),
+              fake_diff(1, 1)
+            ]
+          end
+
+          before(:each) do
+            stub_const('Gitlab::Git::DiffCollection::DEFAULT_LIMITS', { max_files: max_files, max_lines: 80 })
+          end
+
+          it 'prunes diffs by default even little ones' do
+            subject.each_with_index do |d, i|
+              if i < 2
+                expect(d.diff).not_to eq('')
+              else # > 80 bytes
+                expect(d.diff).to eq('')
+              end
+            end
+          end
+        end
+      end
+
+      context 'when limiting is disabled' do
+        let(:all_diffs) { true }
+
+        it 'yields Diff instances even when they are quite big' do
+          expect { |b| subject.each(&b) }.
+            to yield_with_args(an_instance_of(Gitlab::Git::Diff))
+        end
+
+        it 'does not prune diffs' do
+          diff = nil
+
+          subject.each do |d|
+            diff = d
+          end
+
+          expect(diff.diff).not_to eq('')
+        end
+      end
+    end
+  end
+
+  def fake_diff(line_length, line_count)
+    { 'diff' => "#{'a' * line_length}\n" * line_count }
+  end
+end
diff --git a/spec/lib/gitlab/git/diff_spec.rb b/spec/lib/gitlab/git/diff_spec.rb
new file mode 100644
index 00000000000..4c55532d165
--- /dev/null
+++ b/spec/lib/gitlab/git/diff_spec.rb
@@ -0,0 +1,287 @@
+require "spec_helper"
+
+describe Gitlab::Git::Diff, seed_helper: true do
+  let(:repository) { Gitlab::Git::Repository.new(TEST_REPO_PATH) }
+
+  before do
+    @raw_diff_hash = {
+      diff: <<EOT.gsub(/^ {8}/, "").sub(/\n$/, ""),
+        --- a/.gitmodules
+        +++ b/.gitmodules
+        @@ -4,3 +4,6 @@
+         [submodule "gitlab-shell"]
+         \tpath = gitlab-shell
+         \turl = https://github.com/gitlabhq/gitlab-shell.git
+        +[submodule "gitlab-grack"]
+        +	path = gitlab-grack
+        +	url = https://gitlab.com/gitlab-org/gitlab-grack.git
+
+EOT
+      new_path: ".gitmodules",
+      old_path: ".gitmodules",
+      a_mode: '100644',
+      b_mode: '100644',
+      new_file: false,
+      renamed_file: false,
+      deleted_file: false,
+      too_large: false
+    }
+
+    @rugged_diff = repository.rugged.diff("5937ac0a7beb003549fc5fd26fc247adbce4a52e^", "5937ac0a7beb003549fc5fd26fc247adbce4a52e", paths:
+                                          [".gitmodules"]).patches.first
+  end
+
+  describe '.new' do
+    context 'using a Hash' do
+      context 'with a small diff' do
+        let(:diff) { described_class.new(@raw_diff_hash) }
+
+        it 'initializes the diff' do
+          expect(diff.to_hash).to eq(@raw_diff_hash)
+        end
+
+        it 'does not prune the diff' do
+          expect(diff).not_to be_too_large
+        end
+      end
+
+      context 'using a diff that is too large' do
+        it 'prunes the diff' do
+          diff = described_class.new(diff: 'a' * 204800)
+
+          expect(diff.diff).to be_empty
+          expect(diff).to be_too_large
+        end
+      end
+    end
+
+    context 'using a Rugged::Patch' do
+      context 'with a small diff' do
+        let(:diff) { described_class.new(@rugged_diff) }
+
+        it 'initializes the diff' do
+          expect(diff.to_hash).to eq(@raw_diff_hash.merge(too_large: nil))
+        end
+
+        it 'does not prune the diff' do
+          expect(diff).not_to be_too_large
+        end
+      end
+
+      context 'using a diff that is too large' do
+        it 'prunes the diff' do
+          expect_any_instance_of(String).to receive(:bytesize).
+            and_return(1024 * 1024 * 1024)
+
+          diff = described_class.new(@rugged_diff)
+
+          expect(diff.diff).to be_empty
+          expect(diff).to be_too_large
+        end
+      end
+
+      context 'using a collapsable diff that is too large' do
+        before do
+          # The patch total size is 200, with lines between 21 and 54.
+          # This is a quick-and-dirty way to test this. Ideally, a new patch is
+          # added to the test repo with a size that falls between the real limits.
+          stub_const("#{described_class}::DIFF_SIZE_LIMIT", 150)
+          stub_const("#{described_class}::DIFF_COLLAPSE_LIMIT", 100)
+        end
+
+        it 'prunes the diff as a large diff instead of as a collapsed diff' do
+          diff = described_class.new(@rugged_diff, collapse: true)
+
+          expect(diff.diff).to be_empty
+          expect(diff).to be_too_large
+          expect(diff).not_to be_collapsed
+        end
+      end
+
+      context 'using a large binary diff' do
+        it 'does not prune the diff' do
+          expect_any_instance_of(Rugged::Diff::Delta).to receive(:binary?).
+            and_return(true)
+
+          diff = described_class.new(@rugged_diff)
+
+          expect(diff.diff).not_to be_empty
+        end
+      end
+    end
+  end
+
+  describe 'straight diffs' do
+    let(:options) { { straight: true } }
+    let(:diffs) { described_class.between(repository, 'feature', 'master', options) }
+
+    it 'has the correct size' do
+      expect(diffs.size).to eq(24)
+    end
+
+    context 'diff' do
+      it 'is an instance of Diff' do
+        expect(diffs.first).to be_kind_of(described_class)
+      end
+
+      it 'has the correct new_path' do
+        expect(diffs.first.new_path).to eq('.DS_Store')
+      end
+
+      it 'has the correct diff' do
+        expect(diffs.first.diff).to include('Binary files /dev/null and b/.DS_Store differ')
+      end
+    end
+  end
+
+  describe '.between' do
+    let(:diffs) { described_class.between(repository, 'feature', 'master') }
+    subject { diffs }
+
+    it { is_expected.to be_kind_of Gitlab::Git::DiffCollection }
+
+    describe '#size' do
+      subject { super().size }
+
+      it { is_expected.to eq(1) }
+    end
+
+    context 'diff' do
+      subject { diffs.first }
+
+      it { is_expected.to be_kind_of described_class }
+
+      describe '#new_path' do
+        subject { super().new_path }
+
+        it { is_expected.to eq('files/ruby/feature.rb') }
+      end
+
+      describe '#diff' do
+        subject { super().diff }
+
+        it { is_expected.to include '+class Feature' }
+      end
+    end
+  end
+
+  describe '.filter_diff_options' do
+    let(:options) { { max_size: 100, invalid_opt: true } }
+
+    context "without default options" do
+      let(:filtered_options) { described_class.filter_diff_options(options) }
+
+      it "should filter invalid options" do
+        expect(filtered_options).not_to have_key(:invalid_opt)
+      end
+    end
+
+    context "with default options" do
+      let(:filtered_options) do
+        default_options = { max_size: 5, bad_opt: 1, ignore_whitespace: true }
+        described_class.filter_diff_options(options, default_options)
+      end
+
+      it "should filter invalid options" do
+        expect(filtered_options).not_to have_key(:invalid_opt)
+        expect(filtered_options).not_to have_key(:bad_opt)
+      end
+
+      it "should merge with default options" do
+        expect(filtered_options).to have_key(:ignore_whitespace)
+      end
+
+      it "should override default options" do
+        expect(filtered_options).to have_key(:max_size)
+        expect(filtered_options[:max_size]).to eq(100)
+      end
+    end
+  end
+
+  describe '#submodule?' do
+    before do
+      commit = repository.lookup('5937ac0a7beb003549fc5fd26fc247adbce4a52e')
+      @diffs = commit.parents[0].diff(commit).patches
+    end
+
+    it { expect(described_class.new(@diffs[0]).submodule?).to eq(false) }
+    it { expect(described_class.new(@diffs[1]).submodule?).to eq(true) }
+  end
+
+  describe '#line_count' do
+    it 'returns the correct number of lines' do
+      diff = described_class.new(@rugged_diff)
+
+      expect(diff.line_count).to eq(9)
+    end
+  end
+
+  describe '#too_large?' do
+    it 'returns true for a diff that is too large' do
+      diff = described_class.new(diff: 'a' * 204800)
+
+      expect(diff.too_large?).to eq(true)
+    end
+
+    it 'returns false for a diff that is small enough' do
+      diff = described_class.new(diff: 'a')
+
+      expect(diff.too_large?).to eq(false)
+    end
+
+    it 'returns true for a diff that was explicitly marked as being too large' do
+      diff = described_class.new(diff: 'a')
+
+      diff.prune_large_diff!
+
+      expect(diff.too_large?).to eq(true)
+    end
+  end
+
+  describe '#collapsed?' do
+    it 'returns false by default even on quite big diff' do
+      diff = described_class.new(diff: 'a' * 20480)
+
+      expect(diff).not_to be_collapsed
+    end
+
+    it 'returns false by default for a diff that is small enough' do
+      diff = described_class.new(diff: 'a')
+
+      expect(diff).not_to be_collapsed
+    end
+
+    it 'returns true for a diff that was explicitly marked as being collapsed' do
+      diff = described_class.new(diff: 'a')
+
+      diff.prune_collapsed_diff!
+
+      expect(diff).to be_collapsed
+    end
+  end
+
+  describe '#collapsible?' do
+    it 'returns true for a diff that is quite large' do
+      diff = described_class.new(diff: 'a' * 20480)
+
+      expect(diff).to be_collapsible
+    end
+
+    it 'returns false for a diff that is small enough' do
+      diff = described_class.new(diff: 'a')
+
+      expect(diff).not_to be_collapsible
+    end
+  end
+
+  describe '#prune_collapsed_diff!' do
+    it 'prunes the diff' do
+      diff = described_class.new(diff: "foo\nbar")
+
+      diff.prune_collapsed_diff!
+
+      expect(diff.diff).to eq('')
+      expect(diff.line_count).to eq(0)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/git/encoding_helper_spec.rb b/spec/lib/gitlab/git/encoding_helper_spec.rb
new file mode 100644
index 00000000000..83311536893
--- /dev/null
+++ b/spec/lib/gitlab/git/encoding_helper_spec.rb
@@ -0,0 +1,84 @@
+require "spec_helper"
+
+describe Gitlab::Git::EncodingHelper do
+  let(:ext_class) { Class.new { extend Gitlab::Git::EncodingHelper } }
+  let(:binary_string) { File.join(SEED_REPOSITORY_PATH, 'gitlab_logo.png') }
+
+  describe '#encode!' do
+    [
+      [
+        'leaves ascii only string as is',
+        'ascii only string',
+        'ascii only string'
+      ],
+      [
+        'leaves valid utf8 string as is',
+        'multibyte string №∑∉',
+        'multibyte string №∑∉'
+      ],
+      [
+        'removes invalid bytes from ASCII-8bit encoded multibyte string. This can occur when a git diff match line truncates in the middle of a multibyte character. This occurs after the second word in this example. The test string is as short as we can get while still triggering the error condition when not looking at `detect[:confidence]`.',
+        "mu ns\xC3\n Lorem ipsum dolor sit amet, consectetur adipisicing ut\xC3\xA0y\xC3\xB9abcd\xC3\xB9efg kia elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non p\n {: .normal_pn}\n \n-Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in\n# *Lorem ipsum\xC3\xB9l\xC3\xB9l\xC3\xA0 dolor\xC3\xB9k\xC3\xB9 sit\xC3\xA8b\xC3\xA8 N\xC3\xA8 amet b\xC3\xA0d\xC3\xAC*\n+# *consectetur\xC3\xB9l\xC3\xB9l\xC3\xA0 adipisicing\xC3\xB9k\xC3\xB9 elit\xC3\xA8b\xC3\xA8 N\xC3\xA8 sed do\xC3\xA0d\xC3\xAC*{: .italic .smcaps}\n \n \xEF\x9B\xA1 eiusmod tempor incididunt, ut\xC3\xAAn\xC3\xB9 labore et dolore. Tw\xC4\x83nj\xC3\xAC magna aliqua. Ut enim ad minim veniam\n {: .normal}\n@@ -9,5 +9,5 @@ quis nostrud\xC3\xAAt\xC3\xB9 exercitiation ullamco laboris m\xC3\xB9s\xC3\xB9k\xC3\xB9abc\xC3\xB9 nisi ".force_encoding('ASCII-8BIT'),
+        "mu ns\n Lorem ipsum dolor sit amet, consectetur adipisicing ut\xC3\xA0y\xC3\xB9abcd\xC3\xB9efg kia elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non p\n {: .normal_pn}\n \n-Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in\n# *Lorem ipsum\xC3\xB9l\xC3\xB9l\xC3\xA0 dolor\xC3\xB9k\xC3\xB9 sit\xC3\xA8b\xC3\xA8 N\xC3\xA8 amet b\xC3\xA0d\xC3\xAC*\n+# *consectetur\xC3\xB9l\xC3\xB9l\xC3\xA0 adipisicing\xC3\xB9k\xC3\xB9 elit\xC3\xA8b\xC3\xA8 N\xC3\xA8 sed do\xC3\xA0d\xC3\xAC*{: .italic .smcaps}\n \n \xEF\x9B\xA1 eiusmod tempor incididunt, ut\xC3\xAAn\xC3\xB9 labore et dolore. Tw\xC4\x83nj\xC3\xAC magna aliqua. Ut enim ad minim veniam\n {: .normal}\n@@ -9,5 +9,5 @@ quis nostrud\xC3\xAAt\xC3\xB9 exercitiation ullamco laboris m\xC3\xB9s\xC3\xB9k\xC3\xB9abc\xC3\xB9 nisi ",
+      ],
+    ].each do |description, test_string, xpect|
+      it description do
+        expect(ext_class.encode!(test_string)).to eq(xpect)
+      end
+    end
+
+    it 'leaves binary string as is' do
+      expect(ext_class.encode!(binary_string)).to eq(binary_string)
+    end
+  end
+
+  describe '#encode_utf8' do
+    [
+      [
+        "encodes valid utf8 encoded string to utf8",
+        "λ, λ, λ".encode("UTF-8"),
+        "λ, λ, λ".encode("UTF-8"),
+      ],
+      [
+        "encodes valid ASCII-8BIT encoded string to utf8",
+        "ascii only".encode("ASCII-8BIT"),
+        "ascii only".encode("UTF-8"),
+      ],
+      [
+        "encodes valid ISO-8859-1 encoded string to utf8",
+        "Rüby ist eine Programmiersprache. Wir verlängern den text damit ICU die Sprache erkennen kann.".encode("ISO-8859-1", "UTF-8"),
+        "Rüby ist eine Programmiersprache. Wir verlängern den text damit ICU die Sprache erkennen kann.".encode("UTF-8"),
+      ],
+    ].each do |description, test_string, xpect|
+      it description do
+        r = ext_class.encode_utf8(test_string.force_encoding('UTF-8'))
+        expect(r).to eq(xpect)
+        expect(r.encoding.name).to eq('UTF-8')
+      end
+    end
+  end
+
+  describe '#clean' do
+    [
+      [
+        'leaves ascii only string as is',
+        'ascii only string',
+        'ascii only string'
+      ],
+      [
+        'leaves valid utf8 string as is',
+        'multibyte string №∑∉',
+        'multibyte string №∑∉'
+      ],
+      [
+        'removes invalid bytes from ASCII-8bit encoded multibyte string.',
+        "Lorem ipsum\xC3\n dolor sit amet, xy\xC3\xA0y\xC3\xB9abcd\xC3\xB9efg".force_encoding('ASCII-8BIT'),
+        "Lorem ipsum\n dolor sit amet, xyàyùabcdùefg",
+      ],
+    ].each do |description, test_string, xpect|
+      it description do
+        expect(ext_class.encode!(test_string)).to eq(xpect)
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/git/repository_spec.rb b/spec/lib/gitlab/git/repository_spec.rb
new file mode 100644
index 00000000000..2a915bf426f
--- /dev/null
+++ b/spec/lib/gitlab/git/repository_spec.rb
@@ -0,0 +1,1184 @@
+require "spec_helper"
+
+describe Gitlab::Git::Repository, seed_helper: true do
+  include Gitlab::Git::EncodingHelper
+
+  let(:repository) { Gitlab::Git::Repository.new(TEST_REPO_PATH) }
+
+  describe "Respond to" do
+    subject { repository }
+
+    it { is_expected.to respond_to(:raw) }
+    it { is_expected.to respond_to(:rugged) }
+    it { is_expected.to respond_to(:root_ref) }
+    it { is_expected.to respond_to(:tags) }
+  end
+
+  describe "#discover_default_branch" do
+    let(:master) { 'master' }
+    let(:feature) { 'feature' }
+    let(:feature2) { 'feature2' }
+
+    it "returns 'master' when master exists" do
+      expect(repository).to receive(:branch_names).at_least(:once).and_return([feature, master])
+      expect(repository.discover_default_branch).to eq('master')
+    end
+
+    it "returns non-master when master exists but default branch is set to something else" do
+      File.write(File.join(repository.path, 'HEAD'), 'ref: refs/heads/feature')
+      expect(repository).to receive(:branch_names).at_least(:once).and_return([feature, master])
+      expect(repository.discover_default_branch).to eq('feature')
+      File.write(File.join(repository.path, 'HEAD'), 'ref: refs/heads/master')
+    end
+
+    it "returns a non-master branch when only one exists" do
+      expect(repository).to receive(:branch_names).at_least(:once).and_return([feature])
+      expect(repository.discover_default_branch).to eq('feature')
+    end
+
+    it "returns a non-master branch when more than one exists and master does not" do
+      expect(repository).to receive(:branch_names).at_least(:once).and_return([feature, feature2])
+      expect(repository.discover_default_branch).to eq('feature')
+    end
+
+    it "returns nil when no branch exists" do
+      expect(repository).to receive(:branch_names).at_least(:once).and_return([])
+      expect(repository.discover_default_branch).to be_nil
+    end
+  end
+
+  describe :branch_names do
+    subject { repository.branch_names }
+
+    it 'has SeedRepo::Repo::BRANCHES.size elements' do
+      expect(subject.size).to eq(SeedRepo::Repo::BRANCHES.size)
+    end
+    it { is_expected.to include("master") }
+    it { is_expected.not_to include("branch-from-space") }
+  end
+
+  describe :tag_names do
+    subject { repository.tag_names }
+
+    it { is_expected.to be_kind_of Array }
+    it 'has SeedRepo::Repo::TAGS.size elements' do
+      expect(subject.size).to eq(SeedRepo::Repo::TAGS.size)
+    end
+
+    describe '#last' do
+      subject { super().last }
+      it { is_expected.to eq("v1.2.1") }
+    end
+    it { is_expected.to include("v1.0.0") }
+    it { is_expected.not_to include("v5.0.0") }
+  end
+
+  shared_examples 'archive check' do |extenstion|
+    it { expect(metadata['ArchivePath']).to match(/tmp\/gitlab-git-test.git\/gitlab-git-test-master-#{SeedRepo::LastCommit::ID}/) }
+    it { expect(metadata['ArchivePath']).to end_with extenstion }
+  end
+
+  describe :archive do
+    let(:metadata) { repository.archive_metadata('master', '/tmp') }
+
+    it_should_behave_like 'archive check', '.tar.gz'
+  end
+
+  describe :archive_zip do
+    let(:metadata) { repository.archive_metadata('master', '/tmp', 'zip') }
+
+    it_should_behave_like 'archive check', '.zip'
+  end
+
+  describe :archive_bz2 do
+    let(:metadata) { repository.archive_metadata('master', '/tmp', 'tbz2') }
+
+    it_should_behave_like 'archive check', '.tar.bz2'
+  end
+
+  describe :archive_fallback do
+    let(:metadata) { repository.archive_metadata('master', '/tmp', 'madeup') }
+
+    it_should_behave_like 'archive check', '.tar.gz'
+  end
+
+  describe :size do
+    subject { repository.size }
+
+    it { is_expected.to be < 2 }
+  end
+
+  describe :has_commits? do
+    it { expect(repository.has_commits?).to be_truthy }
+  end
+
+  describe :empty? do
+    it { expect(repository.empty?).to be_falsey }
+  end
+
+  describe :bare? do
+    it { expect(repository.bare?).to be_truthy }
+  end
+
+  describe :heads do
+    let(:heads) { repository.heads }
+    subject { heads }
+
+    it { is_expected.to be_kind_of Array }
+
+    describe '#size' do
+      subject { super().size }
+      it { is_expected.to eq(SeedRepo::Repo::BRANCHES.size) }
+    end
+
+    context :head do
+      subject { heads.first }
+
+      describe '#name' do
+        subject { super().name }
+        it { is_expected.to eq("feature") }
+      end
+
+      context :commit do
+        subject { heads.first.dereferenced_target.sha }
+
+        it { is_expected.to eq("0b4bc9a49b562e85de7cc9e834518ea6828729b9") }
+      end
+    end
+  end
+
+  describe :ref_names do
+    let(:ref_names) { repository.ref_names }
+    subject { ref_names }
+
+    it { is_expected.to be_kind_of Array }
+
+    describe '#first' do
+      subject { super().first }
+      it { is_expected.to eq('feature') }
+    end
+
+    describe '#last' do
+      subject { super().last }
+      it { is_expected.to eq('v1.2.1') }
+    end
+  end
+
+  describe :search_files do
+    let(:results) { repository.search_files('rails', 'master') }
+    subject { results }
+
+    it { is_expected.to be_kind_of Array }
+
+    describe '#first' do
+      subject { super().first }
+      it { is_expected.to be_kind_of Gitlab::Git::BlobSnippet }
+    end
+
+    context 'blob result' do
+      subject { results.first }
+
+      describe '#ref' do
+        subject { super().ref }
+        it { is_expected.to eq('master') }
+      end
+
+      describe '#filename' do
+        subject { super().filename }
+        it { is_expected.to eq('CHANGELOG') }
+      end
+
+      describe '#startline' do
+        subject { super().startline }
+        it { is_expected.to eq(35) }
+      end
+
+      describe '#data' do
+        subject { super().data }
+        it { is_expected.to include "Ability to filter by multiple labels" }
+      end
+    end
+  end
+
+  context :submodules do
+    let(:repository) { Gitlab::Git::Repository.new(TEST_REPO_PATH) }
+
+    context 'where repo has submodules' do
+      let(:submodules) { repository.submodules('master') }
+      let(:submodule) { submodules.first }
+
+      it { expect(submodules).to be_kind_of Hash }
+      it { expect(submodules.empty?).to be_falsey }
+
+      it 'should have valid data' do
+        expect(submodule).to eq([
+          "six", {
+            "id" => "409f37c4f05865e4fb208c771485f211a22c4c2d",
+            "path" => "six",
+            "url" => "git://github.com/randx/six.git"
+          }
+        ])
+      end
+
+      it 'should handle nested submodules correctly' do
+        nested = submodules['nested/six']
+        expect(nested['path']).to eq('nested/six')
+        expect(nested['url']).to eq('git://github.com/randx/six.git')
+        expect(nested['id']).to eq('24fb71c79fcabc63dfd8832b12ee3bf2bf06b196')
+      end
+
+      it 'should handle deeply nested submodules correctly' do
+        nested = submodules['deeper/nested/six']
+        expect(nested['path']).to eq('deeper/nested/six')
+        expect(nested['url']).to eq('git://github.com/randx/six.git')
+        expect(nested['id']).to eq('24fb71c79fcabc63dfd8832b12ee3bf2bf06b196')
+      end
+
+      it 'should not have an entry for an invalid submodule' do
+        expect(submodules).not_to have_key('invalid/path')
+      end
+
+      it 'should not have an entry for an uncommited submodule dir' do
+        submodules = repository.submodules('fix-existing-submodule-dir')
+        expect(submodules).not_to have_key('submodule-existing-dir')
+      end
+
+      it 'should handle tags correctly' do
+        submodules = repository.submodules('v1.2.1')
+
+        expect(submodules.first).to eq([
+          "six", {
+            "id" => "409f37c4f05865e4fb208c771485f211a22c4c2d",
+            "path" => "six",
+            "url" => "git://github.com/randx/six.git"
+          }
+        ])
+      end
+    end
+
+    context 'where repo doesn\'t have submodules' do
+      let(:submodules) { repository.submodules('6d39438') }
+      it 'should return an empty hash' do
+        expect(submodules).to be_empty
+      end
+    end
+  end
+
+  describe :commit_count do
+    it { expect(repository.commit_count("master")).to eq(25) }
+    it { expect(repository.commit_count("feature")).to eq(9) }
+  end
+
+  describe "#reset" do
+    change_path = File.join(TEST_NORMAL_REPO_PATH, "CHANGELOG")
+    untracked_path = File.join(TEST_NORMAL_REPO_PATH, "UNTRACKED")
+    tracked_path = File.join(TEST_NORMAL_REPO_PATH, "files", "ruby", "popen.rb")
+
+    change_text = "New changelog text"
+    untracked_text = "This file is untracked"
+
+    reset_commit = SeedRepo::LastCommit::ID
+
+    context "--hard" do
+      before(:all) do
+        # Modify a tracked file
+        File.open(change_path, "w") do |f|
+          f.write(change_text)
+        end
+
+        # Add an untracked file to the working directory
+        File.open(untracked_path, "w") do |f|
+          f.write(untracked_text)
+        end
+
+        @normal_repo = Gitlab::Git::Repository.new(TEST_NORMAL_REPO_PATH)
+        @normal_repo.reset("HEAD", :hard)
+      end
+
+      it "should replace the working directory with the content of the index" do
+        File.open(change_path, "r") do |f|
+          expect(f.each_line.first).not_to eq(change_text)
+        end
+
+        File.open(tracked_path, "r") do |f|
+          expect(f.each_line.to_a[8]).to include('raise RuntimeError, "System commands')
+        end
+      end
+
+      it "should not touch untracked files" do
+        expect(File.exist?(untracked_path)).to be_truthy
+      end
+
+      it "should move the HEAD to the correct commit" do
+        new_head = @normal_repo.rugged.head.target.oid
+        expect(new_head).to eq(reset_commit)
+      end
+
+      it "should move the tip of the master branch to the correct commit" do
+        new_tip = @normal_repo.rugged.references["refs/heads/master"].
+          target.oid
+
+        expect(new_tip).to eq(reset_commit)
+      end
+
+      after(:all) do
+        # Fast-forward to the original HEAD
+        FileUtils.rm_rf(TEST_NORMAL_REPO_PATH)
+        ensure_seeds
+      end
+    end
+  end
+
+  describe "#checkout" do
+    new_branch = "foo_branch"
+
+    context "-b" do
+      before(:all) do
+        @normal_repo = Gitlab::Git::Repository.new(TEST_NORMAL_REPO_PATH)
+        @normal_repo.checkout(new_branch, { b: true }, "origin/feature")
+      end
+
+      it "should create a new branch" do
+        expect(@normal_repo.rugged.branches[new_branch]).not_to be_nil
+      end
+
+      it "should move the HEAD to the correct commit" do
+        expect(@normal_repo.rugged.head.target.oid).to(
+          eq(@normal_repo.rugged.branches["origin/feature"].target.oid)
+        )
+      end
+
+      it "should refresh the repo's #heads collection" do
+        head_names = @normal_repo.heads.map { |h| h.name }
+        expect(head_names).to include(new_branch)
+      end
+
+      after(:all) do
+        FileUtils.rm_rf(TEST_NORMAL_REPO_PATH)
+        ensure_seeds
+      end
+    end
+
+    context "without -b" do
+      context "and specifying a nonexistent branch" do
+        it "should not do anything" do
+          normal_repo = Gitlab::Git::Repository.new(TEST_NORMAL_REPO_PATH)
+
+          expect { normal_repo.checkout(new_branch) }.to raise_error(Rugged::ReferenceError)
+          expect(normal_repo.rugged.branches[new_branch]).to be_nil
+          expect(normal_repo.rugged.head.target.oid).to(
+            eq(normal_repo.rugged.branches["master"].target.oid)
+          )
+
+          head_names = normal_repo.heads.map { |h| h.name }
+          expect(head_names).not_to include(new_branch)
+        end
+
+        after(:all) do
+          FileUtils.rm_rf(TEST_NORMAL_REPO_PATH)
+          ensure_seeds
+        end
+      end
+
+      context "and with a valid branch" do
+        before(:all) do
+          @normal_repo = Gitlab::Git::Repository.new(TEST_NORMAL_REPO_PATH)
+          @normal_repo.rugged.branches.create("feature", "origin/feature")
+          @normal_repo.checkout("feature")
+        end
+
+        it "should move the HEAD to the correct commit" do
+          expect(@normal_repo.rugged.head.target.oid).to(
+            eq(@normal_repo.rugged.branches["feature"].target.oid)
+          )
+        end
+
+        it "should update the working directory" do
+          File.open(File.join(TEST_NORMAL_REPO_PATH, ".gitignore"), "r") do |f|
+            expect(f.read.each_line.to_a).not_to include(".DS_Store\n")
+          end
+        end
+
+        after(:all) do
+          FileUtils.rm_rf(TEST_NORMAL_REPO_PATH)
+          ensure_seeds
+        end
+      end
+    end
+  end
+
+  describe "#delete_branch" do
+    before(:all) do
+      @repo = Gitlab::Git::Repository.new(TEST_MUTABLE_REPO_PATH)
+      @repo.delete_branch("feature")
+    end
+
+    it "should remove the branch from the repo" do
+      expect(@repo.rugged.branches["feature"]).to be_nil
+    end
+
+    it "should update the repo's #heads collection" do
+      expect(@repo.heads).not_to include("feature")
+    end
+
+    after(:all) do
+      FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
+      ensure_seeds
+    end
+  end
+
+  describe "#create_branch" do
+    before(:all) do
+      @repo = Gitlab::Git::Repository.new(TEST_MUTABLE_REPO_PATH)
+    end
+
+    it "should create a new branch" do
+      expect(@repo.create_branch('new_branch', 'master')).not_to be_nil
+    end
+
+    it "should create a new branch with the right name" do
+      expect(@repo.create_branch('another_branch', 'master').name).to eq('another_branch')
+    end
+
+    it "should fail if we create an existing branch" do
+      @repo.create_branch('duplicated_branch', 'master')
+      expect{@repo.create_branch('duplicated_branch', 'master')}.to raise_error("Branch duplicated_branch already exists")
+    end
+
+    it "should fail if we create a branch from a non existing ref" do
+      expect{@repo.create_branch('branch_based_in_wrong_ref', 'master_2_the_revenge')}.to raise_error("Invalid reference master_2_the_revenge")
+    end
+
+    after(:all) do
+      FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
+      ensure_seeds
+    end
+  end
+
+  describe "#remote_names" do
+    let(:remotes) { repository.remote_names }
+
+    it "should have one entry: 'origin'" do
+      expect(remotes.size).to eq(1)
+      expect(remotes.first).to eq("origin")
+    end
+  end
+
+  describe "#refs_hash" do
+    let(:refs) { repository.refs_hash }
+
+    it "should have as many entries as branches and tags" do
+      expected_refs = SeedRepo::Repo::BRANCHES + SeedRepo::Repo::TAGS
+      # We flatten in case a commit is pointed at by more than one branch and/or tag
+      expect(refs.values.flatten.size).to eq(expected_refs.size)
+    end
+  end
+
+  describe "#remote_delete" do
+    before(:all) do
+      @repo = Gitlab::Git::Repository.new(TEST_MUTABLE_REPO_PATH)
+      @repo.remote_delete("expendable")
+    end
+
+    it "should remove the remote" do
+      expect(@repo.rugged.remotes).not_to include("expendable")
+    end
+
+    after(:all) do
+      FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
+      ensure_seeds
+    end
+  end
+
+  describe "#remote_add" do
+    before(:all) do
+      @repo = Gitlab::Git::Repository.new(TEST_MUTABLE_REPO_PATH)
+      @repo.remote_add("new_remote", SeedHelper::GITLAB_URL)
+    end
+
+    it "should add the remote" do
+      expect(@repo.rugged.remotes.each_name.to_a).to include("new_remote")
+    end
+
+    after(:all) do
+      FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
+      ensure_seeds
+    end
+  end
+
+  describe "#remote_update" do
+    before(:all) do
+      @repo = Gitlab::Git::Repository.new(TEST_MUTABLE_REPO_PATH)
+      @repo.remote_update("expendable", url: TEST_NORMAL_REPO_PATH)
+    end
+
+    it "should add the remote" do
+      expect(@repo.rugged.remotes["expendable"].url).to(
+        eq(TEST_NORMAL_REPO_PATH)
+      )
+    end
+
+    after(:all) do
+      FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
+      ensure_seeds
+    end
+  end
+
+  describe "#log" do
+    commit_with_old_name = nil
+    commit_with_new_name = nil
+    rename_commit = nil
+
+    before(:all) do
+      # Add new commits so that there's a renamed file in the commit history
+      repo = Gitlab::Git::Repository.new(TEST_REPO_PATH).rugged
+
+      commit_with_old_name = new_commit_edit_old_file(repo)
+      rename_commit = new_commit_move_file(repo)
+      commit_with_new_name = new_commit_edit_new_file(repo)
+    end
+
+    context "where 'follow' == true" do
+      options = { ref: "master", follow: true }
+
+      context "and 'path' is a directory" do
+        let(:log_commits) do
+          repository.log(options.merge(path: "encoding"))
+        end
+
+        it "should not follow renames" do
+          expect(log_commits).to include(commit_with_new_name)
+          expect(log_commits).to include(rename_commit)
+          expect(log_commits).not_to include(commit_with_old_name)
+        end
+      end
+
+      context "and 'path' is a file that matches the new filename" do
+        let(:log_commits) do
+          repository.log(options.merge(path: "encoding/CHANGELOG"))
+        end
+
+        it "should follow renames" do
+          expect(log_commits).to include(commit_with_new_name)
+          expect(log_commits).to include(rename_commit)
+          expect(log_commits).to include(commit_with_old_name)
+        end
+      end
+
+      context "and 'path' is a file that matches the old filename" do
+        let(:log_commits) do
+          repository.log(options.merge(path: "CHANGELOG"))
+        end
+
+        it "should not follow renames" do
+          expect(log_commits).to include(commit_with_old_name)
+          expect(log_commits).to include(rename_commit)
+          expect(log_commits).not_to include(commit_with_new_name)
+        end
+      end
+
+      context "unknown ref" do
+        let(:log_commits) { repository.log(options.merge(ref: 'unknown')) }
+
+        it "should return empty" do
+          expect(log_commits).to eq([])
+        end
+      end
+    end
+
+    context "where 'follow' == false" do
+      options = { follow: false }
+
+      context "and 'path' is a directory" do
+        let(:log_commits) do
+          repository.log(options.merge(path: "encoding"))
+        end
+
+        it "should not follow renames" do
+          expect(log_commits).to include(commit_with_new_name)
+          expect(log_commits).to include(rename_commit)
+          expect(log_commits).not_to include(commit_with_old_name)
+        end
+      end
+
+      context "and 'path' is a file that matches the new filename" do
+        let(:log_commits) do
+          repository.log(options.merge(path: "encoding/CHANGELOG"))
+        end
+
+        it "should not follow renames" do
+          expect(log_commits).to include(commit_with_new_name)
+          expect(log_commits).to include(rename_commit)
+          expect(log_commits).not_to include(commit_with_old_name)
+        end
+      end
+
+      context "and 'path' is a file that matches the old filename" do
+        let(:log_commits) do
+          repository.log(options.merge(path: "CHANGELOG"))
+        end
+
+        it "should not follow renames" do
+          expect(log_commits).to include(commit_with_old_name)
+          expect(log_commits).to include(rename_commit)
+          expect(log_commits).not_to include(commit_with_new_name)
+        end
+      end
+
+      context "and 'path' includes a directory that used to be a file" do
+        let(:log_commits) do
+          repository.log(options.merge(ref: "refs/heads/fix-blob-path", path: "files/testdir/file.txt"))
+        end
+
+        it "should return a list of commits" do
+          expect(log_commits.size).to eq(1)
+        end
+      end
+    end
+
+    context "compare results between log_by_walk and log_by_shell" do
+      let(:options) { { ref: "master" } }
+      let(:commits_by_walk) { repository.log(options).map(&:oid) }
+      let(:commits_by_shell) { repository.log(options.merge({ disable_walk: true })).map(&:oid) }
+
+      it { expect(commits_by_walk).to eq(commits_by_shell) }
+
+      context "with limit" do
+        let(:options) { { ref: "master", limit: 1 } }
+
+        it { expect(commits_by_walk).to eq(commits_by_shell) }
+      end
+
+      context "with offset" do
+        let(:options) { { ref: "master", offset: 1 } }
+
+        it { expect(commits_by_walk).to eq(commits_by_shell) }
+      end
+
+      context "with skip_merges" do
+        let(:options) { { ref: "master", skip_merges: true } }
+
+        it { expect(commits_by_walk).to eq(commits_by_shell) }
+      end
+
+      context "with path" do
+        let(:options) { { ref: "master", path: "encoding" } }
+
+        it { expect(commits_by_walk).to eq(commits_by_shell) }
+
+        context "with follow" do
+          let(:options) { { ref: "master", path: "encoding", follow: true } }
+
+          it { expect(commits_by_walk).to eq(commits_by_shell) }
+        end
+      end
+    end
+
+    context "where provides 'after' timestamp" do
+      options = { after: Time.iso8601('2014-03-03T20:15:01+00:00') }
+
+      it "should returns commits on or after that timestamp" do
+        commits = repository.log(options)
+
+        expect(commits.size).to be > 0
+        satisfy do
+          commits.all? { |commit| commit.created_at >= options[:after] }
+        end
+      end
+    end
+
+    context "where provides 'before' timestamp" do
+      options = { before: Time.iso8601('2014-03-03T20:15:01+00:00') }
+
+      it "should returns commits on or before that timestamp" do
+        commits = repository.log(options)
+
+        expect(commits.size).to be > 0
+        satisfy do
+          commits.all? { |commit| commit.created_at <= options[:before] }
+        end
+      end
+    end
+
+    after(:all) do
+      # Erase our commits so other tests get the original repo
+      repo = Gitlab::Git::Repository.new(TEST_REPO_PATH).rugged
+      repo.references.update("refs/heads/master", SeedRepo::LastCommit::ID)
+    end
+  end
+
+  describe "#commits_between" do
+    context 'two SHAs' do
+      let(:first_sha) { 'b0e52af38d7ea43cf41d8a6f2471351ac036d6c9' }
+      let(:second_sha) { '0e50ec4d3c7ce42ab74dda1d422cb2cbffe1e326' }
+
+      it 'returns the number of commits between' do
+        expect(repository.commits_between(first_sha, second_sha).count).to eq(3)
+      end
+    end
+
+    context 'SHA and master branch' do
+      let(:sha) { 'b0e52af38d7ea43cf41d8a6f2471351ac036d6c9' }
+      let(:branch) { 'master' }
+
+      it 'returns the number of commits between a sha and a branch' do
+        expect(repository.commits_between(sha, branch).count).to eq(5)
+      end
+
+      it 'returns the number of commits between a branch and a sha' do
+        expect(repository.commits_between(branch, sha).count).to eq(0) # sha is before branch
+      end
+    end
+
+    context 'two branches' do
+      let(:first_branch) { 'feature' }
+      let(:second_branch) { 'master' }
+
+      it 'returns the number of commits between' do
+        expect(repository.commits_between(first_branch, second_branch).count).to eq(17)
+      end
+    end
+  end
+
+  describe '#count_commits_between' do
+    subject { repository.count_commits_between('feature', 'master') }
+
+    it { is_expected.to eq(17) }
+  end
+
+  describe "branch_names_contains" do
+    subject { repository.branch_names_contains(SeedRepo::LastCommit::ID) }
+
+    it { is_expected.to include('master') }
+    it { is_expected.not_to include('feature') }
+    it { is_expected.not_to include('fix') }
+  end
+
+  describe '#autocrlf' do
+    before(:all) do
+      @repo = Gitlab::Git::Repository.new(TEST_MUTABLE_REPO_PATH)
+      @repo.rugged.config['core.autocrlf'] = true
+    end
+
+    it 'return the value of the autocrlf option' do
+      expect(@repo.autocrlf).to be(true)
+    end
+
+    after(:all) do
+      @repo.rugged.config.delete('core.autocrlf')
+    end
+  end
+
+  describe '#autocrlf=' do
+    before(:all) do
+      @repo = Gitlab::Git::Repository.new(TEST_MUTABLE_REPO_PATH)
+      @repo.rugged.config['core.autocrlf'] = false
+    end
+
+    it 'should set the autocrlf option to the provided option' do
+      @repo.autocrlf = :input
+
+      File.open(File.join(TEST_MUTABLE_REPO_PATH, '.git', 'config')) do |config_file|
+        expect(config_file.read).to match('autocrlf = input')
+      end
+    end
+
+    after(:all) do
+      @repo.rugged.config.delete('core.autocrlf')
+    end
+  end
+
+  describe '#find_branch' do
+    it 'should return a Branch for master' do
+      branch = repository.find_branch('master')
+
+      expect(branch).to be_a_kind_of(Gitlab::Git::Branch)
+      expect(branch.name).to eq('master')
+    end
+
+    it 'should handle non-existent branch' do
+      branch = repository.find_branch('this-is-garbage')
+
+      expect(branch).to eq(nil)
+    end
+
+    it 'should reload Rugged::Repository and return master' do
+      expect(Rugged::Repository).to receive(:new).twice.and_call_original
+
+      repository.find_branch('master')
+      branch = repository.find_branch('master', force_reload: true)
+
+      expect(branch).to be_a_kind_of(Gitlab::Git::Branch)
+      expect(branch.name).to eq('master')
+    end
+  end
+
+  describe '#branches with deleted branch' do
+    before(:each) do
+      ref = double()
+      allow(ref).to receive(:name) { 'bad-branch' }
+      allow(ref).to receive(:target) { raise Rugged::ReferenceError }
+      allow(repository.rugged).to receive(:branches) { [ref] }
+    end
+
+    it 'should return empty branches' do
+      expect(repository.branches).to eq([])
+    end
+  end
+
+  describe '#branch_count' do
+    before(:each) do
+      valid_ref   = double(:ref)
+      invalid_ref = double(:ref)
+
+      allow(valid_ref).to receive_messages(name: 'master', target: double(:target))
+
+      allow(invalid_ref).to receive_messages(name: 'bad-branch')
+      allow(invalid_ref).to receive(:target) { raise Rugged::ReferenceError }
+
+      allow(repository.rugged).to receive_messages(branches: [valid_ref, invalid_ref])
+    end
+
+    it 'returns the number of branches' do
+      expect(repository.branch_count).to eq(1)
+    end
+  end
+
+  describe '#mkdir' do
+    let(:commit_options) do
+      {
+        author: {
+          email: 'user@example.com',
+          name: 'Test User',
+          time: Time.now
+        },
+        committer: {
+          email: 'user@example.com',
+          name: 'Test User',
+          time: Time.now
+        },
+        commit: {
+          message: 'Test message',
+          branch: 'refs/heads/fix',
+        }
+      }
+    end
+
+    def generate_diff_for_path(path)
+      "diff --git a/#{path}/.gitkeep b/#{path}/.gitkeep
+new file mode 100644
+index 0000000..e69de29
+--- /dev/null
++++ b/#{path}/.gitkeep\n"
+    end
+
+    shared_examples 'mkdir diff check' do |path, expected_path|
+      it 'creates a directory' do
+        result = repository.mkdir(path, commit_options)
+        expect(result).not_to eq(nil)
+
+        # Verify another mkdir doesn't create a directory that already exists
+        expect{ repository.mkdir(path, commit_options) }.to raise_error('Directory already exists')
+      end
+    end
+
+    describe 'creates a directory in root directory' do
+      it_should_behave_like 'mkdir diff check', 'new_dir', 'new_dir'
+    end
+
+    describe 'creates a directory in subdirectory' do
+      it_should_behave_like 'mkdir diff check', 'files/ruby/test', 'files/ruby/test'
+    end
+
+    describe 'creates a directory in subdirectory with a slash' do
+      it_should_behave_like 'mkdir diff check', '/files/ruby/test2', 'files/ruby/test2'
+    end
+
+    describe 'creates a directory in subdirectory with multiple slashes' do
+      it_should_behave_like 'mkdir diff check', '//files/ruby/test3', 'files/ruby/test3'
+    end
+
+    describe 'handles relative paths' do
+      it_should_behave_like 'mkdir diff check', 'files/ruby/../test_relative', 'files/test_relative'
+    end
+
+    describe 'creates nested directories' do
+      it_should_behave_like 'mkdir diff check', 'files/missing/test', 'files/missing/test'
+    end
+
+    it 'does not attempt to create a directory with invalid relative path' do
+      expect{ repository.mkdir('../files/missing/test', commit_options) }.to raise_error('Invalid path')
+    end
+
+    it 'does not attempt to overwrite a file' do
+      expect{ repository.mkdir('README.md', commit_options) }.to raise_error('Directory already exists as a file')
+    end
+
+    it 'does not attempt to overwrite a directory' do
+      expect{ repository.mkdir('files', commit_options) }.to raise_error('Directory already exists')
+    end
+  end
+
+  describe "#ls_files" do
+    let(:master_file_paths) { repository.ls_files("master") }
+    let(:not_existed_branch) { repository.ls_files("not_existed_branch") }
+
+    it "read every file paths of master branch" do
+      expect(master_file_paths.length).to equal(40)
+    end
+
+    it "reads full file paths of master branch" do
+      expect(master_file_paths).to include("files/html/500.html")
+    end
+
+    it "dose not read submodule directory and empty directory of master branch" do
+      expect(master_file_paths).not_to include("six")
+    end
+
+    it "does not include 'nil'" do
+      expect(master_file_paths).not_to include(nil)
+    end
+
+    it "returns empty array when not existed branch" do
+      expect(not_existed_branch.length).to equal(0)
+    end
+  end
+
+  describe "#copy_gitattributes" do
+    let(:attributes_path) { File.join(TEST_REPO_PATH, 'info/attributes') }
+
+    it "raises an error with invalid ref" do
+      expect { repository.copy_gitattributes("invalid") }.to raise_error(Gitlab::Git::Repository::InvalidRef)
+    end
+
+    context "with no .gitattrbutes" do
+      before(:each) do
+        repository.copy_gitattributes("master")
+      end
+
+      it "does not have an info/attributes" do
+        expect(File.exist?(attributes_path)).to be_falsey
+      end
+
+      after(:each) do
+        FileUtils.rm_rf(attributes_path)
+      end
+    end
+
+    context "with .gitattrbutes" do
+      before(:each) do
+        repository.copy_gitattributes("gitattributes")
+      end
+
+      it "has an info/attributes" do
+        expect(File.exist?(attributes_path)).to be_truthy
+      end
+
+      it "has the same content in info/attributes as .gitattributes" do
+        contents = File.open(attributes_path, "rb") { |f| f.read }
+        expect(contents).to eq("*.md binary\n")
+      end
+
+      after(:each) do
+        FileUtils.rm_rf(attributes_path)
+      end
+    end
+
+    context "with updated .gitattrbutes" do
+      before(:each) do
+        repository.copy_gitattributes("gitattributes")
+        repository.copy_gitattributes("gitattributes-updated")
+      end
+
+      it "has an info/attributes" do
+        expect(File.exist?(attributes_path)).to be_truthy
+      end
+
+      it "has the updated content in info/attributes" do
+        contents = File.read(attributes_path)
+        expect(contents).to eq("*.txt binary\n")
+      end
+
+      after(:each) do
+        FileUtils.rm_rf(attributes_path)
+      end
+    end
+
+    context "with no .gitattrbutes in HEAD but with previous info/attributes" do
+      before(:each) do
+        repository.copy_gitattributes("gitattributes")
+        repository.copy_gitattributes("master")
+      end
+
+      it "does not have an info/attributes" do
+        expect(File.exist?(attributes_path)).to be_falsey
+      end
+
+      after(:each) do
+        FileUtils.rm_rf(attributes_path)
+      end
+    end
+  end
+
+  describe '#diffable' do
+    info_dir_path = attributes_path = File.join(TEST_REPO_PATH, 'info')
+    attributes_path = File.join(info_dir_path, 'attributes')
+
+    before(:all) do
+      FileUtils.mkdir(info_dir_path) unless File.exist?(info_dir_path)
+      File.write(attributes_path, "*.md -diff\n")
+    end
+
+    it "should return true for files which are text and do not have attributes" do
+      blob = Gitlab::Git::Blob.find(
+        repository,
+        '33bcff41c232a11727ac6d660bd4b0c2ba86d63d',
+        'LICENSE'
+      )
+      expect(repository.diffable?(blob)).to be_truthy
+    end
+
+    it "should return false for binary files which do not have attributes" do
+      blob = Gitlab::Git::Blob.find(
+        repository,
+        '33bcff41c232a11727ac6d660bd4b0c2ba86d63d',
+        'files/images/logo-white.png'
+      )
+      expect(repository.diffable?(blob)).to be_falsey
+    end
+
+    it "should return false for text files which have been marked as not being diffable in attributes" do
+      blob = Gitlab::Git::Blob.find(
+        repository,
+        '33bcff41c232a11727ac6d660bd4b0c2ba86d63d',
+        'README.md'
+      )
+      expect(repository.diffable?(blob)).to be_falsey
+    end
+
+    after(:all) do
+      FileUtils.rm_rf(info_dir_path)
+    end
+  end
+
+  describe '#tag_exists?' do
+    it 'returns true for an existing tag' do
+      tag = repository.tag_names.first
+
+      expect(repository.tag_exists?(tag)).to eq(true)
+    end
+
+    it 'returns false for a non-existing tag' do
+      expect(repository.tag_exists?('v9000')).to eq(false)
+    end
+  end
+
+  describe '#branch_exists?' do
+    it 'returns true for an existing branch' do
+      expect(repository.branch_exists?('master')).to eq(true)
+    end
+
+    it 'returns false for a non-existing branch' do
+      expect(repository.branch_exists?('kittens')).to eq(false)
+    end
+
+    it 'returns false when using an invalid branch name' do
+      expect(repository.branch_exists?('.bla')).to eq(false)
+    end
+  end
+
+  describe '#local_branches' do
+    before(:all) do
+      @repo = Gitlab::Git::Repository.new(TEST_MUTABLE_REPO_PATH)
+    end
+
+    after(:all) do
+      FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
+      ensure_seeds
+    end
+
+    it 'returns the local branches' do
+      create_remote_branch('joe', 'remote_branch', 'master')
+      @repo.create_branch('local_branch', 'master')
+
+      expect(@repo.local_branches.any? { |branch| branch.name == 'remote_branch' }).to eq(false)
+      expect(@repo.local_branches.any? { |branch| branch.name == 'local_branch' }).to eq(true)
+    end
+  end
+
+  def create_remote_branch(remote_name, branch_name, source_branch_name)
+    source_branch = @repo.branches.find { |branch| branch.name == source_branch_name }
+    rugged = @repo.rugged
+    rugged.references.create("refs/remotes/#{remote_name}/#{branch_name}", source_branch.dereferenced_target.sha)
+  end
+
+  # Build the options hash that's passed to Rugged::Commit#create
+  def commit_options(repo, index, message)
+    options = {}
+    options[:tree] = index.write_tree(repo)
+    options[:author] = {
+      email: "test@example.com",
+      name: "Test Author",
+      time: Time.gm(2014, "mar", 3, 20, 15, 1)
+    }
+    options[:committer] = {
+      email: "test@example.com",
+      name: "Test Author",
+      time: Time.gm(2014, "mar", 3, 20, 15, 1)
+    }
+    options[:message] ||= message
+    options[:parents] = repo.empty? ? [] : [repo.head.target].compact
+    options[:update_ref] = "HEAD"
+
+    options
+  end
+
+  # Writes a new commit to the repo and returns a Rugged::Commit.  Replaces the
+  # contents of CHANGELOG with a single new line of text.
+  def new_commit_edit_old_file(repo)
+    oid = repo.write("I replaced the changelog with this text", :blob)
+    index = repo.index
+    index.read_tree(repo.head.target.tree)
+    index.add(path: "CHANGELOG", oid: oid, mode: 0100644)
+
+    options = commit_options(
+      repo,
+      index,
+      "Edit CHANGELOG in its original location"
+    )
+
+    sha = Rugged::Commit.create(repo, options)
+    repo.lookup(sha)
+  end
+
+  # Writes a new commit to the repo and returns a Rugged::Commit.  Replaces the
+  # contents of encoding/CHANGELOG with new text.
+  def new_commit_edit_new_file(repo)
+    oid = repo.write("I'm a new changelog with different text", :blob)
+    index = repo.index
+    index.read_tree(repo.head.target.tree)
+    index.add(path: "encoding/CHANGELOG", oid: oid, mode: 0100644)
+
+    options = commit_options(repo, index, "Edit encoding/CHANGELOG")
+
+    sha = Rugged::Commit.create(repo, options)
+    repo.lookup(sha)
+  end
+
+  # Writes a new commit to the repo and returns a Rugged::Commit.  Moves the
+  # CHANGELOG file to the encoding/ directory.
+  def new_commit_move_file(repo)
+    blob_oid = repo.head.target.tree.detect { |i| i[:name] == "CHANGELOG" }[:oid]
+    file_content = repo.lookup(blob_oid).content
+    oid = repo.write(file_content, :blob)
+    index = repo.index
+    index.read_tree(repo.head.target.tree)
+    index.add(path: "encoding/CHANGELOG", oid: oid, mode: 0100644)
+    index.remove("CHANGELOG")
+
+    options = commit_options(repo, index, "Move CHANGELOG to encoding/")
+
+    sha = Rugged::Commit.create(repo, options)
+    repo.lookup(sha)
+  end
+end
diff --git a/spec/lib/gitlab/git/tag_spec.rb b/spec/lib/gitlab/git/tag_spec.rb
new file mode 100644
index 00000000000..ad469e94735
--- /dev/null
+++ b/spec/lib/gitlab/git/tag_spec.rb
@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Gitlab::Git::Tag, seed_helper: true do
+  let(:repository) { Gitlab::Git::Repository.new(TEST_REPO_PATH) }
+
+  describe 'first tag' do
+    let(:tag) { repository.tags.first }
+
+    it { expect(tag.name).to eq("v1.0.0") }
+    it { expect(tag.target).to eq("f4e6814c3e4e7a0de82a9e7cd20c626cc963a2f8") }
+    it { expect(tag.dereferenced_target.sha).to eq("6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9") }
+    it { expect(tag.message).to eq("Release") }
+  end
+
+  describe 'last tag' do
+    let(:tag) { repository.tags.last }
+
+    it { expect(tag.name).to eq("v1.2.1") }
+    it { expect(tag.target).to eq("2ac1f24e253e08135507d0830508febaaccf02ee") }
+    it { expect(tag.dereferenced_target.sha).to eq("fa1b1e6c004a68b7d8763b86455da9e6b23e36d6") }
+    it { expect(tag.message).to eq("Version 1.2.1") }
+  end
+
+  it { expect(repository.tags.size).to eq(SeedRepo::Repo::TAGS.size) }
+end
diff --git a/spec/lib/gitlab/git/tree_spec.rb b/spec/lib/gitlab/git/tree_spec.rb
new file mode 100644
index 00000000000..688e2a75373
--- /dev/null
+++ b/spec/lib/gitlab/git/tree_spec.rb
@@ -0,0 +1,76 @@
+require "spec_helper"
+
+describe Gitlab::Git::Tree, seed_helper: true do
+  context :repo do
+    let(:repository) { Gitlab::Git::Repository.new(TEST_REPO_PATH) }
+    let(:tree) { Gitlab::Git::Tree.where(repository, SeedRepo::Commit::ID) }
+
+    it { expect(tree).to be_kind_of Array }
+    it { expect(tree.empty?).to be_falsey }
+    it { expect(tree.select(&:dir?).size).to eq(2) }
+    it { expect(tree.select(&:file?).size).to eq(10) }
+    it { expect(tree.select(&:submodule?).size).to eq(2) }
+
+    describe :dir do
+      let(:dir) { tree.select(&:dir?).first }
+
+      it { expect(dir).to be_kind_of Gitlab::Git::Tree }
+      it { expect(dir.id).to eq('3c122d2b7830eca25235131070602575cf8b41a1') }
+      it { expect(dir.commit_id).to eq(SeedRepo::Commit::ID) }
+      it { expect(dir.name).to eq('encoding') }
+      it { expect(dir.path).to eq('encoding') }
+
+      context :subdir do
+        let(:subdir) { Gitlab::Git::Tree.where(repository, SeedRepo::Commit::ID, 'files').first }
+
+        it { expect(subdir).to be_kind_of Gitlab::Git::Tree }
+        it { expect(subdir.id).to eq('a1e8f8d745cc87e3a9248358d9352bb7f9a0aeba') }
+        it { expect(subdir.commit_id).to eq(SeedRepo::Commit::ID) }
+        it { expect(subdir.name).to eq('html') }
+        it { expect(subdir.path).to eq('files/html') }
+      end
+
+      context :subdir_file do
+        let(:subdir_file) { Gitlab::Git::Tree.where(repository, SeedRepo::Commit::ID, 'files/ruby').first }
+
+        it { expect(subdir_file).to be_kind_of Gitlab::Git::Tree }
+        it { expect(subdir_file.id).to eq('7e3e39ebb9b2bf433b4ad17313770fbe4051649c') }
+        it { expect(subdir_file.commit_id).to eq(SeedRepo::Commit::ID) }
+        it { expect(subdir_file.name).to eq('popen.rb') }
+        it { expect(subdir_file.path).to eq('files/ruby/popen.rb') }
+      end
+    end
+
+    describe :file do
+      let(:file) { tree.select(&:file?).first }
+
+      it { expect(file).to be_kind_of Gitlab::Git::Tree }
+      it { expect(file.id).to eq('dfaa3f97ca337e20154a98ac9d0be76ddd1fcc82') }
+      it { expect(file.commit_id).to eq(SeedRepo::Commit::ID) }
+      it { expect(file.name).to eq('.gitignore') }
+    end
+
+    describe :readme do
+      let(:file) { tree.select(&:readme?).first }
+
+      it { expect(file).to be_kind_of Gitlab::Git::Tree }
+      it { expect(file.name).to eq('README.md') }
+    end
+
+    describe :contributing do
+      let(:file) { tree.select(&:contributing?).first }
+
+      it { expect(file).to be_kind_of Gitlab::Git::Tree }
+      it { expect(file.name).to eq('CONTRIBUTING.md') }
+    end
+
+    describe :submodule do
+      let(:submodule) { tree.select(&:submodule?).first }
+
+      it { expect(submodule).to be_kind_of Gitlab::Git::Tree }
+      it { expect(submodule.id).to eq('79bceae69cb5750d6567b223597999bfa91cb3b9') }
+      it { expect(submodule.commit_id).to eq('570e7b2abdd848b95f2f578043fc23bd6f6fd24d') }
+      it { expect(submodule.name).to eq('gitlab-shell') }
+    end
+  end
+end
diff --git a/spec/lib/gitlab/git/util_spec.rb b/spec/lib/gitlab/git/util_spec.rb
new file mode 100644
index 00000000000..8d43b570e98
--- /dev/null
+++ b/spec/lib/gitlab/git/util_spec.rb
@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Gitlab::Git::Util do
+  describe :count_lines do
+    [
+      ["", 0],
+      ["foo", 1],
+      ["foo\n", 1],
+      ["foo\n\n", 2],
+    ].each do |string, line_count|
+      it "counts #{line_count} lines in #{string.inspect}" do
+        expect(Gitlab::Git::Util.count_lines(string)).to eq(line_count)
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/import_export/all_models.yml b/spec/lib/gitlab/import_export/all_models.yml
index ceed9c942c1..7fb6829f582 100644
--- a/spec/lib/gitlab/import_export/all_models.yml
+++ b/spec/lib/gitlab/import_export/all_models.yml
@@ -15,6 +15,7 @@ issues:
 - events
 - merge_requests_closing_issues
 - metrics
+- timelogs
 events:
 - author
 - project
@@ -77,6 +78,7 @@ merge_requests:
 - events
 - merge_requests_closing_issues
 - metrics
+- timelogs
 merge_request_diff:
 - merge_request
 pipelines:
@@ -198,3 +200,6 @@ award_emoji:
 - user
 priorities:
 - label
+timelogs:
+- trackable
+- user
diff --git a/spec/lib/gitlab/import_export/members_mapper_spec.rb b/spec/lib/gitlab/import_export/members_mapper_spec.rb
index 1cb02f8e318..b069696b5c7 100644
--- a/spec/lib/gitlab/import_export/members_mapper_spec.rb
+++ b/spec/lib/gitlab/import_export/members_mapper_spec.rb
@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Gitlab::ImportExport::MembersMapper, services: true do
   describe 'map members' do
-    let(:user) { create(:user, authorized_projects_populated: true) }
+    let(:user) { create(:admin, authorized_projects_populated: true) }
     let(:project) { create(:project, :public, name: 'searchable_project') }
     let(:user2) { create(:user, authorized_projects_populated: true) }
     let(:exported_user_id) { 99 }
@@ -24,7 +24,7 @@ describe Gitlab::ImportExport::MembersMapper, services: true do
            {
              "id" => exported_user_id,
              "email" => user2.email,
-             "username" => user2.username
+             "username" => 'test'
            }
        },
        {
@@ -48,6 +48,10 @@ describe Gitlab::ImportExport::MembersMapper, services: true do
         exported_members: exported_members, user: user, project: project)
     end
 
+    it 'includes the exported user ID in the map' do
+      expect(members_mapper.map.keys).to include(exported_user_id)
+    end
+
     it 'maps a project member' do
       expect(members_mapper.map[exported_user_id]).to eq(user2.id)
     end
@@ -56,12 +60,6 @@ describe Gitlab::ImportExport::MembersMapper, services: true do
       expect(members_mapper.map[-1]).to eq(user.id)
     end
 
-    it 'updates missing author IDs on missing project member' do
-      members_mapper.map[-1]
-
-      expect(members_mapper.missing_author_ids.first).to eq(-1)
-    end
-
     it 'has invited members with no user' do
       members_mapper.map
 
@@ -74,5 +72,25 @@ describe Gitlab::ImportExport::MembersMapper, services: true do
       expect(user.authorized_project?(project)).to be true
       expect(user2.authorized_project?(project)).to be true
     end
+
+    context 'user is not an admin' do
+      let(:user) { create(:user, authorized_projects_populated: true) }
+
+      it 'does not map a project member' do
+        expect(members_mapper.map[exported_user_id]).to eq(user.id)
+      end
+
+      it 'defaults to importer project member if it does not exist' do
+        expect(members_mapper.map[-1]).to eq(user.id)
+      end
+    end
+
+    context 'chooses the one with an email first' do
+      let(:user3) { create(:user, username: 'test') }
+
+      it 'maps the project member that has a matching email first' do
+        expect(members_mapper.map[exported_user_id]).to eq(user2.id)
+      end
+    end
   end
 end
diff --git a/spec/lib/gitlab/import_export/relation_factory_spec.rb b/spec/lib/gitlab/import_export/relation_factory_spec.rb
index 3aa492a8ab1..db0084d6823 100644
--- a/spec/lib/gitlab/import_export/relation_factory_spec.rb
+++ b/spec/lib/gitlab/import_export/relation_factory_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Gitlab::ImportExport::RelationFactory, lib: true do
   let(:project) { create(:empty_project) }
   let(:members_mapper) { double('members_mapper').as_null_object }
-  let(:user) { create(:user) }
+  let(:user) { create(:admin) }
   let(:created_object) do
     described_class.create(relation_sym: relation_sym,
                            relation_hash: relation_hash,
@@ -122,4 +122,60 @@ describe Gitlab::ImportExport::RelationFactory, lib: true do
       expect(created_object.values).not_to include(99)
     end
   end
+
+  context 'Notes user references' do
+    let(:relation_sym) { :notes }
+    let(:new_user) { create(:user) }
+    let(:exported_member) do
+      {
+        "id" => 111,
+        "access_level" => 30,
+        "source_id" => 1,
+        "source_type" => "Project",
+        "user_id" => 3,
+        "notification_level" => 3,
+        "created_at" => "2016-11-18T09:29:42.634Z",
+        "updated_at" => "2016-11-18T09:29:42.634Z",
+        "user" => {
+          "id" => 999,
+          "email" => new_user.email,
+          "username" => new_user.username
+        }
+      }
+    end
+
+    let(:relation_hash) do
+      {
+        "id" => 4947,
+        "note" => "merged",
+        "noteable_type" => "MergeRequest",
+        "author_id" => 999,
+        "created_at" => "2016-11-18T09:29:42.634Z",
+        "updated_at" => "2016-11-18T09:29:42.634Z",
+        "project_id" => 1,
+        "attachment" => {
+          "url" => nil
+        },
+        "noteable_id" => 377,
+        "system" => true,
+        "author" => {
+          "name" => "Administrator"
+        },
+        "events" => [
+
+        ]
+      }
+    end
+
+    let(:members_mapper) do
+      Gitlab::ImportExport::MembersMapper.new(
+        exported_members: [exported_member],
+        user: user,
+        project: project)
+    end
+
+    it 'maps the right author to the imported note' do
+      expect(created_object.author).to eq(new_user)
+    end
+  end
 end
diff --git a/spec/lib/gitlab/import_export/safe_model_attributes.yml b/spec/lib/gitlab/import_export/safe_model_attributes.yml
index ac26c831fd0..493bc2db21a 100644
--- a/spec/lib/gitlab/import_export/safe_model_attributes.yml
+++ b/spec/lib/gitlab/import_export/safe_model_attributes.yml
@@ -20,6 +20,7 @@ Issue:
 - lock_version
 - milestone_id
 - weight
+- time_estimate
 Event:
 - id
 - target_type
@@ -150,6 +151,7 @@ MergeRequest:
 - milestone_id
 - approvals_before_merge
 - rebase_commit_sha
+- time_estimate
 MergeRequestDiff:
 - id
 - state
@@ -248,6 +250,7 @@ DeployKey:
 - fingerprint
 - public
 - can_push
+- last_used_at
 Service:
 - id
 - type
@@ -343,3 +346,11 @@ LabelPriority:
 - priority
 - created_at
 - updated_at
+Timelog:
+- id
+- time_spent
+- trackable_id
+- trackable_type
+- user_id
+- created_at
+- updated_at
diff --git a/spec/lib/gitlab/incoming_email_spec.rb b/spec/lib/gitlab/incoming_email_spec.rb
index 1dcf2c0668b..7e951e3fcdd 100644
--- a/spec/lib/gitlab/incoming_email_spec.rb
+++ b/spec/lib/gitlab/incoming_email_spec.rb
@@ -23,6 +23,48 @@ describe Gitlab::IncomingEmail, lib: true do
     end
   end
 
+  describe 'self.supports_wildcard?' do
+    context 'address contains the wildard placeholder' do
+      before do
+        stub_incoming_email_setting(address: 'replies+%{key}@example.com')
+      end
+
+      it 'confirms that wildcard is supported' do
+        expect(described_class.supports_wildcard?).to be_truthy
+      end
+    end
+
+    context "address doesn't contain the wildcard placeholder" do
+      before do
+        stub_incoming_email_setting(address: 'replies@example.com')
+      end
+
+      it 'returns that wildcard is not supported' do
+        expect(described_class.supports_wildcard?).to be_falsey
+      end
+    end
+
+    context 'address is not set' do
+      before do
+        stub_incoming_email_setting(address: nil)
+      end
+
+      it 'returns that wildard is not supported' do
+        expect(described_class.supports_wildcard?).to be_falsey
+      end
+    end
+  end
+
+  context 'self.unsubscribe_address' do
+    before do
+      stub_incoming_email_setting(address: 'replies+%{key}@example.com')
+    end
+
+    it 'returns the address with interpolated reply key and unsubscribe suffix' do
+      expect(described_class.unsubscribe_address('key')).to eq('replies+key+unsubscribe@example.com')
+    end
+  end
+
   context "self.reply_address" do
     before do
       stub_incoming_email_setting(address: "replies+%{key}@example.com")
diff --git a/spec/lib/gitlab/job_waiter_spec.rb b/spec/lib/gitlab/job_waiter_spec.rb
new file mode 100644
index 00000000000..780f5b1f8d7
--- /dev/null
+++ b/spec/lib/gitlab/job_waiter_spec.rb
@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Gitlab::JobWaiter do
+  describe '#wait' do
+    let(:waiter) { described_class.new(%w(a)) }
+    it 'returns when all jobs have been completed' do
+      expect(Gitlab::SidekiqStatus).to receive(:all_completed?).with(%w(a)).
+        and_return(true)
+
+      expect(waiter).not_to receive(:sleep)
+
+      waiter.wait
+    end
+
+    it 'sleeps between checking the job statuses' do
+      expect(Gitlab::SidekiqStatus).to receive(:all_completed?).
+        with(%w(a)).
+        and_return(false, true)
+
+      expect(waiter).to receive(:sleep).with(described_class::INTERVAL)
+
+      waiter.wait
+    end
+
+    it 'returns when timing out' do
+      expect(waiter).not_to receive(:sleep)
+      waiter.wait(0)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ldap/access_spec.rb b/spec/lib/gitlab/ldap/access_spec.rb
index 534bcbf39fe..b9d12c3c24c 100644
--- a/spec/lib/gitlab/ldap/access_spec.rb
+++ b/spec/lib/gitlab/ldap/access_spec.rb
@@ -15,9 +15,9 @@ describe Gitlab::LDAP::Access, lib: true do
       it { is_expected.to be_falsey }
 
       it 'should block user in GitLab' do
+        expect(access).to receive(:block_user).with(user, 'does not exist anymore')
+
         access.allowed?
-        expect(user).to be_blocked
-        expect(user).to be_ldap_blocked
       end
     end
 
@@ -34,9 +34,9 @@ describe Gitlab::LDAP::Access, lib: true do
         it { is_expected.to be_falsey }
 
         it 'blocks user in GitLab' do
+          expect(access).to receive(:block_user).with(user, 'is disabled in Active Directory')
+
           access.allowed?
-          expect(user).to be_blocked
-          expect(user).to be_ldap_blocked
         end
       end
 
@@ -53,7 +53,10 @@ describe Gitlab::LDAP::Access, lib: true do
           end
 
           it 'does not unblock user in GitLab' do
+            expect(access).not_to receive(:unblock_user)
+
             access.allowed?
+
             expect(user).to be_blocked
             expect(user).not_to be_ldap_blocked # this block is handled by omniauth not by our internal logic
           end
@@ -65,8 +68,9 @@ describe Gitlab::LDAP::Access, lib: true do
           end
 
           it 'unblocks user in GitLab' do
+            expect(access).to receive(:unblock_user).with(user, 'is not disabled anymore')
+
             access.allowed?
-            expect(user).not_to be_blocked
           end
         end
       end
@@ -87,9 +91,9 @@ describe Gitlab::LDAP::Access, lib: true do
           it { is_expected.to be_falsey }
 
           it 'blocks user in GitLab' do
+            expect(access).to receive(:block_user).with(user, 'does not exist anymore')
+
             access.allowed?
-            expect(user).to be_blocked
-            expect(user).to be_ldap_blocked
           end
         end
 
@@ -99,11 +103,54 @@ describe Gitlab::LDAP::Access, lib: true do
           end
 
           it 'unblocks the user if it exists' do
+            expect(access).to receive(:unblock_user).with(user, 'is available again')
+
             access.allowed?
-            expect(user).not_to be_blocked
           end
         end
       end
     end
   end
+
+  describe '#block_user' do
+    before do
+      user.activate
+      allow(Gitlab::AppLogger).to receive(:info)
+
+      access.block_user user, 'reason'
+    end
+
+    it 'blocks the user' do
+      expect(user).to be_blocked
+      expect(user).to be_ldap_blocked
+    end
+
+    it 'logs the reason' do
+      expect(Gitlab::AppLogger).to have_received(:info).with(
+        "LDAP account \"123456\" reason, " \
+        "blocking Gitlab user \"#{user.name}\" (#{user.email})"
+      )
+    end
+  end
+
+  describe '#unblock_user' do
+    before do
+      user.ldap_block
+      allow(Gitlab::AppLogger).to receive(:info)
+
+      access.unblock_user user, 'reason'
+    end
+
+    it 'activates the user' do
+      expect(user).not_to be_blocked
+      expect(user).not_to be_ldap_blocked
+    end
+
+    it 'logs the reason' do
+      Gitlab::AppLogger.info(
+        "LDAP account \"123456\" reason, " \
+        "unblocking Gitlab user \"#{user.name}\" (#{user.email})"
+      )
+    end
+  end
 end
diff --git a/spec/lib/gitlab/ldap/config_spec.rb b/spec/lib/gitlab/ldap/config_spec.rb
index 1a6803e01c3..cab2e9908ff 100644
--- a/spec/lib/gitlab/ldap/config_spec.rb
+++ b/spec/lib/gitlab/ldap/config_spec.rb
@@ -129,4 +129,27 @@ describe Gitlab::LDAP::Config, lib: true do
       expect(config.has_auth?).to be_falsey
     end
   end
+
+  describe '#attributes' do
+    it 'uses default attributes when no custom attributes are configured' do
+      expect(config.attributes).to eq(config.default_attributes)
+    end
+
+    it 'merges the configuration attributes with default attributes' do
+      stub_ldap_config(
+        options: {
+          'attributes' => {
+            'username' => %w(sAMAccountName),
+            'email'    => %w(userPrincipalName)
+          }
+        }
+      )
+
+      expect(config.attributes).to include({
+        'username' => %w(sAMAccountName),
+        'email'    => %w(userPrincipalName),
+        'name'     => 'cn'
+      })
+    end
+  end
 end
diff --git a/spec/lib/gitlab/ldap/person_spec.rb b/spec/lib/gitlab/ldap/person_spec.rb
index 60afe046788..9a556cde5d5 100644
--- a/spec/lib/gitlab/ldap/person_spec.rb
+++ b/spec/lib/gitlab/ldap/person_spec.rb
@@ -7,9 +7,11 @@ describe Gitlab::LDAP::Person do
 
   before do
     stub_ldap_config(
-      attributes: {
-        name: 'cn',
-        email: %w(mail email userPrincipalName)
+      options: {
+        'attributes' => {
+          'name' => 'cn',
+          'email' => %w(mail email userPrincipalName)
+        }
       }
     )
   end
@@ -30,7 +32,7 @@ describe Gitlab::LDAP::Person do
       entry['mail'] = mail
       person = Gitlab::LDAP::Person.new(entry, 'ldapmain')
 
-      expect(person.email).to eq(mail)
+      expect(person.email).to eq([mail])
     end
 
     it 'returns the value of userPrincipalName, if mail and email are not present' do
@@ -38,7 +40,7 @@ describe Gitlab::LDAP::Person do
       entry['userPrincipalName'] = user_principal_name
       person = Gitlab::LDAP::Person.new(entry, 'ldapmain')
 
-      expect(person.email).to eq(user_principal_name)
+      expect(person.email).to eq([user_principal_name])
     end
   end
 end
diff --git a/spec/lib/gitlab/metrics/rack_middleware_spec.rb b/spec/lib/gitlab/metrics/rack_middleware_spec.rb
index 7371b578a48..fb470ea7568 100644
--- a/spec/lib/gitlab/metrics/rack_middleware_spec.rb
+++ b/spec/lib/gitlab/metrics/rack_middleware_spec.rb
@@ -126,5 +126,16 @@ describe Gitlab::Metrics::RackMiddleware do
 
       expect(transaction.action).to eq('Grape#GET /projects/:id/archive')
     end
+
+    it 'does not tag a transaction if route infos are missing' do
+      endpoint = double(:endpoint)
+      allow(endpoint).to receive(:route).and_raise
+
+      env['api.endpoint'] = endpoint
+
+      middleware.tag_endpoint(transaction, env)
+
+      expect(transaction.action).to be_nil
+    end
   end
 end
diff --git a/spec/lib/gitlab/project_search_results_spec.rb b/spec/lib/gitlab/project_search_results_spec.rb
index 14ee386dba6..d94eb52f838 100644
--- a/spec/lib/gitlab/project_search_results_spec.rb
+++ b/spec/lib/gitlab/project_search_results_spec.rb
@@ -178,4 +178,119 @@ describe Gitlab::ProjectSearchResults, lib: true do
       expect(results.objects('notes')).not_to include note
     end
   end
+
+  # Examples for commit access level test
+  #
+  # params:
+  # * search_phrase
+  # * commit
+  #
+  shared_examples 'access restricted commits' do
+    context 'when project is internal' do
+      let(:project) { create(:project, :internal) }
+
+      it 'does not search if user is not authenticated' do
+        commits = described_class.new(nil, project, search_phrase).objects('commits')
+
+        expect(commits).to be_empty
+      end
+
+      it 'searches if user is authenticated' do
+        commits = described_class.new(user, project, search_phrase).objects('commits')
+
+        expect(commits).to contain_exactly commit
+      end
+    end
+
+    context 'when project is private' do
+      let!(:creator) { create(:user, username: 'private-project-author') }
+      let!(:private_project) { create(:project, :private, creator: creator, namespace: creator.namespace) }
+      let(:team_master) do
+        user = create(:user, username: 'private-project-master')
+        private_project.team << [user, :master]
+        user
+      end
+      let(:team_reporter) do
+        user = create(:user, username: 'private-project-reporter')
+        private_project.team << [user, :reporter]
+        user
+      end
+
+      it 'does not show commit to stranger' do
+        commits = described_class.new(nil, private_project, search_phrase).objects('commits')
+
+        expect(commits).to be_empty
+      end
+
+      context 'team access' do
+        it 'shows commit to creator' do
+          commits = described_class.new(creator, private_project, search_phrase).objects('commits')
+
+          expect(commits).to contain_exactly commit
+        end
+
+        it 'shows commit to master' do
+          commits = described_class.new(team_master, private_project, search_phrase).objects('commits')
+
+          expect(commits).to contain_exactly commit
+        end
+
+        it 'shows commit to reporter' do
+          commits = described_class.new(team_reporter, private_project, search_phrase).objects('commits')
+
+          expect(commits).to contain_exactly commit
+        end
+      end
+    end
+  end
+
+  describe 'commit search' do
+    context 'by commit message' do
+      let(:project) { create(:project, :public) }
+      let(:commit) { project.repository.commit('59e29889be61e6e0e5e223bfa9ac2721d31605b8') }
+      let(:message) { 'Sorry, I did a mistake' }
+
+      it 'finds commit by message' do
+        commits = described_class.new(user, project, message).objects('commits')
+
+        expect(commits).to contain_exactly commit
+      end
+
+      it 'handles when no commit match' do
+        commits = described_class.new(user, project, 'not really an existing description').objects('commits')
+
+        expect(commits).to be_empty
+      end
+
+      it_behaves_like 'access restricted commits' do
+        let(:search_phrase) { message }
+        let(:commit) { project.repository.commit('59e29889be61e6e0e5e223bfa9ac2721d31605b8') }
+      end
+    end
+
+    context 'by commit hash' do
+      let(:project) { create(:project, :public) }
+      let(:commit) { project.repository.commit('0b4bc9a') }
+      commit_hashes = { short: '0b4bc9a', full: '0b4bc9a49b562e85de7cc9e834518ea6828729b9' }
+
+      commit_hashes.each do |type, commit_hash|
+        it "shows commit by #{type} hash id" do
+          commits = described_class.new(user, project, commit_hash).objects('commits')
+
+          expect(commits).to contain_exactly commit
+        end
+      end
+
+      it 'handles not existing commit hash correctly' do
+        commits = described_class.new(user, project, 'deadbeef').objects('commits')
+
+        expect(commits).to be_empty
+      end
+
+      it_behaves_like 'access restricted commits' do
+        let(:search_phrase) { '0b4bc9a49' }
+        let(:commit) { project.repository.commit('0b4bc9a') }
+      end
+    end
+  end
 end
diff --git a/spec/lib/gitlab/redis_spec.rb b/spec/lib/gitlab/redis_spec.rb
index e5406fb2d33..917c5c46db1 100644
--- a/spec/lib/gitlab/redis_spec.rb
+++ b/spec/lib/gitlab/redis_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Gitlab::Redis do
-  let(:redis_config) { Rails.root.join('config', 'resque.yml').to_s }
+  include StubENV
 
   before(:each) { clear_raw_config }
   after(:each) { clear_raw_config }
@@ -72,6 +72,20 @@ describe Gitlab::Redis do
 
       expect(url2).not_to end_with('foobar')
     end
+
+    context 'when yml file with env variable' do
+      let(:redis_config) { Rails.root.join('spec/fixtures/config/redis_config_with_env.yml') }
+
+      before  do
+        stub_env('TEST_GITLAB_REDIS_URL', 'redis://redishost:6379')
+      end
+
+      it 'reads redis url from env variable' do
+        stub_const("#{described_class}::CONFIG_FILE", redis_config)
+
+        expect(described_class.url).to eq 'redis://redishost:6379'
+      end
+    end
   end
 
   describe '._raw_config' do
diff --git a/spec/lib/gitlab/sidekiq_status/client_middleware_spec.rb b/spec/lib/gitlab/sidekiq_status/client_middleware_spec.rb
new file mode 100644
index 00000000000..287bf62d9bd
--- /dev/null
+++ b/spec/lib/gitlab/sidekiq_status/client_middleware_spec.rb
@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Gitlab::SidekiqStatus::ClientMiddleware do
+  describe '#call' do
+    it 'tracks the job in Redis' do
+      expect(Gitlab::SidekiqStatus).to receive(:set).with('123')
+
+      described_class.new.
+        call('Foo', { 'jid' => '123' }, double(:queue), double(:pool)) { nil }
+    end
+  end
+end
diff --git a/spec/lib/gitlab/sidekiq_status/server_middleware_spec.rb b/spec/lib/gitlab/sidekiq_status/server_middleware_spec.rb
new file mode 100644
index 00000000000..80728197b8c
--- /dev/null
+++ b/spec/lib/gitlab/sidekiq_status/server_middleware_spec.rb
@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Gitlab::SidekiqStatus::ServerMiddleware do
+  describe '#call' do
+    it 'stops tracking of a job upon completion' do
+      expect(Gitlab::SidekiqStatus).to receive(:unset).with('123')
+
+      ret = described_class.new.
+        call(double(:worker), { 'jid' => '123' }, double(:queue)) { 10 }
+
+      expect(ret).to eq(10)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/sidekiq_status_spec.rb b/spec/lib/gitlab/sidekiq_status_spec.rb
new file mode 100644
index 00000000000..0aa36a3416b
--- /dev/null
+++ b/spec/lib/gitlab/sidekiq_status_spec.rb
@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Gitlab::SidekiqStatus do
+  describe '.set', :redis do
+    it 'stores the job ID' do
+      described_class.set('123')
+
+      key = described_class.key_for('123')
+
+      Sidekiq.redis do |redis|
+        expect(redis.exists(key)).to eq(true)
+        expect(redis.ttl(key) > 0).to eq(true)
+      end
+    end
+  end
+
+  describe '.unset', :redis do
+    it 'removes the job ID' do
+      described_class.set('123')
+      described_class.unset('123')
+
+      key = described_class.key_for('123')
+
+      Sidekiq.redis do |redis|
+        expect(redis.exists(key)).to eq(false)
+      end
+    end
+  end
+
+  describe '.all_completed?', :redis do
+    it 'returns true if all jobs have been completed' do
+      expect(described_class.all_completed?(%w(123))).to eq(true)
+    end
+
+    it 'returns false if a job has not yet been completed' do
+      described_class.set('123')
+
+      expect(described_class.all_completed?(%w(123 456))).to eq(false)
+    end
+  end
+
+  describe '.key_for' do
+    it 'returns the key for a job ID' do
+      key = described_class.key_for('123')
+
+      expect(key).to be_an_instance_of(String)
+      expect(key).to include('123')
+    end
+  end
+end
diff --git a/spec/lib/gitlab/user_access_spec.rb b/spec/lib/gitlab/user_access_spec.rb
index d3c3b800b94..369e55f61f1 100644
--- a/spec/lib/gitlab/user_access_spec.rb
+++ b/spec/lib/gitlab/user_access_spec.rb
@@ -66,7 +66,8 @@ describe Gitlab::UserAccess, lib: true do
     end
 
     describe 'push to protected branch' do
-      let(:branch) { create :protected_branch, project: project }
+      let(:branch) { create :protected_branch, project: project, name: "test" }
+      let(:not_existing_branch) { create :protected_branch, :developers_can_merge, project: project }
 
       it 'returns true if user is a master' do
         project.team << [user, :master]
@@ -85,6 +86,12 @@ describe Gitlab::UserAccess, lib: true do
 
         expect(access.can_push_to_branch?(branch.name)).to be_falsey
       end
+
+      it 'returns true if branch does not exist and user has permission to merge' do
+        project.team << [user, :developer]
+
+        expect(access.can_push_to_branch?(not_existing_branch.name)).to be_truthy
+      end
     end
 
     describe 'push to protected branch if allowed for developers' do
diff --git a/spec/lib/gitlab/view/presenter/base_spec.rb b/spec/lib/gitlab/view/presenter/base_spec.rb
new file mode 100644
index 00000000000..f2c152cdcd4
--- /dev/null
+++ b/spec/lib/gitlab/view/presenter/base_spec.rb
@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Gitlab::View::Presenter::Base do
+  let(:project) { double(:project) }
+  let(:presenter_class) do
+    Struct.new(:subject).include(described_class)
+  end
+
+  describe '.presenter?' do
+    it 'returns true' do
+      presenter = presenter_class.new(project)
+
+      expect(presenter.class).to be_presenter
+    end
+  end
+
+  describe '.presents' do
+    it 'exposes #subject with the given keyword' do
+      presenter_class.presents(:foo)
+      presenter = presenter_class.new(project)
+
+      expect(presenter.foo).to eq(project)
+    end
+  end
+
+  describe '#can?' do
+    context 'user is not allowed' do
+      it 'returns false' do
+        presenter = presenter_class.new(build_stubbed(:empty_project))
+
+        expect(presenter.can?(nil, :read_project)).to be_falsy
+      end
+    end
+
+    context 'user is allowed' do
+      it 'returns true' do
+        presenter = presenter_class.new(build_stubbed(:empty_project, :public))
+
+        expect(presenter.can?(nil, :read_project)).to be_truthy
+      end
+    end
+
+    context 'subject is overriden' do
+      it 'returns true' do
+        presenter = presenter_class.new(build_stubbed(:empty_project, :public))
+
+        expect(presenter.can?(nil, :read_project, build_stubbed(:empty_project))).to be_falsy
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/view/presenter/delegated_spec.rb b/spec/lib/gitlab/view/presenter/delegated_spec.rb
new file mode 100644
index 00000000000..888ab80cad5
--- /dev/null
+++ b/spec/lib/gitlab/view/presenter/delegated_spec.rb
@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Gitlab::View::Presenter::Delegated do
+  let(:project) { double(:project, bar: 'baz') }
+  let(:presenter_class) do
+    Class.new(described_class)
+  end
+
+  it 'includes Gitlab::View::Presenter::Base' do
+    expect(described_class).to include(Gitlab::View::Presenter::Base)
+  end
+
+  describe '#initialize' do
+    it 'takes arbitrary key/values and exposes them' do
+      presenter = presenter_class.new(project, user: 'user', foo: 'bar')
+
+      expect(presenter.user).to eq('user')
+      expect(presenter.foo).to eq('bar')
+    end
+  end
+
+  describe 'delegation' do
+    it 'forwards missing methods to subject' do
+      presenter = presenter_class.new(project)
+
+      expect(presenter.bar).to eq('baz')
+    end
+  end
+end
diff --git a/spec/lib/gitlab/view/presenter/factory_spec.rb b/spec/lib/gitlab/view/presenter/factory_spec.rb
new file mode 100644
index 00000000000..55c5ecbf92f
--- /dev/null
+++ b/spec/lib/gitlab/view/presenter/factory_spec.rb
@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Gitlab::View::Presenter::Factory do
+  let(:build) { Ci::Build.new }
+
+  describe '#initialize' do
+    context 'without optional parameters' do
+      it 'takes a subject and optional params' do
+        presenter = described_class.new(build)
+
+        expect { presenter }.not_to raise_error
+      end
+    end
+
+    context 'with optional parameters' do
+      it 'takes a subject and optional params' do
+        presenter = described_class.new(build, user: 'user')
+
+        expect { presenter }.not_to raise_error
+      end
+    end
+  end
+
+  describe '#fabricate!' do
+    it 'exposes given params' do
+      presenter = described_class.new(build, user: 'user', foo: 'bar').fabricate!
+
+      expect(presenter.user).to eq('user')
+      expect(presenter.foo).to eq('bar')
+    end
+
+    it 'detects the presenter based on the given subject' do
+      presenter = described_class.new(build).fabricate!
+
+      expect(presenter).to be_a(Ci::BuildPresenter)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/view/presenter/simple_spec.rb b/spec/lib/gitlab/view/presenter/simple_spec.rb
new file mode 100644
index 00000000000..b489bdf1981
--- /dev/null
+++ b/spec/lib/gitlab/view/presenter/simple_spec.rb
@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Gitlab::View::Presenter::Simple do
+  let(:project) { double(:project) }
+  let(:presenter_class) do
+    Class.new(described_class)
+  end
+
+  it 'includes Gitlab::View::Presenter::Base' do
+    expect(described_class).to include(Gitlab::View::Presenter::Base)
+  end
+
+  describe '#initialize' do
+    it 'takes arbitrary key/values and exposes them' do
+      presenter = presenter_class.new(project, user: 'user', foo: 'bar')
+
+      expect(presenter.user).to eq('user')
+      expect(presenter.foo).to eq('bar')
+    end
+  end
+
+  describe 'delegation' do
+    it 'does not forward missing methods to subject' do
+      presenter = presenter_class.new(project)
+
+      expect { presenter.foo }.to raise_error(NoMethodError)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/workhorse_spec.rb b/spec/lib/gitlab/workhorse_spec.rb
index 61da91dcbd3..4b1cd466677 100644
--- a/spec/lib/gitlab/workhorse_spec.rb
+++ b/spec/lib/gitlab/workhorse_spec.rb
@@ -174,4 +174,27 @@ describe Gitlab::Workhorse, lib: true do
       described_class.verify_api_request!(headers)
     end
   end
+
+  describe '.git_http_ok' do
+    let(:user) { create(:user) }
+
+    subject { described_class.git_http_ok(repository, user) }
+
+    it { expect(subject).to eq({ GL_ID: "user-#{user.id}", RepoPath: repository.path_to_repo }) }
+
+    context 'when Gitaly socket path is present' do
+      let(:gitaly_socket_path) { '/tmp/gitaly.sock' }
+
+      before do
+        allow(Gitlab.config.gitaly).to receive(:socket_path).and_return(gitaly_socket_path)
+      end
+
+      it 'includes Gitaly params in the returned value' do
+        expect(subject).to include({
+          GitalyResourcePath: "/projects/#{repository.project.id}/git-http/info-refs",
+          GitalySocketPath: gitaly_socket_path,
+        })
+      end
+    end
+  end
 end