Merge remote-tracking branch 'upstream/master' into no-ivar-in-modules

* upstream/master: (507 commits)
  Add dropdowns documentation
  Convert migration to populate latest merge request ID into a background migration
  Set 0.69.0 instead of latest for codeclimate image
  De-duplicate background migration matchers defined in spec/support/migrations_helpers.rb
  Update database_debugging.md
  Update database_debugging.md
  Move installation of apps higher
  Change to Google Kubernetes Cluster and add internal links
  Add Ingress description from official docs
  Add info on creating your own k8s cluster from the cluster page
  Add info about the installed apps in the Cluster docs
  Resolve "lock/confidential issuable sidebar custom svg icons iteration"
  Update HA README.md to clarify GitLab support does not troubleshoot DRBD.
  Update license_finder to 3.1.1
  Make sure NotesActions#noteable returns a Noteable in the update action
  Cache the number of user SSH keys
  Adjust openid_connect_spec to use `raise_error`
  Resolve "Clicking on GPG verification badge jumps to top of the page"
  Add changelog for container repository path update
  Update container repository path reference
  ...

332 files changed, 15389 insertions, 3047 deletions

diff --git a/spec/controllers/concerns/issuable_collections_spec.rb b/spec/controllers/concerns/issuable_collections_spec.rb
index c9687af4dd2..d7825364ed5 100644
--- a/spec/controllers/concerns/issuable_collections_spec.rb
+++ b/spec/controllers/concerns/issuable_collections_spec.rb
@@ -12,71 +12,70 @@ describe IssuableCollections do
 
     controller = klass.new
 
-    allow(controller).to receive(:params).and_return(state: 'opened')
+    allow(controller).to receive(:params).and_return(ActionController::Parameters.new(params))
 
     controller
   end
 
-  describe '#redirect_out_of_range' do
-    before do
-      allow(controller).to receive(:url_for)
-    end
-
-    it 'returns true and redirects if the offset is out of range' do
-      relation = double(:relation, current_page: 10)
-
-      expect(controller).to receive(:redirect_to)
-      expect(controller.send(:redirect_out_of_range, relation, 2)).to eq(true)
-    end
-
-    it 'returns false if the offset is not out of range' do
-      relation = double(:relation, current_page: 1)
-
-      expect(controller).not_to receive(:redirect_to)
-      expect(controller.send(:redirect_out_of_range, relation, 2)).to eq(false)
-    end
-  end
-
-  describe '#issues_page_count' do
-    it 'returns the number of issue pages' do
-      project = create(:project, :public)
-
-      create(:issue, project: project)
-
-      finder = IssuesFinder.new(user)
-      issues = finder.execute
+  describe '#page_count_for_relation' do
+    let(:params) { { state: 'opened' } }
 
-      allow(controller).to receive(:issues_finder)
-        .and_return(finder)
+    it 'returns the number of pages' do
+      relation = double(:relation, limit_value: 20)
+      pages = controller.send(:page_count_for_relation, relation, 28)
 
-      expect(controller.send(:issues_page_count, issues)).to eq(1)
+      expect(pages).to eq(2)
     end
   end
 
-  describe '#merge_requests_page_count' do
-    it 'returns the number of merge request pages' do
-      project = create(:project, :public)
-
-      create(:merge_request, source_project: project, target_project: project)
-
-      finder = MergeRequestsFinder.new(user)
-      merge_requests = finder.execute
-
-      allow(controller).to receive(:merge_requests_finder)
-        .and_return(finder)
-
-      pages = controller.send(:merge_requests_page_count, merge_requests)
-
-      expect(pages).to eq(1)
+  describe '#filter_params' do
+    let(:params) do
+      {
+        assignee_id: '1',
+        assignee_username: 'user1',
+        author_id: '2',
+        author_username: 'user2',
+        authorized_only: 'true',
+        due_date: '2017-01-01',
+        group_id: '3',
+        iids: '4',
+        label_name: 'foo',
+        milestone_title: 'bar',
+        my_reaction_emoji: 'thumbsup',
+        non_archived: 'true',
+        project_id: '5',
+        scope: 'all',
+        search: 'baz',
+        sort: 'priority',
+        state: 'opened',
+        invalid_param: 'invalid_param'
+      }
     end
-  end
 
-  describe '#page_count_for_relation' do
-    it 'returns the number of pages' do
-      relation = double(:relation, limit_value: 20)
-      pages = controller.send(:page_count_for_relation, relation, 28)
-
-      expect(pages).to eq(2)
+    it 'filters params' do
+      allow(controller).to receive(:cookies).and_return({})
+
+      filtered_params = controller.send(:filter_params)
+
+      expect(filtered_params).to eq({
+        'assignee_id' => '1',
+        'assignee_username' => 'user1',
+        'author_id' => '2',
+        'author_username' => 'user2',
+        'authorized_only' => 'true',
+        'due_date' => '2017-01-01',
+        'group_id' => '3',
+        'iids' => '4',
+        'label_name' => 'foo',
+        'milestone_title' => 'bar',
+        'my_reaction_emoji' => 'thumbsup',
+        'non_archived' => 'true',
+        'project_id' => '5',
+        'scope' => 'all',
+        'search' => 'baz',
+        'sort' => 'priority',
+        'state' => 'opened'
+      })
     end
   end
 end
diff --git a/spec/controllers/dashboard/todos_controller_spec.rb b/spec/controllers/dashboard/todos_controller_spec.rb
index d862e1447e3..f9faa4fa59a 100644
--- a/spec/controllers/dashboard/todos_controller_spec.rb
+++ b/spec/controllers/dashboard/todos_controller_spec.rb
@@ -44,11 +44,11 @@ describe Dashboard::TodosController do
 
     context 'when using pagination' do
       let(:last_page) { user.todos.page.total_pages }
-      let!(:issues) { create_list(:issue, 2, project: project, assignees: [user]) }
+      let!(:issues) { create_list(:issue, 3, project: project, assignees: [user]) }
 
       before do
         issues.each { |issue| todo_service.new_issue(issue, user) }
-        allow(Kaminari.config).to receive(:default_per_page).and_return(1)
+        allow(Kaminari.config).to receive(:default_per_page).and_return(2)
       end
 
       it 'redirects to last_page if page number is larger than number of pages' do
diff --git a/spec/controllers/import/github_controller_spec.rb b/spec/controllers/import/github_controller_spec.rb
index 45c3fa075ef..9bbd97ec305 100644
--- a/spec/controllers/import/github_controller_spec.rb
+++ b/spec/controllers/import/github_controller_spec.rb
@@ -21,9 +21,9 @@ describe Import::GithubController do
   describe "GET callback" do
     it "updates access token" do
       token = "asdasd12345"
-      allow_any_instance_of(Gitlab::GithubImport::Client)
+      allow_any_instance_of(Gitlab::LegacyGithubImport::Client)
         .to receive(:get_token).and_return(token)
-      allow_any_instance_of(Gitlab::GithubImport::Client)
+      allow_any_instance_of(Gitlab::LegacyGithubImport::Client)
         .to receive(:github_options).and_return({})
       stub_omniauth_provider('github')
 
diff --git a/spec/controllers/metrics_controller_spec.rb b/spec/controllers/metrics_controller_spec.rb
index 4aed2a25baa..9e8a37171ec 100644
--- a/spec/controllers/metrics_controller_spec.rb
+++ b/spec/controllers/metrics_controller_spec.rb
@@ -67,7 +67,8 @@ describe MetricsController do
         it 'returns proper response' do
           get :index
 
-          expect(response.status).to eq(404)
+          expect(response.status).to eq(200)
+          expect(response.body).to eq("# Metrics are disabled, see: http://test.host/help/administration/monitoring/prometheus/gitlab_metrics#gitlab-prometheus-metrics\n")
         end
       end
     end
diff --git a/spec/controllers/projects/clusters/applications_controller_spec.rb b/spec/controllers/projects/clusters/applications_controller_spec.rb
new file mode 100644
index 00000000000..8b460646059
--- /dev/null
+++ b/spec/controllers/projects/clusters/applications_controller_spec.rb
@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Projects::Clusters::ApplicationsController do
+  include AccessMatchersForController
+
+  def current_application
+    Clusters::Cluster::APPLICATIONS[application]
+  end
+
+  describe 'POST create' do
+    let(:cluster) { create(:cluster, :project, :provided_by_gcp) }
+    let(:project) { cluster.project }
+    let(:application) { 'helm' }
+    let(:params) { { application: application, id: cluster.id } }
+
+    describe 'functionality' do
+      let(:user) { create(:user) }
+
+      before do
+        project.add_master(user)
+        sign_in(user)
+      end
+
+      it 'schedule an application installation' do
+        expect(ClusterInstallAppWorker).to receive(:perform_async).with(application, anything).once
+
+        expect { go }.to change { current_application.count }
+        expect(response).to have_http_status(:no_content)
+        expect(cluster.application_helm).to be_scheduled
+      end
+
+      context 'when cluster do not exists' do
+        before do
+          cluster.destroy!
+        end
+
+        it 'return 404' do
+          expect { go }.not_to change { current_application.count }
+          expect(response).to have_http_status(:not_found)
+        end
+      end
+
+      context 'when application is unknown' do
+        let(:application) { 'unkwnown-app' }
+
+        it 'return 404' do
+          go
+
+          expect(response).to have_http_status(:not_found)
+        end
+      end
+
+      context 'when application is already installing' do
+        before do
+          create(:cluster_applications_helm, :installing, cluster: cluster)
+        end
+
+        it 'returns 400' do
+          go
+
+          expect(response).to have_http_status(:bad_request)
+        end
+      end
+    end
+
+    describe 'security' do
+      before do
+        allow(ClusterInstallAppWorker).to receive(:perform_async)
+      end
+
+      it { expect { go }.to be_allowed_for(:admin) }
+      it { expect { go }.to be_allowed_for(:owner).of(project) }
+      it { expect { go }.to be_allowed_for(:master).of(project) }
+      it { expect { go }.to be_denied_for(:developer).of(project) }
+      it { expect { go }.to be_denied_for(:reporter).of(project) }
+      it { expect { go }.to be_denied_for(:guest).of(project) }
+      it { expect { go }.to be_denied_for(:user) }
+      it { expect { go }.to be_denied_for(:external) }
+    end
+
+    def go
+      post :create, params.merge(namespace_id: project.namespace, project_id: project)
+    end
+  end
+end
diff --git a/spec/controllers/projects/clusters_controller_spec.rb b/spec/controllers/projects/clusters_controller_spec.rb
index bd924a1c7be..ca2bcb2b5ae 100644
--- a/spec/controllers/projects/clusters_controller_spec.rb
+++ b/spec/controllers/projects/clusters_controller_spec.rb
@@ -1,68 +1,108 @@
 require 'spec_helper'
 
 describe Projects::ClustersController do
-  set(:user) { create(:user) }
-  set(:project) { create(:project) }
-  let(:role) { :master }
+  include AccessMatchersForController
+  include GoogleApi::CloudPlatformHelpers
 
-  before do
-    project.team << [user, role]
+  describe 'GET index' do
+    describe 'functionality' do
+      let(:user) { create(:user) }
 
-    sign_in(user)
-  end
+      before do
+        project.add_master(user)
+        sign_in(user)
+      end
 
-  describe 'GET index' do
-    subject do
-      get :index, namespace_id: project.namespace,
-                  project_id: project
-    end
+      context 'when project has a cluster' do
+        let(:cluster) { create(:cluster, :project, :provided_by_gcp) }
+        let(:project) { cluster.project }
 
-    context 'when cluster is already created' do
-      let!(:cluster) { create(:gcp_cluster, :created_on_gke, project: project) }
+        it { expect(go).to redirect_to(project_cluster_path(project, project.cluster)) }
+      end
 
-      it 'redirects to show a cluster' do
-        subject
+      context 'when project does not have a cluster' do
+        let(:project) { create(:project) }
 
-        expect(response).to redirect_to(project_cluster_path(project, cluster))
+        it { expect(go).to redirect_to(new_project_cluster_path(project)) }
       end
     end
 
-    context 'when we do not have cluster' do
-      it 'redirects to create a cluster' do
-        subject
+    describe 'security' do
+      let(:cluster) { create(:cluster, :project, :provided_by_gcp) }
+      let(:project) { cluster.project }
+
+      it { expect { go }.to be_allowed_for(:admin) }
+      it { expect { go }.to be_allowed_for(:owner).of(project) }
+      it { expect { go }.to be_allowed_for(:master).of(project) }
+      it { expect { go }.to be_denied_for(:developer).of(project) }
+      it { expect { go }.to be_denied_for(:reporter).of(project) }
+      it { expect { go }.to be_denied_for(:guest).of(project) }
+      it { expect { go }.to be_denied_for(:user) }
+      it { expect { go }.to be_denied_for(:external) }
+    end
 
-        expect(response).to redirect_to(new_project_cluster_path(project))
-      end
+    def go
+      get :index, namespace_id: project.namespace.to_param, project_id: project
     end
   end
 
   describe 'GET login' do
-    render_views
+    let(:project) { create(:project) }
 
-    subject do
-      get :login, namespace_id: project.namespace,
-                  project_id: project
-    end
-
-    context 'when we do have omniauth configured' do
-      it 'shows login button' do
-        subject
+    describe 'functionality' do
+      let(:user) { create(:user) }
 
-        expect(response.body).to include('auth_buttons/signin_with_google')
+      before do
+        project.add_master(user)
+        sign_in(user)
       end
-    end
 
-    context 'when we do not have omniauth configured' do
-      before do
-        stub_omniauth_setting(providers: [])
+      context 'when omniauth has been configured' do
+        let(:key) { 'secere-key' }
+
+        let(:session_key_for_redirect_uri) do
+          GoogleApi::CloudPlatform::Client.session_key_for_redirect_uri(key)
+        end
+
+        before do
+          allow(SecureRandom).to receive(:hex).and_return(key)
+        end
+
+        it 'has authorize_url' do
+          go
+
+          expect(assigns(:authorize_url)).to include(key)
+          expect(session[session_key_for_redirect_uri]).to eq(providers_gcp_new_project_clusters_url(project))
+        end
       end
 
-      it 'shows notice message' do
-        subject
+      context 'when omniauth has not configured' do
+        before do
+          stub_omniauth_setting(providers: [])
+        end
+
+        it 'does not have authorize_url' do
+          go
 
-        expect(response.body).to include('Ask your GitLab administrator if you want to use this service.')
+          expect(assigns(:authorize_url)).to be_nil
+        end
       end
     end
+
+    describe 'security' do
+      it { expect { go }.to be_allowed_for(:admin) }
+      it { expect { go }.to be_allowed_for(:owner).of(project) }
+      it { expect { go }.to be_allowed_for(:master).of(project) }
+      it { expect { go }.to be_denied_for(:developer).of(project) }
+      it { expect { go }.to be_denied_for(:reporter).of(project) }
+      it { expect { go }.to be_denied_for(:guest).of(project) }
+      it { expect { go }.to be_denied_for(:user) }
+      it { expect { go }.to be_denied_for(:external) }
+    end
+
+    def go
+      get :login, namespace_id: project.namespace, project_id: project
+    end
   end
 
   shared_examples 'requires to login' do
@@ -73,236 +113,336 @@ describe Projects::ClustersController do
     end
   end
 
-  describe 'GET new' do
-    render_views
+  describe 'GET new_gcp' do
+    let(:project) { create(:project) }
 
-    subject do
-      get :new, namespace_id: project.namespace,
-                project_id: project
-    end
+    describe 'functionality' do
+      let(:user) { create(:user) }
 
-    context 'when logged' do
       before do
-        make_logged_in
+        project.add_master(user)
+        sign_in(user)
+      end
+
+      context 'when access token is valid' do
+        before do
+          stub_google_api_validate_token
+        end
+
+        it 'has new object' do
+          go
+
+          expect(assigns(:cluster)).to be_an_instance_of(Clusters::Cluster)
+        end
       end
 
-      it 'shows a creation form' do
-        subject
+      context 'when access token is expired' do
+        before do
+          stub_google_api_expired_token
+        end
+
+        it { expect(go).to redirect_to(login_project_clusters_path(project)) }
+      end
 
-        expect(response.body).to include('Create cluster')
+      context 'when access token is not stored in session' do
+        it { expect(go).to redirect_to(login_project_clusters_path(project)) }
       end
     end
 
-    context 'when not logged' do
-      it_behaves_like 'requires to login'
+    describe 'security' do
+      it { expect { go }.to be_allowed_for(:admin) }
+      it { expect { go }.to be_allowed_for(:owner).of(project) }
+      it { expect { go }.to be_allowed_for(:master).of(project) }
+      it { expect { go }.to be_denied_for(:developer).of(project) }
+      it { expect { go }.to be_denied_for(:reporter).of(project) }
+      it { expect { go }.to be_denied_for(:guest).of(project) }
+      it { expect { go }.to be_denied_for(:user) }
+      it { expect { go }.to be_denied_for(:external) }
+    end
+
+    def go
+      get :new_gcp, namespace_id: project.namespace, project_id: project
     end
   end
 
   describe 'POST create' do
-    subject do
-      post :create, params.merge(namespace_id: project.namespace,
-                                 project_id: project)
+    let(:project) { create(:project) }
+
+    let(:params) do
+      {
+        cluster: {
+          name: 'new-cluster',
+          provider_type: :gcp,
+          provider_gcp_attributes: {
+            gcp_project_id: '111'
+          }
+        }
+      }
     end
 
-    context 'when not logged' do
-      let(:params) { {} }
-
-      it_behaves_like 'requires to login'
-    end
+    describe 'functionality' do
+      let(:user) { create(:user) }
 
-    context 'when logged in' do
       before do
-        make_logged_in
+        project.add_master(user)
+        sign_in(user)
       end
 
-      context 'when all required parameters are set' do
-        let(:params) do
-          {
-            cluster: {
-              gcp_cluster_name: 'new-cluster',
-              gcp_project_id: '111'
-            }
-          }
-        end
-
+      context 'when access token is valid' do
         before do
-          expect(ClusterProvisionWorker).to receive(:perform_async) { }
+          stub_google_api_validate_token
         end
 
-        it 'creates a new cluster' do
-          expect { subject }.to change { Gcp::Cluster.count }
-
-          expect(response).to redirect_to(project_cluster_path(project, project.cluster))
+        context 'when creates a cluster on gke' do
+          it 'creates a new cluster' do
+            expect(ClusterProvisionWorker).to receive(:perform_async)
+            expect { go }.to change { Clusters::Cluster.count }
+            expect(response).to redirect_to(project_cluster_path(project, project.cluster))
+          end
         end
       end
 
-      context 'when not all required parameters are set' do
-        render_views
-
-        let(:params) do
-          {
-            cluster: {
-              project_namespace: 'some namespace'
-            }
-          }
+      context 'when access token is expired' do
+        before do
+          stub_google_api_expired_token
         end
 
-        it 'shows an error message' do
-          expect { subject }.not_to change { Gcp::Cluster.count }
+        it 'redirects to login page' do
+          expect(go).to redirect_to(login_project_clusters_path(project))
+        end
+      end
 
-          expect(response).to render_template(:new)
+      context 'when access token is not stored in session' do
+        it 'redirects to login page' do
+          expect(go).to redirect_to(login_project_clusters_path(project))
         end
       end
     end
+
+    describe 'security' do
+      it { expect { go }.to be_allowed_for(:admin) }
+      it { expect { go }.to be_allowed_for(:owner).of(project) }
+      it { expect { go }.to be_allowed_for(:master).of(project) }
+      it { expect { go }.to be_denied_for(:developer).of(project) }
+      it { expect { go }.to be_denied_for(:reporter).of(project) }
+      it { expect { go }.to be_denied_for(:guest).of(project) }
+      it { expect { go }.to be_denied_for(:user) }
+      it { expect { go }.to be_denied_for(:external) }
+    end
+
+    def go
+      post :create, params.merge(namespace_id: project.namespace, project_id: project)
+    end
   end
 
   describe 'GET status' do
-    let(:cluster) { create(:gcp_cluster, :created_on_gke, project: project) }
+    let(:cluster) { create(:cluster, :project, :providing_by_gcp) }
+    let(:project) { cluster.project }
+
+    describe 'functionality' do
+      let(:user) { create(:user) }
 
-    subject do
+      before do
+        project.add_master(user)
+        sign_in(user)
+      end
+
+      it "responds with matching schema" do
+        go
+
+        expect(response).to have_gitlab_http_status(:ok)
+        expect(response).to match_response_schema('cluster_status')
+      end
+    end
+
+    describe 'security' do
+      it { expect { go }.to be_allowed_for(:admin) }
+      it { expect { go }.to be_allowed_for(:owner).of(project) }
+      it { expect { go }.to be_allowed_for(:master).of(project) }
+      it { expect { go }.to be_denied_for(:developer).of(project) }
+      it { expect { go }.to be_denied_for(:reporter).of(project) }
+      it { expect { go }.to be_denied_for(:guest).of(project) }
+      it { expect { go }.to be_denied_for(:user) }
+      it { expect { go }.to be_denied_for(:external) }
+    end
+
+    def go
       get :status, namespace_id: project.namespace,
                    project_id: project,
                    id: cluster,
                    format: :json
     end
-
-    it "responds with matching schema" do
-      subject
-
-      expect(response).to have_gitlab_http_status(:ok)
-      expect(response).to match_response_schema('cluster_status')
-    end
   end
 
   describe 'GET show' do
-    render_views
+    let(:cluster) { create(:cluster, :project, :provided_by_gcp) }
+    let(:project) { cluster.project }
 
-    let(:cluster) { create(:gcp_cluster, :created_on_gke, project: project) }
+    describe 'functionality' do
+      let(:user) { create(:user) }
 
-    subject do
-      get :show, namespace_id: project.namespace,
-                 project_id: project,
-                 id: cluster
-    end
-
-    context 'when logged as master' do
-      it "allows to update cluster" do
-        subject
-
-        expect(response).to have_gitlab_http_status(:ok)
-        expect(response.body).to include("Save")
+      before do
+        project.add_master(user)
+        sign_in(user)
       end
 
-      it "allows remove integration" do
-        subject
+      it "renders view" do
+        go
 
         expect(response).to have_gitlab_http_status(:ok)
-        expect(response.body).to include("Remove integration")
+        expect(assigns(:cluster)).to eq(cluster)
       end
     end
 
-    context 'when logged as developer' do
-      let(:role) { :developer }
-
-      it "does not allow to access page" do
-        subject
+    describe 'security' do
+      it { expect { go }.to be_allowed_for(:admin) }
+      it { expect { go }.to be_allowed_for(:owner).of(project) }
+      it { expect { go }.to be_allowed_for(:master).of(project) }
+      it { expect { go }.to be_denied_for(:developer).of(project) }
+      it { expect { go }.to be_denied_for(:reporter).of(project) }
+      it { expect { go }.to be_denied_for(:guest).of(project) }
+      it { expect { go }.to be_denied_for(:user) }
+      it { expect { go }.to be_denied_for(:external) }
+    end
 
-        expect(response).to have_gitlab_http_status(:not_found)
-      end
+    def go
+      get :show, namespace_id: project.namespace,
+                 project_id: project,
+                 id: cluster
     end
   end
 
   describe 'PUT update' do
-    render_views
+    let(:cluster) { create(:cluster, :project, :provided_by_gcp) }
+    let(:project) { cluster.project }
 
-    let(:service) { project.build_kubernetes_service }
-    let(:cluster) { create(:gcp_cluster, :created_on_gke, project: project, service: service) }
-    let(:params) { {} }
+    describe 'functionality' do
+      let(:user) { create(:user) }
 
-    subject do
-      put :update, params.merge(namespace_id: project.namespace,
-                                project_id: project,
-                                id: cluster)
-    end
+      before do
+        project.add_master(user)
+        sign_in(user)
+      end
 
-    context 'when logged as master' do
-      context 'when valid params are used' do
+      context 'when update enabled' do
         let(:params) do
           {
             cluster: { enabled: false }
           }
         end
 
-        it "redirects back to show page" do
-          subject
+        it "updates and redirects back to show page" do
+          go
 
+          cluster.reload
           expect(response).to redirect_to(project_cluster_path(project, project.cluster))
           expect(flash[:notice]).to eq('Cluster was successfully updated.')
+          expect(cluster.enabled).to be_falsey
         end
-      end
 
-      context 'when invalid params are used' do
-        let(:params) do
-          {
-            cluster: { project_namespace: 'my Namespace 321321321 #' }
-          }
-        end
+        context 'when cluster is being created' do
+          let(:cluster) { create(:cluster, :project, :providing_by_gcp) }
 
-        it "rejects changes" do
-          subject
+          it "rejects changes" do
+            go
 
-          expect(response).to have_gitlab_http_status(:ok)
-          expect(response).to render_template(:show)
+            expect(response).to have_gitlab_http_status(:ok)
+            expect(response).to render_template(:show)
+            expect(cluster.enabled).to be_truthy
+          end
         end
       end
     end
 
-    context 'when logged as developer' do
-      let(:role) { :developer }
+    describe 'security' do
+      let(:params) do
+        {
+          cluster: { enabled: false }
+        }
+      end
 
-      it "does not allow to update cluster" do
-        subject
+      it { expect { go }.to be_allowed_for(:admin) }
+      it { expect { go }.to be_allowed_for(:owner).of(project) }
+      it { expect { go }.to be_allowed_for(:master).of(project) }
+      it { expect { go }.to be_denied_for(:developer).of(project) }
+      it { expect { go }.to be_denied_for(:reporter).of(project) }
+      it { expect { go }.to be_denied_for(:guest).of(project) }
+      it { expect { go }.to be_denied_for(:user) }
+      it { expect { go }.to be_denied_for(:external) }
+    end
 
-        expect(response).to have_gitlab_http_status(:not_found)
-      end
+    def go
+      put :update, params.merge(namespace_id: project.namespace,
+                                project_id: project,
+                                id: cluster)
     end
   end
 
   describe 'delete update' do
-    let(:cluster) { create(:gcp_cluster, :created_on_gke, project: project) }
+    let(:cluster) { create(:cluster, :project, :provided_by_gcp) }
+    let(:project) { cluster.project }
 
-    subject do
-      delete :destroy, namespace_id: project.namespace,
-                       project_id: project,
-                       id: cluster
-    end
+    describe 'functionality' do
+      let(:user) { create(:user) }
 
-    context 'when logged as master' do
-      it "redirects back to clusters list" do
-        subject
+      before do
+        project.add_master(user)
+        sign_in(user)
+      end
+
+      it "destroys and redirects back to clusters list" do
+        expect { go }
+          .to change { Clusters::Cluster.count }.by(-1)
+          .and change { Clusters::Platforms::Kubernetes.count }.by(-1)
+          .and change { Clusters::Providers::Gcp.count }.by(-1)
 
         expect(response).to redirect_to(project_clusters_path(project))
         expect(flash[:notice]).to eq('Cluster integration was successfully removed.')
       end
-    end
 
-    context 'when logged as developer' do
-      let(:role) { :developer }
+      context 'when cluster is being created' do
+        let(:cluster) { create(:cluster, :project, :providing_by_gcp) }
+
+        it "destroys and redirects back to clusters list" do
+          expect { go }
+            .to change { Clusters::Cluster.count }.by(-1)
+            .and change { Clusters::Providers::Gcp.count }.by(-1)
+
+          expect(response).to redirect_to(project_clusters_path(project))
+          expect(flash[:notice]).to eq('Cluster integration was successfully removed.')
+        end
+      end
+
+      context 'when provider is user' do
+        let(:cluster) { create(:cluster, :project, :provided_by_user) }
 
-      it "does not allow to destroy cluster" do
-        subject
+        it "destroys and redirects back to clusters list" do
+          expect { go }
+            .to change { Clusters::Cluster.count }.by(-1)
+            .and change { Clusters::Platforms::Kubernetes.count }.by(-1)
+            .and change { Clusters::Providers::Gcp.count }.by(0)
 
-        expect(response).to have_gitlab_http_status(:not_found)
+          expect(response).to redirect_to(project_clusters_path(project))
+          expect(flash[:notice]).to eq('Cluster integration was successfully removed.')
+        end
       end
     end
-  end
 
-  def make_logged_in
-    session[GoogleApi::CloudPlatform::Client.session_key_for_token] = '1234'
-    session[GoogleApi::CloudPlatform::Client.session_key_for_expires_at] = in_hour.to_i.to_s
-  end
+    describe 'security' do
+      it { expect { go }.to be_allowed_for(:admin) }
+      it { expect { go }.to be_allowed_for(:owner).of(project) }
+      it { expect { go }.to be_allowed_for(:master).of(project) }
+      it { expect { go }.to be_denied_for(:developer).of(project) }
+      it { expect { go }.to be_denied_for(:reporter).of(project) }
+      it { expect { go }.to be_denied_for(:guest).of(project) }
+      it { expect { go }.to be_denied_for(:user) }
+      it { expect { go }.to be_denied_for(:external) }
+    end
 
-  def in_hour
-    Time.now + 1.hour
+    def go
+      delete :destroy, namespace_id: project.namespace,
+                       project_id: project,
+                       id: cluster
+    end
   end
 end
diff --git a/spec/controllers/projects/commit_controller_spec.rb b/spec/controllers/projects/commit_controller_spec.rb
index 4612fc6e441..5dc27e2bbba 100644
--- a/spec/controllers/projects/commit_controller_spec.rb
+++ b/spec/controllers/projects/commit_controller_spec.rb
@@ -134,8 +134,8 @@ describe Projects::CommitController do
     end
   end
 
-  describe "GET branches" do
-    it "contains branch and tags information" do
+  describe 'GET branches' do
+    it 'contains branch and tags information' do
       commit = project.commit('5937ac0a7beb003549fc5fd26fc247adbce4a52e')
 
       get(:branches,
@@ -143,8 +143,26 @@ describe Projects::CommitController do
           project_id: project,
           id: commit.id)
 
-      expect(assigns(:branches)).to include("master", "feature_conflict")
-      expect(assigns(:tags)).to include("v1.1.0")
+      expect(assigns(:branches)).to include('master', 'feature_conflict')
+      expect(assigns(:branches_limit_exceeded)).to be_falsey
+      expect(assigns(:tags)).to include('v1.1.0')
+      expect(assigns(:tags_limit_exceeded)).to be_falsey
+    end
+
+    it 'returns :limit_exceeded when number of branches/tags reach a threshhold' do
+      commit = project.commit('5937ac0a7beb003549fc5fd26fc247adbce4a52e')
+      allow_any_instance_of(Repository).to receive(:branch_count).and_return(1001)
+      allow_any_instance_of(Repository).to receive(:tag_count).and_return(1001)
+
+      get(:branches,
+          namespace_id: project.namespace,
+          project_id: project,
+          id: commit.id)
+
+      expect(assigns(:branches)).to eq([])
+      expect(assigns(:branches_limit_exceeded)).to be_truthy
+      expect(assigns(:tags)).to eq([])
+      expect(assigns(:tags_limit_exceeded)).to be_truthy
     end
   end
 
diff --git a/spec/controllers/projects/jobs_controller_spec.rb b/spec/controllers/projects/jobs_controller_spec.rb
index f9688949a19..7490f8fefce 100644
--- a/spec/controllers/projects/jobs_controller_spec.rb
+++ b/spec/controllers/projects/jobs_controller_spec.rb
@@ -371,8 +371,10 @@ describe Projects::JobsController do
   end
 
   describe 'POST erase' do
+    let(:role) { :master }
+
     before do
-      project.add_developer(user)
+      project.team << [user, role]
       sign_in(user)
 
       post_erase
@@ -404,6 +406,27 @@ describe Projects::JobsController do
       end
     end
 
+    context 'when user is developer' do
+      let(:role) { :developer }
+      let(:job) { create(:ci_build, :erasable, :trace, pipeline: pipeline, user: triggered_by) }
+
+      context 'when triggered by same user' do
+        let(:triggered_by) { user }
+
+        it 'has successful status' do
+          expect(response).to have_gitlab_http_status(:found)
+        end
+      end
+
+      context 'when triggered by different user' do
+        let(:triggered_by) { create(:user) }
+
+        it 'does not have successful status' do
+          expect(response).not_to have_gitlab_http_status(:found)
+        end
+      end
+    end
+
     def post_erase
       post :erase, namespace_id: project.namespace,
                    project_id: project,
diff --git a/spec/controllers/projects/notes_controller_spec.rb b/spec/controllers/projects/notes_controller_spec.rb
index 5f5a789d5cc..37e9f863fc4 100644
--- a/spec/controllers/projects/notes_controller_spec.rb
+++ b/spec/controllers/projects/notes_controller_spec.rb
@@ -336,6 +336,29 @@ describe Projects::NotesController do
     end
   end
 
+  describe 'PUT update' do
+    let(:request_params) do
+      {
+        namespace_id: project.namespace,
+        project_id: project,
+        id: note,
+        format: :json,
+        note: {
+          note: "New comment"
+        }
+      }
+    end
+
+    before do
+      sign_in(note.author)
+      project.team << [note.author, :developer]
+    end
+
+    it "updates the note" do
+      expect { put :update, request_params }.to change { note.reload.note }
+    end
+  end
+
   describe 'DELETE destroy' do
     let(:request_params) do
       {
diff --git a/spec/controllers/projects/refs_controller_spec.rb b/spec/controllers/projects/refs_controller_spec.rb
index 3a3e7467ef2..748ae040928 100644
--- a/spec/controllers/projects/refs_controller_spec.rb
+++ b/spec/controllers/projects/refs_controller_spec.rb
@@ -23,12 +23,15 @@ describe Projects::RefsController do
       xhr :get,
           :logs_tree,
           namespace_id: project.namespace.to_param,
-          project_id: project, id: 'master',
-          path: 'foo/bar/baz.html', format: format
+          project_id: project,
+          id: 'master',
+          path: 'foo/bar/baz.html',
+          format: format
     end
 
     it 'never throws MissingTemplate' do
       expect { default_get }.not_to raise_error
+      expect { xhr_get(:json) }.not_to raise_error
       expect { xhr_get }.not_to raise_error
     end
 
@@ -42,5 +45,12 @@ describe Projects::RefsController do
       xhr_get(:js)
       expect(response).to be_success
     end
+
+    it 'renders JSON' do
+      xhr_get(:json)
+
+      expect(response).to be_success
+      expect(json_response).to be_kind_of(Array)
+    end
   end
 end
diff --git a/spec/controllers/projects_controller_spec.rb b/spec/controllers/projects_controller_spec.rb
index b1d7157e447..e7ab714c550 100644
--- a/spec/controllers/projects_controller_spec.rb
+++ b/spec/controllers/projects_controller_spec.rb
@@ -503,13 +503,14 @@ describe ProjectsController do
   describe "GET refs" do
     let(:public_project) { create(:project, :public, :repository) }
 
-    it "gets a list of branches and tags" do
-      get :refs, namespace_id: public_project.namespace, id: public_project
+    it 'gets a list of branches and tags' do
+      get :refs, namespace_id: public_project.namespace, id: public_project, sort: 'updated_desc'
 
       parsed_body = JSON.parse(response.body)
-      expect(parsed_body["Branches"]).to include("master")
-      expect(parsed_body["Tags"]).to include("v1.0.0")
-      expect(parsed_body["Commits"]).to be_nil
+      expect(parsed_body['Branches']).to include('master')
+      expect(parsed_body['Tags'].first).to eq('v1.1.0')
+      expect(parsed_body['Tags'].last).to eq('v1.0.0')
+      expect(parsed_body['Commits']).to be_nil
     end
 
     it "gets a list of branches, tags and commits" do
diff --git a/spec/factories/clusters/applications/helm.rb b/spec/factories/clusters/applications/helm.rb
new file mode 100644
index 00000000000..fab37195113
--- /dev/null
+++ b/spec/factories/clusters/applications/helm.rb
@@ -0,0 +1,35 @@
+FactoryGirl.define do
+  factory :cluster_applications_helm, class: Clusters::Applications::Helm do
+    cluster factory: %i(cluster provided_by_gcp)
+
+    trait :not_installable do
+      status(-2)
+    end
+
+    trait :installable do
+      status 0
+    end
+
+    trait :scheduled do
+      status 1
+    end
+
+    trait :installing do
+      status 2
+    end
+
+    trait :installed do
+      status 3
+    end
+
+    trait :errored do
+      status(-1)
+      status_reason 'something went wrong'
+    end
+
+    trait :timeouted do
+      installing
+      updated_at ClusterWaitForAppInstallationWorker::TIMEOUT.ago
+    end
+  end
+end
diff --git a/spec/factories/clusters/applications/ingress.rb b/spec/factories/clusters/applications/ingress.rb
new file mode 100644
index 00000000000..b103a980655
--- /dev/null
+++ b/spec/factories/clusters/applications/ingress.rb
@@ -0,0 +1,35 @@
+FactoryGirl.define do
+  factory :cluster_applications_ingress, class: Clusters::Applications::Ingress do
+    cluster factory: %i(cluster provided_by_gcp)
+
+    trait :not_installable do
+      status(-2)
+    end
+
+    trait :installable do
+      status 0
+    end
+
+    trait :scheduled do
+      status 1
+    end
+
+    trait :installing do
+      status 2
+    end
+
+    trait :installed do
+      status 3
+    end
+
+    trait :errored do
+      status(-1)
+      status_reason 'something went wrong'
+    end
+
+    trait :timeouted do
+      installing
+      updated_at ClusterWaitForAppInstallationWorker::TIMEOUT.ago
+    end
+  end
+end
diff --git a/spec/factories/clusters/cluster.rb b/spec/factories/clusters/cluster.rb
new file mode 100644
index 00000000000..c4261178f2d
--- /dev/null
+++ b/spec/factories/clusters/cluster.rb
@@ -0,0 +1,39 @@
+FactoryGirl.define do
+  factory :cluster, class: Clusters::Cluster do
+    user
+    name 'test-cluster'
+
+    trait :project do
+      after(:create) do |cluster, evaluator|
+        cluster.projects << create(:project)
+      end
+    end
+
+    trait :provided_by_user do
+      provider_type :user
+      platform_type :kubernetes
+
+      platform_kubernetes do
+        create(:cluster_platform_kubernetes, :configured)
+      end
+    end
+
+    trait :provided_by_gcp do
+      provider_type :gcp
+      platform_type :kubernetes
+
+      before(:create) do |cluster, evaluator|
+        cluster.platform_kubernetes = build(:cluster_platform_kubernetes, :configured)
+        cluster.provider_gcp = build(:cluster_provider_gcp, :created)
+      end
+    end
+
+    trait :providing_by_gcp do
+      provider_type :gcp
+
+      provider_gcp do
+        create(:cluster_provider_gcp, :creating)
+      end
+    end
+  end
+end
diff --git a/spec/factories/clusters/platforms/kubernetes.rb b/spec/factories/clusters/platforms/kubernetes.rb
new file mode 100644
index 00000000000..8b3e6ff35fa
--- /dev/null
+++ b/spec/factories/clusters/platforms/kubernetes.rb
@@ -0,0 +1,20 @@
+FactoryGirl.define do
+  factory :cluster_platform_kubernetes, class: Clusters::Platforms::Kubernetes do
+    cluster
+    namespace nil
+    api_url 'https://kubernetes.example.com'
+    token 'a' * 40
+
+    trait :configured do
+      api_url 'https://kubernetes.example.com'
+      token 'a' * 40
+      username 'xxxxxx'
+      password 'xxxxxx'
+
+      after(:create) do |platform_kubernetes, evaluator|
+        pem_file = File.expand_path(Rails.root.join('spec/fixtures/clusters/sample_cert.pem'))
+        platform_kubernetes.ca_cert = File.read(pem_file)
+      end
+    end
+  end
+end
diff --git a/spec/factories/clusters/providers/gcp.rb b/spec/factories/clusters/providers/gcp.rb
new file mode 100644
index 00000000000..a815410512a
--- /dev/null
+++ b/spec/factories/clusters/providers/gcp.rb
@@ -0,0 +1,32 @@
+FactoryGirl.define do
+  factory :cluster_provider_gcp, class: Clusters::Providers::Gcp do
+    cluster
+    gcp_project_id 'test-gcp-project'
+
+    trait :scheduled do
+      access_token 'access_token_123'
+    end
+
+    trait :creating do
+      access_token 'access_token_123'
+
+      after(:build) do |gcp, evaluator|
+        gcp.make_creating('operation-123')
+      end
+    end
+
+    trait :created do
+      endpoint '111.111.111.111'
+
+      after(:build) do |gcp, evaluator|
+        gcp.make_created
+      end
+    end
+
+    trait :errored do
+      after(:build) do |gcp, evaluator|
+        gcp.make_errored('Something wrong')
+      end
+    end
+  end
+end
diff --git a/spec/factories/commit_statuses.rb b/spec/factories/commit_statuses.rb
index 169590deb8e..abbe37df90e 100644
--- a/spec/factories/commit_statuses.rb
+++ b/spec/factories/commit_statuses.rb
@@ -1,6 +1,7 @@
 FactoryGirl.define do
   factory :commit_status, class: CommitStatus do
     name 'default'
+    stage 'test'
     status 'success'
     description 'commit status'
     pipeline factory: :ci_pipeline_with_one_job
diff --git a/spec/factories/gcp/cluster.rb b/spec/factories/gcp/cluster.rb
deleted file mode 100644
index 630e40da888..00000000000
--- a/spec/factories/gcp/cluster.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-FactoryGirl.define do
-  factory :gcp_cluster, class: Gcp::Cluster do
-    project
-    user
-    enabled true
-    gcp_project_id 'gcp-project-12345'
-    gcp_cluster_name 'test-cluster'
-    gcp_cluster_zone 'us-central1-a'
-    gcp_cluster_size 1
-    gcp_machine_type 'n1-standard-4'
-
-    trait :with_kubernetes_service do
-      after(:create) do |cluster, evaluator|
-        create(:kubernetes_service, project: cluster.project).tap do |service|
-          cluster.update(service: service)
-        end
-      end
-    end
-
-    trait :custom_project_namespace do
-      project_namespace 'sample-app'
-    end
-
-    trait :created_on_gke do
-      status_event :make_created
-      endpoint '111.111.111.111'
-      ca_cert 'xxxxxx'
-      kubernetes_token 'xxxxxx'
-      username 'xxxxxx'
-      password 'xxxxxx'
-    end
-
-    trait :errored do
-      status_event :make_errored
-      status_reason 'general error'
-    end
-  end
-end
diff --git a/spec/factories/group_custom_attributes.rb b/spec/factories/group_custom_attributes.rb
new file mode 100644
index 00000000000..7ff5f376e8b
--- /dev/null
+++ b/spec/factories/group_custom_attributes.rb
@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :group_custom_attribute do
+    group
+    sequence(:key) { |n| "key#{n}" }
+    sequence(:value) { |n| "value#{n}" }
+  end
+end
diff --git a/spec/factories/merge_requests.rb b/spec/factories/merge_requests.rb
index 7c4a22c94c2..cc6cef63b47 100644
--- a/spec/factories/merge_requests.rb
+++ b/spec/factories/merge_requests.rb
@@ -83,10 +83,10 @@ FactoryGirl.define do
       target_project = merge_request.target_project
       source_project = merge_request.source_project
 
-      # Fake `write_ref` if we don't have repository
+      # Fake `fetch_ref!` if we don't have repository
       # We have too many existing tests replying on this behaviour
       unless [target_project, source_project].all?(&:repository_exists?)
-        allow(merge_request).to receive(:write_ref)
+        allow(merge_request).to receive(:fetch_ref!)
       end
     end
 
diff --git a/spec/factories/project_custom_attributes.rb b/spec/factories/project_custom_attributes.rb
new file mode 100644
index 00000000000..5eedeb86304
--- /dev/null
+++ b/spec/factories/project_custom_attributes.rb
@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :project_custom_attribute do
+    project
+    sequence(:key) { |n| "key#{n}" }
+    sequence(:value) { |n| "value#{n}" }
+  end
+end
diff --git a/spec/features/commits_spec.rb b/spec/features/commits_spec.rb
index 479fb713297..b163ca8dc75 100644
--- a/spec/features/commits_spec.rb
+++ b/spec/features/commits_spec.rb
@@ -1,8 +1,6 @@
 require 'spec_helper'
 
 describe 'Commits' do
-  include CiStatusHelper
-
   let(:project) { create(:project, :repository) }
   let(:user) { create(:user) }
 
@@ -33,7 +31,7 @@ describe 'Commits' do
 
       describe 'Commit builds' do
         before do
-          visit ci_status_path(pipeline)
+          visit pipeline_path(pipeline)
         end
 
         it { expect(page).to have_content pipeline.sha[0..7] }
@@ -79,7 +77,7 @@ describe 'Commits' do
 
         describe 'Commit builds', :js do
           before do
-            visit ci_status_path(pipeline)
+            visit pipeline_path(pipeline)
           end
 
           it 'shows pipeline`s data' do
@@ -95,7 +93,7 @@ describe 'Commits' do
           end
 
           it do
-            visit ci_status_path(pipeline)
+            visit pipeline_path(pipeline)
             click_on 'Download artifacts'
             expect(page.response_headers['Content-Type']).to eq(artifacts_file.content_type)
           end
@@ -103,7 +101,7 @@ describe 'Commits' do
 
         describe 'Cancel all builds' do
           it 'cancels commit', :js do
-            visit ci_status_path(pipeline)
+            visit pipeline_path(pipeline)
             click_on 'Cancel running'
             expect(page).to have_content 'canceled'
           end
@@ -111,7 +109,7 @@ describe 'Commits' do
 
         describe 'Cancel build' do
           it 'cancels build', :js do
-            visit ci_status_path(pipeline)
+            visit pipeline_path(pipeline)
             find('.js-btn-cancel-pipeline').click
             expect(page).to have_content 'canceled'
           end
@@ -120,13 +118,13 @@ describe 'Commits' do
         describe '.gitlab-ci.yml not found warning' do
           context 'ci builds enabled' do
             it "does not show warning" do
-              visit ci_status_path(pipeline)
+              visit pipeline_path(pipeline)
               expect(page).not_to have_content '.gitlab-ci.yml not found in this commit'
             end
 
             it 'shows warning' do
               stub_ci_pipeline_yaml_file(nil)
-              visit ci_status_path(pipeline)
+              visit pipeline_path(pipeline)
               expect(page).to have_content '.gitlab-ci.yml not found in this commit'
             end
           end
@@ -135,7 +133,7 @@ describe 'Commits' do
             before do
               stub_ci_builds_disabled
               stub_ci_pipeline_yaml_file(nil)
-              visit ci_status_path(pipeline)
+              visit pipeline_path(pipeline)
             end
 
             it 'does not show warning' do
@@ -149,7 +147,7 @@ describe 'Commits' do
         before do
           project.team << [user, :reporter]
           build.update_attributes(artifacts_file: artifacts_file)
-          visit ci_status_path(pipeline)
+          visit pipeline_path(pipeline)
         end
 
         it 'Renders header', :js do
@@ -171,7 +169,7 @@ describe 'Commits' do
             visibility_level: Gitlab::VisibilityLevel::INTERNAL,
             public_builds: false)
           build.update_attributes(artifacts_file: artifacts_file)
-          visit ci_status_path(pipeline)
+          visit pipeline_path(pipeline)
         end
 
         it do
diff --git a/spec/features/copy_as_gfm_spec.rb b/spec/features/copy_as_gfm_spec.rb
index c6ba1211b9e..1fcb8d5bc67 100644
--- a/spec/features/copy_as_gfm_spec.rb
+++ b/spec/features/copy_as_gfm_spec.rb
@@ -664,7 +664,7 @@ describe 'Copy as GFM', :js do
   def html_to_gfm(html, transformer = 'transformGFMSelection', target: nil)
     js = <<-JS.strip_heredoc
       (function(html) {
-        var transformer = window.gl.CopyAsGFM[#{transformer.inspect}];
+        var transformer = window.CopyAsGFM[#{transformer.inspect}];
 
         var node = document.createElement('div');
         $(html).each(function() { node.appendChild(this) });
@@ -678,7 +678,7 @@ describe 'Copy as GFM', :js do
         node = transformer(node, target);
         if (!node) return null;
 
-        return window.gl.CopyAsGFM.nodeToGFM(node);
+        return window.CopyAsGFM.nodeToGFM(node);
       })("#{escape_javascript(html)}")
     JS
     page.evaluate_script(js)
diff --git a/spec/features/groups/members/manage_members.rb b/spec/features/groups/members/manage_members.rb
index 9039b283393..da1e17225db 100644
--- a/spec/features/groups/members/manage_members.rb
+++ b/spec/features/groups/members/manage_members.rb
@@ -44,7 +44,11 @@ feature 'Groups > Members > Manage members' do
 
     visit group_group_members_path(group)
 
-    find(:css, '.project-members-page li', text: user2.name).find(:css, 'a.btn-remove').click
+    accept_confirm do
+      find(:css, '.project-members-page li', text: user2.name).find(:css, 'a.btn-remove').click
+    end
+
+    wait_for_requests
 
     expect(page).not_to have_content(user2.name)
     expect(group.users).not_to include(user2)
diff --git a/spec/features/issues/create_branch_merge_request_spec.rb b/spec/features/issues/create_branch_merge_request_spec.rb
index 546dc7e8a49..edea95c6699 100644
--- a/spec/features/issues/create_branch_merge_request_spec.rb
+++ b/spec/features/issues/create_branch_merge_request_spec.rb
@@ -64,6 +64,19 @@ feature 'Create Branch/Merge Request Dropdown on issue page', :feature, :js do
       end
     end
 
+    context 'when merge requests are disabled' do
+      before do
+        project.project_feature.update(merge_requests_access_level: 0)
+
+        visit project_issue_path(project, issue)
+      end
+
+      it 'shows only create branch button' do
+        expect(page).not_to have_button('Create a merge request')
+        expect(page).to have_button('Create a branch')
+      end
+    end
+
     context 'when issue is confidential' do
       it 'disables the create branch button' do
         issue = create(:issue, :confidential, project: project)
diff --git a/spec/features/issues/gfm_autocomplete_spec.rb b/spec/features/issues/gfm_autocomplete_spec.rb
index b8a66245153..95d637265e0 100644
--- a/spec/features/issues/gfm_autocomplete_spec.rb
+++ b/spec/features/issues/gfm_autocomplete_spec.rb
@@ -218,18 +218,18 @@ feature 'GFM autocomplete', :js do
       user_item = find('.atwho-view li', text: user.username)
       expect(user_item).to have_content(user.username)
     end
+  end
 
-    def expect_to_wrap(should_wrap, item, note, value)
-      expect(item).to have_content(value)
-      expect(item).not_to have_content("\"#{value}\"")
+  def expect_to_wrap(should_wrap, item, note, value)
+    expect(item).to have_content(value)
+    expect(item).not_to have_content("\"#{value}\"")
 
-      item.click
+    item.click
 
-      if should_wrap
-        expect(note.value).to include("\"#{value}\"")
-      else
-        expect(note.value).not_to include("\"#{value}\"")
-      end
+    if should_wrap
+      expect(note.value).to include("\"#{value}\"")
+    else
+      expect(note.value).not_to include("\"#{value}\"")
     end
   end
 end
diff --git a/spec/features/issues/issue_detail_spec.rb b/spec/features/issues/issue_detail_spec.rb
index 6fbee0ebcb5..4224a8fe5d4 100644
--- a/spec/features/issues/issue_detail_spec.rb
+++ b/spec/features/issues/issue_detail_spec.rb
@@ -1,9 +1,9 @@
 require 'rails_helper'
 
 feature 'Issue Detail', :js do
-  let(:user)      { create(:user) }
-  let(:project)   { create(:project, :public) }
-  let(:issue)     { create(:issue, project: project, author: user) }
+  let(:user)     { create(:user) }
+  let(:project)  { create(:project, :public) }
+  let(:issue)    { create(:issue, project: project, author: user) }
 
   context 'when user displays the issue' do
     before do
@@ -27,6 +27,7 @@ feature 'Issue Detail', :js do
       click_link 'Edit'
       fill_in 'issuable-title', with: 'issue title'
       click_button 'Save'
+      wait_for_requests
 
       Users::DestroyService.new(user).execute(user)
 
diff --git a/spec/features/merge_requests/create_new_mr_spec.rb b/spec/features/merge_requests/create_new_mr_spec.rb
index 5402d61da54..db5ce2d11a8 100644
--- a/spec/features/merge_requests/create_new_mr_spec.rb
+++ b/spec/features/merge_requests/create_new_mr_spec.rb
@@ -67,6 +67,28 @@ feature 'Create New Merge Request', :js do
     expect(page).to have_content 'git checkout -b orphaned-branch origin/orphaned-branch'
   end
 
+  it 'allows filtering multiple dropdowns' do
+    visit project_new_merge_request_path(project)
+
+    first('.js-source-branch').click
+
+    input = find('.dropdown-source-branch .dropdown-input-field')
+    input.click
+    input.send_keys('orphaned-branch')
+
+    find('.dropdown-source-branch .dropdown-content li', match: :first)
+    source_items = all('.dropdown-source-branch .dropdown-content li')
+
+    expect(source_items.count).to eq(1)
+
+    first('.js-target-branch').click
+
+    find('.dropdown-target-branch .dropdown-content li', match: :first)
+    target_items = all('.dropdown-target-branch .dropdown-content li')
+
+    expect(target_items.count).to be > 1
+  end
+
   context 'when target project cannot be viewed by the current user' do
     it 'does not leak the private project name & namespace' do
       private_project = create(:project, :private, :repository)
diff --git a/spec/features/merge_requests/filter_by_labels_spec.rb b/spec/features/merge_requests/filter_by_labels_spec.rb
index 9912e8165e6..7adae08e499 100644
--- a/spec/features/merge_requests/filter_by_labels_spec.rb
+++ b/spec/features/merge_requests/filter_by_labels_spec.rb
@@ -79,22 +79,6 @@ feature 'Merge Request filtering by Labels', :js do
     end
   end
 
-  context 'clear button' do
-    before do
-      input_filtered_search('label:~bug')
-    end
-
-    it 'allows user to remove filtered labels' do
-      first('.clear-search').click
-      filtered_search.send_keys(:enter)
-
-      expect(page).to have_issuable_counts(open: 3, closed: 0, all: 3)
-      expect(page).to have_content "Bugfix2"
-      expect(page).to have_content "Feature1"
-      expect(page).to have_content "Bugfix1"
-    end
-  end
-
   context 'filter dropdown' do
     it 'filters by label name' do
       init_label_search
diff --git a/spec/features/milestone_spec.rb b/spec/features/milestone_spec.rb
index 6c9dc67ad74..27efc32c95b 100644
--- a/spec/features/milestone_spec.rb
+++ b/spec/features/milestone_spec.rb
@@ -65,4 +65,33 @@ feature 'Milestone' do
       expect(find('.alert-danger')).to have_content('already being used for another group or project milestone.')
     end
   end
+
+  feature 'Open a milestone' do
+    scenario 'shows total issue time spent correctly when no time has been logged' do
+      milestone = create(:milestone, project: project, title: 8.7)
+
+      visit project_milestone_path(project, milestone)
+
+      page.within('.block.time_spent') do
+        expect(page).to have_content 'No time spent'
+        expect(page).to have_content 'None'
+      end
+    end
+
+    scenario 'shows total issue time spent' do
+      milestone = create(:milestone, project: project, title: 8.7)
+      issue1 = create(:issue, project: project, milestone: milestone)
+      issue2 = create(:issue, project: project, milestone: milestone)
+      issue1.spend_time(duration: 3600, user: user)
+      issue1.save!
+      issue2.spend_time(duration: 7200, user: user)
+      issue2.save!
+
+      visit project_milestone_path(project, milestone)
+
+      page.within('.block.time_spent') do
+        expect(page).to have_content '3h'
+      end
+    end
+  end
 end
diff --git a/spec/features/projects/clusters_spec.rb b/spec/features/projects/clusters_spec.rb
index 810f2c39b43..197e6df4997 100644
--- a/spec/features/projects/clusters_spec.rb
+++ b/spec/features/projects/clusters_spec.rb
@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 feature 'Clusters', :js do
+  include GoogleApi::CloudPlatformHelpers
+
   let!(:project) { create(:project, :repository) }
   let!(:user) { create(:user) }
 
@@ -11,13 +13,17 @@ feature 'Clusters', :js do
 
   context 'when user has signed in Google' do
     before do
-      allow_any_instance_of(GoogleApi::CloudPlatform::Client)
-        .to receive(:validate_token).and_return(true)
+      allow_any_instance_of(Projects::ClustersController)
+        .to receive(:token_in_session).and_return('token')
+      allow_any_instance_of(Projects::ClustersController)
+        .to receive(:expires_at_in_session).and_return(1.hour.since.to_i.to_s)
     end
 
     context 'when user does not have a cluster and visits cluster index page' do
       before do
         visit project_clusters_path(project)
+
+        click_link 'Create on GKE'
       end
 
       it 'user sees a new page' do
@@ -36,18 +42,32 @@ feature 'Clusters', :js do
 
           allow(WaitForClusterCreationWorker).to receive(:perform_in).and_return(nil)
 
-          fill_in 'cluster_gcp_project_id', with: 'gcp-project-123'
-          fill_in 'cluster_gcp_cluster_name', with: 'dev-cluster'
+          fill_in 'cluster_provider_gcp_attributes_gcp_project_id', with: 'gcp-project-123'
+          fill_in 'cluster_name', with: 'dev-cluster'
           click_button 'Create cluster'
         end
 
         it 'user sees a cluster details page and creation status' do
           expect(page).to have_content('Cluster is being created on Google Container Engine...')
 
-          Gcp::Cluster.last.make_created!
+          # Application Installation buttons
+          page.within('.js-cluster-application-row-helm') do
+            expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
+            expect(page.find(:css, '.js-cluster-application-install-button').text).to eq('Install')
+          end
+
+          Clusters::Cluster.last.provider.make_created!
 
           expect(page).to have_content('Cluster was successfully created on Google Container Engine')
         end
+
+        it 'user sees a error if something worng during creation' do
+          expect(page).to have_content('Cluster is being created on Google Container Engine...')
+
+          Clusters::Cluster.last.provider.make_errored!('Something wrong!')
+
+          expect(page).to have_content('Something wrong!')
+        end
       end
 
       context 'when user filled form with invalid parameters' do
@@ -62,7 +82,8 @@ feature 'Clusters', :js do
     end
 
     context 'when user has a cluster and visits cluster index page' do
-      let!(:cluster) { create(:gcp_cluster, :created_on_gke, :with_kubernetes_service, project: project) }
+      let!(:cluster) { create(:cluster, :project, :provided_by_gcp) }
+      let(:project) { cluster.project }
 
       before do
         visit project_clusters_path(project)
@@ -70,7 +91,79 @@ feature 'Clusters', :js do
 
       it 'user sees an cluster details page' do
         expect(page).to have_button('Save')
-        expect(page.find(:css, '.cluster-name').value).to eq(cluster.gcp_cluster_name)
+        expect(page.find(:css, '.cluster-name').value).to eq(cluster.name)
+
+        # Application Installation buttons
+        page.within('.js-cluster-application-row-helm') do
+          expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to be_nil
+          expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Install')
+        end
+      end
+
+      context 'when user installs application: Helm Tiller' do
+        before do
+          allow(ClusterInstallAppWorker).to receive(:perform_async).and_return(nil)
+
+          page.within('.js-cluster-application-row-helm') do
+            page.find(:css, '.js-cluster-application-install-button').click
+          end
+        end
+
+        it 'user sees status transition' do
+          page.within('.js-cluster-application-row-helm') do
+            # FE sends request and gets the response, then the buttons is "Install"
+            expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
+            expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Install')
+
+            Clusters::Cluster.last.application_helm.make_installing!
+
+            # FE starts polling and update the buttons to "Installing"
+            expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
+            expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Installing')
+
+            Clusters::Cluster.last.application_helm.make_installed!
+
+            expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
+            expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Installed')
+          end
+
+          expect(page).to have_content('Helm Tiller was successfully installed on your cluster')
+        end
+      end
+
+      context 'when user installs application: Ingress' do
+        before do
+          allow(ClusterInstallAppWorker).to receive(:perform_async).and_return(nil)
+          # Helm Tiller needs to be installed before you can install Ingress
+          create(:cluster_applications_helm, :installed, cluster: cluster)
+
+          visit project_clusters_path(project)
+
+          page.within('.js-cluster-application-row-ingress') do
+            page.find(:css, '.js-cluster-application-install-button').click
+          end
+        end
+
+        it 'user sees status transition' do
+          page.within('.js-cluster-application-row-ingress') do
+            # FE sends request and gets the response, then the buttons is "Install"
+            expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
+            expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Install')
+
+            Clusters::Cluster.last.application_ingress.make_installing!
+
+            # FE starts polling and update the buttons to "Installing"
+            expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
+            expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Installing')
+
+            Clusters::Cluster.last.application_ingress.make_installed!
+
+            expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
+            expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Installed')
+          end
+
+          expect(page).to have_content('Ingress was successfully installed on your cluster')
+        end
       end
 
       context 'when user disables the cluster' do
@@ -93,7 +186,7 @@ feature 'Clusters', :js do
 
         it 'user sees creation form with the succeccful message' do
           expect(page).to have_content('Cluster integration was successfully removed.')
-          expect(page).to have_button('Create cluster')
+          expect(page).to have_link('Create on GKE')
         end
       end
     end
@@ -102,6 +195,8 @@ feature 'Clusters', :js do
   context 'when user has not signed in Google' do
     before do
       visit project_clusters_path(project)
+
+      click_link 'Create on GKE'
     end
 
     it 'user sees a login page' do
diff --git a/spec/features/projects/commit/mini_pipeline_graph_spec.rb b/spec/features/projects/commit/mini_pipeline_graph_spec.rb
index 807a2189cc4..91282063a8d 100644
--- a/spec/features/projects/commit/mini_pipeline_graph_spec.rb
+++ b/spec/features/projects/commit/mini_pipeline_graph_spec.rb
@@ -12,6 +12,13 @@ feature 'Mini Pipeline Graph in Commit View', :js do
     end
     let(:build) { create(:ci_build, pipeline: pipeline) }
 
+    it 'display icon with status' do
+      build.run
+      visit project_commit_path(project, project.commit.id)
+
+      expect(page).to have_selector('.ci-status-icon-running')
+    end
+
     it 'displays a mini pipeline graph' do
       build.run
       visit project_commit_path(project, project.commit.id)
diff --git a/spec/features/projects/import_export/test_project_export.tar.gz b/spec/features/projects/import_export/test_project_export.tar.gz
index 9614c72cdc3..fb6a3b8e733 100644
--- a/spec/features/projects/import_export/test_project_export.tar.gz
+++ b/spec/features/projects/import_export/test_project_export.tar.gz
diff --git a/spec/features/projects/members/list_spec.rb b/spec/features/projects/members/list_spec.rb
index 237c059e595..65b11a1d9e7 100644
--- a/spec/features/projects/members/list_spec.rb
+++ b/spec/features/projects/members/list_spec.rb
@@ -55,6 +55,22 @@ feature 'Project members list' do
     end
   end
 
+  scenario 'remove user from project', :js do
+    other_user = create(:user)
+    project.add_developer(other_user)
+
+    visit_members_page
+
+    accept_confirm do
+      find(:css, 'li.project_member', text: other_user.name).find(:css, 'a.btn-remove').click
+    end
+
+    wait_for_requests
+
+    expect(page).not_to have_content(other_user.name)
+    expect(project.users).not_to include(other_user)
+  end
+
   scenario 'invite user to project', :js do
     visit_members_page
 
diff --git a/spec/features/projects/pipelines/pipelines_spec.rb b/spec/features/projects/pipelines/pipelines_spec.rb
index fc689bbb486..50f8f13d261 100644
--- a/spec/features/projects/pipelines/pipelines_spec.rb
+++ b/spec/features/projects/pipelines/pipelines_spec.rb
@@ -56,31 +56,37 @@ describe 'Pipelines', :js do
         end
 
         it 'shows a tab for All pipelines and count' do
-          expect(page.find('.js-pipelines-tab-all a').text).to include('All')
+          expect(page.find('.js-pipelines-tab-all').text).to include('All')
           expect(page.find('.js-pipelines-tab-all .badge').text).to include('1')
         end
 
         it 'shows a tab for Pending pipelines and count' do
-          expect(page.find('.js-pipelines-tab-pending a').text).to include('Pending')
+          expect(page.find('.js-pipelines-tab-pending').text).to include('Pending')
           expect(page.find('.js-pipelines-tab-pending .badge').text).to include('0')
         end
 
         it 'shows a tab for Running pipelines and count' do
-          expect(page.find('.js-pipelines-tab-running a').text).to include('Running')
+          expect(page.find('.js-pipelines-tab-running').text).to include('Running')
           expect(page.find('.js-pipelines-tab-running .badge').text).to include('1')
         end
 
         it 'shows a tab for Finished pipelines and count' do
-          expect(page.find('.js-pipelines-tab-finished a').text).to include('Finished')
+          expect(page.find('.js-pipelines-tab-finished').text).to include('Finished')
           expect(page.find('.js-pipelines-tab-finished .badge').text).to include('0')
         end
 
         it 'shows a tab for Branches' do
-          expect(page.find('.js-pipelines-tab-branches a').text).to include('Branches')
+          expect(page.find('.js-pipelines-tab-branches').text).to include('Branches')
         end
 
         it 'shows a tab for Tags' do
-          expect(page.find('.js-pipelines-tab-tags a').text).to include('Tags')
+          expect(page.find('.js-pipelines-tab-tags').text).to include('Tags')
+        end
+
+        it 'updates content when tab is clicked' do
+          page.find('.js-pipelines-tab-pending').click
+          wait_for_requests
+          expect(page).to have_content('No pipelines to show.')
         end
       end
 
@@ -396,6 +402,14 @@ describe 'Pipelines', :js do
 
           expect(page).to have_selector('.gl-pagination .page', count: 2)
         end
+
+        it 'should show updated content' do
+          visit project_pipelines_path(project)
+          wait_for_requests
+          page.find('.js-next-button a').click
+
+          expect(page).to have_selector('.gl-pagination .page', count: 2)
+        end
       end
     end
 
diff --git a/spec/features/projects/project_settings_spec.rb b/spec/features/projects/project_settings_spec.rb
index 15a5cd9990b..a3ea778d401 100644
--- a/spec/features/projects/project_settings_spec.rb
+++ b/spec/features/projects/project_settings_spec.rb
@@ -144,7 +144,10 @@ describe 'Edit Project Settings' do
     specify 'the project is accessible via the new path' do
       transfer_project(project, group)
       new_path = namespace_project_path(group, project)
+
       visit new_path
+      wait_for_requests
+
       expect(current_path).to eq(new_path)
       expect(find('.breadcrumbs')).to have_content(project.name)
     end
@@ -153,7 +156,10 @@ describe 'Edit Project Settings' do
       old_path = project_path(project)
       transfer_project(project, group)
       new_path = namespace_project_path(group, project)
+
       visit old_path
+      wait_for_requests
+
       expect(current_path).to eq(new_path)
       expect(find('.breadcrumbs')).to have_content(project.name)
     end
diff --git a/spec/features/projects/tree/create_directory_spec.rb b/spec/features/projects/tree/create_directory_spec.rb
index 8ee7b9cf015..1686e7fa342 100644
--- a/spec/features/projects/tree/create_directory_spec.rb
+++ b/spec/features/projects/tree/create_directory_spec.rb
@@ -31,10 +31,5 @@ feature 'Multi-file editor new directory', :js do
     click_button('Commit 1 file')
 
     expect(page).to have_selector('td', text: 'commit message')
-
-    click_link('foldername')
-
-    expect(page).to have_selector('td', text: 'commit message', count: 2)
-    expect(page).to have_selector('td', text: '.gitkeep')
   end
 end
diff --git a/spec/features/projects/user_creates_project_spec.rb b/spec/features/projects/user_creates_project_spec.rb
index 4a152572502..f95469ad070 100644
--- a/spec/features/projects/user_creates_project_spec.rb
+++ b/spec/features/projects/user_creates_project_spec.rb
@@ -6,10 +6,11 @@ feature 'User creates a project', :js do
   before do
     sign_in(user)
     create(:personal_key, user: user)
-    visit(new_project_path)
   end
 
   it 'creates a new project' do
+    visit(new_project_path)
+
     fill_in(:project_path, with: 'Empty')
 
     page.within('#content-body') do
@@ -24,4 +25,32 @@ feature 'User creates a project', :js do
     expect(page).to have_content('git remote')
     expect(page).to have_content(project.url_to_repo)
   end
+
+  context 'in a subgroup they do not own', :nested_groups do
+    let(:parent) { create(:group) }
+    let!(:subgroup) { create(:group, parent: parent) }
+
+    before do
+      parent.add_owner(user)
+    end
+
+    it 'creates a new project' do
+      visit(new_project_path)
+
+      fill_in :project_path, with: 'a-subgroup-project'
+
+      page.find('.js-select-namespace').click
+      page.find("div[role='option']", text: subgroup.full_path).click
+
+      page.within('#content-body') do
+        click_button('Create project')
+      end
+
+      expect(page).to have_content("Project 'a-subgroup-project' was successfully created")
+
+      project = Project.last
+
+      expect(project.namespace).to eq(subgroup)
+    end
+  end
 end
diff --git a/spec/features/projects/user_transfers_a_project_spec.rb b/spec/features/projects/user_transfers_a_project_spec.rb
new file mode 100644
index 00000000000..78f72b644ff
--- /dev/null
+++ b/spec/features/projects/user_transfers_a_project_spec.rb
@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+feature 'User transfers a project', :js do
+  let(:user) { create(:user) }
+  let(:project) { create(:project, :repository, namespace: user.namespace) }
+
+  before do
+    sign_in user
+  end
+
+  def transfer_project(project, group)
+    visit edit_project_path(project)
+
+    page.within('.js-project-transfer-form') do
+      page.find('.select2-container').click
+    end
+
+    page.find("div[role='option']", text: group.full_name).click
+
+    click_button('Transfer project')
+
+    fill_in 'confirm_name_input', with: project.name
+
+    click_button 'Confirm'
+
+    wait_for_requests
+  end
+
+  it 'allows transferring a project to a subgroup of a namespace' do
+    group = create(:group)
+    group.add_owner(user)
+
+    transfer_project(project, group)
+
+    expect(project.reload.namespace).to eq(group)
+  end
+
+  context 'when nested groups are available', :nested_groups do
+    it 'allows transferring a project to a subgroup' do
+      parent = create(:group)
+      parent.add_owner(user)
+      subgroup = create(:group, parent: parent)
+
+      transfer_project(project, subgroup)
+
+      expect(project.reload.namespace).to eq(subgroup)
+    end
+  end
+end
diff --git a/spec/finders/autocomplete_users_finder_spec.rb b/spec/finders/autocomplete_users_finder_spec.rb
index 684af74d750..dcf9111776e 100644
--- a/spec/finders/autocomplete_users_finder_spec.rb
+++ b/spec/finders/autocomplete_users_finder_spec.rb
@@ -42,6 +42,21 @@ describe AutocompleteUsersFinder do
       it { is_expected.to match_array([user1]) }
     end
 
+    context 'when passed a subgroup', :nested_groups do
+      let(:grandparent) { create(:group, :public) }
+      let(:parent) { create(:group, :public, parent: grandparent) }
+      let(:child) { create(:group, :public, parent: parent) }
+      let(:group) { parent }
+
+      let!(:grandparent_user) { create(:group_member, :developer, group: grandparent).user }
+      let!(:parent_user) { create(:group_member, :developer, group: parent).user }
+      let!(:child_user) { create(:group_member, :developer, group: child).user }
+
+      it 'includes users from parent groups as well' do
+        expect(subject).to match_array([grandparent_user, parent_user])
+      end
+    end
+
     it { is_expected.to match_array([user1, external_user, omniauth_user, current_user]) }
 
     context 'when filtered by search' do
diff --git a/spec/fixtures/api/schemas/cluster_status.json b/spec/fixtures/api/schemas/cluster_status.json
index 1f255a17881..489d563be2b 100644
--- a/spec/fixtures/api/schemas/cluster_status.json
+++ b/spec/fixtures/api/schemas/cluster_status.json
@@ -1,11 +1,38 @@
 {
   "type": "object",
   "required" : [
-    "status"
+    "status",
+    "applications"
   ],
   "properties" : {
     "status": { "type": "string" },
-    "status_reason": { "type": ["string", "null"] }
+    "status_reason": { "type": ["string", "null"] },
+    "applications": {
+      "type": "array",
+      "items": { "$ref": "#/definitions/application_status" }
+    }
   },
-  "additionalProperties": false
+  "additionalProperties": false,
+  "definitions": {
+    "application_status": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties" : {
+        "name": { "type": "string" },
+        "status": {
+          "type": {
+            "enum": [
+              "installable",
+              "scheduled",
+              "installing",
+              "installed",
+              "errored"
+            ]
+          }
+        },
+        "status_reason": { "type": ["string", "null"] }
+      },
+      "required" : [ "name", "status" ]
+    }
+  }
 }
diff --git a/spec/fixtures/api/schemas/public_api/v4/merge_requests.json b/spec/fixtures/api/schemas/public_api/v4/merge_requests.json
index 5828be5255b..034509091a5 100644
--- a/spec/fixtures/api/schemas/public_api/v4/merge_requests.json
+++ b/spec/fixtures/api/schemas/public_api/v4/merge_requests.json
@@ -70,6 +70,7 @@
       "sha": { "type": "string" },
       "merge_commit_sha": { "type": ["string", "null"] },
       "user_notes_count": { "type": "integer" },
+      "changes_count": { "type": "string" },
       "should_remove_source_branch": { "type": ["boolean", "null"] },
       "force_remove_source_branch": { "type": ["boolean", "null"] },
       "discussion_locked": { "type": ["boolean", "null"] },
diff --git a/spec/fixtures/api/schemas/public_api/v4/pages_domain/basic.json b/spec/fixtures/api/schemas/public_api/v4/pages_domain/basic.json
new file mode 100644
index 00000000000..4ba6422406c
--- /dev/null
+++ b/spec/fixtures/api/schemas/public_api/v4/pages_domain/basic.json
@@ -0,0 +1,18 @@
+{
+  "type": "object",
+  "properties": {
+    "domain": { "type": "string" },
+    "url": { "type": "uri" },
+    "certificate_expiration": {
+      "type": "object",
+      "properties": {
+        "expired": { "type": "boolean" },
+        "expiration": { "type": "string" }
+      },
+      "required": ["expired", "expiration"],
+      "additionalProperties": false
+    }
+  },
+  "required": ["domain", "url"],
+  "additionalProperties": false
+}
diff --git a/spec/fixtures/api/schemas/public_api/v4/pages_domain/detail.json b/spec/fixtures/api/schemas/public_api/v4/pages_domain/detail.json
new file mode 100644
index 00000000000..08db8d47050
--- /dev/null
+++ b/spec/fixtures/api/schemas/public_api/v4/pages_domain/detail.json
@@ -0,0 +1,20 @@
+{
+  "type": "object",
+  "properties": {
+    "domain": { "type": "string" },
+    "url": { "type": "uri" },
+    "certificate": {
+      "type": "object",
+      "properties": {
+        "subject": { "type": "string" },
+        "expired": { "type": "boolean" },
+        "certificate": { "type": "string" },
+        "certificate_text": { "type": "string" }
+      },
+      "required": ["subject", "expired"],
+      "additionalProperties": false
+    }
+  },
+  "required": ["domain", "url"],
+  "additionalProperties": false
+}
diff --git a/spec/fixtures/api/schemas/public_api/v4/pages_domain_basics.json b/spec/fixtures/api/schemas/public_api/v4/pages_domain_basics.json
new file mode 100644
index 00000000000..c7d86de7d8e
--- /dev/null
+++ b/spec/fixtures/api/schemas/public_api/v4/pages_domain_basics.json
@@ -0,0 +1,4 @@
+{
+  "type": "array",
+  "items": { "$ref": "pages_domain/basic.json" }
+}
diff --git a/spec/fixtures/api/schemas/public_api/v4/pages_domains.json b/spec/fixtures/api/schemas/public_api/v4/pages_domains.json
index 0de1d0f1228..7c27218dc5a 100644
--- a/spec/fixtures/api/schemas/public_api/v4/pages_domains.json
+++ b/spec/fixtures/api/schemas/public_api/v4/pages_domains.json
@@ -1,23 +1,4 @@
 {
   "type": "array",
-  "items": {
-    "type": "object",
-    "properties": {
-      "domain": { "type": "string" },
-      "url": { "type": "uri" },
-      "certificate": {
-        "type": "object",
-        "properties": {
-          "subject": { "type": "string" },
-          "expired": { "type": "boolean" },
-          "certificate": { "type": "string" },
-          "certificate_text": { "type": "string" }
-        },
-        "required": ["subject", "expired"],
-        "additionalProperties": false
-      }
-    },
-    "required": ["domain", "url"],
-    "additionalProperties": false
-  }
+  "items": { "$ref": "pages_domain/detail.json" }
 }
diff --git a/spec/fixtures/clusters/sample_cert.pem b/spec/fixtures/clusters/sample_cert.pem
new file mode 100644
index 00000000000..e39a2b34416
--- /dev/null
+++ b/spec/fixtures/clusters/sample_cert.pem
@@ -0,0 +1,33 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/spec/helpers/application_helper_spec.rb b/spec/helpers/application_helper_spec.rb
index 7a241b02d28..5c5d53877a6 100644
--- a/spec/helpers/application_helper_spec.rb
+++ b/spec/helpers/application_helper_spec.rb
@@ -4,8 +4,6 @@ require 'spec_helper'
 describe ApplicationHelper do
   include UploadHelpers
 
-  let(:gitlab_host) { "http://#{Gitlab.config.gitlab.host}" }
-
   describe 'current_controller?' do
     it 'returns true when controller matches argument' do
       stub_controller_name('foo')
@@ -57,30 +55,11 @@ describe ApplicationHelper do
   end
 
   describe 'project_icon' do
-    let(:asset_host) { 'http://assets' }
-
     it 'returns an url for the avatar' do
       project = create(:project, :public, avatar: File.open(uploaded_image_temp_path))
-      avatar_url = "/uploads/-/system/project/avatar/#{project.id}/banana_sample.gif"
-
-      expect(helper.project_icon(project.full_path).to_s)
-        .to eq "<img data-src=\"#{avatar_url}\" class=\" lazy\" src=\"#{LazyImageTagHelper.placeholder_image}\" />"
-
-      allow(ActionController::Base).to receive(:asset_host).and_return(asset_host)
-      avatar_url = "#{asset_host}/uploads/-/system/project/avatar/#{project.id}/banana_sample.gif"
-
-      expect(helper.project_icon(project.full_path).to_s)
-        .to eq "<img data-src=\"#{avatar_url}\" class=\" lazy\" src=\"#{LazyImageTagHelper.placeholder_image}\" />"
-    end
-
-    it 'gives uploaded icon when present' do
-      project = create(:project)
 
-      allow_any_instance_of(Project).to receive(:avatar_in_git).and_return(true)
-
-      avatar_url = "#{gitlab_host}#{project_avatar_path(project)}"
       expect(helper.project_icon(project.full_path).to_s)
-        .to eq "<img data-src=\"#{avatar_url}\" class=\" lazy\" src=\"#{LazyImageTagHelper.placeholder_image}\" />"
+        .to eq "<img data-src=\"#{project.avatar.url}\" class=\" lazy\" src=\"#{LazyImageTagHelper.placeholder_image}\" />"
     end
   end
 
@@ -91,40 +70,7 @@ describe ApplicationHelper do
       context 'when there is a matching user' do
         it 'returns a relative URL for the avatar' do
           expect(helper.avatar_icon(user.email).to_s)
-            .to eq("/uploads/-/system/user/avatar/#{user.id}/banana_sample.gif")
-        end
-
-        context 'when an asset_host is set in the config' do
-          let(:asset_host) { 'http://assets' }
-
-          before do
-            allow(ActionController::Base).to receive(:asset_host).and_return(asset_host)
-          end
-
-          it 'returns an absolute URL on that asset host' do
-            expect(helper.avatar_icon(user.email, only_path: false).to_s)
-              .to eq("#{asset_host}/uploads/-/system/user/avatar/#{user.id}/banana_sample.gif")
-          end
-        end
-
-        context 'when only_path is set to false' do
-          it 'returns an absolute URL for the avatar' do
-            expect(helper.avatar_icon(user.email, only_path: false).to_s)
-              .to eq("#{gitlab_host}/uploads/-/system/user/avatar/#{user.id}/banana_sample.gif")
-          end
-        end
-
-        context 'when the GitLab instance is at a relative URL' do
-          before do
-            stub_config_setting(relative_url_root: '/gitlab')
-            # Must be stubbed after the stub above, and separately
-            stub_config_setting(url: Settings.send(:build_gitlab_url))
-          end
-
-          it 'returns a relative URL with the correct prefix' do
-            expect(helper.avatar_icon(user.email).to_s)
-              .to eq("/gitlab/uploads/-/system/user/avatar/#{user.id}/banana_sample.gif")
-          end
+            .to eq(user.avatar.url)
         end
       end
 
@@ -138,18 +84,9 @@ describe ApplicationHelper do
     end
 
     describe 'using a user' do
-      context 'when only_path is true' do
-        it 'returns a relative URL for the avatar' do
-          expect(helper.avatar_icon(user, only_path: true).to_s)
-            .to eq("/uploads/-/system/user/avatar/#{user.id}/banana_sample.gif")
-        end
-      end
-
-      context 'when only_path is false' do
-        it 'returns an absolute URL for the avatar' do
-          expect(helper.avatar_icon(user, only_path: false).to_s)
-            .to eq("#{gitlab_host}/uploads/-/system/user/avatar/#{user.id}/banana_sample.gif")
-        end
+      it 'returns a relative URL for the avatar' do
+        expect(helper.avatar_icon(user).to_s)
+          .to eq(user.avatar.url)
       end
     end
   end
diff --git a/spec/helpers/events_helper_spec.rb b/spec/helpers/events_helper_spec.rb
index d5536fcb22b..8a80b88da5d 100644
--- a/spec/helpers/events_helper_spec.rb
+++ b/spec/helpers/events_helper_spec.rb
@@ -1,96 +1,6 @@
 require 'spec_helper'
 
 describe EventsHelper do
-  describe '#event_note' do
-    let(:user) { build(:user) }
-
-    before do
-      allow(helper).to receive(:current_user).and_return(user)
-    end
-
-    it 'displays one line of plain text without alteration' do
-      input = 'A short, plain note'
-      expect(helper.event_note(input)).to match(input)
-      expect(helper.event_note(input)).not_to match(/\.\.\.\z/)
-    end
-
-    it 'displays inline code' do
-      input = 'A note with `inline code`'
-      expected = 'A note with <code>inline code</code>'
-
-      expect(helper.event_note(input)).to match(expected)
-    end
-
-    it 'truncates a note with multiple paragraphs' do
-      input = "Paragraph 1\n\nParagraph 2"
-      expected = 'Paragraph 1...'
-
-      expect(helper.event_note(input)).to match(expected)
-    end
-
-    it 'displays the first line of a code block' do
-      input = "```\nCode block\nwith two lines\n```"
-      expected = %r{<pre.+><code><span class="line">Code block\.\.\.</span>\n</code></pre>}
-
-      expect(helper.event_note(input)).to match(expected)
-    end
-
-    it 'truncates a single long line of text' do
-      text = 'The quick brown fox jumped over the lazy dog twice' # 50 chars
-      input = text * 4
-      expected = (text * 2).sub(/.{3}/, '...')
-
-      expect(helper.event_note(input)).to match(expected)
-    end
-
-    it 'preserves a link href when link text is truncated' do
-      text = 'The quick brown fox jumped over the lazy dog' # 44 chars
-      input = "#{text}#{text}#{text} " # 133 chars
-      link_url = 'http://example.com/foo/bar/baz' # 30 chars
-      input << link_url
-      expected_link_text = 'http://example...</a>'
-
-      expect(helper.event_note(input)).to match(link_url)
-      expect(helper.event_note(input)).to match(expected_link_text)
-    end
-
-    it 'preserves code color scheme' do
-      input = "```ruby\ndef test\n  'hello world'\nend\n```"
-      expected = "\n<pre class=\"code highlight js-syntax-highlight ruby\">" \
-        "<code><span class=\"line\"><span class=\"k\">def</span> <span class=\"nf\">test</span>...</span>\n" \
-        "</code></pre>"
-      expect(helper.event_note(input)).to eq(expected)
-    end
-
-    it 'preserves data-src for lazy images' do
-      input = "![ImageTest](/uploads/test.png)"
-      image_url = "data-src=\"/uploads/test.png\""
-      expect(helper.event_note(input)).to match(image_url)
-    end
-
-    context 'labels formatting' do
-      let(:input) { 'this should be ~label_1' }
-
-      def format_event_note(project)
-        create(:label, title: 'label_1', project: project)
-
-        helper.event_note(input, { project: project })
-      end
-
-      it 'preserves style attribute for a label that can be accessed by current_user' do
-        project = create(:project, :public)
-
-        expect(format_event_note(project)).to match(/span class=.*style=.*/)
-      end
-
-      it 'does not style a label that can not be accessed by current_user' do
-        project = create(:project, :private)
-
-        expect(format_event_note(project)).to eq("<p>#{input}</p>")
-      end
-    end
-  end
-
   describe '#event_commit_title' do
     let(:message) { "foo & bar " + "A" * 70 + "\n" + "B" * 80 }
     subject { helper.event_commit_title(message) }
diff --git a/spec/helpers/groups_helper_spec.rb b/spec/helpers/groups_helper_spec.rb
index 97f0ed4904e..32432ee1e81 100644
--- a/spec/helpers/groups_helper_spec.rb
+++ b/spec/helpers/groups_helper_spec.rb
@@ -3,8 +3,6 @@ require 'spec_helper'
 describe GroupsHelper do
   include ApplicationHelper
 
-  let(:asset_host) { 'http://assets' }
-
   describe 'group_icon' do
     avatar_file_path = File.join(Rails.root, 'spec', 'fixtures', 'banana_sample.gif')
 
@@ -13,16 +11,8 @@ describe GroupsHelper do
       group.avatar = fixture_file_upload(avatar_file_path)
       group.save!
 
-      avatar_url = "/uploads/-/system/group/avatar/#{group.id}/banana_sample.gif"
-
-      expect(helper.group_icon(group).to_s)
-        .to eq "<img data-src=\"#{avatar_url}\" class=\" lazy\" src=\"#{LazyImageTagHelper.placeholder_image}\" />"
-
-      allow(ActionController::Base).to receive(:asset_host).and_return(asset_host)
-      avatar_url = "#{asset_host}/uploads/-/system/group/avatar/#{group.id}/banana_sample.gif"
-
       expect(helper.group_icon(group).to_s)
-        .to eq "<img data-src=\"#{avatar_url}\" class=\" lazy\" src=\"#{LazyImageTagHelper.placeholder_image}\" />"
+        .to eq "<img data-src=\"#{group.avatar.url}\" class=\" lazy\" src=\"#{LazyImageTagHelper.placeholder_image}\" />"
     end
   end
 
@@ -34,25 +24,7 @@ describe GroupsHelper do
       group.avatar = fixture_file_upload(avatar_file_path)
       group.save!
       expect(group_icon_url(group.path).to_s)
-        .to match("/uploads/-/system/group/avatar/#{group.id}/banana_sample.gif")
-    end
-
-    it 'returns an CDN url for the avatar' do
-      allow(ActionController::Base).to receive(:asset_host).and_return(asset_host)
-      group = create(:group)
-      group.avatar = fixture_file_upload(avatar_file_path)
-      group.save!
-      expect(group_icon_url(group.path).to_s)
-        .to match("#{asset_host}/uploads/-/system/group/avatar/#{group.id}/banana_sample.gif")
-    end
-
-    it 'returns an based url for the avatar if private' do
-      allow(ActionController::Base).to receive(:asset_host).and_return(asset_host)
-      group = create(:group, :private)
-      group.avatar = fixture_file_upload(avatar_file_path)
-      group.save!
-      expect(group_icon_url(group.path).to_s)
-        .to match("/uploads/-/system/group/avatar/#{group.id}/banana_sample.gif")
+        .to match(group.avatar.url)
     end
 
     it 'gives default avatar_icon when no avatar is present' do
diff --git a/spec/helpers/icons_helper_spec.rb b/spec/helpers/icons_helper_spec.rb
index 3d79dac284f..2f23ed55d99 100644
--- a/spec/helpers/icons_helper_spec.rb
+++ b/spec/helpers/icons_helper_spec.rb
@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe IconsHelper do
+  let(:icons_path) { ActionController::Base.helpers.image_path("icons.svg") }
+
   describe 'icon' do
     it 'returns aria-hidden by default' do
       star = icon('star')
@@ -16,22 +18,42 @@ describe IconsHelper do
     end
   end
 
+  describe 'sprite_icon_path' do
+    it 'returns relative path' do
+      expect(sprite_icon_path)
+        .to eq icons_path
+    end
+
+    context 'when an asset_host is set in the config it will return an absolute local URL' do
+      let(:asset_host) { 'http://assets' }
+
+      before do
+        allow(ActionController::Base).to receive(:asset_host).and_return(asset_host)
+      end
+
+      it 'returns an absolute URL on that asset host' do
+        expect(sprite_icon_path)
+          .to eq ActionController::Base.helpers.image_path("icons.svg", host: Gitlab.config.gitlab.url)
+      end
+    end
+  end
+
   describe 'sprite_icon' do
     icon_name = 'clock'
 
     it 'returns svg icon html' do
       expect(sprite_icon(icon_name).to_s)
-        .to eq "<svg><use xlink:href=\"/images/icons.svg##{icon_name}\"></use></svg>"
+        .to eq "<svg><use xlink:href=\"#{icons_path}##{icon_name}\"></use></svg>"
     end
 
     it 'returns svg icon html + size classes' do
       expect(sprite_icon(icon_name, size: 72).to_s)
-        .to eq "<svg class=\"s72\"><use xlink:href=\"/images/icons.svg##{icon_name}\"></use></svg>"
+        .to eq "<svg class=\"s72\"><use xlink:href=\"#{icons_path}##{icon_name}\"></use></svg>"
     end
 
     it 'returns svg icon html + size classes + additional class' do
       expect(sprite_icon(icon_name, size: 72, css_class: 'icon-danger').to_s)
-        .to eq "<svg class=\"s72 icon-danger\"><use xlink:href=\"/images/icons.svg##{icon_name}\"></use></svg>"
+        .to eq "<svg class=\"s72 icon-danger\"><use xlink:href=\"#{icons_path}##{icon_name}\"></use></svg>"
     end
   end
 
diff --git a/spec/helpers/labels_helper_spec.rb b/spec/helpers/labels_helper_spec.rb
index 36d6e495ed0..4ac4302adfd 100644
--- a/spec/helpers/labels_helper_spec.rb
+++ b/spec/helpers/labels_helper_spec.rb
@@ -24,7 +24,7 @@ describe LabelsHelper do
       let(:group) { build(:group, name: 'bar') }
 
       it 'links to group issues page' do
-        expect(link_to_label(label, subject: group)).to match %r{<a href="/groups/bar/issues\?label_name%5B%5D=#{label.name}">.*</a>}
+        expect(link_to_label(label, subject: group)).to match %r{<a href="/groups/bar/-/issues\?label_name%5B%5D=#{label.name}">.*</a>}
       end
     end
 
diff --git a/spec/helpers/markup_helper_spec.rb b/spec/helpers/markup_helper_spec.rb
index 03d706062b7..62ea6d48542 100644
--- a/spec/helpers/markup_helper_spec.rb
+++ b/spec/helpers/markup_helper_spec.rb
@@ -67,7 +67,7 @@ describe MarkupHelper do
 
     describe 'without redacted attribute' do
       it 'renders the markdown value' do
-        expect(Banzai).to receive(:render_field).with(commit, attribute).and_call_original
+        expect(Banzai).to receive(:render_field).with(commit, attribute, {}).and_call_original
 
         helper.markdown_field(commit, attribute)
       end
@@ -252,38 +252,141 @@ describe MarkupHelper do
   end
 
   describe '#first_line_in_markdown' do
-    it 'truncates Markdown properly' do
-      text = "@#{user.username}, can you look at this?\nHello world\n"
-      actual = first_line_in_markdown(text, 100, project: project)
+    shared_examples_for 'common markdown examples' do
+      let(:project_base) { build(:project, :repository) }
 
-      doc = Nokogiri::HTML.parse(actual)
+      it 'displays inline code' do
+        object = create_object('Text with `inline code`')
+        expected = 'Text with <code>inline code</code>'
 
-      # Make sure we didn't create invalid markup
-      expect(doc.errors).to be_empty
+        expect(first_line_in_markdown(object, attribute, 100, project: project)).to match(expected)
+      end
 
-      # Leading user link
-      expect(doc.css('a').length).to eq(1)
-      expect(doc.css('a')[0].attr('href')).to eq user_path(user)
-      expect(doc.css('a')[0].text).to eq "@#{user.username}"
+      it 'truncates the text with multiple paragraphs' do
+        object = create_object("Paragraph 1\n\nParagraph 2")
+        expected = 'Paragraph 1...'
 
-      expect(doc.content).to eq "@#{user.username}, can you look at this?..."
-    end
+        expect(first_line_in_markdown(object, attribute, 100, project: project)).to match(expected)
+      end
 
-    it 'truncates Markdown with emoji properly' do
-      text = "foo :wink:\nbar :grinning:"
-      actual = first_line_in_markdown(text, 100, project: project)
+      it 'displays the first line of a code block' do
+        object = create_object("```\nCode block\nwith two lines\n```")
+        expected = %r{<pre.+><code><span class="line">Code block\.\.\.</span>\n</code></pre>}
 
-      doc = Nokogiri::HTML.parse(actual)
+        expect(first_line_in_markdown(object, attribute, 100, project: project)).to match(expected)
+      end
 
-      # Make sure we didn't create invalid markup
-      # But also account for the 2 errors caused by the unknown `gl-emoji` elements
-      expect(doc.errors.length).to eq(2)
+      it 'truncates a single long line of text' do
+        text = 'The quick brown fox jumped over the lazy dog twice' # 50 chars
+        object = create_object(text * 4)
+        expected = (text * 2).sub(/.{3}/, '...')
+
+        expect(first_line_in_markdown(object, attribute, 150, project: project)).to match(expected)
+      end
+
+      it 'preserves a link href when link text is truncated' do
+        text = 'The quick brown fox jumped over the lazy dog' # 44 chars
+        input = "#{text}#{text}#{text} " # 133 chars
+        link_url = 'http://example.com/foo/bar/baz' # 30 chars
+        input << link_url
+        object = create_object(input)
+        expected_link_text = 'http://example...</a>'
+
+        expect(first_line_in_markdown(object, attribute, 150, project: project)).to match(link_url)
+        expect(first_line_in_markdown(object, attribute, 150, project: project)).to match(expected_link_text)
+      end
+
+      it 'preserves code color scheme' do
+        object = create_object("```ruby\ndef test\n  'hello world'\nend\n```")
+        expected = "\n<pre class=\"code highlight js-syntax-highlight ruby\">" \
+          "<code><span class=\"line\"><span class=\"k\">def</span> <span class=\"nf\">test</span>...</span>\n" \
+          "</code></pre>"
+
+        expect(first_line_in_markdown(object, attribute, 150, project: project)).to eq(expected)
+      end
+
+      it 'preserves data-src for lazy images' do
+        object = create_object("![ImageTest](/uploads/test.png)")
+        image_url = "data-src=\".*/uploads/test.png\""
+
+        expect(first_line_in_markdown(object, attribute, 150, project: project)).to match(image_url)
+      end
+
+      context 'labels formatting' do
+        let(:label_title) { 'this should be ~label_1' }
+
+        def create_and_format_label(project)
+          create(:label, title: 'label_1', project: project)
+          object = create_object(label_title, project: project)
 
-      expect(doc.css('gl-emoji').length).to eq(2)
-      expect(doc.css('gl-emoji')[0].attr('data-name')).to eq 'wink'
-      expect(doc.css('gl-emoji')[1].attr('data-name')).to eq 'grinning'
+          first_line_in_markdown(object, attribute, 150, project: project)
+        end
 
-      expect(doc.content).to eq "foo 😉\nbar 😀"
+        it 'preserves style attribute for a label that can be accessed by current_user' do
+          project = create(:project, :public)
+
+          expect(create_and_format_label(project)).to match(/span class=.*style=.*/)
+        end
+
+        it 'does not style a label that can not be accessed by current_user' do
+          project = create(:project, :private)
+
+          expect(create_and_format_label(project)).to eq("<p>#{label_title}</p>")
+        end
+      end
+
+      it 'truncates Markdown properly' do
+        object = create_object("@#{user.username}, can you look at this?\nHello world\n")
+        actual = first_line_in_markdown(object, attribute, 100, project: project)
+
+        doc = Nokogiri::HTML.parse(actual)
+
+        # Make sure we didn't create invalid markup
+        expect(doc.errors).to be_empty
+
+        # Leading user link
+        expect(doc.css('a').length).to eq(1)
+        expect(doc.css('a')[0].attr('href')).to eq user_path(user)
+        expect(doc.css('a')[0].text).to eq "@#{user.username}"
+
+        expect(doc.content).to eq "@#{user.username}, can you look at this?..."
+      end
+
+      it 'truncates Markdown with emoji properly' do
+        object = create_object("foo :wink:\nbar :grinning:")
+        actual = first_line_in_markdown(object, attribute, 100, project: project)
+
+        doc = Nokogiri::HTML.parse(actual)
+
+        # Make sure we didn't create invalid markup
+        # But also account for the 2 errors caused by the unknown `gl-emoji` elements
+        expect(doc.errors.length).to eq(2)
+
+        expect(doc.css('gl-emoji').length).to eq(2)
+        expect(doc.css('gl-emoji')[0].attr('data-name')).to eq 'wink'
+        expect(doc.css('gl-emoji')[1].attr('data-name')).to eq 'grinning'
+
+        expect(doc.content).to eq "foo 😉\nbar 😀"
+      end
+    end
+
+    context 'when the asked attribute can be redacted' do
+      include_examples 'common markdown examples' do
+        let(:attribute) { :note }
+        def create_object(title, project: project_base)
+          build(:note, note: title, project: project)
+        end
+      end
+    end
+
+    context 'when the asked attribute can not be redacted' do
+      include_examples 'common markdown examples' do
+        let(:attribute) { :body }
+        def create_object(title, project: project_base)
+          issue = build(:issue, title: title)
+          build(:todo, :done, project: project_base, author: user, target: issue)
+        end
+      end
     end
   end
 
diff --git a/spec/helpers/namespaces_helper_spec.rb b/spec/helpers/namespaces_helper_spec.rb
index 8365b3f5538..460d3b6a7e4 100644
--- a/spec/helpers/namespaces_helper_spec.rb
+++ b/spec/helpers/namespaces_helper_spec.rb
@@ -29,5 +29,30 @@ describe NamespacesHelper do
       expect(options).not_to include(admin_group.name)
       expect(options).to include(user_group.name)
     end
+
+    context 'when nested groups are available', :nested_groups do
+      it 'includes groups nested in groups the user can administer' do
+        allow(helper).to receive(:current_user).and_return(user)
+        child_group = create(:group, :private, parent: user_group)
+
+        options = helper.namespaces_options
+
+        expect(options).to include(child_group.name)
+      end
+
+      it 'orders the groups correctly' do
+        allow(helper).to receive(:current_user).and_return(user)
+        child_group = create(:group, :private, parent: user_group)
+        other_child = create(:group, :private, parent: user_group)
+        sub_child = create(:group, :private, parent: child_group)
+
+        expect(helper).to receive(:options_for_group)
+                            .with([user_group, child_group, sub_child, other_child], anything)
+                            .and_call_original
+        allow(helper).to receive(:options_for_group).and_call_original
+
+        helper.namespaces_options
+      end
+    end
   end
 end
diff --git a/spec/helpers/tree_helper_spec.rb b/spec/helpers/tree_helper_spec.rb
index d7b66e6f078..c358ccae9c3 100644
--- a/spec/helpers/tree_helper_spec.rb
+++ b/spec/helpers/tree_helper_spec.rb
@@ -1,10 +1,36 @@
 require 'spec_helper'
 
 describe TreeHelper do
+  let(:project) { create(:project, :repository) }
+  let(:repository) { project.repository }
+  let(:sha) { 'ce369011c189f62c815f5971d096b26759bab0d1' }
+
+  describe '.render_tree' do
+    before do
+      @id = sha
+      @project = project
+    end
+
+    it 'displays all entries without a warning' do
+      tree = repository.tree(sha, 'files')
+
+      html = render_tree(tree)
+
+      expect(html).not_to have_selector('.tree-truncated-warning')
+    end
+
+    it 'truncates entries and adds a warning' do
+      stub_const('TreeHelper::FILE_LIMIT', 1)
+      tree = repository.tree(sha, 'files')
+
+      html = render_tree(tree)
+
+      expect(html).to have_selector('.tree-truncated-warning', count: 1)
+      expect(html).to have_selector('.tree-item-file-name', count: 1)
+    end
+  end
+
   describe 'flatten_tree' do
-    let(:project) { create(:project, :repository) }
-    let(:repository) { project.repository }
-    let(:sha) { 'ce369011c189f62c815f5971d096b26759bab0d1' }
     let(:tree) { repository.tree(sha, 'files') }
     let(:root_path) { 'files' }
     let(:tree_item) { tree.entries.find { |entry| entry.path == path } }
diff --git a/spec/initializers/8_metrics_spec.rb b/spec/initializers/8_metrics_spec.rb
index 4e6052a9f80..80c77057065 100644
--- a/spec/initializers/8_metrics_spec.rb
+++ b/spec/initializers/8_metrics_spec.rb
@@ -3,7 +3,6 @@ require 'spec_helper'
 describe 'instrument_classes' do
   let(:config) { double(:config) }
 
-  let(:unicorn_sampler) { double(:unicorn_sampler) }
   let(:influx_sampler) { double(:influx_sampler) }
 
   before do
@@ -11,9 +10,7 @@ describe 'instrument_classes' do
     allow(config).to receive(:instrument_methods)
     allow(config).to receive(:instrument_instance_method)
     allow(config).to receive(:instrument_instance_methods)
-    allow(Gitlab::Metrics::UnicornSampler).to receive(:initialize_instance).and_return(unicorn_sampler)
-    allow(Gitlab::Metrics::InfluxSampler).to receive(:initialize_instance).and_return(influx_sampler)
-    allow(unicorn_sampler).to receive(:start)
+    allow(Gitlab::Metrics::Samplers::InfluxSampler).to receive(:initialize_instance).and_return(influx_sampler)
     allow(influx_sampler).to receive(:start)
     allow(Gitlab::Application).to receive(:configure)
   end
diff --git a/spec/javascripts/behaviors/copy_as_gfm_spec.js b/spec/javascripts/behaviors/copy_as_gfm_spec.js
new file mode 100644
index 00000000000..b8155144e2a
--- /dev/null
+++ b/spec/javascripts/behaviors/copy_as_gfm_spec.js
@@ -0,0 +1,47 @@
+import { CopyAsGFM } from '~/behaviors/copy_as_gfm';
+
+describe('CopyAsGFM', () => {
+  describe('CopyAsGFM.pasteGFM', () => {
+    function callPasteGFM() {
+      const e = {
+        originalEvent: {
+          clipboardData: {
+            getData(mimeType) {
+              // When GFM code is copied, we put the regular plain text
+              // on the clipboard as `text/plain`, and the GFM as `text/x-gfm`.
+              // This emulates the behavior of `getData` with that data.
+              if (mimeType === 'text/plain') {
+                return 'code';
+              }
+              if (mimeType === 'text/x-gfm') {
+                return '`code`';
+              }
+              return null;
+            },
+          },
+        },
+        preventDefault() {},
+      };
+
+      CopyAsGFM.pasteGFM(e);
+    }
+
+    it('wraps pasted code when not already in code tags', () => {
+      spyOn(window.gl.utils, 'insertText').and.callFake((el, textFunc) => {
+        const insertedText = textFunc('This is code: ', '');
+        expect(insertedText).toEqual('`code`');
+      });
+
+      callPasteGFM();
+    });
+
+    it('does not wrap pasted code when already in code tags', () => {
+      spyOn(window.gl.utils, 'insertText').and.callFake((el, textFunc) => {
+        const insertedText = textFunc('This is code: `', '`');
+        expect(insertedText).toEqual('code');
+      });
+
+      callPasteGFM();
+    });
+  });
+});
diff --git a/spec/javascripts/behaviors/gl_emoji/unicode_support_map_spec.js b/spec/javascripts/behaviors/gl_emoji/unicode_support_map_spec.js
index ec2c549e032..f96f20ed4a5 100644
--- a/spec/javascripts/behaviors/gl_emoji/unicode_support_map_spec.js
+++ b/spec/javascripts/behaviors/gl_emoji/unicode_support_map_spec.js
@@ -21,13 +21,18 @@ describe('Unicode Support Map', () => {
       });
 
       it('should call .getItem and .setItem', () => {
-        const allArgs = window.localStorage.setItem.calls.allArgs();
-
-        expect(window.localStorage.getItem).toHaveBeenCalledWith('gl-emoji-user-agent');
-        expect(allArgs[0][0]).toBe('gl-emoji-user-agent');
-        expect(allArgs[0][1]).toBe(navigator.userAgent);
-        expect(allArgs[1][0]).toBe('gl-emoji-unicode-support-map');
-        expect(allArgs[1][1]).toBe(stringSupportMap);
+        const getArgs = window.localStorage.getItem.calls.allArgs();
+        const setArgs = window.localStorage.setItem.calls.allArgs();
+
+        expect(getArgs[0][0]).toBe('gl-emoji-version');
+        expect(getArgs[1][0]).toBe('gl-emoji-user-agent');
+
+        expect(setArgs[0][0]).toBe('gl-emoji-version');
+        expect(setArgs[0][1]).toBe('0.2.0');
+        expect(setArgs[1][0]).toBe('gl-emoji-user-agent');
+        expect(setArgs[1][1]).toBe(navigator.userAgent);
+        expect(setArgs[2][0]).toBe('gl-emoji-unicode-support-map');
+        expect(setArgs[2][1]).toBe(stringSupportMap);
       });
     });
 
diff --git a/spec/javascripts/clusters/clusters_bundle_spec.js b/spec/javascripts/clusters/clusters_bundle_spec.js
new file mode 100644
index 00000000000..027e8001053
--- /dev/null
+++ b/spec/javascripts/clusters/clusters_bundle_spec.js
@@ -0,0 +1,257 @@
+import Clusters from '~/clusters/clusters_bundle';
+import {
+  APPLICATION_INSTALLABLE,
+  APPLICATION_INSTALLING,
+  APPLICATION_INSTALLED,
+  REQUEST_LOADING,
+  REQUEST_SUCCESS,
+  REQUEST_FAILURE,
+} from '~/clusters/constants';
+import getSetTimeoutPromise from '../helpers/set_timeout_promise_helper';
+
+describe('Clusters', () => {
+  let cluster;
+  preloadFixtures('clusters/show_cluster.html.raw');
+
+  beforeEach(() => {
+    loadFixtures('clusters/show_cluster.html.raw');
+    cluster = new Clusters();
+  });
+
+  afterEach(() => {
+    cluster.destroy();
+  });
+
+  describe('toggle', () => {
+    it('should update the button and the input field on click', () => {
+      cluster.toggleButton.click();
+
+      expect(
+        cluster.toggleButton.classList,
+      ).not.toContain('checked');
+
+      expect(
+        cluster.toggleInput.getAttribute('value'),
+      ).toEqual('false');
+    });
+  });
+
+  describe('checkForNewInstalls', () => {
+    const INITIAL_APP_MAP = {
+      helm: { status: null, title: 'Helm Tiller' },
+      ingress: { status: null, title: 'Ingress' },
+      runner: { status: null, title: 'GitLab Runner' },
+    };
+
+    it('does not show alert when things transition from initial null state to something', () => {
+      cluster.checkForNewInstalls(INITIAL_APP_MAP, {
+        ...INITIAL_APP_MAP,
+        helm: { status: APPLICATION_INSTALLABLE, title: 'Helm Tiller' },
+      });
+
+      expect(document.querySelector('.js-cluster-application-notice .flash-text')).toBeNull();
+    });
+
+    it('shows an alert when something gets newly installed', () => {
+      cluster.checkForNewInstalls({
+        ...INITIAL_APP_MAP,
+        helm: { status: APPLICATION_INSTALLING, title: 'Helm Tiller' },
+      }, {
+        ...INITIAL_APP_MAP,
+        helm: { status: APPLICATION_INSTALLED, title: 'Helm Tiller' },
+      });
+
+      expect(document.querySelector('.js-cluster-application-notice .flash-text')).toBeDefined();
+      expect(document.querySelector('.js-cluster-application-notice .flash-text').textContent.trim()).toEqual('Helm Tiller was successfully installed on your cluster');
+    });
+
+    it('shows an alert when multiple things gets newly installed', () => {
+      cluster.checkForNewInstalls({
+        ...INITIAL_APP_MAP,
+        helm: { status: APPLICATION_INSTALLING, title: 'Helm Tiller' },
+        ingress: { status: APPLICATION_INSTALLABLE, title: 'Ingress' },
+      }, {
+        ...INITIAL_APP_MAP,
+        helm: { status: APPLICATION_INSTALLED, title: 'Helm Tiller' },
+        ingress: { status: APPLICATION_INSTALLED, title: 'Ingress' },
+      });
+
+      expect(document.querySelector('.js-cluster-application-notice .flash-text')).toBeDefined();
+      expect(document.querySelector('.js-cluster-application-notice .flash-text').textContent.trim()).toEqual('Helm Tiller, Ingress was successfully installed on your cluster');
+    });
+  });
+
+  describe('updateContainer', () => {
+    describe('when creating cluster', () => {
+      it('should show the creating container', () => {
+        cluster.updateContainer(null, 'creating');
+
+        expect(
+          cluster.creatingContainer.classList.contains('hidden'),
+        ).toBeFalsy();
+        expect(
+          cluster.successContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+        expect(
+          cluster.errorContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+      });
+
+      it('should continue to show `creating` banner with subsequent updates of the same status', () => {
+        cluster.updateContainer('creating', 'creating');
+
+        expect(
+          cluster.creatingContainer.classList.contains('hidden'),
+        ).toBeFalsy();
+        expect(
+          cluster.successContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+        expect(
+          cluster.errorContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+      });
+    });
+
+    describe('when cluster is created', () => {
+      it('should show the success container', () => {
+        cluster.updateContainer(null, 'created');
+
+        expect(
+          cluster.creatingContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+        expect(
+          cluster.successContainer.classList.contains('hidden'),
+        ).toBeFalsy();
+        expect(
+          cluster.errorContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+      });
+
+      it('should not show a banner when status is already `created`', () => {
+        cluster.updateContainer('created', 'created');
+
+        expect(
+          cluster.creatingContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+        expect(
+          cluster.successContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+        expect(
+          cluster.errorContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+      });
+    });
+
+    describe('when cluster has error', () => {
+      it('should show the error container', () => {
+        cluster.updateContainer(null, 'errored', 'this is an error');
+
+        expect(
+          cluster.creatingContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+        expect(
+          cluster.successContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+        expect(
+          cluster.errorContainer.classList.contains('hidden'),
+        ).toBeFalsy();
+
+        expect(
+          cluster.errorReasonContainer.textContent,
+        ).toContain('this is an error');
+      });
+
+      it('should show `error` banner when previously `creating`', () => {
+        cluster.updateContainer('creating', 'errored');
+
+        expect(
+          cluster.creatingContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+        expect(
+          cluster.successContainer.classList.contains('hidden'),
+        ).toBeTruthy();
+        expect(
+          cluster.errorContainer.classList.contains('hidden'),
+        ).toBeFalsy();
+      });
+    });
+  });
+
+  describe('installApplication', () => {
+    it('tries to install helm', (done) => {
+      spyOn(cluster.service, 'installApplication').and.returnValue(Promise.resolve());
+      expect(cluster.store.state.applications.helm.requestStatus).toEqual(null);
+
+      cluster.installApplication('helm');
+
+      expect(cluster.store.state.applications.helm.requestStatus).toEqual(REQUEST_LOADING);
+      expect(cluster.store.state.applications.helm.requestReason).toEqual(null);
+      expect(cluster.service.installApplication).toHaveBeenCalledWith('helm');
+
+      getSetTimeoutPromise()
+        .then(() => {
+          expect(cluster.store.state.applications.helm.requestStatus).toEqual(REQUEST_SUCCESS);
+          expect(cluster.store.state.applications.helm.requestReason).toEqual(null);
+        })
+        .then(done)
+        .catch(done.fail);
+    });
+
+    it('tries to install ingress', (done) => {
+      spyOn(cluster.service, 'installApplication').and.returnValue(Promise.resolve());
+      expect(cluster.store.state.applications.ingress.requestStatus).toEqual(null);
+
+      cluster.installApplication('ingress');
+
+      expect(cluster.store.state.applications.ingress.requestStatus).toEqual(REQUEST_LOADING);
+      expect(cluster.store.state.applications.ingress.requestReason).toEqual(null);
+      expect(cluster.service.installApplication).toHaveBeenCalledWith('ingress');
+
+      getSetTimeoutPromise()
+        .then(() => {
+          expect(cluster.store.state.applications.ingress.requestStatus).toEqual(REQUEST_SUCCESS);
+          expect(cluster.store.state.applications.ingress.requestReason).toEqual(null);
+        })
+        .then(done)
+        .catch(done.fail);
+    });
+
+    it('tries to install runner', (done) => {
+      spyOn(cluster.service, 'installApplication').and.returnValue(Promise.resolve());
+      expect(cluster.store.state.applications.runner.requestStatus).toEqual(null);
+
+      cluster.installApplication('runner');
+
+      expect(cluster.store.state.applications.runner.requestStatus).toEqual(REQUEST_LOADING);
+      expect(cluster.store.state.applications.runner.requestReason).toEqual(null);
+      expect(cluster.service.installApplication).toHaveBeenCalledWith('runner');
+
+      getSetTimeoutPromise()
+        .then(() => {
+          expect(cluster.store.state.applications.runner.requestStatus).toEqual(REQUEST_SUCCESS);
+          expect(cluster.store.state.applications.runner.requestReason).toEqual(null);
+        })
+        .then(done)
+        .catch(done.fail);
+    });
+
+    it('sets error request status when the request fails', (done) => {
+      spyOn(cluster.service, 'installApplication').and.returnValue(Promise.reject(new Error('STUBBED ERROR')));
+      expect(cluster.store.state.applications.helm.requestStatus).toEqual(null);
+
+      cluster.installApplication('helm');
+
+      expect(cluster.store.state.applications.helm.requestStatus).toEqual(REQUEST_LOADING);
+      expect(cluster.store.state.applications.helm.requestReason).toEqual(null);
+      expect(cluster.service.installApplication).toHaveBeenCalled();
+
+      getSetTimeoutPromise()
+        .then(() => {
+          expect(cluster.store.state.applications.helm.requestStatus).toEqual(REQUEST_FAILURE);
+          expect(cluster.store.state.applications.helm.requestReason).toBeDefined();
+        })
+        .then(done)
+        .catch(done.fail);
+    });
+  });
+});
diff --git a/spec/javascripts/clusters/components/application_row_spec.js b/spec/javascripts/clusters/components/application_row_spec.js
new file mode 100644
index 00000000000..e671c18e1a5
--- /dev/null
+++ b/spec/javascripts/clusters/components/application_row_spec.js
@@ -0,0 +1,237 @@
+import Vue from 'vue';
+import eventHub from '~/clusters/event_hub';
+import {
+  APPLICATION_NOT_INSTALLABLE,
+  APPLICATION_SCHEDULED,
+  APPLICATION_INSTALLABLE,
+  APPLICATION_INSTALLING,
+  APPLICATION_INSTALLED,
+  APPLICATION_ERROR,
+  REQUEST_LOADING,
+  REQUEST_SUCCESS,
+  REQUEST_FAILURE,
+} from '~/clusters/constants';
+import applicationRow from '~/clusters/components/application_row.vue';
+import mountComponent from '../../helpers/vue_mount_component_helper';
+import { DEFAULT_APPLICATION_STATE } from '../services/mock_data';
+
+describe('Application Row', () => {
+  let vm;
+  let ApplicationRow;
+
+  beforeEach(() => {
+    ApplicationRow = Vue.extend(applicationRow);
+  });
+
+  afterEach(() => {
+    vm.$destroy();
+  });
+
+  describe('Title', () => {
+    it('shows title', () => {
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        titleLink: null,
+      });
+      const title = vm.$el.querySelector('.js-cluster-application-title');
+
+      expect(title.tagName).toEqual('SPAN');
+      expect(title.textContent.trim()).toEqual(DEFAULT_APPLICATION_STATE.title);
+    });
+
+    it('shows title link', () => {
+      expect(DEFAULT_APPLICATION_STATE.titleLink).toBeDefined();
+
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+      });
+      const title = vm.$el.querySelector('.js-cluster-application-title');
+
+      expect(title.tagName).toEqual('A');
+      expect(title.textContent.trim()).toEqual(DEFAULT_APPLICATION_STATE.title);
+    });
+  });
+
+  describe('Install button', () => {
+    it('has indeterminate state on page load', () => {
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: null,
+      });
+
+      expect(vm.installButtonLabel).toBeUndefined();
+    });
+
+    it('has disabled "Install" when APPLICATION_NOT_INSTALLABLE', () => {
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_NOT_INSTALLABLE,
+      });
+
+      expect(vm.installButtonLabel).toEqual('Install');
+      expect(vm.installButtonLoading).toEqual(false);
+      expect(vm.installButtonDisabled).toEqual(true);
+    });
+
+    it('has enabled "Install" when APPLICATION_INSTALLABLE', () => {
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_INSTALLABLE,
+      });
+
+      expect(vm.installButtonLabel).toEqual('Install');
+      expect(vm.installButtonLoading).toEqual(false);
+      expect(vm.installButtonDisabled).toEqual(false);
+    });
+
+    it('has loading "Installing" when APPLICATION_SCHEDULED', () => {
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_SCHEDULED,
+      });
+
+      expect(vm.installButtonLabel).toEqual('Installing');
+      expect(vm.installButtonLoading).toEqual(true);
+      expect(vm.installButtonDisabled).toEqual(true);
+    });
+
+    it('has loading "Installing" when APPLICATION_INSTALLING', () => {
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_INSTALLING,
+      });
+
+      expect(vm.installButtonLabel).toEqual('Installing');
+      expect(vm.installButtonLoading).toEqual(true);
+      expect(vm.installButtonDisabled).toEqual(true);
+    });
+
+    it('has disabled "Installed" when APPLICATION_INSTALLED', () => {
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_INSTALLED,
+      });
+
+      expect(vm.installButtonLabel).toEqual('Installed');
+      expect(vm.installButtonLoading).toEqual(false);
+      expect(vm.installButtonDisabled).toEqual(true);
+    });
+
+    it('has enabled "Install" when APPLICATION_ERROR', () => {
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_ERROR,
+      });
+
+      expect(vm.installButtonLabel).toEqual('Install');
+      expect(vm.installButtonLoading).toEqual(false);
+      expect(vm.installButtonDisabled).toEqual(false);
+    });
+
+    it('has loading "Install" when REQUEST_LOADING', () => {
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_INSTALLABLE,
+        requestStatus: REQUEST_LOADING,
+      });
+
+      expect(vm.installButtonLabel).toEqual('Install');
+      expect(vm.installButtonLoading).toEqual(true);
+      expect(vm.installButtonDisabled).toEqual(true);
+    });
+
+    it('has disabled "Install" when REQUEST_SUCCESS', () => {
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_INSTALLABLE,
+        requestStatus: REQUEST_SUCCESS,
+      });
+
+      expect(vm.installButtonLabel).toEqual('Install');
+      expect(vm.installButtonLoading).toEqual(false);
+      expect(vm.installButtonDisabled).toEqual(true);
+    });
+
+    it('has enabled "Install" when REQUEST_FAILURE (so you can try installing again)', () => {
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_INSTALLABLE,
+        requestStatus: REQUEST_FAILURE,
+      });
+
+      expect(vm.installButtonLabel).toEqual('Install');
+      expect(vm.installButtonLoading).toEqual(false);
+      expect(vm.installButtonDisabled).toEqual(false);
+    });
+
+    it('clicking install button emits event', () => {
+      spyOn(eventHub, '$emit');
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_INSTALLABLE,
+      });
+      const installButton = vm.$el.querySelector('.js-cluster-application-install-button');
+
+      installButton.click();
+
+      expect(eventHub.$emit).toHaveBeenCalledWith('installApplication', DEFAULT_APPLICATION_STATE.id);
+    });
+
+    it('clicking disabled install button emits nothing', () => {
+      spyOn(eventHub, '$emit');
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_INSTALLING,
+      });
+      const installButton = vm.$el.querySelector('.js-cluster-application-install-button');
+
+      expect(vm.installButtonDisabled).toEqual(true);
+
+      installButton.click();
+
+      expect(eventHub.$emit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Error block', () => {
+    it('does not show error block when there is no error', () => {
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: null,
+        requestStatus: null,
+      });
+      const generalErrorMessage = vm.$el.querySelector('.js-cluster-application-general-error-message');
+
+      expect(generalErrorMessage).toBeNull();
+    });
+
+    it('shows status reason when APPLICATION_ERROR', () => {
+      const statusReason = 'We broke it 0.0';
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_ERROR,
+        statusReason,
+      });
+      const generalErrorMessage = vm.$el.querySelector('.js-cluster-application-general-error-message');
+      const statusErrorMessage = vm.$el.querySelector('.js-cluster-application-status-error-message');
+
+      expect(generalErrorMessage.textContent.trim()).toEqual(`Something went wrong while installing ${DEFAULT_APPLICATION_STATE.title}`);
+      expect(statusErrorMessage.textContent.trim()).toEqual(statusReason);
+    });
+
+    it('shows request reason when REQUEST_FAILURE', () => {
+      const requestReason = 'We broke thre request 0.0';
+      vm = mountComponent(ApplicationRow, {
+        ...DEFAULT_APPLICATION_STATE,
+        status: APPLICATION_INSTALLABLE,
+        requestStatus: REQUEST_FAILURE,
+        requestReason,
+      });
+      const generalErrorMessage = vm.$el.querySelector('.js-cluster-application-general-error-message');
+      const requestErrorMessage = vm.$el.querySelector('.js-cluster-application-request-error-message');
+
+      expect(generalErrorMessage.textContent.trim()).toEqual(`Something went wrong while installing ${DEFAULT_APPLICATION_STATE.title}`);
+      expect(requestErrorMessage.textContent.trim()).toEqual(requestReason);
+    });
+  });
+});
diff --git a/spec/javascripts/clusters/components/applications_spec.js b/spec/javascripts/clusters/components/applications_spec.js
new file mode 100644
index 00000000000..7460da031c4
--- /dev/null
+++ b/spec/javascripts/clusters/components/applications_spec.js
@@ -0,0 +1,42 @@
+import Vue from 'vue';
+import applications from '~/clusters/components/applications.vue';
+import mountComponent from '../../helpers/vue_mount_component_helper';
+
+describe('Applications', () => {
+  let vm;
+  let Applications;
+
+  beforeEach(() => {
+    Applications = Vue.extend(applications);
+  });
+
+  afterEach(() => {
+    vm.$destroy();
+  });
+
+  describe('', () => {
+    beforeEach(() => {
+      vm = mountComponent(Applications, {
+        applications: {
+          helm: { title: 'Helm Tiller' },
+          ingress: { title: 'Ingress' },
+          runner: { title: 'GitLab Runner' },
+        },
+      });
+    });
+
+    it('renders a row for Helm Tiller', () => {
+      expect(vm.$el.querySelector('.js-cluster-application-row-helm')).toBeDefined();
+    });
+
+    it('renders a row for Ingress', () => {
+      expect(vm.$el.querySelector('.js-cluster-application-row-ingress')).toBeDefined();
+    });
+
+    /* * /
+    it('renders a row for GitLab Runner', () => {
+      expect(vm.$el.querySelector('.js-cluster-application-row-runner')).toBeDefined();
+    });
+    /* */
+  });
+});
diff --git a/spec/javascripts/clusters/services/mock_data.js b/spec/javascripts/clusters/services/mock_data.js
new file mode 100644
index 00000000000..af6b6a73819
--- /dev/null
+++ b/spec/javascripts/clusters/services/mock_data.js
@@ -0,0 +1,50 @@
+import {
+  APPLICATION_INSTALLABLE,
+  APPLICATION_INSTALLING,
+  APPLICATION_ERROR,
+} from '~/clusters/constants';
+
+const CLUSTERS_MOCK_DATA = {
+  GET: {
+    '/gitlab-org/gitlab-shell/clusters/1/status.json': {
+      data: {
+        status: 'errored',
+        status_reason: 'Failed to request to CloudPlatform.',
+        applications: [{
+          name: 'helm',
+          status: APPLICATION_INSTALLABLE,
+          status_reason: null,
+        }, {
+          name: 'ingress',
+          status: APPLICATION_ERROR,
+          status_reason: 'Cannot connect',
+        }, {
+          name: 'runner',
+          status: APPLICATION_INSTALLING,
+          status_reason: null,
+        }],
+      },
+    },
+  },
+  POST: {
+    '/gitlab-org/gitlab-shell/clusters/1/applications/helm': { },
+    '/gitlab-org/gitlab-shell/clusters/1/applications/ingress': { },
+    '/gitlab-org/gitlab-shell/clusters/1/applications/runner': { },
+  },
+};
+
+const DEFAULT_APPLICATION_STATE = {
+  id: 'some-app',
+  title: 'My App',
+  titleLink: 'https://about.gitlab.com/',
+  description: 'Some description about this interesting application!',
+  status: null,
+  statusReason: null,
+  requestStatus: null,
+  requestReason: null,
+};
+
+export {
+  CLUSTERS_MOCK_DATA,
+  DEFAULT_APPLICATION_STATE,
+};
diff --git a/spec/javascripts/clusters/stores/clusters_store_spec.js b/spec/javascripts/clusters/stores/clusters_store_spec.js
new file mode 100644
index 00000000000..cb8b3d38e2e
--- /dev/null
+++ b/spec/javascripts/clusters/stores/clusters_store_spec.js
@@ -0,0 +1,89 @@
+import ClustersStore from '~/clusters/stores/clusters_store';
+import { APPLICATION_INSTALLING } from '~/clusters/constants';
+import { CLUSTERS_MOCK_DATA } from '../services/mock_data';
+
+describe('Clusters Store', () => {
+  let store;
+
+  beforeEach(() => {
+    store = new ClustersStore();
+  });
+
+  describe('updateStatus', () => {
+    it('should store new status', () => {
+      expect(store.state.status).toEqual(null);
+
+      const newStatus = 'errored';
+      store.updateStatus(newStatus);
+
+      expect(store.state.status).toEqual(newStatus);
+    });
+  });
+
+  describe('updateStatusReason', () => {
+    it('should store new reason', () => {
+      expect(store.state.statusReason).toEqual(null);
+
+      const newReason = 'Something went wrong!';
+      store.updateStatusReason(newReason);
+
+      expect(store.state.statusReason).toEqual(newReason);
+    });
+  });
+
+  describe('updateAppProperty', () => {
+    it('should store new request status', () => {
+      expect(store.state.applications.helm.requestStatus).toEqual(null);
+
+      const newStatus = APPLICATION_INSTALLING;
+      store.updateAppProperty('helm', 'requestStatus', newStatus);
+
+      expect(store.state.applications.helm.requestStatus).toEqual(newStatus);
+    });
+
+    it('should store new request reason', () => {
+      expect(store.state.applications.helm.requestReason).toEqual(null);
+
+      const newReason = 'We broke it.';
+      store.updateAppProperty('helm', 'requestReason', newReason);
+
+      expect(store.state.applications.helm.requestReason).toEqual(newReason);
+    });
+  });
+
+  describe('updateStateFromServer', () => {
+    it('should store new polling data from server', () => {
+      const mockResponseData = CLUSTERS_MOCK_DATA.GET['/gitlab-org/gitlab-shell/clusters/1/status.json'].data;
+      store.updateStateFromServer(mockResponseData);
+
+      expect(store.state).toEqual({
+        helpPath: null,
+        status: mockResponseData.status,
+        statusReason: mockResponseData.status_reason,
+        applications: {
+          helm: {
+            title: 'Helm Tiller',
+            status: mockResponseData.applications[0].status,
+            statusReason: mockResponseData.applications[0].status_reason,
+            requestStatus: null,
+            requestReason: null,
+          },
+          ingress: {
+            title: 'Ingress',
+            status: mockResponseData.applications[1].status,
+            statusReason: mockResponseData.applications[1].status_reason,
+            requestStatus: null,
+            requestReason: null,
+          },
+          runner: {
+            title: 'GitLab Runner',
+            status: mockResponseData.applications[2].status,
+            statusReason: mockResponseData.applications[2].status_reason,
+            requestStatus: null,
+            requestReason: null,
+          },
+        },
+      });
+    });
+  });
+});
diff --git a/spec/javascripts/clusters_spec.js b/spec/javascripts/clusters_spec.js
deleted file mode 100644
index eb1cd6eb804..00000000000
--- a/spec/javascripts/clusters_spec.js
+++ /dev/null
@@ -1,79 +0,0 @@
-import Clusters from '~/clusters';
-
-describe('Clusters', () => {
-  let cluster;
-  preloadFixtures('clusters/show_cluster.html.raw');
-
-  beforeEach(() => {
-    loadFixtures('clusters/show_cluster.html.raw');
-    cluster = new Clusters();
-  });
-
-  describe('toggle', () => {
-    it('should update the button and the input field on click', () => {
-      cluster.toggleButton.click();
-
-      expect(
-        cluster.toggleButton.classList,
-      ).not.toContain('checked');
-
-      expect(
-        cluster.toggleInput.getAttribute('value'),
-      ).toEqual('false');
-    });
-  });
-
-  describe('updateContainer', () => {
-    describe('when creating cluster', () => {
-      it('should show the creating container', () => {
-        cluster.updateContainer('creating');
-
-        expect(
-          cluster.creatingContainer.classList.contains('hidden'),
-        ).toBeFalsy();
-        expect(
-          cluster.successContainer.classList.contains('hidden'),
-        ).toBeTruthy();
-        expect(
-          cluster.errorContainer.classList.contains('hidden'),
-        ).toBeTruthy();
-      });
-    });
-
-    describe('when cluster is created', () => {
-      it('should show the success container', () => {
-        cluster.updateContainer('created');
-
-        expect(
-          cluster.creatingContainer.classList.contains('hidden'),
-        ).toBeTruthy();
-        expect(
-          cluster.successContainer.classList.contains('hidden'),
-        ).toBeFalsy();
-        expect(
-          cluster.errorContainer.classList.contains('hidden'),
-        ).toBeTruthy();
-      });
-    });
-
-    describe('when cluster has error', () => {
-      it('should show the error container', () => {
-        cluster.updateContainer('errored', 'this is an error');
-
-        expect(
-          cluster.creatingContainer.classList.contains('hidden'),
-        ).toBeTruthy();
-        expect(
-          cluster.successContainer.classList.contains('hidden'),
-        ).toBeTruthy();
-        expect(
-          cluster.errorContainer.classList.contains('hidden'),
-        ).toBeFalsy();
-
-        expect(
-          cluster.errorReasonContainer.textContent,
-        ).toContain('this is an error');
-      });
-    });
-  });
-});
diff --git a/spec/javascripts/copy_as_gfm_spec.js b/spec/javascripts/copy_as_gfm_spec.js
deleted file mode 100644
index ded450749d3..00000000000
--- a/spec/javascripts/copy_as_gfm_spec.js
+++ /dev/null
@@ -1,49 +0,0 @@
-import '~/copy_as_gfm';
-
-(() => {
-  describe('gl.CopyAsGFM', () => {
-    describe('gl.CopyAsGFM.pasteGFM', () => {
-      function callPasteGFM() {
-        const e = {
-          originalEvent: {
-            clipboardData: {
-              getData(mimeType) {
-                // When GFM code is copied, we put the regular plain text
-                // on the clipboard as `text/plain`, and the GFM as `text/x-gfm`.
-                // This emulates the behavior of `getData` with that data.
-                if (mimeType === 'text/plain') {
-                  return 'code';
-                }
-                if (mimeType === 'text/x-gfm') {
-                  return '`code`';
-                }
-                return null;
-              },
-            },
-          },
-          preventDefault() {},
-        };
-
-        window.gl.CopyAsGFM.pasteGFM(e);
-      }
-
-      it('wraps pasted code when not already in code tags', () => {
-        spyOn(window.gl.utils, 'insertText').and.callFake((el, textFunc) => {
-          const insertedText = textFunc('This is code: ', '');
-          expect(insertedText).toEqual('`code`');
-        });
-
-        callPasteGFM();
-      });
-
-      it('does not wrap pasted code when already in code tags', () => {
-        spyOn(window.gl.utils, 'insertText').and.callFake((el, textFunc) => {
-          const insertedText = textFunc('This is code: `', '`');
-          expect(insertedText).toEqual('code');
-        });
-
-        callPasteGFM();
-      });
-    });
-  });
-})();
diff --git a/spec/javascripts/emoji_spec.js b/spec/javascripts/emoji_spec.js
index fa11c602ec3..124d91f4477 100644
--- a/spec/javascripts/emoji_spec.js
+++ b/spec/javascripts/emoji_spec.js
@@ -1,6 +1,7 @@
 import { glEmojiTag } from '~/emoji';
 import isEmojiUnicodeSupported, {
   isFlagEmoji,
+  isRainbowFlagEmoji,
   isKeycapEmoji,
   isSkinToneComboEmoji,
   isHorceRacingSkinToneComboEmoji,
@@ -217,6 +218,24 @@ describe('gl_emoji', () => {
     });
   });
 
+  describe('isRainbowFlagEmoji', () => {
+    it('should gracefully handle empty string', () => {
+      expect(isRainbowFlagEmoji('')).toBeFalsy();
+    });
+    it('should detect rainbow_flag', () => {
+      expect(isRainbowFlagEmoji('🏳🌈')).toBeTruthy();
+    });
+    it('should not detect flag_white on its\' own', () => {
+      expect(isRainbowFlagEmoji('🏳')).toBeFalsy();
+    });
+    it('should not detect rainbow on its\' own', () => {
+      expect(isRainbowFlagEmoji('🌈')).toBeFalsy();
+    });
+    it('should not detect flag_white with something else', () => {
+      expect(isRainbowFlagEmoji('🏳🔵')).toBeFalsy();
+    });
+  });
+
   describe('isKeycapEmoji', () => {
     it('should gracefully handle empty string', () => {
       expect(isKeycapEmoji('')).toBeFalsy();
diff --git a/spec/javascripts/filtered_search/filtered_search_manager_spec.js b/spec/javascripts/filtered_search/filtered_search_manager_spec.js
index f209328dee1..230c15e5de6 100644
--- a/spec/javascripts/filtered_search/filtered_search_manager_spec.js
+++ b/spec/javascripts/filtered_search/filtered_search_manager_spec.js
@@ -396,6 +396,25 @@ describe('Filtered Search Manager', () => {
     });
   });
 
+  describe('Clearing search', () => {
+    beforeEach(() => {
+      initializeManager();
+    });
+
+    it('Clicking the "x" clear button, clears the input', () => {
+      const inputValue = 'label:~bug ';
+      manager.filteredSearchInput.value = inputValue;
+      manager.filteredSearchInput.dispatchEvent(new Event('input'));
+
+      expect(gl.DropdownUtils.getSearchQuery()).toEqual(inputValue);
+
+      manager.clearSearchButton.click();
+
+      expect(manager.filteredSearchInput.value).toEqual('');
+      expect(gl.DropdownUtils.getSearchQuery()).toEqual('');
+    });
+  });
+
   describe('toggleInputContainerFocus', () => {
     beforeEach(() => {
       initializeManager();
diff --git a/spec/javascripts/fixtures/clusters.rb b/spec/javascripts/fixtures/clusters.rb
index 5774f36f026..8e74c4f859c 100644
--- a/spec/javascripts/fixtures/clusters.rb
+++ b/spec/javascripts/fixtures/clusters.rb
@@ -6,7 +6,7 @@ describe Projects::ClustersController, '(JavaScript fixtures)', type: :controlle
   let(:admin) { create(:admin) }
   let(:namespace) { create(:namespace, name: 'frontend-fixtures' )}
   let(:project) { create(:project, :repository, namespace: namespace) }
-  let(:cluster) { project.create_cluster!(gcp_cluster_name: "gke-test-creation-1", gcp_project_id: 'gitlab-internal-153318', gcp_cluster_zone: 'us-central1-a', gcp_cluster_size: '1', project_namespace: 'aaa', gcp_machine_type: 'n1-standard-1')}
+  let(:cluster) { create(:cluster, :provided_by_gcp, projects: [project]) }
 
   render_views
 
diff --git a/spec/javascripts/fixtures/pipelines.html.haml b/spec/javascripts/fixtures/pipelines.html.haml
index 97b0c25c923..85ee61f0b54 100644
--- a/spec/javascripts/fixtures/pipelines.html.haml
+++ b/spec/javascripts/fixtures/pipelines.html.haml
@@ -1,16 +1,10 @@
 %div
   #pipelines-list-vue{ data: { endpoint: 'foo',
-    "css-class" => 'foo',
     "help-page-path" => 'foo',
+    "help-auto-devops-path" => 'foo',
     "empty-state-svg-path" => 'foo',
     "error-state-svg-path" => 'foo',
     "new-pipeline-path" => 'foo',
     "can-create-pipeline" => 'true',
-    "all-path" =>  'foo',
-    "pending-path" => 'foo',
-    "running-path" => 'foo',
-    "finished-path" => 'foo',
-    "branches-path" => 'foo',
-    "tags-path" => 'foo',
     "has-ci" => 'foo',
     "ci-lint-path" => 'foo' } }
diff --git a/spec/javascripts/fixtures/search_autocomplete.html.haml b/spec/javascripts/fixtures/search_autocomplete.html.haml
index 7785120da5b..0421ed2182f 100644
--- a/spec/javascripts/fixtures/search_autocomplete.html.haml
+++ b/spec/javascripts/fixtures/search_autocomplete.html.haml
@@ -8,3 +8,4 @@
           %input#search.search-input.dropdown-menu-toggle
           .dropdown-menu.dropdown-select
             .dropdown-content
+    %input{ type: "hidden", class: "js-search-project-options" }
diff --git a/spec/javascripts/gfm_auto_complete_spec.js b/spec/javascripts/gfm_auto_complete_spec.js
index ad0c7264616..6f357306ec7 100644
--- a/spec/javascripts/gfm_auto_complete_spec.js
+++ b/spec/javascripts/gfm_auto_complete_spec.js
@@ -67,6 +67,28 @@ describe('GfmAutoComplete', function () {
     });
   });
 
+  describe('DefaultOptions.beforeInsert', () => {
+    const beforeInsert = (context, value) => (
+      gfmAutoCompleteCallbacks.beforeInsert.call(context, value)
+    );
+
+    const atwhoInstance = { setting: { skipSpecialCharacterTest: false } };
+
+    it('should not quote if value only contains alphanumeric charecters', () => {
+      expect(beforeInsert(atwhoInstance, '@user1')).toBe('@user1');
+      expect(beforeInsert(atwhoInstance, '~label1')).toBe('~label1');
+    });
+
+    it('should quote if value contains any non-alphanumeric characters', () => {
+      expect(beforeInsert(atwhoInstance, '~label-20')).toBe('~"label-20"');
+      expect(beforeInsert(atwhoInstance, '~label 20')).toBe('~"label 20"');
+    });
+
+    it('should quote integer labels', () => {
+      expect(beforeInsert(atwhoInstance, '~1234')).toBe('~"1234"');
+    });
+  });
+
   describe('DefaultOptions.matcher', function () {
     const defaultMatcher = (context, flag, subtext) => (
       gfmAutoCompleteCallbacks.matcher.call(context, flag, subtext)
diff --git a/spec/javascripts/issue_show/components/app_spec.js b/spec/javascripts/issue_show/components/app_spec.js
index 2ea290108a4..5662c7387fb 100644
--- a/spec/javascripts/issue_show/components/app_spec.js
+++ b/spec/javascripts/issue_show/components/app_spec.js
@@ -223,23 +223,46 @@ describe('Issuable output', () => {
       });
     });
 
-    it('closes form on error', (done) => {
-      spyOn(window, 'Flash').and.callThrough();
-      spyOn(vm.service, 'updateIssuable').and.callFake(() => new Promise((resolve, reject) => {
-        reject();
-      }));
+    describe('error when updating', () => {
+      beforeEach(() => {
+        spyOn(window, 'Flash').and.callThrough();
+        spyOn(vm.service, 'updateIssuable').and.callFake(() => new Promise((resolve, reject) => {
+          reject();
+        }));
+      });
 
-      vm.updateIssuable();
+      it('closes form on error', (done) => {
+        vm.updateIssuable();
 
-      setTimeout(() => {
-        expect(
-          eventHub.$emit,
-        ).toHaveBeenCalledWith('close.form');
-        expect(
-          window.Flash,
-        ).toHaveBeenCalledWith('Error updating issue');
+        setTimeout(() => {
+          expect(
+            eventHub.$emit,
+          ).toHaveBeenCalledWith('close.form');
+          expect(
+            window.Flash,
+          ).toHaveBeenCalledWith('Error updating issue');
 
-        done();
+          done();
+        });
+      });
+
+      it('returns the correct error message for issuableType', (done) => {
+        vm.issuableType = 'merge request';
+
+        Vue.nextTick(() => {
+          vm.updateIssuable();
+
+          setTimeout(() => {
+            expect(
+              eventHub.$emit,
+            ).toHaveBeenCalledWith('close.form');
+            expect(
+              window.Flash,
+            ).toHaveBeenCalledWith('Error updating merge request');
+
+            done();
+          });
+        });
       });
     });
   });
diff --git a/spec/javascripts/issue_show/components/edit_actions_spec.js b/spec/javascripts/issue_show/components/edit_actions_spec.js
index f6625b748b6..d779ab7bb31 100644
--- a/spec/javascripts/issue_show/components/edit_actions_spec.js
+++ b/spec/javascripts/issue_show/components/edit_actions_spec.js
@@ -61,6 +61,15 @@ describe('Edit Actions components', () => {
     });
   });
 
+  it('should not show delete button if showDeleteButton is false', (done) => {
+    vm.showDeleteButton = false;
+
+    Vue.nextTick(() => {
+      expect(vm.$el.querySelector('.btn-danger')).toBeNull();
+      done();
+    });
+  });
+
   describe('updateIssuable', () => {
     it('sends update.issauble event when clicking save button', () => {
       vm.$el.querySelector('.btn-save').click();
diff --git a/spec/javascripts/lib/utils/common_utils_spec.js b/spec/javascripts/lib/utils/common_utils_spec.js
index a5298be5669..6dad5d6b6bd 100644
--- a/spec/javascripts/lib/utils/common_utils_spec.js
+++ b/spec/javascripts/lib/utils/common_utils_spec.js
@@ -183,6 +183,36 @@ describe('common_utils', () => {
     });
   });
 
+  describe('historyPushState', () => {
+    afterEach(() => {
+      window.history.replaceState({}, null, null);
+    });
+
+    it('should call pushState with the correct path', () => {
+      spyOn(window.history, 'pushState');
+
+      commonUtils.historyPushState('newpath?page=2');
+
+      expect(window.history.pushState).toHaveBeenCalled();
+      expect(window.history.pushState.calls.allArgs()[0][2]).toContain('newpath?page=2');
+    });
+  });
+
+  describe('parseQueryStringIntoObject', () => {
+    it('should return object with query parameters', () => {
+      expect(commonUtils.parseQueryStringIntoObject('scope=all&page=2')).toEqual({ scope: 'all', page: '2' });
+      expect(commonUtils.parseQueryStringIntoObject('scope=all')).toEqual({ scope: 'all' });
+      expect(commonUtils.parseQueryStringIntoObject()).toEqual({});
+    });
+  });
+
+  describe('buildUrlWithCurrentLocation', () => {
+    it('should build an url with current location and given parameters', () => {
+      expect(commonUtils.buildUrlWithCurrentLocation()).toEqual(window.location.pathname);
+      expect(commonUtils.buildUrlWithCurrentLocation('?page=2')).toEqual(`${window.location.pathname}?page=2`);
+    });
+  });
+
   describe('getParameterByName', () => {
     beforeEach(() => {
       window.history.pushState({}, null, '?scope=all&p=2');
diff --git a/spec/javascripts/lib/utils/datefix_spec.js b/spec/javascripts/lib/utils/datefix_spec.js
index 0b9fde2be67..e58ac4300ba 100644
--- a/spec/javascripts/lib/utils/datefix_spec.js
+++ b/spec/javascripts/lib/utils/datefix_spec.js
@@ -1,4 +1,4 @@
-import { pad, parsePikadayDate, pikadayToString } from '~/lib/utils/datefix';
+import { pad, pikadayToString } from '~/lib/utils/datefix';
 
 describe('datefix', () => {
   describe('pad', () => {
@@ -16,9 +16,7 @@ describe('datefix', () => {
   });
 
   describe('parsePikadayDate', () => {
-    it('should return a UTC date', () => {
-      expect(parsePikadayDate('2020-01-29')).toEqual(new Date('2020-01-29'));
-    });
+    // removed because of https://gitlab.com/gitlab-org/gitlab-ce/issues/39834
   });
 
   describe('pikadayToString', () => {
diff --git a/spec/javascripts/lib/utils/number_utility_spec.js b/spec/javascripts/lib/utils/number_utility_spec.js
index 83c92deccdc..fcf27f6805f 100644
--- a/spec/javascripts/lib/utils/number_utility_spec.js
+++ b/spec/javascripts/lib/utils/number_utility_spec.js
@@ -1,4 +1,4 @@
-import { formatRelevantDigits, bytesToKiB, bytesToMiB } from '~/lib/utils/number_utils';
+import { formatRelevantDigits, bytesToKiB, bytesToMiB, bytesToGiB, numberToHumanSize } from '~/lib/utils/number_utils';
 
 describe('Number Utils', () => {
   describe('formatRelevantDigits', () => {
@@ -52,4 +52,29 @@ describe('Number Utils', () => {
       expect(bytesToMiB(1000000)).toEqual(0.95367431640625);
     });
   });
+
+  describe('bytesToGiB', () => {
+    it('calculates GiB for the given bytes', () => {
+      expect(bytesToGiB(1073741824)).toEqual(1);
+      expect(bytesToGiB(10737418240)).toEqual(10);
+    });
+  });
+
+  describe('numberToHumanSize', () => {
+    it('should return bytes', () => {
+      expect(numberToHumanSize(654)).toEqual('654 bytes');
+    });
+
+    it('should return KiB', () => {
+      expect(numberToHumanSize(1079)).toEqual('1.05 KiB');
+    });
+
+    it('should return MiB', () => {
+      expect(numberToHumanSize(10485764)).toEqual('10.00 MiB');
+    });
+
+    it('should return GiB', () => {
+      expect(numberToHumanSize(10737418240)).toEqual('10.00 GiB');
+    });
+  });
 });
diff --git a/spec/javascripts/lib/utils/poll_spec.js b/spec/javascripts/lib/utils/poll_spec.js
index 2aa7011ca51..9b8f68f1676 100644
--- a/spec/javascripts/lib/utils/poll_spec.js
+++ b/spec/javascripts/lib/utils/poll_spec.js
@@ -155,7 +155,7 @@ describe('Poll', () => {
         successCallback: () => {
           Polling.stop();
           setTimeout(() => {
-            Polling.restart();
+            Polling.restart({ data: { page: 4 } });
           }, 0);
         },
         errorCallback: callbacks.error,
@@ -170,10 +170,10 @@ describe('Poll', () => {
         Polling.stop();
 
         expect(service.fetch.calls.count()).toEqual(2);
-        expect(service.fetch).toHaveBeenCalledWith({ page: 1 });
+        expect(service.fetch).toHaveBeenCalledWith({ page: 4 });
         expect(Polling.stop).toHaveBeenCalled();
         expect(Polling.restart).toHaveBeenCalled();
-
+        expect(Polling.options.data).toEqual({ page: 4 });
         done();
       });
     });
diff --git a/spec/javascripts/lib/utils/text_markdown_spec.js b/spec/javascripts/lib/utils/text_markdown_spec.js
new file mode 100644
index 00000000000..a95a7e2a5be
--- /dev/null
+++ b/spec/javascripts/lib/utils/text_markdown_spec.js
@@ -0,0 +1,62 @@
+import textUtils from '~/lib/utils/text_markdown';
+
+describe('init markdown', () => {
+  let textArea;
+
+  beforeAll(() => {
+    textArea = document.createElement('textarea');
+    document.querySelector('body').appendChild(textArea);
+    textArea.focus();
+  });
+
+  afterAll(() => {
+    textArea.parentNode.removeChild(textArea);
+  });
+
+  describe('without selection', () => {
+    it('inserts the tag on an empty line', () => {
+      const initialValue = '';
+
+      textArea.value = initialValue;
+      textArea.selectionStart = 0;
+      textArea.selectionEnd = 0;
+
+      textUtils.insertText(textArea, textArea.value, '*', null, '', false);
+
+      expect(textArea.value).toEqual(`${initialValue}* `);
+    });
+
+    it('inserts the tag on a new line if the current one is not empty', () => {
+      const initialValue = 'some text';
+
+      textArea.value = initialValue;
+      textArea.setSelectionRange(initialValue.length, initialValue.length);
+
+      textUtils.insertText(textArea, textArea.value, '*', null, '', false);
+
+      expect(textArea.value).toEqual(`${initialValue}\n* `);
+    });
+
+    it('inserts the tag on the same line if the current line only contains spaces', () => {
+      const initialValue = '  ';
+
+      textArea.value = initialValue;
+      textArea.setSelectionRange(initialValue.length, initialValue.length);
+
+      textUtils.insertText(textArea, textArea.value, '*', null, '', false);
+
+      expect(textArea.value).toEqual(`${initialValue}* `);
+    });
+
+    it('inserts the tag on the same line if the current line only contains tabs', () => {
+      const initialValue = '\t\t\t';
+
+      textArea.value = initialValue;
+      textArea.setSelectionRange(initialValue.length, initialValue.length);
+
+      textUtils.insertText(textArea, textArea.value, '*', null, '', false);
+
+      expect(textArea.value).toEqual(`${initialValue}* `);
+    });
+  });
+});
diff --git a/spec/javascripts/lib/utils/text_utility_spec.js b/spec/javascripts/lib/utils/text_utility_spec.js
index 829b3ef5735..b21bd958f90 100644
--- a/spec/javascripts/lib/utils/text_utility_spec.js
+++ b/spec/javascripts/lib/utils/text_utility_spec.js
@@ -1,109 +1,57 @@
-import { highCountTrim } from '~/lib/utils/text_utility';
+import * as textUtils from '~/lib/utils/text_utility';
 
 describe('text_utility', () => {
-  describe('gl.text.getTextWidth', () => {
-    it('returns zero width when no text is passed', () => {
-      expect(gl.text.getTextWidth('')).toBe(0);
+  describe('addDelimiter', () => {
+    it('should add a delimiter to the given string', () => {
+      expect(textUtils.addDelimiter('1234')).toEqual('1,234');
+      expect(textUtils.addDelimiter('222222')).toEqual('222,222');
     });
 
-    it('returns zero width when no text is passed and font is passed', () => {
-      expect(gl.text.getTextWidth('', '100px sans-serif')).toBe(0);
-    });
-
-    it('returns width when text is passed', () => {
-      expect(gl.text.getTextWidth('foo') > 0).toBe(true);
-    });
-
-    it('returns bigger width when font is larger', () => {
-      const largeFont = gl.text.getTextWidth('foo', '100px sans-serif');
-      const regular = gl.text.getTextWidth('foo', '10px sans-serif');
-      expect(largeFont > regular).toBe(true);
-    });
-  });
-
-  describe('gl.text.pluralize', () => {
-    it('returns pluralized', () => {
-      expect(gl.text.pluralize('test', 2)).toBe('tests');
-    });
-
-    it('returns pluralized when count is 0', () => {
-      expect(gl.text.pluralize('test', 0)).toBe('tests');
-    });
-
-    it('does not return pluralized', () => {
-      expect(gl.text.pluralize('test', 1)).toBe('test');
+    it('should not add a delimiter if string contains no numbers', () => {
+      expect(textUtils.addDelimiter('aaaa')).toEqual('aaaa');
     });
   });
 
   describe('highCountTrim', () => {
     it('returns 99+ for count >= 100', () => {
-      expect(highCountTrim(105)).toBe('99+');
-      expect(highCountTrim(100)).toBe('99+');
+      expect(textUtils.highCountTrim(105)).toBe('99+');
+      expect(textUtils.highCountTrim(100)).toBe('99+');
     });
 
     it('returns exact number for count < 100', () => {
-      expect(highCountTrim(45)).toBe(45);
+      expect(textUtils.highCountTrim(45)).toBe(45);
     });
   });
 
-  describe('gl.text.insertText', () => {
-    let textArea;
-
-    beforeAll(() => {
-      textArea = document.createElement('textarea');
-      document.querySelector('body').appendChild(textArea);
-      textArea.focus();
+  describe('humanize', () => {
+    it('should remove underscores and uppercase the first letter', () => {
+      expect(textUtils.humanize('foo_bar')).toEqual('Foo bar');
     });
+  });
 
-    afterAll(() => {
-      textArea.parentNode.removeChild(textArea);
+  describe('pluralize', () => {
+    it('should pluralize given string', () => {
+      expect(textUtils.pluralize('test', 2)).toBe('tests');
     });
 
-    describe('without selection', () => {
-      it('inserts the tag on an empty line', () => {
-        const initialValue = '';
-
-        textArea.value = initialValue;
-        textArea.selectionStart = 0;
-        textArea.selectionEnd = 0;
-
-        gl.text.insertText(textArea, textArea.value, '*', null, '', false);
-
-        expect(textArea.value).toEqual(`${initialValue}* `);
-      });
-
-      it('inserts the tag on a new line if the current one is not empty', () => {
-        const initialValue = 'some text';
-
-        textArea.value = initialValue;
-        textArea.setSelectionRange(initialValue.length, initialValue.length);
-
-        gl.text.insertText(textArea, textArea.value, '*', null, '', false);
-
-        expect(textArea.value).toEqual(`${initialValue}\n* `);
-      });
-
-      it('inserts the tag on the same line if the current line only contains spaces', () => {
-        const initialValue = '  ';
-
-        textArea.value = initialValue;
-        textArea.setSelectionRange(initialValue.length, initialValue.length);
-
-        gl.text.insertText(textArea, textArea.value, '*', null, '', false);
-
-        expect(textArea.value).toEqual(`${initialValue}* `);
-      });
-
-      it('inserts the tag on the same line if the current line only contains tabs', () => {
-        const initialValue = '\t\t\t';
+    it('should pluralize when count is 0', () => {
+      expect(textUtils.pluralize('test', 0)).toBe('tests');
+    });
 
-        textArea.value = initialValue;
-        textArea.setSelectionRange(initialValue.length, initialValue.length);
+    it('should not pluralize when count is 1', () => {
+      expect(textUtils.pluralize('test', 1)).toBe('test');
+    });
+  });
 
-        gl.text.insertText(textArea, textArea.value, '*', null, '', false);
+  describe('dasherize', () => {
+    it('should replace underscores with dashes', () => {
+      expect(textUtils.dasherize('foo_bar_foo')).toEqual('foo-bar-foo');
+    });
+  });
 
-        expect(textArea.value).toEqual(`${initialValue}* `);
-      });
+  describe('slugify', () => {
+    it('should remove accents and convert to lower case', () => {
+      expect(textUtils.slugify('João')).toEqual('joão');
     });
   });
 });
diff --git a/spec/javascripts/monitoring/graph/legend_spec.js b/spec/javascripts/monitoring/graph/legend_spec.js
index 2571b7ef869..145c8db28d5 100644
--- a/spec/javascripts/monitoring/graph/legend_spec.js
+++ b/spec/javascripts/monitoring/graph/legend_spec.js
@@ -28,7 +28,7 @@ const defaultValuesComponent = {
   currentDataIndex: 0,
 };
 
-const timeSeries = createTimeSeries(convertedMetrics[0].queries[0],
+const timeSeries = createTimeSeries(convertedMetrics[0].queries,
   defaultValuesComponent.graphWidth, defaultValuesComponent.graphHeight,
   defaultValuesComponent.graphHeightOffset);
 
diff --git a/spec/javascripts/monitoring/graph_path_spec.js b/spec/javascripts/monitoring/graph_path_spec.js
index 81825a3ae87..c83bd19345f 100644
--- a/spec/javascripts/monitoring/graph_path_spec.js
+++ b/spec/javascripts/monitoring/graph_path_spec.js
@@ -13,7 +13,7 @@ const createComponent = (propsData) => {
 
 const convertedMetrics = convertDatesMultipleSeries(singleRowMetricsMultipleSeries);
 
-const timeSeries = createTimeSeries(convertedMetrics[0].queries[0], 428, 272, 120);
+const timeSeries = createTimeSeries(convertedMetrics[0].queries, 428, 272, 120);
 const firstTimeSeries = timeSeries[0];
 
 describe('Monitoring Paths', () => {
@@ -32,4 +32,21 @@ describe('Monitoring Paths', () => {
     expect(metricLine.getAttribute('stroke')).toBe('#1f78d1');
     expect(metricLine.getAttribute('d')).toBe(firstTimeSeries.linePath);
   });
+
+  describe('Computed properties', () => {
+    it('strokeDashArray', () => {
+      const component = createComponent({
+        generatedLinePath: firstTimeSeries.linePath,
+        generatedAreaPath: firstTimeSeries.areaPath,
+        lineColor: firstTimeSeries.lineColor,
+        areaColor: firstTimeSeries.areaColor,
+      });
+
+      component.lineStyle = 'dashed';
+      expect(component.strokeDashArray).toBe('3, 1');
+
+      component.lineStyle = 'dotted';
+      expect(component.strokeDashArray).toBe('1, 1');
+    });
+  });
 });
diff --git a/spec/javascripts/monitoring/utils/multiple_time_series_spec.js b/spec/javascripts/monitoring/utils/multiple_time_series_spec.js
index 7e44a9ade9e..99584c75287 100644
--- a/spec/javascripts/monitoring/utils/multiple_time_series_spec.js
+++ b/spec/javascripts/monitoring/utils/multiple_time_series_spec.js
@@ -2,7 +2,7 @@ import createTimeSeries from '~/monitoring/utils/multiple_time_series';
 import { convertDatesMultipleSeries, singleRowMetricsMultipleSeries } from '../mock_data';
 
 const convertedMetrics = convertDatesMultipleSeries(singleRowMetricsMultipleSeries);
-const timeSeries = createTimeSeries(convertedMetrics[0].queries[0], 428, 272, 120);
+const timeSeries = createTimeSeries(convertedMetrics[0].queries, 428, 272, 120);
 const firstTimeSeries = timeSeries[0];
 
 describe('Multiple time series', () => {
diff --git a/spec/javascripts/notes/components/issue_comment_form_spec.js b/spec/javascripts/notes/components/issue_comment_form_spec.js
index a26fc8f63cc..db75262b562 100644
--- a/spec/javascripts/notes/components/issue_comment_form_spec.js
+++ b/spec/javascripts/notes/components/issue_comment_form_spec.js
@@ -55,6 +55,25 @@ describe('issue_comment_form component', () => {
 
         expect(vm.toggleIssueState).toHaveBeenCalled();
       });
+
+      it('should disable action button whilst submitting', (done) => {
+        const saveNotePromise = Promise.resolve();
+        vm.note = 'hello world';
+        spyOn(vm, 'saveNote').and.returnValue(saveNotePromise);
+        spyOn(vm, 'stopPolling');
+
+        const actionButton = vm.$el.querySelector('.js-action-button');
+
+        vm.handleSave();
+
+        Vue.nextTick()
+          .then(() => expect(actionButton.disabled).toBeTruthy())
+          .then(saveNotePromise)
+          .then(Vue.nextTick)
+          .then(() => expect(actionButton.disabled).toBeFalsy())
+          .then(done)
+          .catch(done.fail);
+      });
     });
 
     describe('textarea', () => {
diff --git a/spec/javascripts/pipelines/navigation_tabs_spec.js b/spec/javascripts/pipelines/navigation_tabs_spec.js
index 53a88e6322f..f125a2fa189 100644
--- a/spec/javascripts/pipelines/navigation_tabs_spec.js
+++ b/spec/javascripts/pipelines/navigation_tabs_spec.js
@@ -8,120 +8,48 @@ describe('navigation tabs pipeline component', () => {
   let data;
 
   beforeEach(() => {
-    data = {
-      scope: 'all',
-      count: {
-        all: 16,
-        running: 1,
-        pending: 10,
-        finished: 0,
+    data = [
+      {
+        name: 'All',
+        scope: 'all',
+        count: 1,
+        isActive: true,
+      },
+      {
+        name: 'Pending',
+        scope: 'pending',
+        count: 0,
+        isActive: false,
       },
-      paths: {
-        allPath: '/gitlab-org/gitlab-ce/pipelines',
-        pendingPath: '/gitlab-org/gitlab-ce/pipelines?scope=pending',
-        finishedPath: '/gitlab-org/gitlab-ce/pipelines?scope=finished',
-        runningPath: '/gitlab-org/gitlab-ce/pipelines?scope=running',
-        branchesPath: '/gitlab-org/gitlab-ce/pipelines?scope=branches',
-        tagsPath: '/gitlab-org/gitlab-ce/pipelines?scope=tags',
+      {
+        name: 'Running',
+        scope: 'running',
+        isActive: false,
       },
-    };
+    ];
 
     Component = Vue.extend(navigationTabs);
+    vm = mountComponent(Component, { tabs: data });
   });
 
   afterEach(() => {
     vm.$destroy();
   });
 
-  it('should render tabs with correct paths', () => {
-    vm = mountComponent(Component, data);
-
-    // All
-    const allTab = vm.$el.querySelector('.js-pipelines-tab-all a');
-    expect(allTab.textContent.trim()).toContain('All');
-    expect(allTab.getAttribute('href')).toEqual(data.paths.allPath);
-
-    // Pending
-    const pendingTab = vm.$el.querySelector('.js-pipelines-tab-pending a');
-    expect(pendingTab.textContent.trim()).toContain('Pending');
-    expect(pendingTab.getAttribute('href')).toEqual(data.paths.pendingPath);
-
-    // Running
-    const runningTab = vm.$el.querySelector('.js-pipelines-tab-running a');
-    expect(runningTab.textContent.trim()).toContain('Running');
-    expect(runningTab.getAttribute('href')).toEqual(data.paths.runningPath);
-
-    // Finished
-    const finishedTab = vm.$el.querySelector('.js-pipelines-tab-finished a');
-    expect(finishedTab.textContent.trim()).toContain('Finished');
-    expect(finishedTab.getAttribute('href')).toEqual(data.paths.finishedPath);
-
-    // Branches
-    const branchesTab = vm.$el.querySelector('.js-pipelines-tab-branches a');
-    expect(branchesTab.textContent.trim()).toContain('Branches');
-
-    // Tags
-    const tagsTab = vm.$el.querySelector('.js-pipelines-tab-tags a');
-    expect(tagsTab.textContent.trim()).toContain('Tags');
+  it('should render tabs', () => {
+    expect(vm.$el.querySelectorAll('li').length).toEqual(data.length);
   });
 
-  describe('scope', () => {
-    it('should render scope provided as active tab', () => {
-      vm = mountComponent(Component, data);
-      expect(vm.$el.querySelector('.js-pipelines-tab-all').className).toContain('active');
-    });
+  it('should render active tab', () => {
+    expect(vm.$el.querySelector('.active .js-pipelines-tab-all')).toBeDefined();
   });
 
-  describe('badges', () => {
-    it('should render provided number', () => {
-      vm = mountComponent(Component, data);
-      // All
-      expect(
-        vm.$el.querySelector('.js-totalbuilds-count').textContent.trim(),
-      ).toContain(data.count.all);
-
-      // Pending
-      expect(
-        vm.$el.querySelector('.js-pipelines-tab-pending .badge').textContent.trim(),
-      ).toContain(data.count.pending);
-
-      // Running
-      expect(
-        vm.$el.querySelector('.js-pipelines-tab-running .badge').textContent.trim(),
-      ).toContain(data.count.running);
-
-      // Finished
-      expect(
-        vm.$el.querySelector('.js-pipelines-tab-finished .badge').textContent.trim(),
-      ).toContain(data.count.finished);
-    });
-
-    it('should not render badge when number is undefined', () => {
-      vm = mountComponent(Component, {
-        scope: 'all',
-        paths: {},
-        count: {},
-      });
-
-       // All
-      expect(
-        vm.$el.querySelector('.js-totalbuilds-count'),
-      ).toEqual(null);
-
-      // Pending
-      expect(
-        vm.$el.querySelector('.js-pipelines-tab-pending .badge'),
-      ).toEqual(null);
-
-      // Running
-      expect(
-        vm.$el.querySelector('.js-pipelines-tab-running .badge'),
-      ).toEqual(null);
+  it('should render badge', () => {
+    expect(vm.$el.querySelector('.js-pipelines-tab-all .badge').textContent.trim()).toEqual('1');
+    expect(vm.$el.querySelector('.js-pipelines-tab-pending .badge').textContent.trim()).toEqual('0');
+  });
 
-      // Finished
-      expect(
-        vm.$el.querySelector('.js-pipelines-tab-finished .badge'),
-      ).toEqual(null);
-    });
+  it('should not render badge', () => {
+    expect(vm.$el.querySelector('.js-pipelines-tab-running .badge')).toEqual(null);
   });
 });
diff --git a/spec/javascripts/pipelines/pipelines_spec.js b/spec/javascripts/pipelines/pipelines_spec.js
index c30abb2edb0..ff38bc1974d 100644
--- a/spec/javascripts/pipelines/pipelines_spec.js
+++ b/spec/javascripts/pipelines/pipelines_spec.js
@@ -1,6 +1,7 @@
 import Vue from 'vue';
 import pipelinesComp from '~/pipelines/components/pipelines.vue';
 import Store from '~/pipelines/stores/pipelines_store';
+import mountComponent from '../helpers/vue_mount_component_helper';
 
 describe('Pipelines', () => {
   const jsonFixtureName = 'pipelines/pipelines.json';
@@ -9,26 +10,33 @@ describe('Pipelines', () => {
   preloadFixtures(jsonFixtureName);
 
   let PipelinesComponent;
-  let pipeline;
+  let pipelines;
+  let component;
 
   beforeEach(() => {
     loadFixtures('static/pipelines.html.raw');
-    const pipelines = getJSONFixture(jsonFixtureName).pipelines;
-    pipeline = pipelines.find(p => p.id === 1);
+    pipelines = getJSONFixture(jsonFixtureName);
 
     PipelinesComponent = Vue.extend(pipelinesComp);
   });
 
+  afterEach(() => {
+    component.$destroy();
+  });
+
   describe('successfull request', () => {
     describe('with pipelines', () => {
       const pipelinesInterceptor = (request, next) => {
-        next(request.respondWith(JSON.stringify(pipeline), {
+        next(request.respondWith(JSON.stringify(pipelines), {
           status: 200,
         }));
       };
 
       beforeEach(() => {
         Vue.http.interceptors.push(pipelinesInterceptor);
+        component = mountComponent(PipelinesComponent, {
+          store: new Store(),
+        });
       });
 
       afterEach(() => {
@@ -38,18 +46,71 @@ describe('Pipelines', () => {
       });
 
       it('should render table', (done) => {
-        const component = new PipelinesComponent({
-          propsData: {
-            store: new Store(),
-          },
-        }).$mount();
-
         setTimeout(() => {
           expect(component.$el.querySelector('.table-holder')).toBeDefined();
-          expect(component.$el.querySelector('.realtime-loading')).toBe(null);
+          expect(
+            component.$el.querySelectorAll('.gl-responsive-table-row').length,
+          ).toEqual(pipelines.pipelines.length + 1);
           done();
         });
       });
+
+      it('should render navigation tabs', (done) => {
+        setTimeout(() => {
+          expect(
+            component.$el.querySelector('.js-pipelines-tab-pending').textContent.trim(),
+          ).toContain('Pending');
+          expect(
+            component.$el.querySelector('.js-pipelines-tab-all').textContent.trim(),
+          ).toContain('All');
+          expect(
+            component.$el.querySelector('.js-pipelines-tab-running').textContent.trim(),
+          ).toContain('Running');
+          expect(
+            component.$el.querySelector('.js-pipelines-tab-finished').textContent.trim(),
+          ).toContain('Finished');
+          expect(
+            component.$el.querySelector('.js-pipelines-tab-branches').textContent.trim(),
+          ).toContain('Branches');
+          expect(
+            component.$el.querySelector('.js-pipelines-tab-tags').textContent.trim(),
+          ).toContain('Tags');
+          done();
+        });
+      });
+
+      it('should make an API request when using tabs', (done) => {
+        setTimeout(() => {
+          spyOn(component, 'updateContent');
+          component.$el.querySelector('.js-pipelines-tab-finished').click();
+
+          expect(component.updateContent).toHaveBeenCalledWith({ scope: 'finished', page: '1' });
+          done();
+        });
+      });
+
+      describe('with pagination', () => {
+        it('should make an API request when using pagination', (done) => {
+          setTimeout(() => {
+            spyOn(component, 'updateContent');
+            // Mock pagination
+            component.store.state.pageInfo = {
+              page: 1,
+              total: 10,
+              perPage: 2,
+              nextPage: 2,
+              totalPages: 5,
+            };
+
+            Vue.nextTick(() => {
+              component.$el.querySelector('.js-next-button a').click();
+              expect(component.updateContent).toHaveBeenCalledWith({ scope: 'all', page: '2' });
+
+              done();
+            });
+          });
+        });
+      });
     });
 
     describe('without pipelines', () => {
@@ -70,15 +131,14 @@ describe('Pipelines', () => {
       });
 
       it('should render empty state', (done) => {
-        const component = new PipelinesComponent({
+        component = new PipelinesComponent({
           propsData: {
             store: new Store(),
           },
         }).$mount();
 
         setTimeout(() => {
-          expect(component.$el.querySelector('.empty-state')).toBeDefined();
-          expect(component.$el.querySelector('.realtime-loading')).toBe(null);
+          expect(component.$el.querySelector('.empty-state')).not.toBe(null);
           done();
         });
       });
@@ -103,7 +163,7 @@ describe('Pipelines', () => {
     });
 
     it('should render error state', (done) => {
-      const component = new PipelinesComponent({
+      component = new PipelinesComponent({
         propsData: {
           store: new Store(),
         },
@@ -111,9 +171,50 @@ describe('Pipelines', () => {
 
       setTimeout(() => {
         expect(component.$el.querySelector('.js-pipelines-error-state')).toBeDefined();
-        expect(component.$el.querySelector('.realtime-loading')).toBe(null);
         done();
       });
     });
   });
+
+  describe('updateContent', () => {
+    it('should set given parameters', () => {
+      component = mountComponent(PipelinesComponent, {
+        store: new Store(),
+      });
+      component.updateContent({ scope: 'finished', page: '4' });
+
+      expect(component.page).toEqual('4');
+      expect(component.scope).toEqual('finished');
+      expect(component.requestData.scope).toEqual('finished');
+      expect(component.requestData.page).toEqual('4');
+    });
+  });
+
+  describe('onChangeTab', () => {
+    it('should set page to 1', () => {
+      component = mountComponent(PipelinesComponent, {
+        store: new Store(),
+      });
+
+      spyOn(component, 'updateContent');
+
+      component.onChangeTab('running');
+
+      expect(component.updateContent).toHaveBeenCalledWith({ scope: 'running', page: '1' });
+    });
+  });
+
+  describe('onChangePage', () => {
+    it('should update page and keep scope', () => {
+      component = mountComponent(PipelinesComponent, {
+        store: new Store(),
+      });
+
+      spyOn(component, 'updateContent');
+
+      component.onChangePage(4);
+
+      expect(component.updateContent).toHaveBeenCalledWith({ scope: component.scope, page: '4' });
+    });
+  });
 });
diff --git a/spec/javascripts/repo/components/repo_file_spec.js b/spec/javascripts/repo/components/repo_file_spec.js
index c45f8a18d1f..bf9181fb09c 100644
--- a/spec/javascripts/repo/components/repo_file_spec.js
+++ b/spec/javascripts/repo/components/repo_file_spec.js
@@ -20,7 +20,7 @@ describe('RepoFile', () => {
     resetStore(vm.$store);
   });
 
-  it('renders link, icon, name and last commit details', () => {
+  it('renders link, icon and name', () => {
     const RepoFile = Vue.extend(repoFile);
     vm = new RepoFile({
       store,
@@ -37,10 +37,9 @@ describe('RepoFile', () => {
     expect(vm.$el.querySelector(`.${vm.file.icon}`).style.marginLeft).toEqual('0px');
     expect(name.href).toMatch(`/${vm.file.url}`);
     expect(name.textContent.trim()).toEqual(vm.file.name);
-    expect(vm.$el.querySelector('.commit-message').textContent.trim()).toBe(vm.file.lastCommit.message);
-    expect(vm.$el.querySelector('.commit-update').textContent.trim()).toBe(updated);
     expect(fileIcon.classList.contains(vm.file.icon)).toBeTruthy();
     expect(fileIcon.style.marginLeft).toEqual(`${vm.file.level * 10}px`);
+    expect(vm.$el.querySelectorAll('.animation-container').length).toBe(2);
   });
 
   it('does render if hasFiles is true and is loading tree', () => {
diff --git a/spec/javascripts/repo/helpers.js b/spec/javascripts/repo/helpers.js
index 376c291c64b..820a44992b4 100644
--- a/spec/javascripts/repo/helpers.js
+++ b/spec/javascripts/repo/helpers.js
@@ -12,9 +12,4 @@ export const file = (name = 'name', id = name, type = '') => decorateData({
   url: 'url',
   name,
   path: name,
-  last_commit: {
-    id: '123',
-    message: 'test',
-    committed_date: new Date().toISOString(),
-  },
 });
diff --git a/spec/javascripts/repo/stores/actions/branch_spec.js b/spec/javascripts/repo/stores/actions/branch_spec.js
new file mode 100644
index 00000000000..af9d6835a67
--- /dev/null
+++ b/spec/javascripts/repo/stores/actions/branch_spec.js
@@ -0,0 +1,38 @@
+import store from '~/repo/stores';
+import service from '~/repo/services';
+import { resetStore } from '../../helpers';
+
+describe('Multi-file store branch actions', () => {
+  afterEach(() => {
+    resetStore(store);
+  });
+
+  describe('createNewBranch', () => {
+    beforeEach(() => {
+      spyOn(service, 'createBranch').and.returnValue(Promise.resolve({
+        json: () => ({
+          name: 'testing',
+        }),
+      }));
+      spyOn(history, 'pushState');
+
+      store.state.project.id = 2;
+      store.state.currentBranch = 'testing';
+    });
+
+    it('creates new branch', (done) => {
+      store.dispatch('createNewBranch', 'master')
+        .then(() => {
+          expect(store.state.currentBranch).toBe('testing');
+          expect(service.createBranch).toHaveBeenCalledWith(2, {
+            branch: 'master',
+            ref: 'testing',
+          });
+          expect(history.pushState).toHaveBeenCalled();
+
+          done();
+        })
+        .catch(done.fail);
+    });
+  });
+});
diff --git a/spec/javascripts/repo/stores/actions/file_spec.js b/spec/javascripts/repo/stores/actions/file_spec.js
new file mode 100644
index 00000000000..099c0556e71
--- /dev/null
+++ b/spec/javascripts/repo/stores/actions/file_spec.js
@@ -0,0 +1,417 @@
+import Vue from 'vue';
+import store from '~/repo/stores';
+import service from '~/repo/services';
+import { file, resetStore } from '../../helpers';
+
+describe('Multi-file store file actions', () => {
+  afterEach(() => {
+    resetStore(store);
+  });
+
+  describe('closeFile', () => {
+    let localFile;
+    let getLastCommitDataSpy;
+    let oldGetLastCommitData;
+
+    beforeEach(() => {
+      getLastCommitDataSpy = jasmine.createSpy('getLastCommitData');
+      oldGetLastCommitData = store._actions.getLastCommitData; // eslint-disable-line
+      store._actions.getLastCommitData = [getLastCommitDataSpy]; // eslint-disable-line
+
+      localFile = file();
+      localFile.active = true;
+      localFile.opened = true;
+      localFile.parentTreeUrl = 'parentTreeUrl';
+
+      store.state.openFiles.push(localFile);
+
+      spyOn(history, 'pushState');
+    });
+
+    afterEach(() => {
+      store._actions.getLastCommitData = oldGetLastCommitData; // eslint-disable-line
+    });
+
+    it('closes open files', (done) => {
+      store.dispatch('closeFile', { file: localFile })
+        .then(() => {
+          expect(localFile.opened).toBeFalsy();
+          expect(localFile.active).toBeFalsy();
+          expect(store.state.openFiles.length).toBe(0);
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('does not close file if has changed', (done) => {
+      localFile.changed = true;
+
+      store.dispatch('closeFile', { file: localFile })
+        .then(() => {
+          expect(localFile.opened).toBeTruthy();
+          expect(localFile.active).toBeTruthy();
+          expect(store.state.openFiles.length).toBe(1);
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('does not close file if temp file', (done) => {
+      localFile.tempFile = true;
+
+      store.dispatch('closeFile', { file: localFile })
+        .then(() => {
+          expect(localFile.opened).toBeTruthy();
+          expect(localFile.active).toBeTruthy();
+          expect(store.state.openFiles.length).toBe(1);
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('force closes a changed file', (done) => {
+      localFile.changed = true;
+
+      store.dispatch('closeFile', { file: localFile, force: true })
+        .then(() => {
+          expect(localFile.opened).toBeFalsy();
+          expect(localFile.active).toBeFalsy();
+          expect(store.state.openFiles.length).toBe(0);
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('calls pushState when no open files are left', (done) => {
+      store.dispatch('closeFile', { file: localFile })
+        .then(() => {
+          expect(history.pushState).toHaveBeenCalledWith(jasmine.anything(), '', 'parentTreeUrl');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('sets next file as active', (done) => {
+      const f = file();
+      store.state.openFiles.push(f);
+
+      expect(f.active).toBeFalsy();
+
+      store.dispatch('closeFile', { file: localFile })
+        .then(() => {
+          expect(f.active).toBeTruthy();
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('calls getLastCommitData', (done) => {
+      store.dispatch('closeFile', { file: localFile })
+        .then(() => {
+          expect(getLastCommitDataSpy).toHaveBeenCalled();
+
+          done();
+        }).catch(done.fail);
+    });
+  });
+
+  describe('setFileActive', () => {
+    let scrollToTabSpy;
+    let oldScrollToTab;
+
+    beforeEach(() => {
+      scrollToTabSpy = jasmine.createSpy('scrollToTab');
+      oldScrollToTab = store._actions.scrollToTab; // eslint-disable-line
+      store._actions.scrollToTab = [scrollToTabSpy]; // eslint-disable-line
+    });
+
+    afterEach(() => {
+      store._actions.scrollToTab = oldScrollToTab; // eslint-disable-line
+    });
+
+    it('calls scrollToTab', (done) => {
+      store.dispatch('setFileActive', file())
+        .then(() => {
+          expect(scrollToTabSpy).toHaveBeenCalled();
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('sets the file active', (done) => {
+      const localFile = file();
+
+      store.dispatch('setFileActive', localFile)
+        .then(() => {
+          expect(localFile.active).toBeTruthy();
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('returns early if file is already active', (done) => {
+      const localFile = file();
+      localFile.active = true;
+
+      store.dispatch('setFileActive', localFile)
+        .then(() => {
+          expect(scrollToTabSpy).not.toHaveBeenCalled();
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('sets current active file to not active', (done) => {
+      const localFile = file();
+      localFile.active = true;
+      store.state.openFiles.push(localFile);
+
+      store.dispatch('setFileActive', file())
+        .then(() => {
+          expect(localFile.active).toBeFalsy();
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('resets location.hash for line highlighting', (done) => {
+      location.hash = 'test';
+
+      store.dispatch('setFileActive', file())
+        .then(() => {
+          expect(location.hash).not.toBe('test');
+
+          done();
+        }).catch(done.fail);
+    });
+  });
+
+  describe('getFileData', () => {
+    let localFile = file();
+
+    beforeEach(() => {
+      spyOn(service, 'getFileData').and.returnValue(Promise.resolve({
+        headers: {
+          'page-title': 'testing getFileData',
+        },
+        json: () => Promise.resolve({
+          blame_path: 'blame_path',
+          commits_path: 'commits_path',
+          permalink: 'permalink',
+          raw_path: 'raw_path',
+          binary: false,
+          html: '123',
+          render_error: '',
+        }),
+      }));
+
+      localFile = file();
+      localFile.url = 'getFileDataURL';
+    });
+
+    it('calls the service', (done) => {
+      store.dispatch('getFileData', localFile)
+        .then(() => {
+          expect(service.getFileData).toHaveBeenCalledWith('getFileDataURL');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('sets the file data', (done) => {
+      store.dispatch('getFileData', localFile)
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(localFile.blamePath).toBe('blame_path');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('sets document title', (done) => {
+      store.dispatch('getFileData', localFile)
+        .then(() => {
+          expect(document.title).toBe('testing getFileData');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('sets the file as active', (done) => {
+      store.dispatch('getFileData', localFile)
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(localFile.active).toBeTruthy();
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('adds the file to open files', (done) => {
+      store.dispatch('getFileData', localFile)
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(store.state.openFiles.length).toBe(1);
+          expect(store.state.openFiles[0].name).toBe(localFile.name);
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('toggles the file loading', (done) => {
+      store.dispatch('getFileData', localFile)
+        .then(() => {
+          expect(localFile.loading).toBeTruthy();
+
+          return Vue.nextTick();
+        })
+        .then(() => {
+          expect(localFile.loading).toBeFalsy();
+
+          done();
+        }).catch(done.fail);
+    });
+  });
+
+  describe('getRawFileData', () => {
+    let tmpFile;
+
+    beforeEach(() => {
+      spyOn(service, 'getRawFileData').and.returnValue(Promise.resolve('raw'));
+
+      tmpFile = file();
+    });
+
+    it('calls getRawFileData service method', (done) => {
+      store.dispatch('getRawFileData', tmpFile)
+        .then(() => {
+          expect(service.getRawFileData).toHaveBeenCalledWith(tmpFile);
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('updates file raw data', (done) => {
+      store.dispatch('getRawFileData', tmpFile)
+        .then(() => {
+          expect(tmpFile.raw).toBe('raw');
+
+          done();
+        }).catch(done.fail);
+    });
+  });
+
+  describe('changeFileContent', () => {
+    let tmpFile;
+
+    beforeEach(() => {
+      tmpFile = file();
+    });
+
+    it('updates file content', (done) => {
+      store.dispatch('changeFileContent', {
+        file: tmpFile,
+        content: 'content',
+      })
+      .then(() => {
+        expect(tmpFile.content).toBe('content');
+
+        done();
+      }).catch(done.fail);
+    });
+  });
+
+  describe('createTempFile', () => {
+    beforeEach(() => {
+      document.body.innerHTML += '<div class="flash-container"></div>';
+    });
+
+    afterEach(() => {
+      document.querySelector('.flash-container').remove();
+    });
+
+    it('creates temp file', (done) => {
+      store.dispatch('createTempFile', {
+        tree: store.state,
+        name: 'test',
+      }).then((f) => {
+        expect(f.tempFile).toBeTruthy();
+        expect(store.state.tree.length).toBe(1);
+
+        done();
+      }).catch(done.fail);
+    });
+
+    it('adds tmp file to open files', (done) => {
+      store.dispatch('createTempFile', {
+        tree: store.state,
+        name: 'test',
+      }).then((f) => {
+        expect(store.state.openFiles.length).toBe(1);
+        expect(store.state.openFiles[0].name).toBe(f.name);
+
+        done();
+      }).catch(done.fail);
+    });
+
+    it('sets tmp file as active', (done) => {
+      store.dispatch('createTempFile', {
+        tree: store.state,
+        name: 'test',
+      }).then((f) => {
+        expect(f.active).toBeTruthy();
+
+        done();
+      }).catch(done.fail);
+    });
+
+    it('enters edit mode if file is not base64', (done) => {
+      store.dispatch('createTempFile', {
+        tree: store.state,
+        name: 'test',
+      }).then(() => {
+        expect(store.state.editMode).toBeTruthy();
+
+        done();
+      }).catch(done.fail);
+    });
+
+    it('does not enter edit mode if file is base64', (done) => {
+      store.dispatch('createTempFile', {
+        tree: store.state,
+        name: 'test',
+        base64: true,
+      }).then(() => {
+        expect(store.state.editMode).toBeFalsy();
+
+        done();
+      }).catch(done.fail);
+    });
+
+    it('creates flash message is file already exists', (done) => {
+      store.state.tree.push(file('test', '1', 'blob'));
+
+      store.dispatch('createTempFile', {
+        tree: store.state,
+        name: 'test',
+      }).then(() => {
+        expect(document.querySelector('.flash-alert')).not.toBeNull();
+
+        done();
+      }).catch(done.fail);
+    });
+
+    it('increases level of file', (done) => {
+      store.state.level = 1;
+
+      store.dispatch('createTempFile', {
+        tree: store.state,
+        name: 'test',
+      }).then((f) => {
+        expect(f.level).toBe(2);
+
+        done();
+      }).catch(done.fail);
+    });
+  });
+});
diff --git a/spec/javascripts/repo/stores/actions/tree_spec.js b/spec/javascripts/repo/stores/actions/tree_spec.js
new file mode 100644
index 00000000000..393a797c6a3
--- /dev/null
+++ b/spec/javascripts/repo/stores/actions/tree_spec.js
@@ -0,0 +1,469 @@
+import Vue from 'vue';
+import store from '~/repo/stores';
+import service from '~/repo/services';
+import { file, resetStore } from '../../helpers';
+
+describe('Multi-file store tree actions', () => {
+  afterEach(() => {
+    resetStore(store);
+  });
+
+  describe('getTreeData', () => {
+    beforeEach(() => {
+      spyOn(service, 'getTreeData').and.returnValue(Promise.resolve({
+        headers: {
+          'page-title': 'test',
+        },
+        json: () => Promise.resolve({
+          last_commit_path: 'last_commit_path',
+          parent_tree_url: 'parent_tree_url',
+          path: '/',
+          trees: [{ name: 'tree' }],
+          blobs: [{ name: 'blob' }],
+          submodules: [{ name: 'submodule' }],
+        }),
+      }));
+      spyOn(history, 'pushState');
+
+      Object.assign(store.state.endpoints, {
+        rootEndpoint: 'rootEndpoint',
+      });
+    });
+
+    it('calls service getTreeData', (done) => {
+      store.dispatch('getTreeData')
+        .then(() => {
+          expect(service.getTreeData).toHaveBeenCalledWith('rootEndpoint');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('adds data into tree', (done) => {
+      store.dispatch('getTreeData')
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(store.state.tree.length).toBe(3);
+          expect(store.state.tree[0].type).toBe('tree');
+          expect(store.state.tree[1].type).toBe('submodule');
+          expect(store.state.tree[2].type).toBe('blob');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('sets parent tree URL', (done) => {
+      store.dispatch('getTreeData')
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(store.state.parentTreeUrl).toBe('parent_tree_url');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('sets last commit path', (done) => {
+      store.dispatch('getTreeData')
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(store.state.lastCommitPath).toBe('last_commit_path');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('sets root if not currently at root', (done) => {
+      store.state.isInitialRoot = false;
+
+      store.dispatch('getTreeData')
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(store.state.isInitialRoot).toBeTruthy();
+          expect(store.state.isRoot).toBeTruthy();
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('sets page title', (done) => {
+      store.dispatch('getTreeData')
+        .then(() => {
+          expect(document.title).toBe('test');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('toggles loading', (done) => {
+      store.dispatch('getTreeData')
+        .then(() => {
+          expect(store.state.loading).toBeTruthy();
+
+          return Vue.nextTick();
+        })
+        .then(() => {
+          expect(store.state.loading).toBeFalsy();
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('calls pushState with endpoint', (done) => {
+      store.dispatch('getTreeData')
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(history.pushState).toHaveBeenCalledWith(jasmine.anything(), '', 'rootEndpoint');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('calls getLastCommitData if prevLastCommitPath is not null', (done) => {
+      const getLastCommitDataSpy = jasmine.createSpy('getLastCommitData');
+      const oldGetLastCommitData = store._actions.getLastCommitData; // eslint-disable-line
+      store._actions.getLastCommitData = [getLastCommitDataSpy]; // eslint-disable-line
+      store.state.prevLastCommitPath = 'test';
+
+      store.dispatch('getTreeData')
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(getLastCommitDataSpy).toHaveBeenCalledWith(store.state);
+
+          store._actions.getLastCommitData = oldGetLastCommitData; // eslint-disable-line
+
+          done();
+        }).catch(done.fail);
+    });
+  });
+
+  describe('toggleTreeOpen', () => {
+    let oldGetTreeData;
+    let getTreeDataSpy;
+    let tree;
+
+    beforeEach(() => {
+      getTreeDataSpy = jasmine.createSpy('getTreeData');
+
+      oldGetTreeData = store._actions.getTreeData;  // eslint-disable-line
+      store._actions.getTreeData = [getTreeDataSpy]; // eslint-disable-line
+
+      tree = {
+        opened: false,
+        tree: [],
+      };
+    });
+
+    afterEach(() => {
+      store._actions.getTreeData = oldGetTreeData; // eslint-disable-line
+    });
+
+    it('toggles the tree open', (done) => {
+      store.dispatch('toggleTreeOpen', {
+        endpoint: 'test',
+        tree,
+      }).then(() => {
+        expect(tree.opened).toBeTruthy();
+
+        done();
+      }).catch(done.fail);
+    });
+
+    it('calls getTreeData if tree is closed', (done) => {
+      store.dispatch('toggleTreeOpen', {
+        endpoint: 'test',
+        tree,
+      }).then(() => {
+        expect(getTreeDataSpy).toHaveBeenCalledWith({
+          endpoint: 'test',
+          tree,
+        });
+        expect(store.state.previousUrl).toBe('test');
+
+        done();
+      }).catch(done.fail);
+    });
+
+    it('resets entries tree', (done) => {
+      Object.assign(tree, {
+        opened: true,
+        tree: ['a'],
+      });
+
+      store.dispatch('toggleTreeOpen', {
+        endpoint: 'test',
+        tree,
+      }).then(() => {
+        expect(tree.tree.length).toBe(0);
+
+        done();
+      }).catch(done.fail);
+    });
+
+    it('pushes new state', (done) => {
+      spyOn(history, 'pushState');
+      Object.assign(tree, {
+        opened: true,
+        parentTreeUrl: 'testing',
+      });
+
+      store.dispatch('toggleTreeOpen', {
+        endpoint: 'test',
+        tree,
+      }).then(() => {
+        expect(history.pushState).toHaveBeenCalledWith(jasmine.anything(), '', 'testing');
+
+        done();
+      }).catch(done.fail);
+    });
+  });
+
+  describe('clickedTreeRow', () => {
+    describe('tree', () => {
+      let toggleTreeOpenSpy;
+      let oldToggleTreeOpen;
+
+      beforeEach(() => {
+        toggleTreeOpenSpy = jasmine.createSpy('toggleTreeOpen');
+
+        oldToggleTreeOpen = store._actions.toggleTreeOpen; // eslint-disable-line
+        store._actions.toggleTreeOpen = [toggleTreeOpenSpy]; // eslint-disable-line
+      });
+
+      afterEach(() => {
+        store._actions.toggleTreeOpen = oldToggleTreeOpen; // eslint-disable-line
+      });
+
+      it('opens tree', (done) => {
+        const tree = {
+          url: 'a',
+          type: 'tree',
+        };
+
+        store.dispatch('clickedTreeRow', tree)
+          .then(() => {
+            expect(toggleTreeOpenSpy).toHaveBeenCalledWith({
+              endpoint: tree.url,
+              tree,
+            });
+
+            done();
+          }).catch(done.fail);
+      });
+    });
+
+    describe('submodule', () => {
+      let row;
+
+      beforeEach(() => {
+        spyOn(gl.utils, 'visitUrl');
+
+        row = {
+          url: 'submoduleurl',
+          type: 'submodule',
+          loading: false,
+        };
+      });
+
+      it('toggles loading for row', (done) => {
+        store.dispatch('clickedTreeRow', row)
+          .then(() => {
+            expect(row.loading).toBeTruthy();
+
+            done();
+          }).catch(done.fail);
+      });
+
+      it('opens submodule URL', (done) => {
+        store.dispatch('clickedTreeRow', row)
+          .then(() => {
+            expect(gl.utils.visitUrl).toHaveBeenCalledWith('submoduleurl');
+
+            done();
+          }).catch(done.fail);
+      });
+    });
+
+    describe('blob', () => {
+      let row;
+
+      beforeEach(() => {
+        row = {
+          type: 'blob',
+          opened: false,
+        };
+      });
+
+      it('calls getFileData', (done) => {
+        const getFileDataSpy = jasmine.createSpy('getFileData');
+        const oldGetFileData = store._actions.getFileData; // eslint-disable-line
+        store._actions.getFileData = [getFileDataSpy]; // eslint-disable-line
+
+        store.dispatch('clickedTreeRow', row)
+          .then(() => {
+            expect(getFileDataSpy).toHaveBeenCalledWith(row);
+
+            store._actions.getFileData = oldGetFileData; // eslint-disable-line
+
+            done();
+          }).catch(done.fail);
+      });
+
+      it('calls setFileActive when file is opened', (done) => {
+        const setFileActiveSpy = jasmine.createSpy('setFileActive');
+        const oldSetFileActive = store._actions.setFileActive; // eslint-disable-line
+        store._actions.setFileActive = [setFileActiveSpy]; // eslint-disable-line
+
+        row.opened = true;
+
+        store.dispatch('clickedTreeRow', row)
+          .then(() => {
+            expect(setFileActiveSpy).toHaveBeenCalledWith(row);
+
+            store._actions.setFileActive = oldSetFileActive; // eslint-disable-line
+
+            done();
+          }).catch(done.fail);
+      });
+    });
+  });
+
+  describe('createTempTree', () => {
+    it('creates temp tree', (done) => {
+      store.dispatch('createTempTree', 'test')
+        .then(() => {
+          expect(store.state.tree[0].tempFile).toBeTruthy();
+          expect(store.state.tree[0].name).toBe('test');
+          expect(store.state.tree[0].type).toBe('tree');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('creates .gitkeep file in temp tree', (done) => {
+      store.dispatch('createTempTree', 'test')
+        .then(() => {
+          expect(store.state.tree[0].tree[0].tempFile).toBeTruthy();
+          expect(store.state.tree[0].tree[0].name).toBe('.gitkeep');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('creates new folder inside another tree', (done) => {
+      const tree = {
+        type: 'tree',
+        name: 'testing',
+        tree: [],
+      };
+
+      store.state.tree.push(tree);
+
+      store.dispatch('createTempTree', 'testing/test')
+        .then(() => {
+          expect(store.state.tree[0].name).toBe('testing');
+          expect(store.state.tree[0].tree[0].tempFile).toBeTruthy();
+          expect(store.state.tree[0].tree[0].name).toBe('test');
+          expect(store.state.tree[0].tree[0].type).toBe('tree');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('does not create new tree if already exists', (done) => {
+      const tree = {
+        type: 'tree',
+        name: 'testing',
+        tree: [],
+      };
+
+      store.state.tree.push(tree);
+
+      store.dispatch('createTempTree', 'testing/test')
+        .then(() => {
+          expect(store.state.tree[0].name).toBe('testing');
+          expect(store.state.tree[0].tempFile).toBeUndefined();
+
+          done();
+        }).catch(done.fail);
+    });
+  });
+
+  describe('getLastCommitData', () => {
+    beforeEach(() => {
+      spyOn(service, 'getTreeLastCommit').and.returnValue(Promise.resolve({
+        headers: {
+          'more-logs-url': null,
+        },
+        json: () => Promise.resolve([{
+          type: 'tree',
+          file_name: 'testing',
+          commit: {
+            message: 'commit message',
+            authored_date: '123',
+          },
+        }]),
+      }));
+
+      store.state.tree.push(file('testing', '1', 'tree'));
+      store.state.lastCommitPath = 'lastcommitpath';
+    });
+
+    it('calls service with lastCommitPath', (done) => {
+      store.dispatch('getLastCommitData')
+        .then(() => {
+          expect(service.getTreeLastCommit).toHaveBeenCalledWith('lastcommitpath');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('updates trees last commit data', (done) => {
+      store.dispatch('getLastCommitData')
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(store.state.tree[0].lastCommit.message).toBe('commit message');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('does not update entry if not found', (done) => {
+      store.state.tree[0].name = 'a';
+
+      store.dispatch('getLastCommitData')
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(store.state.tree[0].lastCommit.message).not.toBe('commit message');
+
+          done();
+        }).catch(done.fail);
+    });
+  });
+
+  describe('updateDirectoryData', () => {
+    it('adds data into tree', (done) => {
+      const tree = {
+        tree: [],
+      };
+      const data = {
+        trees: [{ name: 'tree' }],
+        submodules: [{ name: 'submodule' }],
+        blobs: [{ name: 'blob' }],
+      };
+
+      store.dispatch('updateDirectoryData', {
+        data,
+        tree,
+      }).then(() => {
+        expect(tree.tree[0].name).toBe('tree');
+        expect(tree.tree[0].type).toBe('tree');
+        expect(tree.tree[1].name).toBe('submodule');
+        expect(tree.tree[1].type).toBe('submodule');
+        expect(tree.tree[2].name).toBe('blob');
+        expect(tree.tree[2].type).toBe('blob');
+
+        done();
+      }).catch(done.fail);
+    });
+  });
+});
diff --git a/spec/javascripts/repo/stores/actions_spec.js b/spec/javascripts/repo/stores/actions_spec.js
new file mode 100644
index 00000000000..f2a7a698912
--- /dev/null
+++ b/spec/javascripts/repo/stores/actions_spec.js
@@ -0,0 +1,419 @@
+import Vue from 'vue';
+import store from '~/repo/stores';
+import service from '~/repo/services';
+import { resetStore, file } from '../helpers';
+
+describe('Multi-file store actions', () => {
+  afterEach(() => {
+    resetStore(store);
+  });
+
+  describe('redirectToUrl', () => {
+    it('calls visitUrl', (done) => {
+      spyOn(gl.utils, 'visitUrl');
+
+      store.dispatch('redirectToUrl', 'test')
+        .then(() => {
+          expect(gl.utils.visitUrl).toHaveBeenCalledWith('test');
+
+          done();
+        })
+        .catch(done.fail);
+    });
+  });
+
+  describe('setInitialData', () => {
+    it('commits initial data', (done) => {
+      store.dispatch('setInitialData', { canCommit: true })
+        .then(() => {
+          expect(store.state.canCommit).toBeTruthy();
+          done();
+        })
+        .catch(done.fail);
+    });
+  });
+
+  describe('closeDiscardPopup', () => {
+    it('closes the discard popup', (done) => {
+      store.dispatch('closeDiscardPopup', false)
+        .then(() => {
+          expect(store.state.discardPopupOpen).toBeFalsy();
+
+          done();
+        })
+        .catch(done.fail);
+    });
+  });
+
+  describe('discardAllChanges', () => {
+    beforeEach(() => {
+      store.state.openFiles.push(file());
+      store.state.openFiles[0].changed = true;
+    });
+  });
+
+  describe('closeAllFiles', () => {
+    beforeEach(() => {
+      store.state.openFiles.push(file());
+      store.state.openFiles[0].opened = true;
+    });
+
+    it('closes all open files', (done) => {
+      store.dispatch('closeAllFiles')
+        .then(() => {
+          expect(store.state.openFiles.length).toBe(0);
+
+          done();
+        })
+        .catch(done.fail);
+    });
+  });
+
+  describe('toggleEditMode', () => {
+    it('toggles edit mode', (done) => {
+      store.state.editMode = true;
+
+      store.dispatch('toggleEditMode')
+        .then(() => {
+          expect(store.state.editMode).toBeFalsy();
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('sets preview mode', (done) => {
+      store.state.currentBlobView = 'repo-editor';
+      store.state.editMode = true;
+
+      store.dispatch('toggleEditMode')
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(store.state.currentBlobView).toBe('repo-preview');
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('opens discard popup if there are changed files', (done) => {
+      store.state.editMode = true;
+      store.state.openFiles.push(file());
+      store.state.openFiles[0].changed = true;
+
+      store.dispatch('toggleEditMode')
+        .then(() => {
+          expect(store.state.discardPopupOpen).toBeTruthy();
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('can force closed if there are changed files', (done) => {
+      store.state.editMode = true;
+      store.state.openFiles.push(file());
+      store.state.openFiles[0].changed = true;
+
+      store.dispatch('toggleEditMode', true)
+        .then(() => {
+          expect(store.state.discardPopupOpen).toBeFalsy();
+          expect(store.state.editMode).toBeFalsy();
+
+          done();
+        }).catch(done.fail);
+    });
+
+    it('discards file changes', (done) => {
+      const f = file();
+      store.state.editMode = true;
+      store.state.tree.push(f);
+      store.state.openFiles.push(f);
+      f.changed = true;
+
+      store.dispatch('toggleEditMode', true)
+        .then(Vue.nextTick)
+        .then(() => {
+          expect(f.changed).toBeFalsy();
+
+          done();
+        }).catch(done.fail);
+    });
+  });
+
+  describe('toggleBlobView', () => {
+    it('sets edit mode view if in edit mode', (done) => {
+      store.state.editMode = true;
+
+      store.dispatch('toggleBlobView')
+        .then(() => {
+          expect(store.state.currentBlobView).toBe('repo-editor');
+
+          done();
+        })
+        .catch(done.fail);
+    });
+
+    it('sets preview mode view if not in edit mode', (done) => {
+      store.dispatch('toggleBlobView')
+      .then(() => {
+        expect(store.state.currentBlobView).toBe('repo-preview');
+
+        done();
+      })
+      .catch(done.fail);
+    });
+  });
+
+  describe('checkCommitStatus', () => {
+    beforeEach(() => {
+      store.state.project.id = 2;
+      store.state.currentBranch = 'master';
+      store.state.currentRef = '1';
+    });
+
+    it('calls service', (done) => {
+      spyOn(service, 'getBranchData').and.returnValue(Promise.resolve({
+        commit: { id: '123' },
+      }));
+
+      store.dispatch('checkCommitStatus')
+        .then(() => {
+          expect(service.getBranchData).toHaveBeenCalledWith(2, 'master');
+
+          done();
+        })
+        .catch(done.fail);
+    });
+
+    it('returns true if current ref does not equal returned ID', (done) => {
+      spyOn(service, 'getBranchData').and.returnValue(Promise.resolve({
+        commit: { id: '123' },
+      }));
+
+      store.dispatch('checkCommitStatus')
+        .then((val) => {
+          expect(val).toBeTruthy();
+
+          done();
+        })
+        .catch(done.fail);
+    });
+
+    it('returns false if current ref equals returned ID', (done) => {
+      spyOn(service, 'getBranchData').and.returnValue(Promise.resolve({
+        commit: { id: '1' },
+      }));
+
+      store.dispatch('checkCommitStatus')
+        .then((val) => {
+          expect(val).toBeFalsy();
+
+          done();
+        })
+        .catch(done.fail);
+    });
+  });
+
+  describe('commitChanges', () => {
+    let payload;
+
+    beforeEach(() => {
+      spyOn(window, 'scrollTo');
+
+      document.body.innerHTML += '<div class="flash-container"></div>';
+
+      store.state.project.id = 123;
+      payload = {
+        branch: 'master',
+      };
+    });
+
+    afterEach(() => {
+      document.querySelector('.flash-container').remove();
+    });
+
+    describe('success', () => {
+      beforeEach(() => {
+        spyOn(service, 'commit').and.returnValue(Promise.resolve({
+          id: '123456',
+          short_id: '123',
+          message: 'test message',
+          committed_date: 'date',
+          stats: {
+            additions: '1',
+            deletions: '2',
+          },
+        }));
+      });
+
+      it('calls service', (done) => {
+        store.dispatch('commitChanges', { payload, newMr: false })
+          .then(() => {
+            expect(service.commit).toHaveBeenCalledWith(123, payload);
+
+            done();
+          }).catch(done.fail);
+      });
+
+      it('shows flash notice', (done) => {
+        store.dispatch('commitChanges', { payload, newMr: false })
+          .then(() => {
+            const alert = document.querySelector('.flash-container');
+
+            expect(alert.querySelector('.flash-notice')).not.toBeNull();
+            expect(alert.textContent.trim()).toBe(
+              'Your changes have been committed. Commit 123 with 1 additions, 2 deletions.',
+            );
+
+            done();
+          }).catch(done.fail);
+      });
+
+      it('adds commit data to changed files', (done) => {
+        const changedFile = file();
+        const f = file();
+        changedFile.changed = true;
+
+        store.state.openFiles.push(changedFile, f);
+
+        store.dispatch('commitChanges', { payload, newMr: false })
+          .then(() => {
+            expect(changedFile.lastCommit.message).toBe('test message');
+            expect(f.lastCommit.message).not.toBe('test message');
+
+            done();
+          }).catch(done.fail);
+      });
+
+      it('toggles edit mode', (done) => {
+        store.state.editMode = true;
+
+        store.dispatch('commitChanges', { payload, newMr: false })
+          .then(() => {
+            expect(store.state.editMode).toBeFalsy();
+
+            done();
+          }).catch(done.fail);
+      });
+
+      it('closes all files', (done) => {
+        store.state.openFiles.push(file());
+        store.state.openFiles[0].opened = true;
+
+        store.dispatch('commitChanges', { payload, newMr: false })
+          .then(Vue.nextTick)
+          .then(() => {
+            expect(store.state.openFiles.length).toBe(0);
+
+            done();
+          }).catch(done.fail);
+      });
+
+      it('scrolls to top of page', (done) => {
+        store.dispatch('commitChanges', { payload, newMr: false })
+          .then(() => {
+            expect(window.scrollTo).toHaveBeenCalledWith(0, 0);
+
+            done();
+          }).catch(done.fail);
+      });
+
+      it('updates commit ref', (done) => {
+        store.dispatch('commitChanges', { payload, newMr: false })
+          .then(() => {
+            expect(store.state.currentRef).toBe('123456');
+
+            done();
+          }).catch(done.fail);
+      });
+
+      it('redirects to new merge request page', (done) => {
+        spyOn(gl.utils, 'visitUrl');
+
+        store.state.endpoints.newMergeRequestUrl = 'newMergeRequestUrl?branch=';
+
+        store.dispatch('commitChanges', { payload, newMr: true })
+          .then(() => {
+            expect(gl.utils.visitUrl).toHaveBeenCalledWith('newMergeRequestUrl?branch=master');
+
+            done();
+          }).catch(done.fail);
+      });
+    });
+
+    describe('failed', () => {
+      beforeEach(() => {
+        spyOn(service, 'commit').and.returnValue(Promise.resolve({
+          message: 'failed message',
+        }));
+      });
+
+      it('shows failed message', (done) => {
+        store.dispatch('commitChanges', { payload, newMr: false })
+          .then(() => {
+            const alert = document.querySelector('.flash-container');
+
+            expect(alert.textContent.trim()).toBe(
+              'failed message',
+            );
+
+            done();
+          }).catch(done.fail);
+      });
+    });
+  });
+
+  describe('createTempEntry', () => {
+    it('creates a temp tree', (done) => {
+      store.dispatch('createTempEntry', {
+        name: 'test',
+        type: 'tree',
+      })
+      .then(() => {
+        expect(store.state.tree.length).toBe(1);
+        expect(store.state.tree[0].tempFile).toBeTruthy();
+        expect(store.state.tree[0].type).toBe('tree');
+
+        done();
+      })
+      .catch(done.fail);
+    });
+
+    it('creates temp file', (done) => {
+      store.dispatch('createTempEntry', {
+        name: 'test',
+        type: 'blob',
+      })
+      .then(() => {
+        expect(store.state.tree.length).toBe(1);
+        expect(store.state.tree[0].tempFile).toBeTruthy();
+        expect(store.state.tree[0].type).toBe('blob');
+
+        done();
+      })
+      .catch(done.fail);
+    });
+  });
+
+  describe('popHistoryState', () => {
+
+  });
+
+  describe('scrollToTab', () => {
+    it('focuses the current active element', (done) => {
+      document.body.innerHTML += '<div id="tabs"><div class="active"><div class="repo-tab"></div></div></div>';
+      const el = document.querySelector('.repo-tab');
+      spyOn(el, 'focus');
+
+      store.dispatch('scrollToTab')
+        .then(() => {
+          setTimeout(() => {
+            expect(el.focus).toHaveBeenCalled();
+
+            document.getElementById('tabs').remove();
+
+            done();
+          });
+        })
+        .catch(done.fail);
+    });
+  });
+});
diff --git a/spec/javascripts/repo/stores/getters_spec.js b/spec/javascripts/repo/stores/getters_spec.js
new file mode 100644
index 00000000000..a204b2386cd
--- /dev/null
+++ b/spec/javascripts/repo/stores/getters_spec.js
@@ -0,0 +1,119 @@
+import * as getters from '~/repo/stores/getters';
+import state from '~/repo/stores/state';
+import { file } from '../helpers';
+
+describe('Multi-file store getters', () => {
+  let localState;
+
+  beforeEach(() => {
+    localState = state();
+  });
+
+  describe('treeList', () => {
+    it('returns flat tree list', () => {
+      localState.tree.push(file('1'));
+      localState.tree[0].tree.push(file('2'));
+      localState.tree[0].tree[0].tree.push(file('3'));
+
+      const treeList = getters.treeList(localState);
+
+      expect(treeList.length).toBe(3);
+      expect(treeList[1].name).toBe(localState.tree[0].tree[0].name);
+      expect(treeList[2].name).toBe(localState.tree[0].tree[0].tree[0].name);
+    });
+  });
+
+  describe('changedFiles', () => {
+    it('returns a list of changed opened files', () => {
+      localState.openFiles.push(file());
+      localState.openFiles.push(file('changed'));
+      localState.openFiles[1].changed = true;
+
+      const changedFiles = getters.changedFiles(localState);
+
+      expect(changedFiles.length).toBe(1);
+      expect(changedFiles[0].name).toBe('changed');
+    });
+  });
+
+  describe('activeFile', () => {
+    it('returns the current active file', () => {
+      localState.openFiles.push(file());
+      localState.openFiles.push(file('active'));
+      localState.openFiles[1].active = true;
+
+      expect(getters.activeFile(localState).name).toBe('active');
+    });
+
+    it('returns undefined if no active files are found', () => {
+      localState.openFiles.push(file());
+      localState.openFiles.push(file('active'));
+
+      expect(getters.activeFile(localState)).toBeUndefined();
+    });
+  });
+
+  describe('activeFileExtension', () => {
+    it('returns the file extension for the current active file', () => {
+      localState.openFiles.push(file('active'));
+      localState.openFiles[0].active = true;
+      localState.openFiles[0].path = 'test.js';
+
+      expect(getters.activeFileExtension(localState)).toBe('.js');
+
+      localState.openFiles[0].path = 'test.es6.js';
+
+      expect(getters.activeFileExtension(localState)).toBe('.js');
+    });
+  });
+
+  describe('isCollapsed', () => {
+    it('returns true if state has open files', () => {
+      localState.openFiles.push(file());
+
+      expect(getters.isCollapsed(localState)).toBeTruthy();
+    });
+
+    it('returns false if state has no open files', () => {
+      expect(getters.isCollapsed(localState)).toBeFalsy();
+    });
+  });
+
+  describe('canEditFile', () => {
+    beforeEach(() => {
+      localState.onTopOfBranch = true;
+      localState.canCommit = true;
+
+      localState.openFiles.push(file());
+      localState.openFiles[0].active = true;
+    });
+
+    it('returns true if user can commit and has open files', () => {
+      expect(getters.canEditFile(localState)).toBeTruthy();
+    });
+
+    it('returns false if user can commit and has no open files', () => {
+      localState.openFiles = [];
+
+      expect(getters.canEditFile(localState)).toBeFalsy();
+    });
+
+    it('returns false if user can commit and active file is binary', () => {
+      localState.openFiles[0].binary = true;
+
+      expect(getters.canEditFile(localState)).toBeFalsy();
+    });
+
+    it('returns false if user cant commit', () => {
+      localState.canCommit = false;
+
+      expect(getters.canEditFile(localState)).toBeFalsy();
+    });
+
+    it('returns false if user can commit but on a branch', () => {
+      localState.onTopOfBranch = false;
+
+      expect(getters.canEditFile(localState)).toBeFalsy();
+    });
+  });
+});
diff --git a/spec/javascripts/repo/stores/mutations/branch_spec.js b/spec/javascripts/repo/stores/mutations/branch_spec.js
new file mode 100644
index 00000000000..3c06794d5e3
--- /dev/null
+++ b/spec/javascripts/repo/stores/mutations/branch_spec.js
@@ -0,0 +1,18 @@
+import mutations from '~/repo/stores/mutations/branch';
+import state from '~/repo/stores/state';
+
+describe('Multi-file store branch mutations', () => {
+  let localState;
+
+  beforeEach(() => {
+    localState = state();
+  });
+
+  describe('SET_CURRENT_BRANCH', () => {
+    it('sets currentBranch', () => {
+      mutations.SET_CURRENT_BRANCH(localState, 'master');
+
+      expect(localState.currentBranch).toBe('master');
+    });
+  });
+});
diff --git a/spec/javascripts/repo/stores/mutations/file_spec.js b/spec/javascripts/repo/stores/mutations/file_spec.js
new file mode 100644
index 00000000000..2f2835dde1f
--- /dev/null
+++ b/spec/javascripts/repo/stores/mutations/file_spec.js
@@ -0,0 +1,131 @@
+import mutations from '~/repo/stores/mutations/file';
+import state from '~/repo/stores/state';
+import { file } from '../../helpers';
+
+describe('Multi-file store file mutations', () => {
+  let localState;
+  let localFile;
+
+  beforeEach(() => {
+    localState = state();
+    localFile = file();
+  });
+
+  describe('SET_FILE_ACTIVE', () => {
+    it('sets the file active', () => {
+      mutations.SET_FILE_ACTIVE(localState, {
+        file: localFile,
+        active: true,
+      });
+
+      expect(localFile.active).toBeTruthy();
+    });
+  });
+
+  describe('TOGGLE_FILE_OPEN', () => {
+    beforeEach(() => {
+      mutations.TOGGLE_FILE_OPEN(localState, localFile);
+    });
+
+    it('adds into opened files', () => {
+      expect(localFile.opened).toBeTruthy();
+      expect(localState.openFiles.length).toBe(1);
+    });
+
+    it('removes from opened files', () => {
+      mutations.TOGGLE_FILE_OPEN(localState, localFile);
+
+      expect(localFile.opened).toBeFalsy();
+      expect(localState.openFiles.length).toBe(0);
+    });
+  });
+
+  describe('SET_FILE_DATA', () => {
+    it('sets extra file data', () => {
+      mutations.SET_FILE_DATA(localState, {
+        data: {
+          blame_path: 'blame',
+          commits_path: 'commits',
+          permalink: 'permalink',
+          raw_path: 'raw',
+          binary: true,
+          html: 'html',
+          render_error: 'render_error',
+        },
+        file: localFile,
+      });
+
+      expect(localFile.blamePath).toBe('blame');
+      expect(localFile.commitsPath).toBe('commits');
+      expect(localFile.permalink).toBe('permalink');
+      expect(localFile.rawPath).toBe('raw');
+      expect(localFile.binary).toBeTruthy();
+      expect(localFile.html).toBe('html');
+      expect(localFile.renderError).toBe('render_error');
+    });
+  });
+
+  describe('SET_FILE_RAW_DATA', () => {
+    it('sets raw data', () => {
+      mutations.SET_FILE_RAW_DATA(localState, {
+        file: localFile,
+        raw: 'testing',
+      });
+
+      expect(localFile.raw).toBe('testing');
+    });
+  });
+
+  describe('UPDATE_FILE_CONTENT', () => {
+    beforeEach(() => {
+      localFile.raw = 'test';
+    });
+
+    it('sets content', () => {
+      mutations.UPDATE_FILE_CONTENT(localState, {
+        file: localFile,
+        content: 'test',
+      });
+
+      expect(localFile.content).toBe('test');
+    });
+
+    it('sets changed if content does not match raw', () => {
+      mutations.UPDATE_FILE_CONTENT(localState, {
+        file: localFile,
+        content: 'testing',
+      });
+
+      expect(localFile.content).toBe('testing');
+      expect(localFile.changed).toBeTruthy();
+    });
+  });
+
+  describe('DISCARD_FILE_CHANGES', () => {
+    beforeEach(() => {
+      localFile.content = 'test';
+      localFile.changed = true;
+    });
+
+    it('resets content and changed', () => {
+      mutations.DISCARD_FILE_CHANGES(localState, localFile);
+
+      expect(localFile.content).toBe('');
+      expect(localFile.changed).toBeFalsy();
+    });
+  });
+
+  describe('CREATE_TMP_FILE', () => {
+    it('adds file into parent tree', () => {
+      const f = file();
+
+      mutations.CREATE_TMP_FILE(localState, {
+        file: f,
+        parent: localFile,
+      });
+
+      expect(localFile.tree.length).toBe(1);
+      expect(localFile.tree[0].name).toBe(f.name);
+    });
+  });
+});
diff --git a/spec/javascripts/repo/stores/mutations/tree_spec.js b/spec/javascripts/repo/stores/mutations/tree_spec.js
new file mode 100644
index 00000000000..1c76cfed9c8
--- /dev/null
+++ b/spec/javascripts/repo/stores/mutations/tree_spec.js
@@ -0,0 +1,71 @@
+import mutations from '~/repo/stores/mutations/tree';
+import state from '~/repo/stores/state';
+import { file } from '../../helpers';
+
+describe('Multi-file store tree mutations', () => {
+  let localState;
+  let localTree;
+
+  beforeEach(() => {
+    localState = state();
+    localTree = file();
+  });
+
+  describe('TOGGLE_TREE_OPEN', () => {
+    it('toggles tree open', () => {
+      mutations.TOGGLE_TREE_OPEN(localState, localTree);
+
+      expect(localTree.opened).toBeTruthy();
+
+      mutations.TOGGLE_TREE_OPEN(localState, localTree);
+
+      expect(localTree.opened).toBeFalsy();
+    });
+  });
+
+  describe('SET_DIRECTORY_DATA', () => {
+    const data = [{
+      name: 'tree',
+    },
+    {
+      name: 'submodule',
+    },
+    {
+      name: 'blob',
+    }];
+
+    it('adds directory data', () => {
+      mutations.SET_DIRECTORY_DATA(localState, {
+        data,
+        tree: localState,
+      });
+
+      expect(localState.tree.length).toBe(3);
+      expect(localState.tree[0].name).toBe('tree');
+      expect(localState.tree[1].name).toBe('submodule');
+      expect(localState.tree[2].name).toBe('blob');
+    });
+  });
+
+  describe('SET_PARENT_TREE_URL', () => {
+    it('sets the parent tree url', () => {
+      mutations.SET_PARENT_TREE_URL(localState, 'test');
+
+      expect(localState.parentTreeUrl).toBe('test');
+    });
+  });
+
+  describe('CREATE_TMP_TREE', () => {
+    it('adds tree into parent tree', () => {
+      const tmpEntry = file();
+
+      mutations.CREATE_TMP_TREE(localState, {
+        tmpEntry,
+        parent: localTree,
+      });
+
+      expect(localTree.tree.length).toBe(1);
+      expect(localTree.tree[0].name).toBe(tmpEntry.name);
+    });
+  });
+});
diff --git a/spec/javascripts/repo/stores/mutations_spec.js b/spec/javascripts/repo/stores/mutations_spec.js
new file mode 100644
index 00000000000..d1c9885e01d
--- /dev/null
+++ b/spec/javascripts/repo/stores/mutations_spec.js
@@ -0,0 +1,117 @@
+import mutations from '~/repo/stores/mutations';
+import state from '~/repo/stores/state';
+import { file } from '../helpers';
+
+describe('Multi-file store mutations', () => {
+  let localState;
+  let entry;
+
+  beforeEach(() => {
+    localState = state();
+    entry = file();
+  });
+
+  describe('SET_INITIAL_DATA', () => {
+    it('sets all initial data', () => {
+      mutations.SET_INITIAL_DATA(localState, {
+        test: 'test',
+      });
+
+      expect(localState.test).toBe('test');
+    });
+  });
+
+  describe('SET_PREVIEW_MODE', () => {
+    it('sets currentBlobView to repo-preview', () => {
+      mutations.SET_PREVIEW_MODE(localState);
+
+      expect(localState.currentBlobView).toBe('repo-preview');
+
+      localState.currentBlobView = 'testing';
+
+      mutations.SET_PREVIEW_MODE(localState);
+
+      expect(localState.currentBlobView).toBe('repo-preview');
+    });
+  });
+
+  describe('SET_EDIT_MODE', () => {
+    it('sets currentBlobView to repo-editor', () => {
+      mutations.SET_EDIT_MODE(localState);
+
+      expect(localState.currentBlobView).toBe('repo-editor');
+
+      localState.currentBlobView = 'testing';
+
+      mutations.SET_EDIT_MODE(localState);
+
+      expect(localState.currentBlobView).toBe('repo-editor');
+    });
+  });
+
+  describe('TOGGLE_LOADING', () => {
+    it('toggles loading of entry', () => {
+      mutations.TOGGLE_LOADING(localState, entry);
+
+      expect(entry.loading).toBeTruthy();
+
+      mutations.TOGGLE_LOADING(localState, entry);
+
+      expect(entry.loading).toBeFalsy();
+    });
+  });
+
+  describe('TOGGLE_EDIT_MODE', () => {
+    it('toggles editMode', () => {
+      mutations.TOGGLE_EDIT_MODE(localState);
+
+      expect(localState.editMode).toBeTruthy();
+
+      mutations.TOGGLE_EDIT_MODE(localState);
+
+      expect(localState.editMode).toBeFalsy();
+    });
+  });
+
+  describe('TOGGLE_DISCARD_POPUP', () => {
+    it('sets discardPopupOpen', () => {
+      mutations.TOGGLE_DISCARD_POPUP(localState, true);
+
+      expect(localState.discardPopupOpen).toBeTruthy();
+
+      mutations.TOGGLE_DISCARD_POPUP(localState, false);
+
+      expect(localState.discardPopupOpen).toBeFalsy();
+    });
+  });
+
+  describe('SET_COMMIT_REF', () => {
+    it('sets currentRef', () => {
+      mutations.SET_COMMIT_REF(localState, '123');
+
+      expect(localState.currentRef).toBe('123');
+    });
+  });
+
+  describe('SET_ROOT', () => {
+    it('sets isRoot & initialRoot', () => {
+      mutations.SET_ROOT(localState, true);
+
+      expect(localState.isRoot).toBeTruthy();
+      expect(localState.isInitialRoot).toBeTruthy();
+
+      mutations.SET_ROOT(localState, false);
+
+      expect(localState.isRoot).toBeFalsy();
+      expect(localState.isInitialRoot).toBeFalsy();
+    });
+  });
+
+  describe('SET_PREVIOUS_URL', () => {
+    it('sets previousUrl', () => {
+      mutations.SET_PREVIOUS_URL(localState, 'testing');
+
+      expect(localState.previousUrl).toBe('testing');
+    });
+  });
+});
diff --git a/spec/javascripts/repo/stores/utils_spec.js b/spec/javascripts/repo/stores/utils_spec.js
new file mode 100644
index 00000000000..37287c587d7
--- /dev/null
+++ b/spec/javascripts/repo/stores/utils_spec.js
@@ -0,0 +1,102 @@
+import * as utils from '~/repo/stores/utils';
+
+describe('Multi-file store utils', () => {
+  describe('setPageTitle', () => {
+    it('sets the document page title', () => {
+      utils.setPageTitle('test');
+
+      expect(document.title).toBe('test');
+    });
+  });
+
+  describe('pushState', () => {
+    it('calls history.pushState', () => {
+      spyOn(history, 'pushState');
+
+      utils.pushState('test');
+
+      expect(history.pushState).toHaveBeenCalledWith({ url: 'test' }, '', 'test');
+    });
+  });
+
+  describe('createTemp', () => {
+    it('creates temp tree', () => {
+      const tmp = utils.createTemp({
+        name: 'test',
+        path: 'test',
+        type: 'tree',
+        level: 0,
+        changed: false,
+        content: '',
+        base64: '',
+      });
+
+      expect(tmp.tempFile).toBeTruthy();
+      expect(tmp.icon).toBe('fa-folder');
+    });
+
+    it('creates temp file', () => {
+      const tmp = utils.createTemp({
+        name: 'test',
+        path: 'test',
+        type: 'blob',
+        level: 0,
+        changed: false,
+        content: '',
+        base64: '',
+      });
+
+      expect(tmp.tempFile).toBeTruthy();
+      expect(tmp.icon).toBe('fa-file-text-o');
+    });
+  });
+
+  describe('findIndexOfFile', () => {
+    let state;
+
+    beforeEach(() => {
+      state = [{
+        path: '1',
+      }, {
+        path: '2',
+      }];
+    });
+
+    it('finds in the index of an entry by path', () => {
+      const index = utils.findIndexOfFile(state, {
+        path: '2',
+      });
+
+      expect(index).toBe(1);
+    });
+  });
+
+  describe('findEntry', () => {
+    let state;
+
+    beforeEach(() => {
+      state = {
+        tree: [{
+          type: 'tree',
+          name: 'test',
+        }, {
+          type: 'blob',
+          name: 'file',
+        }],
+      };
+    });
+
+    it('returns an entry found by name', () => {
+      const foundEntry = utils.findEntry(state, 'tree', 'test');
+
+      expect(foundEntry.type).toBe('tree');
+      expect(foundEntry.name).toBe('test');
+    });
+
+    it('returns undefined when no entry found', () => {
+      const foundEntry = utils.findEntry(state, 'blob', 'test');
+
+      expect(foundEntry).toBeUndefined();
+    });
+  });
+});
diff --git a/spec/javascripts/search_autocomplete_spec.js b/spec/javascripts/search_autocomplete_spec.js
index 5e55a5d2686..a2394857b82 100644
--- a/spec/javascripts/search_autocomplete_spec.js
+++ b/spec/javascripts/search_autocomplete_spec.js
@@ -57,6 +57,10 @@ import '~/lib/utils/common_utils';
     }
   };
 
+  const disableProjectIssues = function() {
+    document.querySelector('.js-search-project-options').setAttribute('data-issues-disabled', true);
+  };
+
   // Mock `gl` object in window for dashboard specific page. App code will need it.
   mockDashboardOptions = function() {
     window.gl || (window.gl = {});
@@ -91,18 +95,20 @@ import '~/lib/utils/common_utils';
 
   assertLinks = function(list, issuesPath, mrsPath) {
     var a1, a2, a3, a4, issuesAssignedToMeLink, issuesIHaveCreatedLink, mrsAssignedToMeLink, mrsIHaveCreatedLink;
-    issuesAssignedToMeLink = issuesPath + "/?assignee_username=" + userName;
-    issuesIHaveCreatedLink = issuesPath + "/?author_username=" + userName;
+    if (issuesPath) {
+      issuesAssignedToMeLink = issuesPath + "/?assignee_username=" + userName;
+      issuesIHaveCreatedLink = issuesPath + "/?author_username=" + userName;
+      a1 = "a[href='" + issuesAssignedToMeLink + "']";
+      a2 = "a[href='" + issuesIHaveCreatedLink + "']";
+      expect(list.find(a1).length).toBe(1);
+      expect(list.find(a1).text()).toBe('Issues assigned to me');
+      expect(list.find(a2).length).toBe(1);
+      expect(list.find(a2).text()).toBe("Issues I've created");
+    }
     mrsAssignedToMeLink = mrsPath + "/?assignee_username=" + userName;
     mrsIHaveCreatedLink = mrsPath + "/?author_username=" + userName;
-    a1 = "a[href='" + issuesAssignedToMeLink + "']";
-    a2 = "a[href='" + issuesIHaveCreatedLink + "']";
     a3 = "a[href='" + mrsAssignedToMeLink + "']";
     a4 = "a[href='" + mrsIHaveCreatedLink + "']";
-    expect(list.find(a1).length).toBe(1);
-    expect(list.find(a1).text()).toBe('Issues assigned to me');
-    expect(list.find(a2).length).toBe(1);
-    expect(list.find(a2).text()).toBe("Issues I've created");
     expect(list.find(a3).length).toBe(1);
     expect(list.find(a3).text()).toBe('Merge requests assigned to me');
     expect(list.find(a4).length).toBe(1);
@@ -153,6 +159,14 @@ import '~/lib/utils/common_utils';
       list = widget.wrap.find('.dropdown-menu').find('ul');
       return assertLinks(list, projectIssuesPath, projectMRsPath);
     });
+    it('should show only Project mergeRequest dropdown menu items when project issues are disabled', function() {
+      addBodyAttributes('project');
+      disableProjectIssues();
+      mockProjectOptions();
+      widget.searchInput.triggerHandler('focus');
+      const list = widget.wrap.find('.dropdown-menu').find('ul');
+      assertLinks(list, null, projectMRsPath);
+    });
     it('should not show category related menu if there is text in the input', function() {
       var link, list;
       addBodyAttributes('project');
diff --git a/spec/javascripts/shortcuts_issuable_spec.js b/spec/javascripts/shortcuts_issuable_spec.js
index f6320db8dc4..5d6a885d4cc 100644
--- a/spec/javascripts/shortcuts_issuable_spec.js
+++ b/spec/javascripts/shortcuts_issuable_spec.js
@@ -1,6 +1,8 @@
-import '~/copy_as_gfm';
+import initCopyAsGFM from '~/behaviors/copy_as_gfm';
 import ShortcutsIssuable from '~/shortcuts_issuable';
 
+initCopyAsGFM();
+
 describe('ShortcutsIssuable', () => {
   const fixtureName = 'merge_requests/diff_comment.html.raw';
   preloadFixtures(fixtureName);
diff --git a/spec/javascripts/sidebar/sidebar_service_spec.js b/spec/javascripts/sidebar/sidebar_service_spec.js
deleted file mode 100644
index 7324d34d84a..00000000000
--- a/spec/javascripts/sidebar/sidebar_service_spec.js
+++ /dev/null
@@ -1,66 +0,0 @@
-import Vue from 'vue';
-import SidebarService from '~/sidebar/services/sidebar_service';
-import Mock from './mock_data';
-
-describe('Sidebar service', () => {
-  beforeEach(() => {
-    Vue.http.interceptors.push(Mock.sidebarMockInterceptor);
-    this.service = new SidebarService({
-      endpoint: '/gitlab-org/gitlab-shell/issues/5.json',
-      toggleSubscriptionEndpoint: '/gitlab-org/gitlab-shell/issues/5/toggle_subscription',
-      moveIssueEndpoint: '/gitlab-org/gitlab-shell/issues/5/move',
-      projectsAutocompleteEndpoint: '/autocomplete/projects?project_id=15',
-    });
-  });
-
-  afterEach(() => {
-    SidebarService.singleton = null;
-    Vue.http.interceptors = _.without(Vue.http.interceptors, Mock.sidebarMockInterceptor);
-  });
-
-  it('gets the data', (done) => {
-    this.service.get()
-      .then((resp) => {
-        expect(resp).toBeDefined();
-        done();
-      })
-      .then(done)
-      .catch(done.fail);
-  });
-
-  it('updates the data', (done) => {
-    this.service.update('issue[assignee_ids]', [1])
-      .then((resp) => {
-        expect(resp).toBeDefined();
-      })
-      .then(done)
-      .catch(done.fail);
-  });
-
-  it('gets projects for autocomplete', (done) => {
-    this.service.getProjectsAutocomplete()
-      .then((resp) => {
-        expect(resp).toBeDefined();
-      })
-      .then(done)
-      .catch(done.fail);
-  });
-
-  it('moves the issue to another project', (done) => {
-    this.service.moveIssue(123)
-      .then((resp) => {
-        expect(resp).toBeDefined();
-      })
-      .then(done)
-      .catch(done.fail);
-  });
-
-  it('toggles the subscription', (done) => {
-    this.service.toggleSubscription()
-      .then((resp) => {
-        expect(resp).toBeDefined();
-      })
-      .then(done)
-      .catch(done.fail);
-  });
-});
diff --git a/spec/javascripts/smart_interval_spec.js b/spec/javascripts/smart_interval_spec.js
index 7833bf3fb04..1c87fcec245 100644
--- a/spec/javascripts/smart_interval_spec.js
+++ b/spec/javascripts/smart_interval_spec.js
@@ -1,6 +1,6 @@
-import '~/smart_interval';
+import SmartInterval from '~/smart_interval';
 
-(() => {
+describe('SmartInterval', function () {
   const DEFAULT_MAX_INTERVAL = 100;
   const DEFAULT_STARTING_INTERVAL = 5;
   const DEFAULT_SHORT_TIMEOUT = 75;
@@ -9,7 +9,7 @@ import '~/smart_interval';
 
   function createDefaultSmartInterval(config) {
     const defaultParams = {
-      callback: () => {},
+      callback: () => Promise.resolve(),
       startingInterval: DEFAULT_STARTING_INTERVAL,
       maxInterval: DEFAULT_MAX_INTERVAL,
       incrementByFactorOf: DEFAULT_INCREMENT_FACTOR,
@@ -22,158 +22,171 @@ import '~/smart_interval';
       _.extend(defaultParams, config);
     }
 
-    return new gl.SmartInterval(defaultParams);
+    return new SmartInterval(defaultParams);
   }
 
-  describe('SmartInterval', function () {
-    describe('Increment Interval', function () {
-      beforeEach(function () {
-        this.smartInterval = createDefaultSmartInterval();
-      });
+  describe('Increment Interval', function () {
+    beforeEach(function () {
+      this.smartInterval = createDefaultSmartInterval();
+    });
 
-      it('should increment the interval delay', function (done) {
-        const interval = this.smartInterval;
-        setTimeout(() => {
-          const intervalConfig = this.smartInterval.cfg;
-          const iterationCount = 4;
-          const maxIntervalAfterIterations = intervalConfig.startingInterval *
-            (intervalConfig.incrementByFactorOf ** (iterationCount - 1)); // 40
-          const currentInterval = interval.getCurrentInterval();
-
-          // Provide some flexibility for performance of testing environment
-          expect(currentInterval).toBeGreaterThan(intervalConfig.startingInterval);
-          expect(currentInterval <= maxIntervalAfterIterations).toBeTruthy();
-
-          done();
-        }, DEFAULT_SHORT_TIMEOUT); // 4 iterations, increment by 2x = (5 + 10 + 20 + 40)
-      });
+    it('should increment the interval delay', function (done) {
+      const interval = this.smartInterval;
+      setTimeout(() => {
+        const intervalConfig = this.smartInterval.cfg;
+        const iterationCount = 4;
+        const maxIntervalAfterIterations = intervalConfig.startingInterval *
+          (intervalConfig.incrementByFactorOf ** (iterationCount - 1)); // 40
+        const currentInterval = interval.getCurrentInterval();
+
+        // Provide some flexibility for performance of testing environment
+        expect(currentInterval).toBeGreaterThan(intervalConfig.startingInterval);
+        expect(currentInterval <= maxIntervalAfterIterations).toBeTruthy();
+
+        done();
+      }, DEFAULT_SHORT_TIMEOUT); // 4 iterations, increment by 2x = (5 + 10 + 20 + 40)
+    });
 
-      it('should not increment past maxInterval', function (done) {
-        const interval = this.smartInterval;
+    it('should not increment past maxInterval', function (done) {
+      const interval = this.smartInterval;
 
-        setTimeout(() => {
-          const currentInterval = interval.getCurrentInterval();
-          expect(currentInterval).toBe(interval.cfg.maxInterval);
+      setTimeout(() => {
+        const currentInterval = interval.getCurrentInterval();
+        expect(currentInterval).toBe(interval.cfg.maxInterval);
 
-          done();
-        }, DEFAULT_LONG_TIMEOUT);
-      });
+        done();
+      }, DEFAULT_LONG_TIMEOUT);
     });
 
-    describe('Public methods', function () {
-      beforeEach(function () {
-        this.smartInterval = createDefaultSmartInterval();
+    it('does not increment while waiting for callback', function () {
+      jasmine.clock().install();
+
+      const smartInterval = createDefaultSmartInterval({
+        callback: () => new Promise($.noop),
       });
 
-      it('should cancel an interval', function (done) {
-        const interval = this.smartInterval;
+      jasmine.clock().tick(DEFAULT_SHORT_TIMEOUT);
+
+      const oneInterval = smartInterval.cfg.startingInterval * DEFAULT_INCREMENT_FACTOR;
+      expect(smartInterval.getCurrentInterval()).toEqual(oneInterval);
 
-        setTimeout(() => {
-          interval.cancel();
+      jasmine.clock().uninstall();
+    });
+  });
 
-          const intervalId = interval.state.intervalId;
-          const currentInterval = interval.getCurrentInterval();
-          const intervalLowerLimit = interval.cfg.startingInterval;
+  describe('Public methods', function () {
+    beforeEach(function () {
+      this.smartInterval = createDefaultSmartInterval();
+    });
 
-          expect(intervalId).toBeUndefined();
-          expect(currentInterval).toBe(intervalLowerLimit);
+    it('should cancel an interval', function (done) {
+      const interval = this.smartInterval;
 
-          done();
-        }, DEFAULT_SHORT_TIMEOUT);
-      });
+      setTimeout(() => {
+        interval.cancel();
 
-      it('should resume an interval', function (done) {
-        const interval = this.smartInterval;
+        const intervalId = interval.state.intervalId;
+        const currentInterval = interval.getCurrentInterval();
+        const intervalLowerLimit = interval.cfg.startingInterval;
 
-        setTimeout(() => {
-          interval.cancel();
+        expect(intervalId).toBeUndefined();
+        expect(currentInterval).toBe(intervalLowerLimit);
 
-          interval.resume();
+        done();
+      }, DEFAULT_SHORT_TIMEOUT);
+    });
 
-          const intervalId = interval.state.intervalId;
+    it('should resume an interval', function (done) {
+      const interval = this.smartInterval;
 
-          expect(intervalId).toBeTruthy();
+      setTimeout(() => {
+        interval.cancel();
 
-          done();
-        }, DEFAULT_SHORT_TIMEOUT);
-      });
+        interval.resume();
+
+        const intervalId = interval.state.intervalId;
+
+        expect(intervalId).toBeTruthy();
+
+        done();
+      }, DEFAULT_SHORT_TIMEOUT);
     });
+  });
 
-    describe('DOM Events', function () {
-      beforeEach(function () {
-        // This ensures DOM and DOM events are initialized for these specs.
-        setFixtures('<div></div>');
+  describe('DOM Events', function () {
+    beforeEach(function () {
+      // This ensures DOM and DOM events are initialized for these specs.
+      setFixtures('<div></div>');
 
-        this.smartInterval = createDefaultSmartInterval();
-      });
+      this.smartInterval = createDefaultSmartInterval();
+    });
 
-      it('should pause when page is not visible', function (done) {
-        const interval = this.smartInterval;
+    it('should pause when page is not visible', function (done) {
+      const interval = this.smartInterval;
 
-        setTimeout(() => {
-          expect(interval.state.intervalId).toBeTruthy();
+      setTimeout(() => {
+        expect(interval.state.intervalId).toBeTruthy();
 
-          // simulates triggering of visibilitychange event
-          interval.handleVisibilityChange({ target: { visibilityState: 'hidden' } });
+        // simulates triggering of visibilitychange event
+        interval.handleVisibilityChange({ target: { visibilityState: 'hidden' } });
 
-          expect(interval.state.intervalId).toBeUndefined();
-          done();
-        }, DEFAULT_SHORT_TIMEOUT);
-      });
+        expect(interval.state.intervalId).toBeUndefined();
+        done();
+      }, DEFAULT_SHORT_TIMEOUT);
+    });
 
-      it('should change to the hidden interval when page is not visible', function (done) {
-        const HIDDEN_INTERVAL = 1500;
-        const interval = createDefaultSmartInterval({ hiddenInterval: HIDDEN_INTERVAL });
+    it('should change to the hidden interval when page is not visible', function (done) {
+      const HIDDEN_INTERVAL = 1500;
+      const interval = createDefaultSmartInterval({ hiddenInterval: HIDDEN_INTERVAL });
 
-        setTimeout(() => {
-          expect(interval.state.intervalId).toBeTruthy();
-          expect(interval.getCurrentInterval() >= DEFAULT_STARTING_INTERVAL &&
-            interval.getCurrentInterval() <= DEFAULT_MAX_INTERVAL).toBeTruthy();
+      setTimeout(() => {
+        expect(interval.state.intervalId).toBeTruthy();
+        expect(interval.getCurrentInterval() >= DEFAULT_STARTING_INTERVAL &&
+          interval.getCurrentInterval() <= DEFAULT_MAX_INTERVAL).toBeTruthy();
 
-          // simulates triggering of visibilitychange event
-          interval.handleVisibilityChange({ target: { visibilityState: 'hidden' } });
+        // simulates triggering of visibilitychange event
+        interval.handleVisibilityChange({ target: { visibilityState: 'hidden' } });
 
-          expect(interval.state.intervalId).toBeTruthy();
-          expect(interval.getCurrentInterval()).toBe(HIDDEN_INTERVAL);
-          done();
-        }, DEFAULT_SHORT_TIMEOUT);
-      });
+        expect(interval.state.intervalId).toBeTruthy();
+        expect(interval.getCurrentInterval()).toBe(HIDDEN_INTERVAL);
+        done();
+      }, DEFAULT_SHORT_TIMEOUT);
+    });
 
-      it('should resume when page is becomes visible at the previous interval', function (done) {
-        const interval = this.smartInterval;
+    it('should resume when page is becomes visible at the previous interval', function (done) {
+      const interval = this.smartInterval;
 
-        setTimeout(() => {
-          expect(interval.state.intervalId).toBeTruthy();
+      setTimeout(() => {
+        expect(interval.state.intervalId).toBeTruthy();
 
-          // simulates triggering of visibilitychange event
-          interval.handleVisibilityChange({ target: { visibilityState: 'hidden' } });
+        // simulates triggering of visibilitychange event
+        interval.handleVisibilityChange({ target: { visibilityState: 'hidden' } });
 
-          expect(interval.state.intervalId).toBeUndefined();
+        expect(interval.state.intervalId).toBeUndefined();
 
-          // simulates triggering of visibilitychange event
-          interval.handleVisibilityChange({ target: { visibilityState: 'visible' } });
+        // simulates triggering of visibilitychange event
+        interval.handleVisibilityChange({ target: { visibilityState: 'visible' } });
 
-          expect(interval.state.intervalId).toBeTruthy();
+        expect(interval.state.intervalId).toBeTruthy();
 
-          done();
-        }, DEFAULT_SHORT_TIMEOUT);
-      });
+        done();
+      }, DEFAULT_SHORT_TIMEOUT);
+    });
 
-      it('should cancel on page unload', function (done) {
-        const interval = this.smartInterval;
+    it('should cancel on page unload', function (done) {
+      const interval = this.smartInterval;
 
-        setTimeout(() => {
-          $(document).triggerHandler('beforeunload');
-          expect(interval.state.intervalId).toBeUndefined();
-          expect(interval.getCurrentInterval()).toBe(interval.cfg.startingInterval);
-          done();
-        }, DEFAULT_SHORT_TIMEOUT);
-      });
+      setTimeout(() => {
+        $(document).triggerHandler('beforeunload');
+        expect(interval.state.intervalId).toBeUndefined();
+        expect(interval.getCurrentInterval()).toBe(interval.cfg.startingInterval);
+        done();
+      }, DEFAULT_SHORT_TIMEOUT);
+    });
 
-      it('should execute callback before first interval', function () {
-        const interval = createDefaultSmartInterval({ immediateExecution: true });
-        expect(interval.cfg.immediateExecution).toBeFalsy();
-      });
+    it('should execute callback before first interval', function () {
+      const interval = createDefaultSmartInterval({ immediateExecution: true });
+      expect(interval.cfg.immediateExecution).toBeFalsy();
     });
   });
-})(window.gl || (window.gl = {}));
+});
diff --git a/spec/javascripts/test_bundle.js b/spec/javascripts/test_bundle.js
index d4e134583c7..fd7aa332d17 100644
--- a/spec/javascripts/test_bundle.js
+++ b/spec/javascripts/test_bundle.js
@@ -11,6 +11,12 @@ const isHeadlessChrome = /\bHeadlessChrome\//.test(navigator.userAgent);
 Vue.config.devtools = !isHeadlessChrome;
 Vue.config.productionTip = false;
 
+let hasVueWarnings = false;
+Vue.config.warnHandler = (msg, vm, trace) => {
+  hasVueWarnings = true;
+  fail(`${msg}${trace}`);
+};
+
 Vue.use(VueResource);
 
 // enable test fixtures
@@ -34,11 +40,6 @@ window.addEventListener('unhandledrejection', (event) => {
   console.error(event.reason.stack || event.reason);
 });
 
-const checkUnhandledPromiseRejections = (done) => {
-  expect(hasUnhandledPromiseRejections).toBe(false);
-  done();
-};
-
 // HACK: Chrome 59 disconnects if there are too many synchronous tests in a row
 // because it appears to lock up the thread that communicates to Karma's socket
 // This async beforeEach gets called on every spec and releases the JS thread long
@@ -47,17 +48,6 @@ const checkUnhandledPromiseRejections = (done) => {
 // to run our unit tests.
 beforeEach(done => done());
 
-beforeAll(() => {
-  const origError = console.error;
-  spyOn(console, 'error').and.callFake((message) => {
-    if (/^\[Vue warn\]/.test(message)) {
-      fail(message);
-    } else {
-      origError(message);
-    }
-  });
-});
-
 const builtinVueHttpInterceptors = Vue.http.interceptors.slice();
 
 beforeEach(() => {
@@ -80,8 +70,22 @@ testsContext.keys().forEach(function (path) {
   }
 });
 
-it('has no unhandled Promise rejections', (done) => {
-  setTimeout(checkUnhandledPromiseRejections(done), 1000);
+describe('test errors', () => {
+  beforeAll((done) => {
+    if (hasUnhandledPromiseRejections || hasVueWarnings) {
+      setTimeout(done, 1000);
+    } else {
+      done();
+    }
+  });
+
+  it('has no unhandled Promise rejections', () => {
+    expect(hasUnhandledPromiseRejections).toBe(false);
+  });
+
+  it('has no Vue warnings', () => {
+    expect(hasVueWarnings).toBe(false);
+  });
 });
 
 // if we're generating coverage reports, make sure to include all files so
diff --git a/spec/javascripts/vue_mr_widget/components/mr_widget_pipeline_spec.js b/spec/javascripts/vue_mr_widget/components/mr_widget_pipeline_spec.js
index 33ed0cb4342..d7af956c9c1 100644
--- a/spec/javascripts/vue_mr_widget/components/mr_widget_pipeline_spec.js
+++ b/spec/javascripts/vue_mr_widget/components/mr_widget_pipeline_spec.js
@@ -1,140 +1,147 @@
 import Vue from 'vue';
-import pipelineComponent from '~/vue_merge_request_widget/components/mr_widget_pipeline';
+import pipelineComponent from '~/vue_merge_request_widget/components/mr_widget_pipeline.vue';
+import mountComponent from '../../helpers/vue_mount_component_helper';
 import mockData from '../mock_data';
 
-const createComponent = (mr) => {
-  const Component = Vue.extend(pipelineComponent);
-  return new Component({
-    el: document.createElement('div'),
-    propsData: { mr },
-  });
-};
-
 describe('MRWidgetPipeline', () => {
-  describe('props', () => {
-    it('should have props', () => {
-      const { mr } = pipelineComponent.props;
+  let vm;
+  let Component;
 
-      expect(mr.type instanceof Object).toBeTruthy();
-      expect(mr.required).toBeTruthy();
-    });
+  beforeEach(() => {
+    Component = Vue.extend(pipelineComponent);
   });
 
-  describe('components', () => {
-    it('should have components added', () => {
-      expect(pipelineComponent.components['pipeline-stage']).toBeDefined();
-      expect(pipelineComponent.components.ciIcon).toBeDefined();
-    });
+  afterEach(() => {
+    vm.$destroy();
   });
 
   describe('computed', () => {
     describe('hasPipeline', () => {
       it('should return true when there is a pipeline', () => {
-        expect(Object.keys(mockData.pipeline).length).toBeGreaterThan(0);
-
-        const vm = createComponent({
+        vm = mountComponent(Component, {
           pipeline: mockData.pipeline,
+          ciStatus: 'success',
+          hasCi: true,
         });
 
-        expect(vm.hasPipeline).toBeTruthy();
+        expect(vm.hasPipeline).toEqual(true);
       });
 
       it('should return false when there is no pipeline', () => {
-        const vm = createComponent({
-          pipeline: null,
+        vm = mountComponent(Component, {
+          pipeline: {},
         });
 
-        expect(vm.hasPipeline).toBeFalsy();
+        expect(vm.hasPipeline).toEqual(false);
       });
     });
 
     describe('hasCIError', () => {
       it('should return false when there is no CI error', () => {
-        const vm = createComponent({
+        vm = mountComponent(Component, {
           pipeline: mockData.pipeline,
-          hasCI: true,
+          hasCi: true,
           ciStatus: 'success',
         });
 
-        expect(vm.hasCIError).toBeFalsy();
+        expect(vm.hasCIError).toEqual(false);
       });
 
       it('should return true when there is a CI error', () => {
-        const vm = createComponent({
+        vm = mountComponent(Component, {
           pipeline: mockData.pipeline,
-          hasCI: true,
+          hasCi: true,
           ciStatus: null,
         });
 
-        expect(vm.hasCIError).toBeTruthy();
+        expect(vm.hasCIError).toEqual(true);
       });
     });
   });
 
-  describe('template', () => {
-    let vm;
-    let el;
-    const { pipeline } = mockData;
-    const mr = {
-      hasCI: true,
-      ciStatus: 'success',
-      pipelineDetailedStatus: pipeline.details.status,
-      pipeline,
-    };
-
-    beforeEach(() => {
-      vm = createComponent(mr);
-      el = vm.$el;
-    });
+  describe('rendered output', () => {
+    it('should render CI error', () => {
+      vm = mountComponent(Component, {
+        pipeline: mockData.pipeline,
+        hasCi: true,
+        ciStatus: null,
+      });
 
-    it('should render template elements correctly', () => {
-      expect(el.classList.contains('mr-widget-heading')).toBeTruthy();
-      expect(el.querySelectorAll('.ci-status-icon.ci-status-icon-success').length).toEqual(1);
-      expect(el.querySelector('.pipeline-id').textContent).toContain(`#${pipeline.id}`);
-      expect(el.innerText).toContain('passed');
-      expect(el.querySelector('.pipeline-id').getAttribute('href')).toEqual(pipeline.path);
-      expect(el.querySelectorAll('.stage-container').length).toEqual(2);
-      expect(el.querySelector('.js-ci-error')).toEqual(null);
-      expect(el.querySelector('.js-commit-link').getAttribute('href')).toEqual(pipeline.commit.commit_path);
-      expect(el.querySelector('.js-commit-link').textContent).toContain(pipeline.commit.short_id);
-      expect(el.querySelector('.js-mr-coverage').textContent).toContain(`Coverage ${pipeline.coverage}%`);
+      expect(
+        vm.$el.querySelector('.media-body').textContent.trim(),
+      ).toEqual('Could not connect to the CI server. Please check your settings and try again');
     });
 
-    it('should list single stage', (done) => {
-      pipeline.details.stages.splice(0, 1);
+    describe('with a pipeline', () => {
+      beforeEach(() => {
+        vm = mountComponent(Component, {
+          pipeline: mockData.pipeline,
+          hasCi: true,
+          ciStatus: 'success',
+        });
+      });
+
+      it('should render pipeline ID', () => {
+        expect(
+          vm.$el.querySelector('.pipeline-id').textContent.trim(),
+        ).toEqual(`#${mockData.pipeline.id}`);
+      });
+
+      it('should render pipeline status and commit id', () => {
+        expect(
+          vm.$el.querySelector('.media-body').textContent.trim(),
+        ).toContain(mockData.pipeline.details.status.label);
 
-      Vue.nextTick(() => {
-        expect(el.querySelectorAll('.stage-container button').length).toEqual(1);
-        done();
+        expect(
+          vm.$el.querySelector('.js-commit-link').textContent.trim(),
+        ).toEqual(mockData.pipeline.commit.short_id);
+
+        expect(
+          vm.$el.querySelector('.js-commit-link').getAttribute('href'),
+        ).toEqual(mockData.pipeline.commit.commit_path);
       });
-    });
 
-    it('should not have stages when there is no stage', (done) => {
-      vm.mr.pipeline.details.stages = [];
+      it('should render pipeline graph', () => {
+        expect(vm.$el.querySelector('.mr-widget-pipeline-graph')).toBeDefined();
+        expect(vm.$el.querySelectorAll('.stage-container').length).toEqual(mockData.pipeline.details.stages.length);
+      });
 
-      Vue.nextTick(() => {
-        expect(el.querySelectorAll('.stage-container button').length).toEqual(0);
-        done();
+      it('should render coverage information', () => {
+        expect(
+          vm.$el.querySelector('.media-body').textContent,
+        ).toContain(`Coverage ${mockData.pipeline.coverage}`);
       });
     });
 
-    it('should not have coverage text when pipeline has no coverage info', (done) => {
-      vm.mr.pipeline.coverage = null;
+    describe('without coverage', () => {
+      it('should not render a coverage', () => {
+        const mockCopy = Object.assign({}, mockData);
+        delete mockCopy.pipeline.coverage;
 
-      Vue.nextTick(() => {
-        expect(el.querySelector('.js-mr-coverage')).toEqual(null);
-        done();
+        vm = mountComponent(Component, {
+          pipeline: mockCopy.pipeline,
+          hasCi: true,
+          ciStatus: 'success',
+        });
+
+        expect(
+          vm.$el.querySelector('.media-body').textContent,
+        ).not.toContain('Coverage');
       });
     });
 
-    it('should show CI error when there is a CI error', (done) => {
-      vm.mr.ciStatus = null;
+    describe('without a pipeline graph', () => {
+      it('should not render a pipeline graph', () => {
+        const mockCopy = Object.assign({}, mockData);
+        delete mockCopy.pipeline.details.stages;
+
+        vm = mountComponent(Component, {
+          pipeline: mockCopy.pipeline,
+          hasCi: true,
+          ciStatus: 'success',
+        });
 
-      Vue.nextTick(() => {
-        expect(el.querySelectorAll('.js-ci-error').length).toEqual(1);
-        expect(el.innerText).toContain('Could not connect to the CI server');
-        expect(el.querySelector('.ci-status-icon svg use').getAttribute('xlink:href')).toContain('status_failed');
-        done();
+        expect(vm.$el.querySelector('.js-mini-pipeline-graph')).toEqual(null);
       });
     });
   });
diff --git a/spec/javascripts/vue_mr_widget/mock_data.js b/spec/javascripts/vue_mr_widget/mock_data.js
index 0795d0aaa82..1ad7c2d8efa 100644
--- a/spec/javascripts/vue_mr_widget/mock_data.js
+++ b/spec/javascripts/vue_mr_widget/mock_data.js
@@ -202,7 +202,6 @@ export default {
   "revert_in_fork_path": "/root/acets-app/forks?continue%5Bnotice%5D=You%27re+not+allowed+to+make+changes+to+this+project+directly.+A+fork+of+this+project+has+been+created+that+you+can+make+changes+in%2C+so+you+can+submit+a+merge+request.+Try+to+cherry-pick+this+commit+again.&continue%5Bnotice_now%5D=You%27re+not+allowed+to+make+changes+to+this+project+directly.+A+fork+of+this+project+is+being+created+that+you+can+make+changes+in%2C+so+you+can+submit+a+merge+request.&continue%5Bto%5D=%2Froot%2Facets-app%2Fmerge_requests%2F22&namespace_key=1",
   "email_patches_path": "/root/acets-app/merge_requests/22.patch",
   "plain_diff_path": "/root/acets-app/merge_requests/22.diff",
-  "ci_status_path": "/root/acets-app/merge_requests/22/ci_status",
   "status_path": "/root/acets-app/merge_requests/22.json",
   "merge_check_path": "/root/acets-app/merge_requests/22/merge_check",
   "ci_environments_status_url": "/root/acets-app/merge_requests/22/ci_environments_status",
diff --git a/spec/javascripts/vue_mr_widget/mr_widget_options_spec.js b/spec/javascripts/vue_mr_widget/mr_widget_options_spec.js
index e4324e91502..9e6d0aa472c 100644
--- a/spec/javascripts/vue_mr_widget/mr_widget_options_spec.js
+++ b/spec/javascripts/vue_mr_widget/mr_widget_options_spec.js
@@ -1,16 +1,9 @@
 import Vue from 'vue';
-import MRWidgetService from '~/vue_merge_request_widget/services/mr_widget_service';
 import mrWidgetOptions from '~/vue_merge_request_widget/mr_widget_options';
 import eventHub from '~/vue_merge_request_widget/event_hub';
 import notify from '~/lib/utils/notify';
 import mockData from './mock_data';
-
-const createComponent = () => {
-  delete mrWidgetOptions.el; // Prevent component mounting
-  gl.mrWidgetData = mockData;
-  const Component = Vue.extend(mrWidgetOptions);
-  return new Component();
-};
+import mountComponent from '../helpers/vue_mount_component_helper';
 
 const returnPromise = data => new Promise((resolve) => {
   resolve({
@@ -23,9 +16,16 @@ const returnPromise = data => new Promise((resolve) => {
 
 describe('mrWidgetOptions', () => {
   let vm;
+  let MrWidgetOptions;
 
   beforeEach(() => {
-    vm = createComponent();
+    // Prevent component mounting
+    delete mrWidgetOptions.el;
+
+    MrWidgetOptions = Vue.extend(mrWidgetOptions);
+    vm = mountComponent(MrWidgetOptions, {
+      mrData: { ...mockData },
+    });
   });
 
   describe('data', () => {
@@ -78,7 +78,7 @@ describe('mrWidgetOptions', () => {
       });
 
       it('should return true if there is relatedLinks in MR', () => {
-        vm.mr.relatedLinks = {};
+        Vue.set(vm.mr, 'relatedLinks', {});
         expect(vm.shouldRenderRelatedLinks).toBeTruthy();
       });
     });
@@ -121,24 +121,28 @@ describe('mrWidgetOptions', () => {
 
     describe('initPolling', () => {
       it('should call SmartInterval', () => {
-        spyOn(gl, 'SmartInterval').and.returnValue({
-          resume() {},
-          stopTimer() {},
-        });
+        spyOn(vm, 'checkStatus').and.returnValue(Promise.resolve());
+        jasmine.clock().install();
         vm.initPolling();
 
+        expect(vm.checkStatus).not.toHaveBeenCalled();
+
+        jasmine.clock().tick(10000);
+
         expect(vm.pollingInterval).toBeDefined();
-        expect(gl.SmartInterval).toHaveBeenCalled();
+        expect(vm.checkStatus).toHaveBeenCalled();
+
+        jasmine.clock().uninstall();
       });
     });
 
     describe('initDeploymentsPolling', () => {
       it('should call SmartInterval', () => {
-        spyOn(gl, 'SmartInterval');
+        spyOn(vm, 'fetchDeployments').and.returnValue(Promise.resolve());
         vm.initDeploymentsPolling();
 
         expect(vm.deploymentsInterval).toBeDefined();
-        expect(gl.SmartInterval).toHaveBeenCalled();
+        expect(vm.fetchDeployments).toHaveBeenCalled();
       });
     });
 
@@ -312,28 +316,6 @@ describe('mrWidgetOptions', () => {
         expect(vm.pollingInterval.stopTimer).toHaveBeenCalled();
       });
     });
-
-    describe('createService', () => {
-      it('should instantiate a Service', () => {
-        const endpoints = {
-          mergePath: '/nice/path',
-          mergeCheckPath: '/nice/path',
-          cancelAutoMergePath: '/nice/path',
-          removeWIPPath: '/nice/path',
-          sourceBranchPath: '/nice/path',
-          ciEnvironmentsStatusPath: '/nice/path',
-          statusPath: '/nice/path',
-          mergeActionsContentPath: '/nice/path',
-        };
-
-        const serviceInstance = vm.createService(endpoints);
-        const isInstanceOfMRService = serviceInstance instanceof MRWidgetService;
-        expect(isInstanceOfMRService).toBe(true);
-        Object.keys(serviceInstance).forEach((key) => {
-          expect(serviceInstance[key]).toBeDefined();
-        });
-      });
-    });
   });
 
   describe('components', () => {
diff --git a/spec/javascripts/vue_mr_widget/services/mr_widget_service_spec.js b/spec/javascripts/vue_mr_widget/services/mr_widget_service_spec.js
deleted file mode 100644
index e667b4b3677..00000000000
--- a/spec/javascripts/vue_mr_widget/services/mr_widget_service_spec.js
+++ /dev/null
@@ -1,47 +0,0 @@
-import Vue from 'vue';
-import VueResource from 'vue-resource';
-import MRWidgetService from '~/vue_merge_request_widget/services/mr_widget_service';
-
-Vue.use(VueResource);
-
-describe('MRWidgetService', () => {
-  const mr = {
-    mergePath: './',
-    mergeCheckPath: './',
-    cancelAutoMergePath: './',
-    removeWIPPath: './',
-    sourceBranchPath: './',
-    ciEnvironmentsStatusPath: './',
-    statusPath: './',
-    mergeActionsContentPath: './',
-    isServiceStore: true,
-  };
-
-  it('should have store and resources created in constructor', () => {
-    const service = new MRWidgetService(mr);
-
-    expect(service.mergeResource).toBeDefined();
-    expect(service.mergeCheckResource).toBeDefined();
-    expect(service.cancelAutoMergeResource).toBeDefined();
-    expect(service.removeWIPResource).toBeDefined();
-    expect(service.removeSourceBranchResource).toBeDefined();
-    expect(service.deploymentsResource).toBeDefined();
-    expect(service.pollResource).toBeDefined();
-    expect(service.mergeActionsContentResource).toBeDefined();
-  });
-
-  it('should have methods defined', () => {
-    window.history.pushState({}, null, '/');
-    const service = new MRWidgetService(mr);
-
-    expect(service.merge()).toBeDefined();
-    expect(service.cancelAutomaticMerge()).toBeDefined();
-    expect(service.removeWIP()).toBeDefined();
-    expect(service.removeSourceBranch()).toBeDefined();
-    expect(service.fetchDeployments()).toBeDefined();
-    expect(service.poll()).toBeDefined();
-    expect(service.checkStatus()).toBeDefined();
-    expect(service.fetchMergeActionsContent()).toBeDefined();
-    expect(MRWidgetService.stopEnvironment()).toBeDefined();
-  });
-});
diff --git a/spec/javascripts/vue_shared/components/issue/issue_warning_spec.js b/spec/javascripts/vue_shared/components/issue/issue_warning_spec.js
index 2cf4d8e00ed..24484796bf1 100644
--- a/spec/javascripts/vue_shared/components/issue/issue_warning_spec.js
+++ b/spec/javascripts/vue_shared/components/issue/issue_warning_spec.js
@@ -16,7 +16,7 @@ describe('Issue Warning Component', () => {
         isLocked: true,
       });
 
-      expect(vm.$el.querySelector('i').className).toEqual('fa icon fa-lock');
+      expect(vm.$el.querySelector('.icon use').href.baseVal).toMatch(/lock$/);
       expect(formatWarning(vm.$el.querySelector('span').textContent)).toEqual('This issue is locked. Only project members can comment.');
     });
   });
@@ -27,7 +27,7 @@ describe('Issue Warning Component', () => {
         isConfidential: true,
       });
 
-      expect(vm.$el.querySelector('i').className).toEqual('fa icon fa-eye-slash');
+      expect(vm.$el.querySelector('.icon use').href.baseVal).toMatch(/eye-slash$/);
       expect(formatWarning(vm.$el.querySelector('span').textContent)).toEqual('This is a confidential issue. Your comment will not be visible to the public.');
     });
   });
@@ -39,7 +39,7 @@ describe('Issue Warning Component', () => {
         isConfidential: true,
       });
 
-      expect(vm.$el.querySelector('i')).toBeFalsy();
+      expect(vm.$el.querySelector('.icon')).toBeFalsy();
       expect(formatWarning(vm.$el.querySelector('span').textContent)).toEqual('This issue is confidential and locked. People without permission will never get a notification and won\'t be able to comment.');
     });
   });
diff --git a/spec/javascripts/vue_shared/components/loading_button_spec.js b/spec/javascripts/vue_shared/components/loading_button_spec.js
index 97c8a08fcdd..c1eabdede00 100644
--- a/spec/javascripts/vue_shared/components/loading_button_spec.js
+++ b/spec/javascripts/vue_shared/components/loading_button_spec.js
@@ -66,6 +66,23 @@ describe('LoadingButton', function () {
     });
   });
 
+  describe('container class', () => {
+    it('should default to btn btn-align-content', () => {
+      vm = mountComponent(LoadingButton, {});
+      expect(vm.$el.classList.contains('btn')).toEqual(true);
+      expect(vm.$el.classList.contains('btn-align-content')).toEqual(true);
+    });
+
+    it('should be configurable through props', () => {
+      vm = mountComponent(LoadingButton, {
+        containerClass: 'test-class',
+      });
+      expect(vm.$el.classList.contains('btn')).toEqual(false);
+      expect(vm.$el.classList.contains('btn-align-content')).toEqual(false);
+      expect(vm.$el.classList.contains('test-class')).toEqual(true);
+    });
+  });
+
   describe('click callback prop', () => {
     it('calls given callback when normal', () => {
       vm = mountComponent(LoadingButton, {
diff --git a/spec/javascripts/vue_shared/components/markdown/field_spec.js b/spec/javascripts/vue_shared/components/markdown/field_spec.js
index 65c49b9f30b..24209be83fe 100644
--- a/spec/javascripts/vue_shared/components/markdown/field_spec.js
+++ b/spec/javascripts/vue_shared/components/markdown/field_spec.js
@@ -1,6 +1,12 @@
 import Vue from 'vue';
 import fieldComponent from '~/vue_shared/components/markdown/field.vue';
 
+function assertMarkdownTabs(isWrite, writeLink, previewLink, vm) {
+  expect(writeLink.parentNode.classList.contains('active')).toEqual(isWrite);
+  expect(previewLink.parentNode.classList.contains('active')).toEqual(!isWrite);
+  expect(vm.$el.querySelector('.md-preview').style.display).toEqual(isWrite ? 'none' : '');
+}
+
 describe('Markdown field component', () => {
   let vm;
 
@@ -39,6 +45,7 @@ describe('Markdown field component', () => {
 
     describe('markdown preview', () => {
       let previewLink;
+      let writeLink;
 
       beforeEach(() => {
         spyOn(Vue.http, 'post').and.callFake(() => new Promise((resolve) => {
@@ -53,7 +60,8 @@ describe('Markdown field component', () => {
           });
         }));
 
-        previewLink = vm.$el.querySelector('.nav-links li:nth-child(2) a');
+        previewLink = vm.$el.querySelector('.nav-links .js-preview-link');
+        writeLink = vm.$el.querySelector('.nav-links .js-write-link');
       });
 
       it('sets preview link as active', (done) => {
@@ -105,6 +113,23 @@ describe('Markdown field component', () => {
           done();
         }, 0);
       });
+
+      it('clicking already active write or preview link does nothing', (done) => {
+        writeLink.click();
+        Vue.nextTick()
+          .then(() => assertMarkdownTabs(true, writeLink, previewLink, vm))
+          .then(() => writeLink.click())
+          .then(() => Vue.nextTick())
+          .then(() => assertMarkdownTabs(true, writeLink, previewLink, vm))
+          .then(() => previewLink.click())
+          .then(() => Vue.nextTick())
+          .then(() => assertMarkdownTabs(false, writeLink, previewLink, vm))
+          .then(() => previewLink.click())
+          .then(() => Vue.nextTick())
+          .then(() => assertMarkdownTabs(false, writeLink, previewLink, vm))
+          .then(done)
+          .catch(done.fail);
+      });
     });
 
     describe('markdown buttons', () => {
diff --git a/spec/javascripts/vue_shared/components/markdown/header_spec.js b/spec/javascripts/vue_shared/components/markdown/header_spec.js
index 7110ff36937..edebd822295 100644
--- a/spec/javascripts/vue_shared/components/markdown/header_spec.js
+++ b/spec/javascripts/vue_shared/components/markdown/header_spec.js
@@ -43,11 +43,13 @@ describe('Markdown field header component', () => {
   it('emits toggle markdown event when clicking preview', () => {
     spyOn(vm, '$emit');
 
-    vm.$el.querySelector('li:nth-child(2) a').click();
+    vm.$el.querySelector('.js-preview-link').click();
 
-    expect(
-      vm.$emit,
-    ).toHaveBeenCalledWith('toggle-markdown');
+    expect(vm.$emit).toHaveBeenCalledWith('preview-markdown');
+
+    vm.$el.querySelector('.js-write-link').click();
+
+    expect(vm.$emit).toHaveBeenCalledWith('write-markdown');
   });
 
   it('blurs preview link after click', (done) => {
diff --git a/spec/javascripts/vue_shared/components/skeleton_loading_container_spec.js b/spec/javascripts/vue_shared/components/skeleton_loading_container_spec.js
new file mode 100644
index 00000000000..a5db0b2c59e
--- /dev/null
+++ b/spec/javascripts/vue_shared/components/skeleton_loading_container_spec.js
@@ -0,0 +1,49 @@
+import Vue from 'vue';
+import skeletonLoadingContainer from '~/vue_shared/components/skeleton_loading_container.vue';
+import mountComponent from '../../helpers/vue_mount_component_helper';
+
+describe('Skeleton loading container', () => {
+  let vm;
+
+  beforeEach(() => {
+    const component = Vue.extend(skeletonLoadingContainer);
+    vm = mountComponent(component);
+  });
+
+  afterEach(() => {
+    vm.$destroy();
+  });
+
+  it('renders 6 skeleton lines by default', () => {
+    expect(vm.$el.querySelector('.skeleton-line-6')).not.toBeNull();
+  });
+
+  it('renders in full mode by default', () => {
+    expect(vm.$el.classList.contains('animation-container-small')).toBeFalsy();
+  });
+
+  describe('small', () => {
+    beforeEach((done) => {
+      vm.small = true;
+
+      Vue.nextTick(done);
+    });
+
+    it('renders in small mode', () => {
+      expect(vm.$el.classList.contains('animation-container-small')).toBeTruthy();
+    });
+  });
+
+  describe('lines', () => {
+    beforeEach((done) => {
+      vm.lines = 5;
+
+      Vue.nextTick(done);
+    });
+
+    it('renders 5 lines', () => {
+      expect(vm.$el.querySelector('.skeleton-line-5')).not.toBeNull();
+      expect(vm.$el.querySelector('.skeleton-line-6')).toBeNull();
+    });
+  });
+});
diff --git a/spec/lib/banzai/commit_renderer_spec.rb b/spec/lib/banzai/commit_renderer_spec.rb
index 049d025a5b9..84adaebdcbe 100644
--- a/spec/lib/banzai/commit_renderer_spec.rb
+++ b/spec/lib/banzai/commit_renderer_spec.rb
@@ -10,7 +10,7 @@ describe Banzai::CommitRenderer do
 
       described_class::ATTRIBUTES.each do |attr|
         expect_any_instance_of(Banzai::ObjectRenderer).to receive(:render).with([project.commit], attr).once.and_call_original
-        expect(Banzai::Renderer).to receive(:cacheless_render_field).with(project.commit, attr)
+        expect(Banzai::Renderer).to receive(:cacheless_render_field).with(project.commit, attr, {})
       end
 
       described_class.render([project.commit], project, user)
diff --git a/spec/lib/banzai/filter/absolute_link_filter_spec.rb b/spec/lib/banzai/filter/absolute_link_filter_spec.rb
new file mode 100644
index 00000000000..a3ad056efcd
--- /dev/null
+++ b/spec/lib/banzai/filter/absolute_link_filter_spec.rb
@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Banzai::Filter::AbsoluteLinkFilter do
+  def filter(doc, context = {})
+    described_class.call(doc, context)
+  end
+
+  context 'with html links' do
+    context 'if only_path is false' do
+      let(:only_path_context) do
+        { only_path: false }
+      end
+      let(:fake_url) { 'http://www.example.com' }
+
+      before do
+        allow(Gitlab.config.gitlab).to receive(:url).and_return(fake_url)
+      end
+
+      context 'has the .gfm class' do
+        it 'converts a relative url into absolute' do
+          doc = filter(link('/foo', 'gfm'), only_path_context)
+          expect(doc.at_css('a')['href']).to eq "#{fake_url}/foo"
+        end
+
+        it 'does not change the url if it already absolute' do
+          doc = filter(link("#{fake_url}/foo", 'gfm'), only_path_context)
+          expect(doc.at_css('a')['href']).to eq "#{fake_url}/foo"
+        end
+
+        context 'if relative_url_root is set' do
+          it 'joins the url without without doubling the path' do
+            allow(Gitlab.config.gitlab).to receive(:url).and_return("#{fake_url}/gitlab/")
+            doc = filter(link("/gitlab/foo", 'gfm'), only_path_context)
+            expect(doc.at_css('a')['href']).to eq "#{fake_url}/gitlab/foo"
+          end
+        end
+      end
+
+      context 'has not the .gfm class' do
+        it 'does not convert a relative url into absolute' do
+          doc = filter(link('/foo'), only_path_context)
+          expect(doc.at_css('a')['href']).to eq '/foo'
+        end
+      end
+    end
+
+    context 'if only_path is not false' do
+      it 'does not convert a relative url into absolute' do
+        expect(filter(link('/foo', 'gfm')).at_css('a')['href']).to eq '/foo'
+        expect(filter(link('/foo')).at_css('a')['href']).to eq '/foo'
+      end
+    end
+  end
+
+  def link(path, css_class = '')
+    %(<a class="#{css_class}" href="#{path}">example</a>)
+  end
+end
diff --git a/spec/lib/banzai/filter/milestone_reference_filter_spec.rb b/spec/lib/banzai/filter/milestone_reference_filter_spec.rb
index 84578668133..6a9087d2e59 100644
--- a/spec/lib/banzai/filter/milestone_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/milestone_reference_filter_spec.rb
@@ -294,8 +294,7 @@ describe Banzai::Filter::MilestoneReferenceFilter do
     end
   end
 
-  context 'project milestones' do
-    let(:milestone) { create(:milestone, project: project) }
+  shared_context 'project milestones' do
     let(:reference) { milestone.to_reference(format: :iid) }
 
     include_examples 'reference parsing'
@@ -309,8 +308,7 @@ describe Banzai::Filter::MilestoneReferenceFilter do
     it_behaves_like 'cross project shorthand reference'
   end
 
-  context 'group milestones' do
-    let(:milestone) { create(:milestone, group: group) }
+  shared_context 'group milestones' do
     let(:reference) { milestone.to_reference(format: :name) }
 
     include_examples 'reference parsing'
@@ -354,4 +352,32 @@ describe Banzai::Filter::MilestoneReferenceFilter do
       expect(result.css('a').first.attr('href')).to eq(urls.milestone_url(milestone))
     end
   end
+
+  context 'when milestone is open' do
+    context 'project milestones' do
+      let(:milestone) { create(:milestone, project: project) }
+
+      include_context 'project milestones'
+    end
+
+    context 'group milestones' do
+      let(:milestone) { create(:milestone, group: group) }
+
+      include_context 'group milestones'
+    end
+  end
+
+  context 'when milestone is closed' do
+    context 'project milestones' do
+      let(:milestone) { create(:milestone, :closed, project: project) }
+
+      include_context 'project milestones'
+    end
+
+    context 'group milestones' do
+      let(:milestone) { create(:milestone, :closed, group: group) }
+
+      include_context 'group milestones'
+    end
+  end
 end
diff --git a/spec/lib/banzai/note_renderer_spec.rb b/spec/lib/banzai/note_renderer_spec.rb
deleted file mode 100644
index 32764bee5eb..00000000000
--- a/spec/lib/banzai/note_renderer_spec.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Banzai::NoteRenderer do
-  describe '.render' do
-    it 'renders a Note' do
-      note = double(:note)
-      project = double(:project)
-      wiki = double(:wiki)
-      user = double(:user)
-
-      expect(Banzai::ObjectRenderer).to receive(:new)
-        .with(project, user,
-             requested_path: 'foo',
-             project_wiki: wiki,
-             ref: 'bar')
-        .and_call_original
-
-      expect_any_instance_of(Banzai::ObjectRenderer)
-        .to receive(:render).with([note], :note)
-
-      described_class.render([note], project, user, 'foo', wiki, 'bar')
-    end
-  end
-end
diff --git a/spec/lib/banzai/object_renderer_spec.rb b/spec/lib/banzai/object_renderer_spec.rb
index b172a1b718c..074d521a5c6 100644
--- a/spec/lib/banzai/object_renderer_spec.rb
+++ b/spec/lib/banzai/object_renderer_spec.rb
@@ -22,7 +22,7 @@ describe Banzai::ObjectRenderer do
       end
 
       it 'retrieves field content using Banzai::Renderer.render_field' do
-        expect(Banzai::Renderer).to receive(:render_field).with(object, :note).and_call_original
+        expect(Banzai::Renderer).to receive(:render_field).with(object, :note, {}).and_call_original
 
         renderer.render([object], :note)
       end
@@ -68,7 +68,7 @@ describe Banzai::ObjectRenderer do
       end
 
       it 'retrieves field content using Banzai::Renderer.cacheless_render_field' do
-        expect(Banzai::Renderer).to receive(:cacheless_render_field).with(commit, :title).and_call_original
+        expect(Banzai::Renderer).to receive(:cacheless_render_field).with(commit, :title, {}).and_call_original
 
         renderer.render([commit], :title)
       end
diff --git a/spec/lib/banzai/renderer_spec.rb b/spec/lib/banzai/renderer_spec.rb
index 81a04a2d46d..650cecfc778 100644
--- a/spec/lib/banzai/renderer_spec.rb
+++ b/spec/lib/banzai/renderer_spec.rb
@@ -18,7 +18,7 @@ describe Banzai::Renderer do
       let(:commit) { create(:project, :repository).commit }
 
       it 'returns cacheless render field' do
-        expect(renderer).to receive(:cacheless_render_field).with(commit, :title)
+        expect(renderer).to receive(:cacheless_render_field).with(commit, :title, {})
 
         renderer.render_field(commit, :title)
       end
diff --git a/spec/lib/container_registry/path_spec.rb b/spec/lib/container_registry/path_spec.rb
index 84cacdd3f0d..010deae822c 100644
--- a/spec/lib/container_registry/path_spec.rb
+++ b/spec/lib/container_registry/path_spec.rb
@@ -86,6 +86,24 @@ describe ContainerRegistry::Path do
 
       it { is_expected.to be_valid }
     end
+
+    context 'when path contains double underscore' do
+      let(:path) { 'my/repository__name' }
+
+      it { is_expected.to be_valid }
+    end
+
+    context 'when path contains invalid separator with dot' do
+      let(:path) { 'some/registry-.name' }
+
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when path contains invalid separator with underscore' do
+      let(:path) { 'some/registry._name' }
+
+      it { is_expected.not_to be_valid }
+    end
   end
 
   describe '#has_repository?' do
diff --git a/spec/lib/feature_spec.rb b/spec/lib/feature_spec.rb
index 1076c63b5f2..10020511bf8 100644
--- a/spec/lib/feature_spec.rb
+++ b/spec/lib/feature_spec.rb
@@ -13,6 +13,47 @@ describe Feature do
     end
   end
 
+  describe '.persisted_names' do
+    it 'returns the names of the persisted features' do
+      Feature::FlipperFeature.create!(key: 'foo')
+
+      expect(described_class.persisted_names).to eq(%w[foo])
+    end
+
+    it 'returns an empty Array when no features are presisted' do
+      expect(described_class.persisted_names).to be_empty
+    end
+
+    it 'caches the feature names when request store is active', :request_store do
+      Feature::FlipperFeature.create!(key: 'foo')
+
+      expect(Feature::FlipperFeature)
+        .to receive(:feature_names)
+        .once
+        .and_call_original
+
+      2.times do
+        expect(described_class.persisted_names).to eq(%w[foo])
+      end
+    end
+  end
+
+  describe '.persisted?' do
+    it 'returns true for a persisted feature' do
+      Feature::FlipperFeature.create!(key: 'foo')
+
+      feature = double(:feature, name: 'foo')
+
+      expect(described_class.persisted?(feature)).to eq(true)
+    end
+
+    it 'returns false for a feature that is not persisted' do
+      feature = double(:feature, name: 'foo')
+
+      expect(described_class.persisted?(feature)).to eq(false)
+    end
+  end
+
   describe '.all' do
     let(:features) { Set.new }
 
diff --git a/spec/lib/github/client_spec.rb b/spec/lib/github/client_spec.rb
deleted file mode 100644
index b846096fe25..00000000000
--- a/spec/lib/github/client_spec.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe Github::Client do
-  let(:connection) { spy }
-  let(:rate_limit) { double(get: [false, 1]) }
-  let(:client) { described_class.new({}) }
-  let(:results) { double }
-  let(:response) { double }
-
-  before do
-    allow(Faraday).to receive(:new).and_return(connection)
-    allow(Github::RateLimit).to receive(:new).with(connection).and_return(rate_limit)
-  end
-
-  describe '#get' do
-    before do
-      allow(Github::Response).to receive(:new).with(results).and_return(response)
-    end
-
-    it 'uses a default per_page param' do
-      expect(connection).to receive(:get).with('/foo', per_page: 100).and_return(results)
-
-      expect(client.get('/foo')).to eq(response)
-    end
-
-    context 'with per_page given' do
-      it 'overwrites the default per_page' do
-        expect(connection).to receive(:get).with('/foo', per_page: 30).and_return(results)
-
-        expect(client.get('/foo', per_page: 30)).to eq(response)
-      end
-    end
-  end
-end
diff --git a/spec/lib/github/import/legacy_diff_note_spec.rb b/spec/lib/github/import/legacy_diff_note_spec.rb
deleted file mode 100644
index 8c50b46cacb..00000000000
--- a/spec/lib/github/import/legacy_diff_note_spec.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Github::Import::LegacyDiffNote do
-  describe '#type' do
-    it 'returns the original note type' do
-      expect(described_class.new.type).to eq('LegacyDiffNote')
-    end
-  end
-end
diff --git a/spec/lib/github/import/note_spec.rb b/spec/lib/github/import/note_spec.rb
deleted file mode 100644
index fcdccd9e097..00000000000
--- a/spec/lib/github/import/note_spec.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Github::Import::Note do
-  describe '#type' do
-    it 'returns the original note type' do
-      expect(described_class.new.type).to eq('Note')
-    end
-  end
-end
diff --git a/spec/lib/gitlab/auth_spec.rb b/spec/lib/gitlab/auth_spec.rb
index 54a853c9ce3..3164d2ebf04 100644
--- a/spec/lib/gitlab/auth_spec.rb
+++ b/spec/lib/gitlab/auth_spec.rb
@@ -133,6 +133,25 @@ describe Gitlab::Auth do
 
         gl_auth.find_for_git_client(user.username, token, project: nil, ip: 'ip')
       end
+
+      it 'grants deploy key write permissions' do
+        project = create(:project)
+        key = create(:deploy_key, can_push: true)
+        create(:deploy_keys_project, deploy_key: key, project: project)
+        token = Gitlab::LfsToken.new(key).token
+
+        expect(gl_auth).to receive(:rate_limit!).with('ip', success: true, login: "lfs+deploy-key-#{key.id}")
+        expect(gl_auth.find_for_git_client("lfs+deploy-key-#{key.id}", token, project: project, ip: 'ip')).to eq(Gitlab::Auth::Result.new(key, nil, :lfs_deploy_token, read_write_authentication_abilities))
+      end
+
+      it 'does not grant deploy key write permissions' do
+        project = create(:project)
+        key = create(:deploy_key, can_push: true)
+        token = Gitlab::LfsToken.new(key).token
+
+        expect(gl_auth).to receive(:rate_limit!).with('ip', success: true, login: "lfs+deploy-key-#{key.id}")
+        expect(gl_auth.find_for_git_client("lfs+deploy-key-#{key.id}", token, project: project, ip: 'ip')).to eq(Gitlab::Auth::Result.new(key, nil, :lfs_deploy_token, read_authentication_abilities))
+      end
     end
 
     context 'while using OAuth tokens as passwords' do
@@ -326,10 +345,15 @@ describe Gitlab::Auth do
     ]
   end
 
-  def full_authentication_abilities
+  def read_write_authentication_abilities
     read_authentication_abilities + [
       :push_code,
-      :create_container_image,
+      :create_container_image
+    ]
+  end
+
+  def full_authentication_abilities
+    read_write_authentication_abilities + [
       :admin_container_image
     ]
   end
diff --git a/spec/lib/gitlab/background_migration/create_fork_network_memberships_range_spec.rb b/spec/lib/gitlab/background_migration/create_fork_network_memberships_range_spec.rb
index 1a4ea2bac48..79d2c071446 100644
--- a/spec/lib/gitlab/background_migration/create_fork_network_memberships_range_spec.rb
+++ b/spec/lib/gitlab/background_migration/create_fork_network_memberships_range_spec.rb
@@ -93,7 +93,14 @@ describe Gitlab::BackgroundMigration::CreateForkNetworkMembershipsRange, :migrat
   end
 
   it 'knows it is finished for this range' do
-    expect(migration.missing_members?(1, 7)).to be_falsy
+    expect(migration.missing_members?(1, 8)).to be_falsy
+  end
+
+  it 'does not miss members for forks of forks for which the root was deleted' do
+    forked_project_links.create(id: 9, forked_from_project_id: base1_fork1.id, forked_to_project_id: create(:project).id)
+    base1.destroy
+
+    expect(migration.missing_members?(7, 10)).to be_falsy
   end
 
   context 'with more forks' do
diff --git a/spec/lib/gitlab/background_migration/populate_fork_networks_range_spec.rb b/spec/lib/gitlab/background_migration/populate_fork_networks_range_spec.rb
index 2c2684a6fc9..994992f79d4 100644
--- a/spec/lib/gitlab/background_migration/populate_fork_networks_range_spec.rb
+++ b/spec/lib/gitlab/background_migration/populate_fork_networks_range_spec.rb
@@ -3,12 +3,9 @@ require 'spec_helper'
 describe Gitlab::BackgroundMigration::PopulateForkNetworksRange, :migration, schema: 20170929131201 do
   let(:migration) { described_class.new }
   let(:base1) { create(:project) }
-  let(:base1_fork1) { create(:project) }
-  let(:base1_fork2) { create(:project) }
 
   let(:base2) { create(:project) }
   let(:base2_fork1) { create(:project) }
-  let(:base2_fork2) { create(:project) }
 
   let!(:forked_project_links) { table(:forked_project_links) }
   let!(:fork_networks) { table(:fork_networks) }
@@ -21,21 +18,24 @@ describe Gitlab::BackgroundMigration::PopulateForkNetworksRange, :migration, sch
     # A normal fork link
     forked_project_links.create(id: 1,
                                 forked_from_project_id: base1.id,
-                                forked_to_project_id: base1_fork1.id)
+                                forked_to_project_id: create(:project).id)
     forked_project_links.create(id: 2,
                                 forked_from_project_id: base1.id,
-                                forked_to_project_id: base1_fork2.id)
-
+                                forked_to_project_id: create(:project).id)
     forked_project_links.create(id: 3,
                                 forked_from_project_id: base2.id,
                                 forked_to_project_id: base2_fork1.id)
+
+    # create a fork of a fork
     forked_project_links.create(id: 4,
                                 forked_from_project_id: base2_fork1.id,
                                 forked_to_project_id: create(:project).id)
-
     forked_project_links.create(id: 5,
-                                forked_from_project_id: base2.id,
-                                forked_to_project_id: base2_fork2.id)
+                                forked_from_project_id: create(:project).id,
+                                forked_to_project_id: create(:project).id)
+
+    # Stub out the calls to the other migrations
+    allow(BackgroundMigrationWorker).to receive(:perform_in)
 
     migration.perform(1, 3)
   end
@@ -80,11 +80,11 @@ describe Gitlab::BackgroundMigration::PopulateForkNetworksRange, :migration, sch
   end
 
   it 'only processes a single batch of links at a time' do
-    expect(fork_network_members.count).to eq(5)
+    expect(fork_networks.count).to eq(2)
 
     migration.perform(3, 5)
 
-    expect(fork_network_members.count).to eq(7)
+    expect(fork_networks.count).to eq(3)
   end
 
   it 'can be repeated without effect' do
diff --git a/spec/migrations/populate_merge_requests_latest_merge_request_diff_id_spec.rb b/spec/lib/gitlab/background_migration/populate_merge_requests_latest_merge_request_diff_id_spec.rb
index 4ea7f441f7c..0cb753c5853 100644
--- a/spec/migrations/populate_merge_requests_latest_merge_request_diff_id_spec.rb
+++ b/spec/lib/gitlab/background_migration/populate_merge_requests_latest_merge_request_diff_id_spec.rb
@@ -1,7 +1,6 @@
 require 'spec_helper'
-require Rails.root.join('db', 'post_migrate', '20171026082505_populate_merge_requests_latest_merge_request_diff_id')
 
-describe PopulateMergeRequestsLatestMergeRequestDiffId, :migration do
+describe Gitlab::BackgroundMigration::PopulateMergeRequestsLatestMergeRequestDiffId, :migration, schema: 20171026082505 do
   let(:projects_table) { table(:projects) }
   let(:merge_requests_table) { table(:merge_requests) }
   let(:merge_request_diffs_table) { table(:merge_request_diffs) }
@@ -27,30 +26,32 @@ describe PopulateMergeRequestsLatestMergeRequestDiffId, :migration do
     merge_request_diffs_table.where(merge_request_id: merge_request.id)
   end
 
-  describe '#up' do
+  describe '#perform' do
     it 'ignores MRs without diffs' do
       merge_request_without_diff = create_mr!('without_diff')
+      mr_id = merge_request_without_diff.id
 
       expect(merge_request_without_diff.latest_merge_request_diff_id).to be_nil
 
-      expect { migrate! }
+      expect { subject.perform(mr_id, mr_id) }
         .not_to change { merge_request_without_diff.reload.latest_merge_request_diff_id }
     end
 
     it 'ignores MRs that have a diff ID already set' do
       merge_request_with_multiple_diffs = create_mr!('with_multiple_diffs', diffs: 3)
       diff_id = diffs_for(merge_request_with_multiple_diffs).minimum(:id)
+      mr_id = merge_request_with_multiple_diffs.id
 
       merge_request_with_multiple_diffs.update!(latest_merge_request_diff_id: diff_id)
 
-      expect { migrate! }
+      expect { subject.perform(mr_id, mr_id) }
         .not_to change { merge_request_with_multiple_diffs.reload.latest_merge_request_diff_id }
     end
 
     it 'migrates multiple MR diffs to the correct values' do
       merge_requests = Array.new(3).map.with_index { |_, i| create_mr!(i, diffs: 3) }
 
-      migrate!
+      subject.perform(merge_requests.first.id, merge_requests.last.id)
 
       merge_requests.each do |merge_request|
         expect(merge_request.reload.latest_merge_request_diff_id)
diff --git a/spec/lib/gitlab/bare_repository_import/importer_spec.rb b/spec/lib/gitlab/bare_repository_import/importer_spec.rb
new file mode 100644
index 00000000000..7f3bf5fc41c
--- /dev/null
+++ b/spec/lib/gitlab/bare_repository_import/importer_spec.rb
@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe Gitlab::BareRepositoryImport::Importer, repository: true do
+  let!(:admin) { create(:admin) }
+  let!(:base_dir) { Dir.mktmpdir + '/' }
+  let(:bare_repository) { Gitlab::BareRepositoryImport::Repository.new(base_dir, File.join(base_dir, "#{project_path}.git")) }
+
+  subject(:importer) { described_class.new(admin, bare_repository) }
+
+  before do
+    allow(described_class).to receive(:log)
+  end
+
+  after do
+    FileUtils.rm_rf(base_dir)
+  end
+
+  shared_examples 'importing a repository' do
+    describe '.execute' do
+      it 'creates a project for a repository in storage' do
+        FileUtils.mkdir_p(File.join(base_dir, "#{project_path}.git"))
+        fake_importer = double
+
+        expect(described_class).to receive(:new).and_return(fake_importer)
+        expect(fake_importer).to receive(:create_project_if_needed)
+
+        described_class.execute(base_dir)
+      end
+
+      it 'skips wiki repos' do
+        repo_dir = File.join(base_dir, 'the-group', 'the-project.wiki.git')
+        FileUtils.mkdir_p(File.join(repo_dir))
+
+        expect(described_class).to receive(:log).with(" * Skipping repo #{repo_dir}")
+        expect(described_class).not_to receive(:new)
+
+        described_class.execute(base_dir)
+      end
+
+      context 'without admin users' do
+        let(:admin) { nil }
+
+        it 'raises an error' do
+          expect { described_class.execute(base_dir) }.to raise_error(Gitlab::BareRepositoryImport::Importer::NoAdminError)
+        end
+      end
+    end
+
+    describe '#create_project_if_needed' do
+      it 'starts an import for a project that did not exist' do
+        expect(importer).to receive(:create_project)
+
+        importer.create_project_if_needed
+      end
+
+      it 'skips importing when the project already exists' do
+        project = create(:project, path: 'a-project', namespace: existing_group)
+
+        expect(importer).not_to receive(:create_project)
+        expect(importer).to receive(:log).with(" * #{project.name} (#{project_path}) exists")
+
+        importer.create_project_if_needed
+      end
+
+      it 'creates a project with the correct path in the database' do
+        importer.create_project_if_needed
+
+        expect(Project.find_by_full_path(project_path)).not_to be_nil
+      end
+
+      it 'creates the Git repo in disk' do
+        FileUtils.mkdir_p(File.join(base_dir, "#{project_path}.git"))
+
+        importer.create_project_if_needed
+
+        project = Project.find_by_full_path(project_path)
+
+        expect(File).to exist(File.join(project.repository_storage_path, project.disk_path + '.git'))
+      end
+
+      context 'hashed storage enabled' do
+        it 'creates a project with the correct path in the database' do
+          stub_application_setting(hashed_storage_enabled: true)
+
+          importer.create_project_if_needed
+
+          expect(Project.find_by_full_path(project_path)).not_to be_nil
+        end
+      end
+    end
+  end
+
+  context 'with subgroups', :nested_groups do
+    let(:project_path) { 'a-group/a-sub-group/a-project' }
+
+    let(:existing_group) do
+      group = create(:group, path: 'a-group')
+      create(:group, path: 'a-sub-group', parent: group)
+    end
+
+    it_behaves_like 'importing a repository'
+  end
+
+  context 'without subgroups' do
+    let(:project_path) { 'a-group/a-project' }
+    let(:existing_group) { create(:group, path: 'a-group') }
+
+    it_behaves_like 'importing a repository'
+  end
+
+  context 'without groups' do
+    let(:project_path) { 'a-project' }
+
+    it 'starts an import for a project that did not exist' do
+      expect(importer).to receive(:create_project)
+
+      importer.create_project_if_needed
+    end
+
+    it 'creates a project with the correct path in the database' do
+      importer.create_project_if_needed
+
+      expect(Project.find_by_full_path("#{admin.full_path}/#{project_path}")).not_to be_nil
+    end
+
+    it 'creates the Git repo in disk' do
+      FileUtils.mkdir_p(File.join(base_dir, "#{project_path}.git"))
+
+      importer.create_project_if_needed
+
+      project = Project.find_by_full_path("#{admin.full_path}/#{project_path}")
+
+      expect(File).to exist(File.join(project.repository_storage_path, project.disk_path + '.git'))
+    end
+  end
+
+  context 'with Wiki' do
+    let(:project_path) { 'a-group/a-project' }
+    let(:existing_group) { create(:group, path: 'a-group') }
+
+    it_behaves_like 'importing a repository'
+
+    it 'creates the Wiki git repo in disk' do
+      FileUtils.mkdir_p(File.join(base_dir, "#{project_path}.git"))
+      FileUtils.mkdir_p(File.join(base_dir, "#{project_path}.wiki.git"))
+
+      importer.create_project_if_needed
+
+      project = Project.find_by_full_path(project_path)
+
+      expect(File).to exist(File.join(project.repository_storage_path, project.disk_path + '.wiki.git'))
+    end
+  end
+
+  context 'when subgroups are not available' do
+    let(:project_path) { 'a-group/a-sub-group/a-project' }
+
+    before do
+      expect(Group).to receive(:supports_nested_groups?) { false }
+    end
+
+    describe '#create_project_if_needed' do
+      it 'raises an error' do
+        expect { importer.create_project_if_needed }.to raise_error('Nested groups are not supported on MySQL')
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/bare_repository_import/repository_spec.rb b/spec/lib/gitlab/bare_repository_import/repository_spec.rb
new file mode 100644
index 00000000000..2db737f5fb6
--- /dev/null
+++ b/spec/lib/gitlab/bare_repository_import/repository_spec.rb
@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe ::Gitlab::BareRepositoryImport::Repository do
+  let(:project_repo_path) { described_class.new('/full/path/', '/full/path/to/repo.git') }
+
+  it 'stores the repo path' do
+    expect(project_repo_path.repo_path).to eq('/full/path/to/repo.git')
+  end
+
+  it 'stores the group path' do
+    expect(project_repo_path.group_path).to eq('to')
+  end
+
+  it 'stores the project name' do
+    expect(project_repo_path.project_name).to eq('repo')
+  end
+
+  it 'stores the wiki path' do
+    expect(project_repo_path.wiki_path).to eq('/full/path/to/repo.wiki.git')
+  end
+
+  describe '#wiki?' do
+    it 'returns true if it is a wiki' do
+      wiki_path = described_class.new('/full/path/', '/full/path/to/a/b/my.wiki.git')
+
+      expect(wiki_path.wiki?).to eq(true)
+    end
+
+    it 'returns false if it is not a wiki' do
+      expect(project_repo_path.wiki?).to eq(false)
+    end
+  end
+
+  describe '#hashed?' do
+    it 'returns true if it is a hashed folder' do
+      path = described_class.new('/full/path/', '/full/path/@hashed/my.repo.git')
+
+      expect(path.hashed?).to eq(true)
+    end
+
+    it 'returns false if it is not a hashed folder' do
+      expect(project_repo_path.hashed?).to eq(false)
+    end
+  end
+
+  describe '#project_full_path' do
+    it 'returns the project full path' do
+      expect(project_repo_path.repo_path).to eq('/full/path/to/repo.git')
+    end
+  end
+end
diff --git a/spec/lib/gitlab/bare_repository_importer_spec.rb b/spec/lib/gitlab/bare_repository_importer_spec.rb
deleted file mode 100644
index 36d1844b5b1..00000000000
--- a/spec/lib/gitlab/bare_repository_importer_spec.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-describe Gitlab::BareRepositoryImporter, repository: true do
-  subject(:importer) { described_class.new('default', project_path) }
-
-  let!(:admin) { create(:admin) }
-
-  before do
-    allow(described_class).to receive(:log)
-  end
-
-  shared_examples 'importing a repository' do
-    describe '.execute' do
-      it 'creates a project for a repository in storage' do
-        FileUtils.mkdir_p(File.join(TestEnv.repos_path, "#{project_path}.git"))
-        fake_importer = double
-
-        expect(described_class).to receive(:new).with('default', project_path)
-                                     .and_return(fake_importer)
-        expect(fake_importer).to receive(:create_project_if_needed)
-
-        described_class.execute
-      end
-
-      it 'skips wiki repos' do
-        FileUtils.mkdir_p(File.join(TestEnv.repos_path, 'the-group', 'the-project.wiki.git'))
-
-        expect(described_class).to receive(:log).with(' * Skipping wiki repo')
-        expect(described_class).not_to receive(:new)
-
-        described_class.execute
-      end
-    end
-
-    describe '#initialize' do
-      context 'without admin users' do
-        let(:admin) { nil }
-
-        it 'raises an error' do
-          expect { importer }.to raise_error(Gitlab::BareRepositoryImporter::NoAdminError)
-        end
-      end
-    end
-
-    describe '#create_project_if_needed' do
-      it 'starts an import for a project that did not exist' do
-        expect(importer).to receive(:create_project)
-
-        importer.create_project_if_needed
-      end
-
-      it 'skips importing when the project already exists' do
-        project = create(:project, path: 'a-project', namespace: existing_group)
-
-        expect(importer).not_to receive(:create_project)
-        expect(importer).to receive(:log).with(" * #{project.name} (#{project_path}) exists")
-
-        importer.create_project_if_needed
-      end
-
-      it 'creates a project with the correct path in the database' do
-        importer.create_project_if_needed
-
-        expect(Project.find_by_full_path(project_path)).not_to be_nil
-      end
-    end
-  end
-
-  context 'with subgroups', :nested_groups do
-    let(:project_path) { 'a-group/a-sub-group/a-project' }
-
-    let(:existing_group) do
-      group = create(:group, path: 'a-group')
-      create(:group, path: 'a-sub-group', parent: group)
-    end
-
-    it_behaves_like 'importing a repository'
-  end
-
-  context 'without subgroups' do
-    let(:project_path) { 'a-group/a-project' }
-    let(:existing_group) { create(:group, path: 'a-group') }
-
-    it_behaves_like 'importing a repository'
-  end
-
-  context 'when subgroups are not available' do
-    let(:project_path) { 'a-group/a-sub-group/a-project' }
-
-    before do
-      expect(Group).to receive(:supports_nested_groups?) { false }
-    end
-
-    describe '#create_project_if_needed' do
-      it 'raises an error' do
-        expect { importer.create_project_if_needed }.to raise_error('Nested groups are not supported on MySQL')
-      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 6c25b7349e1..c2bca816aae 100644
--- a/spec/lib/gitlab/checks/change_access_spec.rb
+++ b/spec/lib/gitlab/checks/change_access_spec.rb
@@ -11,13 +11,13 @@ describe Gitlab::Checks::ChangeAccess do
     let(:changes) { { oldrev: oldrev, newrev: newrev, ref: ref } }
     let(:protocol) { 'ssh' }
 
-    subject do
+    subject(:change_access) do
       described_class.new(
         changes,
         project: project,
         user_access: user_access,
         protocol: protocol
-      ).exec
+      )
     end
 
     before do
@@ -26,7 +26,7 @@ describe Gitlab::Checks::ChangeAccess do
 
     context 'without failed checks' do
       it "doesn't raise an error" do
-        expect { subject }.not_to raise_error
+        expect { subject.exec }.not_to raise_error
       end
     end
 
@@ -34,7 +34,7 @@ describe Gitlab::Checks::ChangeAccess do
       it 'raises an error' do
         expect(user_access).to receive(:can_do_action?).with(:push_code).and_return(false)
 
-        expect { subject }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You are not allowed to push code to this project.')
+        expect { subject.exec }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You are not allowed to push code to this project.')
       end
     end
 
@@ -45,7 +45,7 @@ describe Gitlab::Checks::ChangeAccess do
         allow(user_access).to receive(:can_do_action?).with(:push_code).and_return(true)
         expect(user_access).to receive(:can_do_action?).with(:admin_project).and_return(false)
 
-        expect { subject }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You are not allowed to change existing tags on this project.')
+        expect { subject.exec }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You are not allowed to change existing tags on this project.')
       end
 
       context 'with protected tag' do
@@ -61,7 +61,7 @@ describe Gitlab::Checks::ChangeAccess do
             let(:newrev) { '0000000000000000000000000000000000000000' }
 
             it 'is prevented' do
-              expect { subject }.to raise_error(Gitlab::GitAccess::UnauthorizedError, /cannot be deleted/)
+              expect { subject.exec }.to raise_error(Gitlab::GitAccess::UnauthorizedError, /cannot be deleted/)
             end
           end
 
@@ -70,7 +70,7 @@ describe Gitlab::Checks::ChangeAccess do
             let(:newrev) { '54fcc214b94e78d7a41a9a8fe6d87a5e59500e51' }
 
             it 'is prevented' do
-              expect { subject }.to raise_error(Gitlab::GitAccess::UnauthorizedError, /cannot be updated/)
+              expect { subject.exec }.to raise_error(Gitlab::GitAccess::UnauthorizedError, /cannot be updated/)
             end
           end
         end
@@ -81,14 +81,14 @@ describe Gitlab::Checks::ChangeAccess do
           let(:ref) { 'refs/tags/v9.1.0' }
 
           it 'prevents creation below access level' do
-            expect { subject }.to raise_error(Gitlab::GitAccess::UnauthorizedError, /allowed to create this tag as it is protected/)
+            expect { subject.exec }.to raise_error(Gitlab::GitAccess::UnauthorizedError, /allowed to create this tag as it is protected/)
           end
 
           context 'when user has access' do
             let!(:protected_tag) { create(:protected_tag, :developers_can_create, project: project, name: 'v*') }
 
             it 'allows tag creation' do
-              expect { subject }.not_to raise_error
+              expect { subject.exec }.not_to raise_error
             end
           end
         end
@@ -101,7 +101,7 @@ describe Gitlab::Checks::ChangeAccess do
         let(:ref) { 'refs/heads/master' }
 
         it 'raises an error' do
-          expect { subject }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'The default branch of a project cannot be deleted.')
+          expect { subject.exec }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'The default branch of a project cannot be deleted.')
         end
       end
 
@@ -114,7 +114,7 @@ describe Gitlab::Checks::ChangeAccess do
         it 'raises 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 { subject }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You are not allowed to force push code to a protected branch on this project.')
+          expect { subject.exec }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You are not allowed to force push code to a protected branch on this project.')
         end
 
         it 'raises an error if the user is not allowed to merge to protected branches' do
@@ -122,13 +122,13 @@ describe Gitlab::Checks::ChangeAccess do
           expect(user_access).to receive(:can_merge_to_branch?).and_return(false)
           expect(user_access).to receive(:can_push_to_branch?).and_return(false)
 
-          expect { subject }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You are not allowed to merge code into protected branches on this project.')
+          expect { subject.exec }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You are not allowed to merge code into protected branches on this project.')
         end
 
         it 'raises an error if the user is not allowed to push to protected branches' do
           expect(user_access).to receive(:can_push_to_branch?).and_return(false)
 
-          expect { subject }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You are not allowed to push code to protected branches on this project.')
+          expect { subject.exec }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You are not allowed to push code to protected branches on this project.')
         end
 
         context 'branch deletion' do
@@ -137,7 +137,7 @@ describe Gitlab::Checks::ChangeAccess do
 
           context 'if the user is not allowed to delete protected branches' do
             it 'raises an error' do
-              expect { subject }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You are not allowed to delete protected branches from this project. Only a project master or owner can delete a protected branch.')
+              expect { subject.exec }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You are not allowed to delete protected branches from this project. Only a project master or owner can delete a protected branch.')
             end
           end
 
@@ -150,18 +150,32 @@ describe Gitlab::Checks::ChangeAccess do
               let(:protocol) { 'web' }
 
               it 'allows branch deletion' do
-                expect { subject }.not_to raise_error
+                expect { subject.exec }.not_to raise_error
               end
             end
 
             context 'over SSH or HTTP' do
               it 'raises an error' do
-                expect { subject }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You can only delete protected branches using the web interface.')
+                expect { subject.exec }.to raise_error(Gitlab::GitAccess::UnauthorizedError, 'You can only delete protected branches using the web interface.')
               end
             end
           end
         end
       end
     end
+
+    context 'LFS integrity check' do
+      it 'fails if any LFS blobs are missing' do
+        allow_any_instance_of(Gitlab::Checks::LfsIntegrity).to receive(:objects_missing?).and_return(true)
+
+        expect { subject.exec }.to raise_error(Gitlab::GitAccess::UnauthorizedError, /LFS objects are missing/)
+      end
+
+      it 'succeeds if LFS objects have already been uploaded' do
+        allow_any_instance_of(Gitlab::Checks::LfsIntegrity).to receive(:objects_missing?).and_return(false)
+
+        expect { subject.exec }.not_to raise_error
+      end
+    end
   end
 end
diff --git a/spec/lib/gitlab/checks/lfs_integrity_spec.rb b/spec/lib/gitlab/checks/lfs_integrity_spec.rb
new file mode 100644
index 00000000000..17756621221
--- /dev/null
+++ b/spec/lib/gitlab/checks/lfs_integrity_spec.rb
@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Gitlab::Checks::LfsIntegrity do
+  include ProjectForksHelper
+  let(:project) { create(:project, :repository) }
+  let(:newrev) { '54fcc214b94e78d7a41a9a8fe6d87a5e59500e51' }
+
+  subject { described_class.new(project, newrev) }
+
+  describe '#objects_missing?' do
+    let(:blob_object) { project.repository.blob_at_branch('lfs', 'files/lfs/lfs_object.iso') }
+
+    before do
+      allow_any_instance_of(Gitlab::Git::RevList).to receive(:new_objects) do |&lazy_block|
+        lazy_block.call([blob_object.id])
+      end
+    end
+
+    context 'with LFS not enabled' do
+      it 'skips integrity check' do
+        expect_any_instance_of(Gitlab::Git::RevList).not_to receive(:new_objects)
+
+        subject.objects_missing?
+      end
+    end
+
+    context 'with LFS enabled' do
+      before do
+        allow(project).to receive(:lfs_enabled?).and_return(true)
+      end
+
+      context 'deletion' do
+        let(:newrev) { nil }
+
+        it 'skips integrity check' do
+          expect_any_instance_of(Gitlab::Git::RevList).not_to receive(:new_objects)
+
+          expect(subject.objects_missing?).to be_falsey
+        end
+      end
+
+      it 'is true if any LFS blobs are missing' do
+        expect(subject.objects_missing?).to be_truthy
+      end
+
+      it 'is false if LFS objects have already been uploaded' do
+        lfs_object = create(:lfs_object, oid: blob_object.lfs_oid)
+        create(:lfs_objects_project, project: project, lfs_object: lfs_object)
+
+        expect(subject.objects_missing?).to be_falsey
+      end
+    end
+
+    context 'for forked project' do
+      let(:parent_project) { create(:project, :repository) }
+      let(:project) { fork_project(parent_project, nil, repository: true) }
+
+      before do
+        allow(project).to receive(:lfs_enabled?).and_return(true)
+      end
+
+      it 'is true parent project is missing LFS objects' do
+        expect(subject.objects_missing?).to be_truthy
+      end
+
+      it 'is false parent project already conatins LFS objects for the fork' do
+        lfs_object = create(:lfs_object, oid: blob_object.lfs_oid)
+        create(:lfs_objects_project, project: parent_project, lfs_object: lfs_object)
+
+        expect(subject.objects_missing?).to be_falsey
+      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 2b32e47e9ba..d196bc6a4c2 100644
--- a/spec/lib/gitlab/ci/status/build/factory_spec.rb
+++ b/spec/lib/gitlab/ci/status/build/factory_spec.rb
@@ -84,7 +84,7 @@ describe Gitlab::Ci::Status::Build::Factory do
 
       it 'fabricates status with correct details' do
         expect(status.text).to eq 'failed'
-        expect(status.icon).to eq 'warning'
+        expect(status.icon).to eq 'status_warning'
         expect(status.favicon).to eq 'favicon_status_failed'
         expect(status.label).to eq 'failed (allowed to fail)'
         expect(status).to have_details
diff --git a/spec/lib/gitlab/ci/status/build/failed_allowed_spec.rb b/spec/lib/gitlab/ci/status/build/failed_allowed_spec.rb
index 79a65fc67e8..99a5a7e4aca 100644
--- a/spec/lib/gitlab/ci/status/build/failed_allowed_spec.rb
+++ b/spec/lib/gitlab/ci/status/build/failed_allowed_spec.rb
@@ -18,7 +18,7 @@ describe Gitlab::Ci::Status::Build::FailedAllowed do
 
   describe '#icon' do
     it 'returns a warning icon' do
-      expect(subject.icon).to eq 'warning'
+      expect(subject.icon).to eq 'status_warning'
     end
   end
 
diff --git a/spec/lib/gitlab/database/grant_spec.rb b/spec/lib/gitlab/database/grant_spec.rb
index 651da3e8476..5ebf3f399b6 100644
--- a/spec/lib/gitlab/database/grant_spec.rb
+++ b/spec/lib/gitlab/database/grant_spec.rb
@@ -1,16 +1,6 @@
 require 'spec_helper'
 
 describe Gitlab::Database::Grant do
-  describe '.scope_to_current_user' do
-    it 'scopes the relation to the current user' do
-      user = Gitlab::Database.username
-      column = Gitlab::Database.postgresql? ? :grantee : :User
-      names = described_class.scope_to_current_user.pluck(column).uniq
-
-      expect(names).to eq([user])
-    end
-  end
-
   describe '.create_and_execute_trigger' do
     it 'returns true when the user can create and execute a trigger' do
       # We assume the DB/user is set up correctly so that triggers can be
@@ -18,13 +8,11 @@ describe Gitlab::Database::Grant do
       expect(described_class.create_and_execute_trigger?('users')).to eq(true)
     end
 
-    it 'returns false when the user can not create and/or execute a trigger' do
-      allow(described_class).to receive(:scope_to_current_user)
-        .and_return(described_class.none)
-
-      result = described_class.create_and_execute_trigger?('kittens')
-
-      expect(result).to eq(false)
+    it 'returns false when the user can not create and/or execute a trigger', :postgresql do
+      # In case of MySQL the user may have SUPER permissions, making it
+      # impossible to have `false` returned when running tests; hence we only
+      # run these tests on PostgreSQL.
+      expect(described_class.create_and_execute_trigger?('foo')).to eq(false)
     end
   end
 end
diff --git a/spec/lib/gitlab/database_spec.rb b/spec/lib/gitlab/database_spec.rb
index 7aeb85b8f5a..fcddfad3f9f 100644
--- a/spec/lib/gitlab/database_spec.rb
+++ b/spec/lib/gitlab/database_spec.rb
@@ -202,6 +202,26 @@ describe Gitlab::Database do
     it 'handles non-UTF-8 data' do
       expect { described_class.bulk_insert('test', [{ a: "\255" }]) }.not_to raise_error
     end
+
+    context 'when using PostgreSQL' do
+      before do
+        allow(described_class).to receive(:mysql?).and_return(false)
+      end
+
+      it 'allows the returning of the IDs of the inserted rows' do
+        result = double(:result, values: [['10']])
+
+        expect(connection)
+          .to receive(:execute)
+          .with(/RETURNING id/)
+          .and_return(result)
+
+        ids = described_class
+          .bulk_insert('test', [{ number: 10 }], return_ids: true)
+
+        expect(ids).to eq([10])
+      end
+    end
   end
 
   describe '.create_connection_pool' do
diff --git a/spec/lib/gitlab/git/remote_repository_spec.rb b/spec/lib/gitlab/git/remote_repository_spec.rb
new file mode 100644
index 00000000000..0506210887c
--- /dev/null
+++ b/spec/lib/gitlab/git/remote_repository_spec.rb
@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Gitlab::Git::RemoteRepository, seed_helper: true do
+  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+  subject { described_class.new(repository) }
+
+  describe '#empty_repo?' do
+    using RSpec::Parameterized::TableSyntax
+
+    where(:repository, :result) do
+      Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '')       | false
+      Gitlab::Git::Repository.new('default', 'does-not-exist.git', '') | true
+    end
+
+    with_them do
+      it { expect(subject.empty_repo?).to eq(result) }
+    end
+  end
+
+  describe '#commit_id' do
+    it 'returns an OID if the revision exists' do
+      expect(subject.commit_id('v1.0.0')).to eq('6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9')
+    end
+
+    it 'is nil when the revision does not exist' do
+      expect(subject.commit_id('does-not-exist')).to be_nil
+    end
+  end
+
+  describe '#branch_exists?' do
+    using RSpec::Parameterized::TableSyntax
+
+    where(:branch, :result) do
+      'master'         | true
+      'does-not-exist' | false
+    end
+
+    with_them do
+      it { expect(subject.branch_exists?(branch)).to eq(result) }
+    end
+  end
+
+  describe '#same_repository?' do
+    using RSpec::Parameterized::TableSyntax
+
+    where(:other_repository, :result) do
+      repository                                                                     | true
+      Gitlab::Git::Repository.new(repository.storage, repository.relative_path, '')  | true
+      Gitlab::Git::Repository.new('broken', TEST_REPO_PATH, '')                      | false
+      Gitlab::Git::Repository.new(repository.storage, 'wrong/relative-path.git', '') | false
+      Gitlab::Git::Repository.new('broken', 'wrong/relative-path.git', '')           | false
+    end
+
+    with_them do
+      it { expect(subject.same_repository?(other_repository)).to eq(result) }
+    end
+  end
+
+  describe '#fetch_env' do
+    let(:remote_repository) { described_class.new(repository) }
+
+    let(:gitaly_client) { double(:gitaly_client) }
+    let(:address) { 'fake-address' }
+    let(:token) { 'fake-token' }
+
+    subject { remote_repository.fetch_env }
+
+    before do
+      allow(remote_repository).to receive(:gitaly_client).and_return(gitaly_client)
+
+      expect(gitaly_client).to receive(:address).with(repository.storage).and_return(address)
+      expect(gitaly_client).to receive(:token).with(repository.storage).and_return(token)
+    end
+
+    it { expect(subject).to be_a(Hash) }
+    it { expect(subject['GITALY_ADDRESS']).to eq(address) }
+    it { expect(subject['GITALY_TOKEN']).to eq(token) }
+    it { expect(subject['GITALY_WD']).to eq(Dir.pwd) }
+
+    it 'creates a plausible GIT_SSH_COMMAND' do
+      git_ssh_command = subject['GIT_SSH_COMMAND']
+
+      expect(git_ssh_command).to start_with('/')
+      expect(git_ssh_command).to end_with('/gitaly-ssh upload-pack')
+    end
+
+    it 'creates a plausible GITALY_PAYLOAD' do
+      req = Gitaly::SSHUploadPackRequest.decode_json(subject['GITALY_PAYLOAD'])
+
+      expect(remote_repository.gitaly_repository).to eq(req.repository)
+    end
+
+    context 'when the token is blank' do
+      let(:token) { '' }
+
+      it { expect(subject.keys).not_to include('GITALY_TOKEN') }
+    end
+  end
+end
diff --git a/spec/lib/gitlab/git/repository_spec.rb b/spec/lib/gitlab/git/repository_spec.rb
index 1d4d0c300eb..5d990b42c24 100644
--- a/spec/lib/gitlab/git/repository_spec.rb
+++ b/spec/lib/gitlab/git/repository_spec.rb
@@ -449,7 +449,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
       let(:repository) { Gitlab::Git::Repository.new('default', TEST_MUTABLE_REPO_PATH, '') }
 
       after do
-        FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
         ensure_seeds
       end
 
@@ -484,7 +483,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
       let(:repository) { Gitlab::Git::Repository.new('default', TEST_MUTABLE_REPO_PATH, '') }
 
       after do
-        FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
         ensure_seeds
       end
 
@@ -544,7 +542,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
     end
 
     after(:all) do
-      FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
       ensure_seeds
     end
   end
@@ -570,7 +567,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
     end
 
     after(:all) do
-      FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
       ensure_seeds
     end
   end
@@ -588,7 +584,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
     end
 
     after(:all) do
-      FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
       ensure_seeds
     end
   end
@@ -648,6 +643,21 @@ describe Gitlab::Git::Repository, seed_helper: true do
     end
   end
 
+  describe '#remote_exists?' do
+    before(:all) do
+      @repo = Gitlab::Git::Repository.new('default', TEST_MUTABLE_REPO_PATH, '')
+      @repo.add_remote("new_remote", SeedHelper::GITLAB_GIT_TEST_REPO_URL)
+    end
+
+    it 'returns true for an existing remote' do
+      expect(@repo.remote_exists?('new_remote')).to eq(true)
+    end
+
+    it 'returns false for a non-existing remote' do
+      expect(@repo.remote_exists?('foo')).to eq(false)
+    end
+  end
+
   describe "#log" do
     let(:commit_with_old_name) do
       Gitlab::Git::Commit.decorate(repository, @commit_with_old_name_id)
@@ -1107,7 +1117,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
       end
 
       after do
-        FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
         ensure_seeds
       end
 
@@ -1154,7 +1163,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
       end
 
       after do
-        FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
         ensure_seeds
       end
 
@@ -1404,7 +1412,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
     end
 
     after(:all) do
-      FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
       ensure_seeds
     end
 
@@ -1521,36 +1528,61 @@ describe Gitlab::Git::Repository, seed_helper: true do
     end
   end
 
-  describe '#fetch_source_branch' do
-    let(:local_ref) { 'refs/merge-requests/1/head' }
+  describe '#fetch_source_branch!' do
+    shared_examples '#fetch_source_branch!' do
+      let(:local_ref) { 'refs/merge-requests/1/head' }
+      let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+      let(:source_repository) { Gitlab::Git::Repository.new('default', TEST_MUTABLE_REPO_PATH, '') }
 
-    context 'when the branch exists' do
-      let(:source_branch) { 'master' }
+      after do
+        ensure_seeds
+      end
 
-      it 'writes the ref' do
-        expect(repository).to receive(:write_ref).with(local_ref, /\h{40}/)
+      context 'when the branch exists' do
+        context 'when the commit does not exist locally' do
+          let(:source_branch) { 'new-branch-for-fetch-source-branch' }
+          let(:source_rugged) { source_repository.rugged }
+          let(:new_oid) { new_commit_edit_old_file(source_rugged).oid }
 
-        repository.fetch_source_branch(repository, source_branch, local_ref)
-      end
+          before do
+            source_rugged.branches.create(source_branch, new_oid)
+          end
 
-      it 'returns true' do
-        expect(repository.fetch_source_branch(repository, source_branch, local_ref)).to eq(true)
-      end
-    end
+          it 'writes the ref' do
+            expect(repository.fetch_source_branch!(source_repository, source_branch, local_ref)).to eq(true)
+            expect(repository.commit(local_ref).sha).to eq(new_oid)
+          end
+        end
 
-    context 'when the branch does not exist' do
-      let(:source_branch) { 'definitely-not-master' }
+        context 'when the commit exists locally' do
+          let(:source_branch) { 'master' }
+          let(:expected_oid) { SeedRepo::LastCommit::ID }
 
-      it 'does not write the ref' do
-        expect(repository).not_to receive(:write_ref)
+          it 'writes the ref' do
+            # Sanity check: the commit should already exist
+            expect(repository.commit(expected_oid)).not_to be_nil
 
-        repository.fetch_source_branch(repository, source_branch, local_ref)
+            expect(repository.fetch_source_branch!(source_repository, source_branch, local_ref)).to eq(true)
+            expect(repository.commit(local_ref).sha).to eq(expected_oid)
+          end
+        end
       end
 
-      it 'returns false' do
-        expect(repository.fetch_source_branch(repository, source_branch, local_ref)).to eq(false)
+      context 'when the branch does not exist' do
+        let(:source_branch) { 'definitely-not-master' }
+
+        it 'does not write the ref' do
+          expect(repository.fetch_source_branch!(source_repository, source_branch, local_ref)).to eq(false)
+          expect(repository.commit(local_ref)).to be_nil
+        end
       end
     end
+
+    it_behaves_like '#fetch_source_branch!'
+
+    context 'without gitaly', :skip_gitaly_mock do
+      it_behaves_like '#fetch_source_branch!'
+    end
   end
 
   describe '#rm_branch' do
@@ -1626,7 +1658,6 @@ describe Gitlab::Git::Repository, seed_helper: true do
     end
 
     after do
-      FileUtils.rm_rf(TEST_MUTABLE_REPO_PATH)
       ensure_seeds
     end
 
diff --git a/spec/lib/gitlab/gitaly_client/wiki_service_spec.rb b/spec/lib/gitlab/gitaly_client/wiki_service_spec.rb
new file mode 100644
index 00000000000..6ad9f5ef766
--- /dev/null
+++ b/spec/lib/gitlab/gitaly_client/wiki_service_spec.rb
@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Gitlab::GitalyClient::WikiService do
+  let(:project) { create(:project) }
+  let(:storage_name) { project.repository_storage }
+  let(:relative_path) { project.disk_path + '.git' }
+  let(:client) { described_class.new(project.repository) }
+  let(:commit) { create(:gitaly_commit) }
+  let(:page_version) { Gitaly::WikiPageVersion.new(format: 'markdown', commit: commit) }
+  let(:page_info) { { title: 'My Page', raw_data: 'a', version: page_version } }
+
+  describe '#find_page' do
+    let(:response) do
+      [
+        Gitaly::WikiFindPageResponse.new(page: Gitaly::WikiPage.new(page_info)),
+        Gitaly::WikiFindPageResponse.new(page: Gitaly::WikiPage.new(raw_data: 'b'))
+      ]
+    end
+    let(:wiki_page) { subject.first }
+    let(:wiki_page_version) { subject.last }
+
+    subject { client.find_page(title: 'My Page', version: 'master', dir: '') }
+
+    it 'sends a wiki_find_page message' do
+      expect_any_instance_of(Gitaly::WikiService::Stub)
+        .to receive(:wiki_find_page)
+        .with(gitaly_request_with_path(storage_name, relative_path), kind_of(Hash))
+        .and_return([].each)
+
+      subject
+    end
+
+    it 'concatenates the raw data and returns a pair of WikiPage and WikiPageVersion' do
+      expect_any_instance_of(Gitaly::WikiService::Stub)
+        .to receive(:wiki_find_page)
+        .with(gitaly_request_with_path(storage_name, relative_path), kind_of(Hash))
+        .and_return(response.each)
+
+      expect(wiki_page.title).to eq('My Page')
+      expect(wiki_page.raw_data).to eq('ab')
+      expect(wiki_page_version.format).to eq('markdown')
+    end
+  end
+
+  describe '#get_all_pages' do
+    let(:page_2_info) { { title: 'My Page 2', raw_data: 'c', version: page_version } }
+    let(:response) do
+      [
+        Gitaly::WikiGetAllPagesResponse.new(page: Gitaly::WikiPage.new(page_info)),
+        Gitaly::WikiGetAllPagesResponse.new(page: Gitaly::WikiPage.new(raw_data: 'b')),
+        Gitaly::WikiGetAllPagesResponse.new(end_of_page: true),
+        Gitaly::WikiGetAllPagesResponse.new(page: Gitaly::WikiPage.new(page_2_info)),
+        Gitaly::WikiGetAllPagesResponse.new(page: Gitaly::WikiPage.new(raw_data: 'd')),
+        Gitaly::WikiGetAllPagesResponse.new(end_of_page: true)
+      ]
+    end
+    let(:wiki_page_1) { subject[0].first }
+    let(:wiki_page_1_version) { subject[0].last }
+    let(:wiki_page_2) { subject[1].first }
+    let(:wiki_page_2_version) { subject[1].last }
+
+    subject { client.get_all_pages }
+
+    it 'sends a wiki_get_all_pages message' do
+      expect_any_instance_of(Gitaly::WikiService::Stub)
+        .to receive(:wiki_get_all_pages)
+        .with(gitaly_request_with_path(storage_name, relative_path), kind_of(Hash))
+        .and_return([].each)
+
+      subject
+    end
+
+    it 'concatenates the raw data and returns a pair of WikiPage and WikiPageVersion for each page' do
+      expect_any_instance_of(Gitaly::WikiService::Stub)
+        .to receive(:wiki_get_all_pages)
+        .with(gitaly_request_with_path(storage_name, relative_path), kind_of(Hash))
+        .and_return(response.each)
+
+      expect(subject.size).to be(2)
+      expect(wiki_page_1.title).to eq('My Page')
+      expect(wiki_page_1.raw_data).to eq('ab')
+      expect(wiki_page_1_version.format).to eq('markdown')
+      expect(wiki_page_2.title).to eq('My Page 2')
+      expect(wiki_page_2.raw_data).to eq('cd')
+      expect(wiki_page_2_version.format).to eq('markdown')
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/bulk_importing_spec.rb b/spec/lib/gitlab/github_import/bulk_importing_spec.rb
new file mode 100644
index 00000000000..91229d9c7d4
--- /dev/null
+++ b/spec/lib/gitlab/github_import/bulk_importing_spec.rb
@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::BulkImporting do
+  let(:importer) do
+    Class.new { include(Gitlab::GithubImport::BulkImporting) }.new
+  end
+
+  describe '#build_database_rows' do
+    it 'returns an Array containing the rows to insert' do
+      object = double(:object, title: 'Foo')
+
+      expect(importer)
+        .to receive(:build)
+        .with(object)
+        .and_return({ title: 'Foo' })
+
+      expect(importer)
+        .to receive(:already_imported?)
+        .with(object)
+        .and_return(false)
+
+      enum = [[object, 1]].to_enum
+
+      expect(importer.build_database_rows(enum)).to eq([{ title: 'Foo' }])
+    end
+
+    it 'does not import objects that have already been imported' do
+      object = double(:object, title: 'Foo')
+
+      expect(importer)
+        .not_to receive(:build)
+
+      expect(importer)
+        .to receive(:already_imported?)
+        .with(object)
+        .and_return(true)
+
+      enum = [[object, 1]].to_enum
+
+      expect(importer.build_database_rows(enum)).to be_empty
+    end
+  end
+
+  describe '#bulk_insert' do
+    it 'bulk inserts rows into the database' do
+      rows = [{ title: 'Foo' }] * 10
+      model = double(:model, table_name: 'kittens')
+
+      expect(Gitlab::Database)
+        .to receive(:bulk_insert)
+        .ordered
+        .with('kittens', rows.first(5))
+
+      expect(Gitlab::Database)
+        .to receive(:bulk_insert)
+        .ordered
+        .with('kittens', rows.last(5))
+
+      importer.bulk_insert(model, rows, batch_size: 5)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/caching_spec.rb b/spec/lib/gitlab/github_import/caching_spec.rb
new file mode 100644
index 00000000000..70ecdc16da1
--- /dev/null
+++ b/spec/lib/gitlab/github_import/caching_spec.rb
@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Caching, :clean_gitlab_redis_cache do
+  describe '.read' do
+    it 'reads a value from the cache' do
+      described_class.write('foo', 'bar')
+
+      expect(described_class.read('foo')).to eq('bar')
+    end
+
+    it 'returns nil if the cache key does not exist' do
+      expect(described_class.read('foo')).to be_nil
+    end
+
+    it 'refreshes the cache key if a value is present' do
+      described_class.write('foo', 'bar')
+
+      redis = double(:redis)
+
+      expect(redis).to receive(:get).with(/foo/).and_return('bar')
+      expect(redis).to receive(:expire).with(/foo/, described_class::TIMEOUT)
+      expect(Gitlab::Redis::Cache).to receive(:with).twice.and_yield(redis)
+
+      described_class.read('foo')
+    end
+
+    it 'does not refresh the cache key if a value is empty' do
+      described_class.write('foo', nil)
+
+      redis = double(:redis)
+
+      expect(redis).to receive(:get).with(/foo/).and_return('')
+      expect(redis).not_to receive(:expire)
+      expect(Gitlab::Redis::Cache).to receive(:with).and_yield(redis)
+
+      described_class.read('foo')
+    end
+  end
+
+  describe '.read_integer' do
+    it 'returns an Integer' do
+      described_class.write('foo', '10')
+
+      expect(described_class.read_integer('foo')).to eq(10)
+    end
+
+    it 'returns nil if no value was found' do
+      expect(described_class.read_integer('foo')).to be_nil
+    end
+  end
+
+  describe '.write' do
+    it 'writes a value to the cache and returns the written value' do
+      expect(described_class.write('foo', 10)).to eq(10)
+      expect(described_class.read('foo')).to eq('10')
+    end
+  end
+
+  describe '.set_add' do
+    it 'adds a value to a set' do
+      described_class.set_add('foo', 10)
+      described_class.set_add('foo', 10)
+
+      key = described_class.cache_key_for('foo')
+      values = Gitlab::Redis::Cache.with { |r| r.smembers(key) }
+
+      expect(values).to eq(['10'])
+    end
+  end
+
+  describe '.set_includes?' do
+    it 'returns false when the key does not exist' do
+      expect(described_class.set_includes?('foo', 10)).to eq(false)
+    end
+
+    it 'returns false when the value is not present in the set' do
+      described_class.set_add('foo', 10)
+
+      expect(described_class.set_includes?('foo', 20)).to eq(false)
+    end
+
+    it 'returns true when the set includes the given value' do
+      described_class.set_add('foo', 10)
+
+      expect(described_class.set_includes?('foo', 10)).to eq(true)
+    end
+  end
+
+  describe '.write_multiple' do
+    it 'sets multiple keys' do
+      mapping = { 'foo' => 10, 'bar' => 20 }
+
+      described_class.write_multiple(mapping)
+
+      mapping.each do |key, value|
+        full_key = described_class.cache_key_for(key)
+        found = Gitlab::Redis::Cache.with { |r| r.get(full_key) }
+
+        expect(found).to eq(value.to_s)
+      end
+    end
+  end
+
+  describe '.expire' do
+    it 'sets the expiration time of a key' do
+      timeout = 1.hour.to_i
+
+      described_class.write('foo', 'bar', timeout: 2.hours.to_i)
+      described_class.expire('foo', timeout)
+
+      key = described_class.cache_key_for('foo')
+      found_ttl = Gitlab::Redis::Cache.with { |r| r.ttl(key) }
+
+      expect(found_ttl).to be <= timeout
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/client_spec.rb b/spec/lib/gitlab/github_import/client_spec.rb
index 66273255b6f..5b2642d9473 100644
--- a/spec/lib/gitlab/github_import/client_spec.rb
+++ b/spec/lib/gitlab/github_import/client_spec.rb
@@ -1,97 +1,392 @@
 require 'spec_helper'
 
 describe Gitlab::GithubImport::Client do
-  let(:token) { '123456' }
-  let(:github_provider) { Settingslogic.new('app_id' => 'asd123', 'app_secret' => 'asd123', 'name' => 'github', 'args' => { 'client_options' => {} }) }
+  describe '#parallel?' do
+    it 'returns true when the client is running in parallel mode' do
+      client = described_class.new('foo', parallel: true)
 
-  subject(:client) { described_class.new(token) }
+      expect(client).to be_parallel
+    end
+
+    it 'returns false when the client is running in sequential mode' do
+      client = described_class.new('foo', parallel: false)
 
-  before do
-    allow(Gitlab.config.omniauth).to receive(:providers).and_return([github_provider])
+      expect(client).not_to be_parallel
+    end
   end
 
-  it 'convert OAuth2 client options to symbols' do
-    client.client.options.keys.each do |key|
-      expect(key).to be_kind_of(Symbol)
+  describe '#user' do
+    it 'returns the details for the given username' do
+      client = described_class.new('foo')
+
+      expect(client.octokit).to receive(:user).with('foo')
+      expect(client).to receive(:with_rate_limit).and_yield
+
+      client.user('foo')
     end
   end
 
-  it 'does not crash (e.g. Settingslogic::MissingSetting) when verify_ssl config is not present' do
-    expect { client.api }.not_to raise_error
+  describe '#repository' do
+    it 'returns the details of a repository' do
+      client = described_class.new('foo')
+
+      expect(client.octokit).to receive(:repo).with('foo/bar')
+      expect(client).to receive(:with_rate_limit).and_yield
+
+      client.repository('foo/bar')
+    end
   end
 
-  context 'when config is missing' do
-    before do
-      allow(Gitlab.config.omniauth).to receive(:providers).and_return([])
+  describe '#labels' do
+    it 'returns the labels' do
+      client = described_class.new('foo')
+
+      expect(client)
+        .to receive(:each_object)
+        .with(:labels, 'foo/bar')
+
+      client.labels('foo/bar')
     end
+  end
 
-    it 'is still possible to get an Octokit client' do
-      expect { client.api }.not_to raise_error
+  describe '#milestones' do
+    it 'returns the milestones' do
+      client = described_class.new('foo')
+
+      expect(client)
+        .to receive(:each_object)
+        .with(:milestones, 'foo/bar')
+
+      client.milestones('foo/bar')
     end
+  end
 
-    it 'is not be possible to get an OAuth2 client' do
-      expect { client.client }.to raise_error(Projects::ImportService::Error)
+  describe '#releases' do
+    it 'returns the releases' do
+      client = described_class.new('foo')
+
+      expect(client)
+        .to receive(:each_object)
+        .with(:releases, 'foo/bar')
+
+      client.releases('foo/bar')
     end
   end
 
-  context 'allow SSL verification to be configurable on API' do
+  describe '#each_page' do
+    let(:client) { described_class.new('foo') }
+    let(:object1) { double(:object1) }
+    let(:object2) { double(:object2) }
+
     before do
-      github_provider['verify_ssl'] = false
+      allow(client)
+        .to receive(:with_rate_limit)
+        .and_yield
+
+      allow(client.octokit)
+        .to receive(:public_send)
+        .and_return([object1])
+
+      response = double(:response, data: [object2], rels: { next: nil })
+      next_page = double(:next_page, get: response)
+
+      allow(client.octokit)
+        .to receive(:last_response)
+        .and_return(double(:last_response, rels: { next: next_page }))
+    end
+
+    context 'without a block' do
+      it 'returns an Enumerator' do
+        expect(client.each_page(:foo)).to be_an_instance_of(Enumerator)
+      end
+
+      it 'the returned Enumerator returns Page objects' do
+        enum = client.each_page(:foo)
+
+        page1 = enum.next
+        page2 = enum.next
+
+        expect(page1).to be_an_instance_of(described_class::Page)
+        expect(page2).to be_an_instance_of(described_class::Page)
+
+        expect(page1.objects).to eq([object1])
+        expect(page1.number).to eq(1)
+
+        expect(page2.objects).to eq([object2])
+        expect(page2.number).to eq(2)
+      end
+    end
+
+    context 'with a block' do
+      it 'yields every retrieved page to the supplied block' do
+        pages = []
+
+        client.each_page(:foo) { |page| pages << page }
+
+        expect(pages[0]).to be_an_instance_of(described_class::Page)
+        expect(pages[1]).to be_an_instance_of(described_class::Page)
+
+        expect(pages[0].objects).to eq([object1])
+        expect(pages[0].number).to eq(1)
+
+        expect(pages[1].objects).to eq([object2])
+        expect(pages[1].number).to eq(2)
+      end
+
+      it 'starts at the given page' do
+        pages = []
+
+        client.each_page(:foo, page: 2) { |page| pages << page }
+
+        expect(pages[0].number).to eq(2)
+        expect(pages[1].number).to eq(3)
+      end
+    end
+  end
+
+  describe '#with_rate_limit' do
+    let(:client) { described_class.new('foo') }
+
+    it 'yields the supplied block when enough requests remain' do
+      expect(client).to receive(:requests_remaining?).and_return(true)
+
+      expect { |b| client.with_rate_limit(&b) }.to yield_control
+    end
+
+    it 'waits before yielding if not enough requests remain' do
+      expect(client).to receive(:requests_remaining?).and_return(false)
+      expect(client).to receive(:raise_or_wait_for_rate_limit)
+
+      expect { |b| client.with_rate_limit(&b) }.to yield_control
+    end
+
+    it 'waits and retries the operation if all requests were consumed in the supplied block' do
+      retries = 0
+
+      expect(client).to receive(:requests_remaining?).and_return(true)
+      expect(client).to receive(:raise_or_wait_for_rate_limit)
+
+      client.with_rate_limit do
+        if retries.zero?
+          retries += 1
+          raise(Octokit::TooManyRequests)
+        end
+      end
+
+      expect(retries).to eq(1)
+    end
+
+    it 'increments the request count counter' do
+      expect(client.request_count_counter)
+        .to receive(:increment)
+        .and_call_original
+
+      expect(client).to receive(:requests_remaining?).and_return(true)
+
+      client.with_rate_limit { }
+    end
+
+    it 'ignores rate limiting when disabled' do
+      expect(client)
+        .to receive(:rate_limiting_enabled?)
+        .and_return(false)
+
+      expect(client)
+        .not_to receive(:requests_remaining?)
+
+      expect(client.with_rate_limit { 10 }).to eq(10)
+    end
+  end
+
+  describe '#requests_remaining?' do
+    let(:client) { described_class.new('foo') }
+
+    it 'returns true if enough requests remain' do
+      expect(client).to receive(:remaining_requests).and_return(9000)
+
+      expect(client.requests_remaining?).to eq(true)
+    end
+
+    it 'returns false if not enough requests remain' do
+      expect(client).to receive(:remaining_requests).and_return(1)
+
+      expect(client.requests_remaining?).to eq(false)
+    end
+  end
+
+  describe '#raise_or_wait_for_rate_limit' do
+    it 'raises RateLimitError when running in parallel mode' do
+      client = described_class.new('foo', parallel: true)
+
+      expect { client.raise_or_wait_for_rate_limit }
+        .to raise_error(Gitlab::GithubImport::RateLimitError)
     end
 
-    it 'uses supplied value' do
-      expect(client.client.options[:connection_opts][:ssl]).to eq({ verify: false })
-      expect(client.api.connection_options[:ssl]).to eq({ verify: false })
+    it 'sleeps when running in sequential mode' do
+      client = described_class.new('foo', parallel: false)
+
+      expect(client).to receive(:rate_limit_resets_in).and_return(1)
+      expect(client).to receive(:sleep).with(1)
+
+      client.raise_or_wait_for_rate_limit
+    end
+
+    it 'increments the rate limit counter' do
+      client = described_class.new('foo', parallel: false)
+
+      expect(client)
+        .to receive(:rate_limit_resets_in)
+        .and_return(1)
+
+      expect(client)
+        .to receive(:sleep)
+        .with(1)
+
+      expect(client.rate_limit_counter)
+        .to receive(:increment)
+        .and_call_original
+
+      client.raise_or_wait_for_rate_limit
+    end
+  end
+
+  describe '#remaining_requests' do
+    it 'returns the number of remaining requests' do
+      client = described_class.new('foo')
+      rate_limit = double(remaining: 1)
+
+      expect(client.octokit).to receive(:rate_limit).and_return(rate_limit)
+      expect(client.remaining_requests).to eq(1)
+    end
+  end
+
+  describe '#rate_limit_resets_in' do
+    it 'returns the number of seconds after which the rate limit is reset' do
+      client = described_class.new('foo')
+      rate_limit = double(resets_in: 1)
+
+      expect(client.octokit).to receive(:rate_limit).and_return(rate_limit)
+
+      expect(client.rate_limit_resets_in).to eq(6)
     end
   end
 
   describe '#api_endpoint' do
-    context 'when provider does not specity an API endpoint' do
-      it 'uses GitHub root API endpoint' do
-        expect(client.api.api_endpoint).to eq 'https://api.github.com/'
+    let(:client) { described_class.new('foo') }
+
+    context 'without a custom endpoint configured in Omniauth' do
+      it 'returns the default API endpoint' do
+        expect(client)
+          .to receive(:custom_api_endpoint)
+          .and_return(nil)
+
+        expect(client.api_endpoint).to eq('https://api.github.com')
       end
     end
 
-    context 'when provider specify a custom API endpoint' do
-      before do
-        github_provider['args']['client_options']['site'] = 'https://github.company.com/'
+    context 'with a custom endpoint configured in Omniauth' do
+      it 'returns the custom endpoint' do
+        endpoint = 'https://github.kittens.com'
+
+        expect(client)
+          .to receive(:custom_api_endpoint)
+          .and_return(endpoint)
+
+        expect(client.api_endpoint).to eq(endpoint)
       end
+    end
+  end
+
+  describe '#custom_api_endpoint' do
+    let(:client) { described_class.new('foo') }
+
+    context 'without a custom endpoint' do
+      it 'returns nil' do
+        expect(client)
+          .to receive(:github_omniauth_provider)
+          .and_return({})
+
+        expect(client.custom_api_endpoint).to be_nil
+      end
+    end
+
+    context 'with a custom endpoint' do
+      it 'returns the API endpoint' do
+        endpoint = 'https://github.kittens.com'
+
+        expect(client)
+          .to receive(:github_omniauth_provider)
+          .and_return({ 'args' => { 'client_options' => { 'site' => endpoint } } })
 
-      it 'uses the custom API endpoint' do
-        expect(OmniAuth::Strategies::GitHub).not_to receive(:default_options)
-        expect(client.api.api_endpoint).to eq 'https://github.company.com/'
+        expect(client.custom_api_endpoint).to eq(endpoint)
       end
     end
+  end
+
+  describe '#default_api_endpoint' do
+    it 'returns the default API endpoint' do
+      client = described_class.new('foo')
+
+      expect(client.default_api_endpoint).to eq('https://api.github.com')
+    end
+  end
+
+  describe '#verify_ssl' do
+    let(:client) { described_class.new('foo') }
 
-    context 'when given a host' do
-      subject(:client) { described_class.new(token, host: 'https://try.gitea.io/') }
+    context 'without a custom configuration' do
+      it 'returns true' do
+        expect(client)
+          .to receive(:github_omniauth_provider)
+          .and_return({})
 
-      it 'builds a endpoint with the given host and the default API version' do
-        expect(client.api.api_endpoint).to eq 'https://try.gitea.io/api/v3/'
+        expect(client.verify_ssl).to eq(true)
       end
     end
 
-    context 'when given an API version' do
-      subject(:client) { described_class.new(token, api_version: 'v3') }
+    context 'with a custom configuration' do
+      it 'returns the configured value' do
+        expect(client.verify_ssl).to eq(false)
+      end
+    end
+  end
+
+  describe '#github_omniauth_provider' do
+    let(:client) { described_class.new('foo') }
 
-      it 'does not use the API version without a host' do
-        expect(client.api.api_endpoint).to eq 'https://api.github.com/'
+    context 'without a configured provider' do
+      it 'returns an empty Hash' do
+        expect(Gitlab.config.omniauth)
+          .to receive(:providers)
+          .and_return([])
+
+        expect(client.github_omniauth_provider).to eq({})
       end
     end
 
-    context 'when given a host and version' do
-      subject(:client) { described_class.new(token, host: 'https://try.gitea.io/', api_version: 'v3') }
+    context 'with a configured provider' do
+      it 'returns the provider details as a Hash' do
+        hash = client.github_omniauth_provider
 
-      it 'builds a endpoint with the given options' do
-        expect(client.api.api_endpoint).to eq 'https://try.gitea.io/api/v3/'
+        expect(hash['name']).to eq('github')
+        expect(hash['url']).to eq('https://github.com/')
       end
     end
   end
 
-  it 'does not raise error when rate limit is disabled' do
-    stub_request(:get, /api.github.com/)
-    allow(client.api).to receive(:rate_limit!).and_raise(Octokit::NotFound)
+  describe '#rate_limiting_enabled?' do
+    let(:client) { described_class.new('foo') }
 
-    expect { client.issues {} }.not_to raise_error
+    it 'returns true when using GitHub.com' do
+      expect(client.rate_limiting_enabled?).to eq(true)
+    end
+
+    it 'returns false for GitHub enterprise installations' do
+      expect(client)
+        .to receive(:api_endpoint)
+        .and_return('https://github.kittens.com/')
+
+      expect(client.rate_limiting_enabled?).to eq(false)
+    end
   end
 end
diff --git a/spec/lib/gitlab/github_import/importer/diff_note_importer_spec.rb b/spec/lib/gitlab/github_import/importer/diff_note_importer_spec.rb
new file mode 100644
index 00000000000..1568c657a1e
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/diff_note_importer_spec.rb
@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::DiffNoteImporter do
+  let(:project) { create(:project) }
+  let(:client) { double(:client) }
+  let(:user) { create(:user) }
+  let(:created_at) { Time.new(2017, 1, 1, 12, 00) }
+  let(:updated_at) { Time.new(2017, 1, 1, 12, 15) }
+
+  let(:hunk) do
+    '@@ -1 +1 @@
+    -Hello
+    +Hello world'
+  end
+
+  let(:note) do
+    Gitlab::GithubImport::Representation::DiffNote.new(
+      noteable_type: 'MergeRequest',
+      noteable_id: 1,
+      commit_id: '123abc',
+      file_path: 'README.md',
+      diff_hunk: hunk,
+      author: Gitlab::GithubImport::Representation::User
+        .new(id: user.id, login: user.username),
+      note: 'Hello',
+      created_at: created_at,
+      updated_at: updated_at,
+      github_id: 1
+    )
+  end
+
+  let(:importer) { described_class.new(note, project, client) }
+
+  describe '#execute' do
+    context 'when the merge request no longer exists' do
+      it 'does not import anything' do
+        expect(Gitlab::Database).not_to receive(:bulk_insert)
+
+        importer.execute
+      end
+    end
+
+    context 'when the merge request exists' do
+      let!(:merge_request) do
+        create(:merge_request, source_project: project, target_project: project)
+      end
+
+      before do
+        allow(importer)
+          .to receive(:find_merge_request_id)
+          .and_return(merge_request.id)
+      end
+
+      it 'imports the note' do
+        allow(importer.user_finder)
+          .to receive(:author_id_for)
+          .and_return([user.id, true])
+
+        expect(Gitlab::Database)
+          .to receive(:bulk_insert)
+          .with(
+            LegacyDiffNote.table_name,
+            [
+              {
+                noteable_type: 'MergeRequest',
+                noteable_id: merge_request.id,
+                project_id: project.id,
+                author_id: user.id,
+                note: 'Hello',
+                system: false,
+                commit_id: '123abc',
+                line_code: note.line_code,
+                type: 'LegacyDiffNote',
+                created_at: created_at,
+                updated_at: updated_at,
+                st_diff: note.diff_hash.to_yaml
+              }
+            ]
+          )
+          .and_call_original
+
+        importer.execute
+      end
+
+      it 'imports the note when the author could not be found' do
+        allow(importer.user_finder)
+          .to receive(:author_id_for)
+          .and_return([project.creator_id, false])
+
+        expect(Gitlab::Database)
+          .to receive(:bulk_insert)
+          .with(
+            LegacyDiffNote.table_name,
+            [
+              {
+                noteable_type: 'MergeRequest',
+                noteable_id: merge_request.id,
+                project_id: project.id,
+                author_id: project.creator_id,
+                note: "*Created by: #{user.username}*\n\nHello",
+                system: false,
+                commit_id: '123abc',
+                line_code: note.line_code,
+                type: 'LegacyDiffNote',
+                created_at: created_at,
+                updated_at: updated_at,
+                st_diff: note.diff_hash.to_yaml
+              }
+            ]
+          )
+          .and_call_original
+
+        importer.execute
+      end
+
+      it 'produces a valid LegacyDiffNote' do
+        allow(importer.user_finder)
+          .to receive(:author_id_for)
+          .and_return([user.id, true])
+
+        importer.execute
+
+        note = project.notes.diff_notes.take
+
+        expect(note).to be_valid
+        expect(note.diff).to be_an_instance_of(Gitlab::Git::Diff)
+      end
+
+      it 'does not import the note when a foreign key error is raised' do
+        allow(importer.user_finder)
+          .to receive(:author_id_for)
+          .and_return([project.creator_id, false])
+
+        expect(Gitlab::Database)
+          .to receive(:bulk_insert)
+          .and_raise(ActiveRecord::InvalidForeignKey, 'invalid foreign key')
+
+        expect { importer.execute }.not_to raise_error
+      end
+    end
+  end
+
+  describe '#find_merge_request_id' do
+    it 'returns a merge request ID' do
+      expect_any_instance_of(Gitlab::GithubImport::IssuableFinder)
+        .to receive(:database_id)
+        .and_return(10)
+
+      expect(importer.find_merge_request_id).to eq(10)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/diff_notes_importer_spec.rb b/spec/lib/gitlab/github_import/importer/diff_notes_importer_spec.rb
new file mode 100644
index 00000000000..4713c6795bb
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/diff_notes_importer_spec.rb
@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::DiffNotesImporter do
+  let(:project) { double(:project, id: 4, import_source: 'foo/bar') }
+  let(:client) { double(:client) }
+
+  let(:github_comment) do
+    double(
+      :response,
+      html_url: 'https://github.com/foo/bar/pull/42',
+      path: 'README.md',
+      commit_id: '123abc',
+      diff_hunk: "@@ -1 +1 @@\n-Hello\n+Hello world",
+      user: double(:user, id: 4, login: 'alice'),
+      body: 'Hello world',
+      created_at: Time.zone.now,
+      updated_at: Time.zone.now,
+      id: 1
+    )
+  end
+
+  describe '#parallel?' do
+    it 'returns true when running in parallel mode' do
+      importer = described_class.new(project, client)
+      expect(importer).to be_parallel
+    end
+
+    it 'returns false when running in sequential mode' do
+      importer = described_class.new(project, client, parallel: false)
+      expect(importer).not_to be_parallel
+    end
+  end
+
+  describe '#execute' do
+    context 'when running in parallel mode' do
+      it 'imports diff notes in parallel' do
+        importer = described_class.new(project, client)
+
+        expect(importer).to receive(:parallel_import)
+
+        importer.execute
+      end
+    end
+
+    context 'when running in sequential mode' do
+      it 'imports diff notes in sequence' do
+        importer = described_class.new(project, client, parallel: false)
+
+        expect(importer).to receive(:sequential_import)
+
+        importer.execute
+      end
+    end
+  end
+
+  describe '#sequential_import' do
+    it 'imports each diff note in sequence' do
+      importer = described_class.new(project, client, parallel: false)
+      diff_note_importer = double(:diff_note_importer)
+
+      allow(importer)
+        .to receive(:each_object_to_import)
+        .and_yield(github_comment)
+
+      expect(Gitlab::GithubImport::Importer::DiffNoteImporter)
+        .to receive(:new)
+        .with(
+          an_instance_of(Gitlab::GithubImport::Representation::DiffNote),
+          project,
+          client
+        )
+        .and_return(diff_note_importer)
+
+      expect(diff_note_importer).to receive(:execute)
+
+      importer.sequential_import
+    end
+  end
+
+  describe '#parallel_import' do
+    it 'imports each diff note in parallel' do
+      importer = described_class.new(project, client)
+
+      allow(importer)
+        .to receive(:each_object_to_import)
+        .and_yield(github_comment)
+
+      expect(Gitlab::GithubImport::ImportDiffNoteWorker)
+        .to receive(:perform_async)
+        .with(project.id, an_instance_of(Hash), an_instance_of(String))
+
+      waiter = importer.parallel_import
+
+      expect(waiter).to be_an_instance_of(Gitlab::JobWaiter)
+      expect(waiter.jobs_remaining).to eq(1)
+    end
+  end
+
+  describe '#id_for_already_imported_cache' do
+    it 'returns the ID of the given note' do
+      importer = described_class.new(project, client)
+
+      expect(importer.id_for_already_imported_cache(github_comment))
+        .to eq(1)
+    end
+  end
+
+  describe '#collection_options' do
+    it 'returns an empty Hash' do
+      # For large projects (e.g. kubernetes/kubernetes) GitHub's API may produce
+      # HTTP 500 errors when using explicit sorting options, regardless of what
+      # order you sort in. Not using any sorting options at all allows us to
+      # work around this.
+      importer = described_class.new(project, client)
+
+      expect(importer.collection_options).to eq({})
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/issue_and_label_links_importer_spec.rb b/spec/lib/gitlab/github_import/importer/issue_and_label_links_importer_spec.rb
new file mode 100644
index 00000000000..665b31ef244
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/issue_and_label_links_importer_spec.rb
@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::IssueAndLabelLinksImporter do
+  describe '#execute' do
+    it 'imports an issue and its labels' do
+      issue = double(:issue)
+      project = double(:project)
+      client = double(:client)
+      label_links_instance = double(:label_links_importer)
+      importer = described_class.new(issue, project, client)
+
+      expect(Gitlab::GithubImport::Importer::IssueImporter)
+        .to receive(:import_if_issue)
+        .with(issue, project, client)
+
+      expect(Gitlab::GithubImport::Importer::LabelLinksImporter)
+        .to receive(:new)
+        .with(issue, project, client)
+        .and_return(label_links_instance)
+
+      expect(label_links_instance)
+        .to receive(:execute)
+
+      importer.execute
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/issue_importer_spec.rb b/spec/lib/gitlab/github_import/importer/issue_importer_spec.rb
new file mode 100644
index 00000000000..d34ca0b76b8
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/issue_importer_spec.rb
@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::IssueImporter, :clean_gitlab_redis_cache do
+  let(:project) { create(:project) }
+  let(:client) { double(:client) }
+  let(:user) { create(:user) }
+  let(:milestone) { create(:milestone, project: project) }
+  let(:created_at) { Time.new(2017, 1, 1, 12, 00) }
+  let(:updated_at) { Time.new(2017, 1, 1, 12, 15) }
+
+  let(:issue) do
+    Gitlab::GithubImport::Representation::Issue.new(
+      iid: 42,
+      title: 'My Issue',
+      description: 'This is my issue',
+      milestone_number: 1,
+      state: :opened,
+      assignees: [
+        Gitlab::GithubImport::Representation::User.new(id: 4, login: 'alice'),
+        Gitlab::GithubImport::Representation::User.new(id: 5, login: 'bob')
+      ],
+      label_names: %w[bug],
+      author: Gitlab::GithubImport::Representation::User.new(id: 4, login: 'alice'),
+      created_at: created_at,
+      updated_at: updated_at,
+      pull_request: false
+    )
+  end
+
+  describe '.import_if_issue' do
+    it 'imports an issuable if it is a regular issue' do
+      importer = double(:importer)
+
+      expect(described_class)
+        .to receive(:new)
+        .with(issue, project, client)
+        .and_return(importer)
+
+      expect(importer).to receive(:execute)
+
+      described_class.import_if_issue(issue, project, client)
+    end
+
+    it 'does not import the issuable if it is a pull request' do
+      expect(issue).to receive(:pull_request?).and_return(true)
+
+      expect(described_class).not_to receive(:new)
+
+      described_class.import_if_issue(issue, project, client)
+    end
+  end
+
+  describe '#execute' do
+    let(:importer) { described_class.new(issue, project, client) }
+
+    it 'creates the issue and assignees' do
+      expect(importer)
+        .to receive(:create_issue)
+        .and_return(10)
+
+      expect(importer)
+        .to receive(:create_assignees)
+        .with(10)
+
+      expect(importer.issuable_finder)
+        .to receive(:cache_database_id)
+        .with(10)
+
+      importer.execute
+    end
+  end
+
+  describe '#create_issue' do
+    let(:importer) { described_class.new(issue, project, client) }
+
+    before do
+      allow(importer.milestone_finder)
+        .to receive(:id_for)
+        .with(issue)
+        .and_return(milestone.id)
+    end
+
+    context 'when the issue author could be found' do
+      it 'creates the issue with the found author as the issue author' do
+        allow(importer.user_finder)
+          .to receive(:author_id_for)
+          .with(issue)
+          .and_return([user.id, true])
+
+        expect(Gitlab::GithubImport)
+          .to receive(:insert_and_return_id)
+          .with(
+            {
+              iid: 42,
+              title: 'My Issue',
+              author_id: user.id,
+              project_id: project.id,
+              description: 'This is my issue',
+              milestone_id: milestone.id,
+              state: :opened,
+              created_at: created_at,
+              updated_at: updated_at
+            },
+            project.issues
+          )
+          .and_call_original
+
+        importer.create_issue
+      end
+    end
+
+    context 'when the issue author could not be found' do
+      it 'creates the issue with the project creator as the issue author' do
+        allow(importer.user_finder)
+          .to receive(:author_id_for)
+          .with(issue)
+          .and_return([project.creator_id, false])
+
+        expect(Gitlab::GithubImport)
+          .to receive(:insert_and_return_id)
+          .with(
+            {
+              iid: 42,
+              title: 'My Issue',
+              author_id: project.creator_id,
+              project_id: project.id,
+              description: "*Created by: alice*\n\nThis is my issue",
+              milestone_id: milestone.id,
+              state: :opened,
+              created_at: created_at,
+              updated_at: updated_at
+            },
+            project.issues
+          )
+          .and_call_original
+
+        importer.create_issue
+      end
+    end
+
+    context 'when the import fails due to a foreign key error' do
+      it 'does not raise any errors' do
+        allow(importer.user_finder)
+          .to receive(:author_id_for)
+          .with(issue)
+          .and_return([user.id, true])
+
+        expect(Gitlab::GithubImport)
+          .to receive(:insert_and_return_id)
+          .and_raise(ActiveRecord::InvalidForeignKey, 'invalid foreign key')
+
+        expect { importer.create_issue }.not_to raise_error
+      end
+    end
+
+    it 'produces a valid Issue' do
+      allow(importer.user_finder)
+        .to receive(:author_id_for)
+        .with(issue)
+        .and_return([user.id, true])
+
+      importer.create_issue
+
+      expect(project.issues.take).to be_valid
+    end
+
+    it 'returns the ID of the created issue' do
+      allow(importer.user_finder)
+        .to receive(:author_id_for)
+        .with(issue)
+        .and_return([user.id, true])
+
+      expect(importer.create_issue).to be_a_kind_of(Numeric)
+    end
+  end
+
+  describe '#create_assignees' do
+    it 'inserts the issue assignees in bulk' do
+      importer = described_class.new(issue, project, client)
+
+      allow(importer.user_finder)
+        .to receive(:user_id_for)
+        .ordered.with(issue.assignees[0])
+        .and_return(4)
+
+      allow(importer.user_finder)
+        .to receive(:user_id_for)
+        .ordered.with(issue.assignees[1])
+        .and_return(5)
+
+      expect(Gitlab::Database)
+        .to receive(:bulk_insert)
+        .with(
+          IssueAssignee.table_name,
+          [{ issue_id: 1, user_id: 4 }, { issue_id: 1, user_id: 5 }]
+        )
+
+      importer.create_assignees(1)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/issues_importer_spec.rb b/spec/lib/gitlab/github_import/importer/issues_importer_spec.rb
new file mode 100644
index 00000000000..e237e79e94b
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/issues_importer_spec.rb
@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::IssuesImporter do
+  let(:project) { double(:project, id: 4, import_source: 'foo/bar') }
+  let(:client) { double(:client) }
+  let(:created_at) { Time.new(2017, 1, 1, 12, 00) }
+  let(:updated_at) { Time.new(2017, 1, 1, 12, 15) }
+
+  let(:github_issue) do
+    double(
+      :response,
+      number: 42,
+      title: 'My Issue',
+      body: 'This is my issue',
+      milestone: double(:milestone, number: 4),
+      state: 'open',
+      assignees: [double(:user, id: 4, login: 'alice')],
+      labels: [double(:label, name: 'bug')],
+      user: double(:user, id: 4, login: 'alice'),
+      created_at: created_at,
+      updated_at: updated_at,
+      pull_request: false
+    )
+  end
+
+  describe '#parallel?' do
+    it 'returns true when running in parallel mode' do
+      importer = described_class.new(project, client)
+      expect(importer).to be_parallel
+    end
+
+    it 'returns false when running in sequential mode' do
+      importer = described_class.new(project, client, parallel: false)
+      expect(importer).not_to be_parallel
+    end
+  end
+
+  describe '#execute' do
+    context 'when running in parallel mode' do
+      it 'imports issues in parallel' do
+        importer = described_class.new(project, client)
+
+        expect(importer).to receive(:parallel_import)
+
+        importer.execute
+      end
+    end
+
+    context 'when running in sequential mode' do
+      it 'imports issues in sequence' do
+        importer = described_class.new(project, client, parallel: false)
+
+        expect(importer).to receive(:sequential_import)
+
+        importer.execute
+      end
+    end
+  end
+
+  describe '#sequential_import' do
+    it 'imports each issue in sequence' do
+      importer = described_class.new(project, client, parallel: false)
+      issue_importer = double(:importer)
+
+      allow(importer)
+        .to receive(:each_object_to_import)
+        .and_yield(github_issue)
+
+      expect(Gitlab::GithubImport::Importer::IssueAndLabelLinksImporter)
+        .to receive(:new)
+        .with(
+          an_instance_of(Gitlab::GithubImport::Representation::Issue),
+          project,
+          client
+        )
+        .and_return(issue_importer)
+
+      expect(issue_importer).to receive(:execute)
+
+      importer.sequential_import
+    end
+  end
+
+  describe '#parallel_import' do
+    it 'imports each issue in parallel' do
+      importer = described_class.new(project, client)
+
+      allow(importer)
+        .to receive(:each_object_to_import)
+        .and_yield(github_issue)
+
+      expect(Gitlab::GithubImport::ImportIssueWorker)
+        .to receive(:perform_async)
+        .with(project.id, an_instance_of(Hash), an_instance_of(String))
+
+      waiter = importer.parallel_import
+
+      expect(waiter).to be_an_instance_of(Gitlab::JobWaiter)
+      expect(waiter.jobs_remaining).to eq(1)
+    end
+  end
+
+  describe '#id_for_already_imported_cache' do
+    it 'returns the issue number of the given issue' do
+      importer = described_class.new(project, client)
+
+      expect(importer.id_for_already_imported_cache(github_issue))
+        .to eq(42)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/label_links_importer_spec.rb b/spec/lib/gitlab/github_import/importer/label_links_importer_spec.rb
new file mode 100644
index 00000000000..e2a71e78574
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/label_links_importer_spec.rb
@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::LabelLinksImporter do
+  let(:project) { create(:project) }
+  let(:client) { double(:client) }
+  let(:issue) do
+    double(
+      :issue,
+      iid: 4,
+      label_names: %w[bug],
+      issuable_type: Issue,
+      pull_request?: false
+    )
+  end
+
+  let(:importer) { described_class.new(issue, project, client) }
+
+  describe '#execute' do
+    it 'creates the label links' do
+      importer = described_class.new(issue, project, client)
+
+      expect(importer).to receive(:create_labels)
+
+      importer.execute
+    end
+  end
+
+  describe '#create_labels' do
+    it 'inserts the label links in bulk' do
+      expect(importer.label_finder)
+        .to receive(:id_for)
+        .with('bug')
+        .and_return(2)
+
+      expect(importer)
+        .to receive(:find_target_id)
+        .and_return(1)
+
+      Timecop.freeze do
+        expect(Gitlab::Database)
+          .to receive(:bulk_insert)
+          .with(
+            LabelLink.table_name,
+            [
+              {
+                label_id: 2,
+                target_id: 1,
+                target_type: Issue,
+                created_at: Time.zone.now,
+                updated_at: Time.zone.now
+              }
+            ]
+          )
+
+        importer.create_labels
+      end
+    end
+
+    it 'does not insert label links for non-existing labels' do
+      expect(importer.label_finder)
+        .to receive(:id_for)
+        .with('bug')
+        .and_return(nil)
+
+      expect(Gitlab::Database)
+        .to receive(:bulk_insert)
+        .with(LabelLink.table_name, [])
+
+      importer.create_labels
+    end
+  end
+
+  describe '#find_target_id' do
+    it 'returns the ID of the issuable to create the label link for' do
+      expect_any_instance_of(Gitlab::GithubImport::IssuableFinder)
+        .to receive(:database_id)
+        .and_return(10)
+
+      expect(importer.find_target_id).to eq(10)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/labels_importer_spec.rb b/spec/lib/gitlab/github_import/importer/labels_importer_spec.rb
new file mode 100644
index 00000000000..156ef96a0fa
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/labels_importer_spec.rb
@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::LabelsImporter, :clean_gitlab_redis_cache do
+  let(:project) { create(:project, import_source: 'foo/bar') }
+  let(:client) { double(:client) }
+  let(:importer) { described_class.new(project, client) }
+
+  describe '#execute' do
+    it 'imports the labels in bulk' do
+      label_hash = { title: 'bug', color: '#fffaaa' }
+
+      expect(importer)
+        .to receive(:build_labels)
+        .and_return([label_hash])
+
+      expect(importer)
+        .to receive(:bulk_insert)
+        .with(Label, [label_hash])
+
+      expect(importer)
+        .to receive(:build_labels_cache)
+
+      importer.execute
+    end
+  end
+
+  describe '#build_labels' do
+    it 'returns an Array containnig label rows' do
+      label = double(:label, name: 'bug', color: 'ffffff')
+
+      expect(importer).to receive(:each_label).and_return([label])
+
+      rows = importer.build_labels
+
+      expect(rows.length).to eq(1)
+      expect(rows[0][:title]).to eq('bug')
+    end
+
+    it 'does not create labels that already exist' do
+      create(:label, project: project, title: 'bug')
+
+      label = double(:label, name: 'bug', color: 'ffffff')
+
+      expect(importer).to receive(:each_label).and_return([label])
+      expect(importer.build_labels).to be_empty
+    end
+  end
+
+  describe '#build_labels_cache' do
+    it 'builds the labels cache' do
+      expect_any_instance_of(Gitlab::GithubImport::LabelFinder)
+        .to receive(:build_cache)
+
+      importer.build_labels_cache
+    end
+  end
+
+  describe '#build' do
+    let(:label_hash) do
+      importer.build(double(:label, name: 'bug', color: 'ffffff'))
+    end
+
+    it 'returns the attributes of the label as a Hash' do
+      expect(label_hash).to be_an_instance_of(Hash)
+    end
+
+    context 'the returned Hash' do
+      it 'includes the label title' do
+        expect(label_hash[:title]).to eq('bug')
+      end
+
+      it 'includes the label color' do
+        expect(label_hash[:color]).to eq('#ffffff')
+      end
+
+      it 'includes the project ID' do
+        expect(label_hash[:project_id]).to eq(project.id)
+      end
+
+      it 'includes the label type' do
+        expect(label_hash[:type]).to eq('ProjectLabel')
+      end
+
+      it 'includes the created timestamp' do
+        Timecop.freeze do
+          expect(label_hash[:created_at]).to eq(Time.zone.now)
+        end
+      end
+
+      it 'includes the updated timestamp' do
+        Timecop.freeze do
+          expect(label_hash[:updated_at]).to eq(Time.zone.now)
+        end
+      end
+    end
+  end
+
+  describe '#each_label' do
+    it 'returns the labels' do
+      expect(client)
+        .to receive(:labels)
+        .with('foo/bar')
+
+      importer.each_label
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/milestones_importer_spec.rb b/spec/lib/gitlab/github_import/importer/milestones_importer_spec.rb
new file mode 100644
index 00000000000..b1cac3b6e46
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/milestones_importer_spec.rb
@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::MilestonesImporter, :clean_gitlab_redis_cache do
+  let(:project) { create(:project, import_source: 'foo/bar') }
+  let(:client) { double(:client) }
+  let(:importer) { described_class.new(project, client) }
+  let(:created_at) { Time.new(2017, 1, 1, 12, 00) }
+  let(:updated_at) { Time.new(2017, 1, 1, 12, 15) }
+
+  let(:milestone) do
+    double(
+      :milestone,
+      number: 1,
+      title: '1.0',
+      description: 'The first release',
+      state: 'open',
+      created_at: created_at,
+      updated_at: updated_at
+    )
+  end
+
+  describe '#execute' do
+    it 'imports the milestones in bulk' do
+      milestone_hash = { number: 1, title: '1.0' }
+
+      expect(importer)
+        .to receive(:build_milestones)
+        .and_return([milestone_hash])
+
+      expect(importer)
+        .to receive(:bulk_insert)
+        .with(Milestone, [milestone_hash])
+
+      expect(importer)
+        .to receive(:build_milestones_cache)
+
+      importer.execute
+    end
+  end
+
+  describe '#build_milestones' do
+    it 'returns an Array containnig milestone rows' do
+      expect(importer)
+        .to receive(:each_milestone)
+        .and_return([milestone])
+
+      rows = importer.build_milestones
+
+      expect(rows.length).to eq(1)
+      expect(rows[0][:title]).to eq('1.0')
+    end
+
+    it 'does not create milestones that already exist' do
+      create(:milestone, project: project, title: '1.0', iid: 1)
+
+      expect(importer)
+        .to receive(:each_milestone)
+        .and_return([milestone])
+
+      expect(importer.build_milestones).to be_empty
+    end
+  end
+
+  describe '#build_milestones_cache' do
+    it 'builds the milestones cache' do
+      expect_any_instance_of(Gitlab::GithubImport::MilestoneFinder)
+        .to receive(:build_cache)
+
+      importer.build_milestones_cache
+    end
+  end
+
+  describe '#build' do
+    let(:milestone_hash) { importer.build(milestone) }
+
+    it 'returns the attributes of the milestone as a Hash' do
+      expect(milestone_hash).to be_an_instance_of(Hash)
+    end
+
+    context 'the returned Hash' do
+      it 'includes the milestone number' do
+        expect(milestone_hash[:iid]).to eq(1)
+      end
+
+      it 'includes the milestone title' do
+        expect(milestone_hash[:title]).to eq('1.0')
+      end
+
+      it 'includes the milestone description' do
+        expect(milestone_hash[:description]).to eq('The first release')
+      end
+
+      it 'includes the project ID' do
+        expect(milestone_hash[:project_id]).to eq(project.id)
+      end
+
+      it 'includes the milestone state' do
+        expect(milestone_hash[:state]).to eq(:active)
+      end
+
+      it 'includes the created timestamp' do
+        expect(milestone_hash[:created_at]).to eq(created_at)
+      end
+
+      it 'includes the updated timestamp' do
+        expect(milestone_hash[:updated_at]).to eq(updated_at)
+      end
+    end
+  end
+
+  describe '#each_milestone' do
+    it 'returns the milestones' do
+      expect(client)
+        .to receive(:milestones)
+        .with('foo/bar', state: 'all')
+
+      importer.each_milestone
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/note_importer_spec.rb b/spec/lib/gitlab/github_import/importer/note_importer_spec.rb
new file mode 100644
index 00000000000..9bdcc42be19
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/note_importer_spec.rb
@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::NoteImporter do
+  let(:client) { double(:client) }
+  let(:project) { create(:project) }
+  let(:user) { create(:user) }
+  let(:created_at) { Time.new(2017, 1, 1, 12, 00) }
+  let(:updated_at) { Time.new(2017, 1, 1, 12, 15) }
+
+  let(:github_note) do
+    Gitlab::GithubImport::Representation::Note.new(
+      noteable_id: 1,
+      noteable_type: 'Issue',
+      author: Gitlab::GithubImport::Representation::User.new(id: 4, login: 'alice'),
+      note: 'This is my note',
+      created_at: created_at,
+      updated_at: updated_at,
+      github_id: 1
+    )
+  end
+
+  let(:importer) { described_class.new(github_note, project, client) }
+
+  describe '#execute' do
+    context 'when the noteable exists' do
+      let!(:issue_row) { create(:issue, project: project, iid: 1) }
+
+      before do
+        allow(importer)
+          .to receive(:find_noteable_id)
+          .and_return(issue_row.id)
+      end
+
+      context 'when the author could be found' do
+        it 'imports the note with the found author as the note author' do
+          expect(importer.user_finder)
+            .to receive(:author_id_for)
+            .with(github_note)
+            .and_return([user.id, true])
+
+          expect(Gitlab::Database)
+            .to receive(:bulk_insert)
+            .with(
+              Note.table_name,
+              [
+                {
+                  noteable_type: 'Issue',
+                  noteable_id: issue_row.id,
+                  project_id: project.id,
+                  author_id: user.id,
+                  note: 'This is my note',
+                  system: false,
+                  created_at: created_at,
+                  updated_at: updated_at
+                }
+              ]
+            )
+            .and_call_original
+
+          importer.execute
+        end
+      end
+
+      context 'when the note author could not be found' do
+        it 'imports the note with the project creator as the note author' do
+          expect(importer.user_finder)
+            .to receive(:author_id_for)
+            .with(github_note)
+            .and_return([project.creator_id, false])
+
+          expect(Gitlab::Database)
+            .to receive(:bulk_insert)
+            .with(
+              Note.table_name,
+              [
+                {
+                  noteable_type: 'Issue',
+                  noteable_id: issue_row.id,
+                  project_id: project.id,
+                  author_id: project.creator_id,
+                  note: "*Created by: alice*\n\nThis is my note",
+                  system: false,
+                  created_at: created_at,
+                  updated_at: updated_at
+                }
+              ]
+            )
+            .and_call_original
+
+          importer.execute
+        end
+      end
+    end
+
+    context 'when the noteable does not exist' do
+      it 'does not import the note' do
+        expect(Gitlab::Database).not_to receive(:bulk_insert)
+
+        importer.execute
+      end
+    end
+
+    context 'when the import fails due to a foreign key error' do
+      it 'does not raise any errors' do
+        issue_row = create(:issue, project: project, iid: 1)
+
+        allow(importer)
+          .to receive(:find_noteable_id)
+          .and_return(issue_row.id)
+
+        allow(importer.user_finder)
+          .to receive(:author_id_for)
+          .with(github_note)
+          .and_return([user.id, true])
+
+        expect(Gitlab::Database)
+          .to receive(:bulk_insert)
+          .and_raise(ActiveRecord::InvalidForeignKey, 'invalid foreign key')
+
+        expect { importer.execute }.not_to raise_error
+      end
+    end
+
+    it 'produces a valid Note' do
+      issue_row = create(:issue, project: project, iid: 1)
+
+      allow(importer)
+        .to receive(:find_noteable_id)
+        .and_return(issue_row.id)
+
+      allow(importer.user_finder)
+        .to receive(:author_id_for)
+        .with(github_note)
+        .and_return([user.id, true])
+
+      importer.execute
+
+      expect(project.notes.take).to be_valid
+    end
+  end
+
+  describe '#find_noteable_id' do
+    it 'returns the ID of the noteable' do
+      expect_any_instance_of(Gitlab::GithubImport::IssuableFinder)
+        .to receive(:database_id)
+        .and_return(10)
+
+      expect(importer.find_noteable_id).to eq(10)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/notes_importer_spec.rb b/spec/lib/gitlab/github_import/importer/notes_importer_spec.rb
new file mode 100644
index 00000000000..f046d13f879
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/notes_importer_spec.rb
@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::NotesImporter do
+  let(:project) { double(:project, id: 4, import_source: 'foo/bar') }
+  let(:client) { double(:client) }
+
+  let(:github_comment) do
+    double(
+      :response,
+      html_url: 'https://github.com/foo/bar/issues/42',
+      user: double(:user, id: 4, login: 'alice'),
+      body: 'Hello world',
+      created_at: Time.zone.now,
+      updated_at: Time.zone.now,
+      id: 1
+    )
+  end
+
+  describe '#parallel?' do
+    it 'returns true when running in parallel mode' do
+      importer = described_class.new(project, client)
+      expect(importer).to be_parallel
+    end
+
+    it 'returns false when running in sequential mode' do
+      importer = described_class.new(project, client, parallel: false)
+      expect(importer).not_to be_parallel
+    end
+  end
+
+  describe '#execute' do
+    context 'when running in parallel mode' do
+      it 'imports notes in parallel' do
+        importer = described_class.new(project, client)
+
+        expect(importer).to receive(:parallel_import)
+
+        importer.execute
+      end
+    end
+
+    context 'when running in sequential mode' do
+      it 'imports notes in sequence' do
+        importer = described_class.new(project, client, parallel: false)
+
+        expect(importer).to receive(:sequential_import)
+
+        importer.execute
+      end
+    end
+  end
+
+  describe '#sequential_import' do
+    it 'imports each note in sequence' do
+      importer = described_class.new(project, client, parallel: false)
+      note_importer = double(:note_importer)
+
+      allow(importer)
+        .to receive(:each_object_to_import)
+        .and_yield(github_comment)
+
+      expect(Gitlab::GithubImport::Importer::NoteImporter)
+        .to receive(:new)
+        .with(
+          an_instance_of(Gitlab::GithubImport::Representation::Note),
+          project,
+          client
+        )
+        .and_return(note_importer)
+
+      expect(note_importer).to receive(:execute)
+
+      importer.sequential_import
+    end
+  end
+
+  describe '#parallel_import' do
+    it 'imports each note in parallel' do
+      importer = described_class.new(project, client)
+
+      allow(importer)
+        .to receive(:each_object_to_import)
+        .and_yield(github_comment)
+
+      expect(Gitlab::GithubImport::ImportNoteWorker)
+        .to receive(:perform_async)
+        .with(project.id, an_instance_of(Hash), an_instance_of(String))
+
+      waiter = importer.parallel_import
+
+      expect(waiter).to be_an_instance_of(Gitlab::JobWaiter)
+      expect(waiter.jobs_remaining).to eq(1)
+    end
+  end
+
+  describe '#id_for_already_imported_cache' do
+    it 'returns the ID of the given note' do
+      importer = described_class.new(project, client)
+
+      expect(importer.id_for_already_imported_cache(github_comment))
+        .to eq(1)
+    end
+  end
+
+  describe '#collection_options' do
+    it 'returns an empty Hash' do
+      # For large projects (e.g. kubernetes/kubernetes) GitHub's API may produce
+      # HTTP 500 errors when using explicit sorting options, regardless of what
+      # order you sort in. Not using any sorting options at all allows us to
+      # work around this.
+      importer = described_class.new(project, client)
+
+      expect(importer.collection_options).to eq({})
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/pull_request_importer_spec.rb b/spec/lib/gitlab/github_import/importer/pull_request_importer_spec.rb
new file mode 100644
index 00000000000..35f3fdf8304
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/pull_request_importer_spec.rb
@@ -0,0 +1,221 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::PullRequestImporter, :clean_gitlab_redis_cache do
+  let(:project) { create(:project, :repository) }
+  let(:client) { double(:client) }
+  let(:user) { create(:user) }
+  let(:created_at) { Time.new(2017, 1, 1, 12, 00) }
+  let(:updated_at) { Time.new(2017, 1, 1, 12, 15) }
+  let(:merged_at) { Time.new(2017, 1, 1, 12, 17) }
+
+  let(:source_commit) { project.repository.commit('feature') }
+  let(:target_commit) { project.repository.commit('master') }
+  let(:milestone) { create(:milestone, project: project) }
+
+  let(:pull_request) do
+    alice = Gitlab::GithubImport::Representation::User.new(id: 4, login: 'alice')
+
+    Gitlab::GithubImport::Representation::PullRequest.new(
+      iid: 42,
+      title: 'My Pull Request',
+      description: 'This is my pull request',
+      source_branch: 'feature',
+      source_branch_sha: source_commit.id,
+      target_branch: 'master',
+      target_branch_sha: target_commit.id,
+      source_repository_id: 400,
+      target_repository_id: 200,
+      source_repository_owner: 'alice',
+      state: :closed,
+      milestone_number: milestone.iid,
+      author: alice,
+      assignee: alice,
+      created_at: created_at,
+      updated_at: updated_at,
+      merged_at: merged_at
+    )
+  end
+
+  let(:importer) { described_class.new(pull_request, project, client) }
+
+  describe '#execute' do
+    it 'imports the pull request' do
+      expect(importer)
+        .to receive(:create_merge_request)
+        .and_return(10)
+
+      expect_any_instance_of(Gitlab::GithubImport::IssuableFinder)
+        .to receive(:cache_database_id)
+        .with(10)
+
+      importer.execute
+    end
+  end
+
+  describe '#create_merge_request' do
+    before do
+      allow(importer.milestone_finder)
+        .to receive(:id_for)
+        .with(pull_request)
+        .and_return(milestone.id)
+    end
+
+    context 'when the author could be found' do
+      before do
+        allow(importer.user_finder)
+          .to receive(:author_id_for)
+          .with(pull_request)
+          .and_return([user.id, true])
+
+        allow(importer.user_finder)
+          .to receive(:assignee_id_for)
+          .with(pull_request)
+          .and_return(user.id)
+      end
+
+      it 'imports the pull request with the pull request author as the merge request author' do
+        expect(Gitlab::GithubImport)
+          .to receive(:insert_and_return_id)
+          .with(
+            {
+              iid: 42,
+              title: 'My Pull Request',
+              description: 'This is my pull request',
+              source_project_id: project.id,
+              target_project_id: project.id,
+              source_branch: 'alice:feature',
+              target_branch: 'master',
+              state: :merged,
+              milestone_id: milestone.id,
+              author_id: user.id,
+              assignee_id: user.id,
+              created_at: created_at,
+              updated_at: updated_at
+            },
+            project.merge_requests
+          )
+          .and_call_original
+
+        importer.create_merge_request
+      end
+
+      it 'returns the ID of the created merge request' do
+        id = importer.create_merge_request
+
+        expect(id).to be_a_kind_of(Numeric)
+      end
+
+      it 'creates the merge request diffs' do
+        importer.create_merge_request
+
+        mr = project.merge_requests.take
+
+        expect(mr.merge_request_diffs.exists?).to eq(true)
+      end
+    end
+
+    context 'when the author could not be found' do
+      it 'imports the pull request with the project creator as the merge request author' do
+        allow(importer.user_finder)
+          .to receive(:author_id_for)
+          .with(pull_request)
+          .and_return([project.creator_id, false])
+
+        allow(importer.user_finder)
+          .to receive(:assignee_id_for)
+          .with(pull_request)
+          .and_return(user.id)
+
+        expect(Gitlab::GithubImport)
+          .to receive(:insert_and_return_id)
+          .with(
+            {
+              iid: 42,
+              title: 'My Pull Request',
+              description: "*Created by: alice*\n\nThis is my pull request",
+              source_project_id: project.id,
+              target_project_id: project.id,
+              source_branch: 'alice:feature',
+              target_branch: 'master',
+              state: :merged,
+              milestone_id: milestone.id,
+              author_id: project.creator_id,
+              assignee_id: user.id,
+              created_at: created_at,
+              updated_at: updated_at
+            },
+            project.merge_requests
+          )
+          .and_call_original
+
+        importer.create_merge_request
+      end
+    end
+
+    context 'when the source and target branch are identical' do
+      it 'uses a generated source branch name for the merge request' do
+        allow(importer.user_finder)
+          .to receive(:author_id_for)
+          .with(pull_request)
+          .and_return([user.id, true])
+
+        allow(importer.user_finder)
+          .to receive(:assignee_id_for)
+          .with(pull_request)
+          .and_return(user.id)
+
+        allow(pull_request)
+          .to receive(:source_repository_id)
+          .and_return(pull_request.target_repository_id)
+
+        allow(pull_request)
+          .to receive(:source_branch)
+          .and_return('master')
+
+        expect(Gitlab::GithubImport)
+          .to receive(:insert_and_return_id)
+          .with(
+            {
+              iid: 42,
+              title: 'My Pull Request',
+              description: 'This is my pull request',
+              source_project_id: project.id,
+              target_project_id: project.id,
+              source_branch: 'master-42',
+              target_branch: 'master',
+              state: :merged,
+              milestone_id: milestone.id,
+              author_id: user.id,
+              assignee_id: user.id,
+              created_at: created_at,
+              updated_at: updated_at
+            },
+            project.merge_requests
+          )
+          .and_call_original
+
+        importer.create_merge_request
+      end
+    end
+
+    context 'when the import fails due to a foreign key error' do
+      it 'does not raise any errors' do
+        allow(importer.user_finder)
+          .to receive(:author_id_for)
+          .with(pull_request)
+          .and_return([user.id, true])
+
+        allow(importer.user_finder)
+          .to receive(:assignee_id_for)
+          .with(pull_request)
+          .and_return(user.id)
+
+        expect(Gitlab::GithubImport)
+          .to receive(:insert_and_return_id)
+          .and_raise(ActiveRecord::InvalidForeignKey, 'invalid foreign key')
+
+        expect { importer.create_merge_request }.not_to raise_error
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/pull_requests_importer_spec.rb b/spec/lib/gitlab/github_import/importer/pull_requests_importer_spec.rb
new file mode 100644
index 00000000000..d72572cd510
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/pull_requests_importer_spec.rb
@@ -0,0 +1,272 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::PullRequestsImporter do
+  let(:project) { create(:project, import_source: 'foo/bar') }
+  let(:client) { double(:client) }
+
+  let(:pull_request) do
+    double(
+      :response,
+      number: 42,
+      title: 'My Pull Request',
+      body: 'This is my pull request',
+      state: 'closed',
+      head: double(
+        :head,
+        sha: '123abc',
+        ref: 'my-feature',
+        repo: double(:repo, id: 400),
+        user: double(:user, id: 4, login: 'alice')
+      ),
+      base: double(
+        :base,
+        sha: '456def',
+        ref: 'master',
+        repo: double(:repo, id: 200)
+      ),
+      milestone: double(:milestone, number: 4),
+      user: double(:user, id: 4, login: 'alice'),
+      assignee: double(:user, id: 4, login: 'alice'),
+      created_at: Time.zone.now,
+      updated_at: Time.zone.now,
+      merged_at: Time.zone.now
+    )
+  end
+
+  describe '#parallel?' do
+    it 'returns true when running in parallel mode' do
+      importer = described_class.new(project, client)
+      expect(importer).to be_parallel
+    end
+
+    it 'returns false when running in sequential mode' do
+      importer = described_class.new(project, client, parallel: false)
+      expect(importer).not_to be_parallel
+    end
+  end
+
+  describe '#execute' do
+    context 'when running in parallel mode' do
+      it 'imports pull requests in parallel' do
+        importer = described_class.new(project, client)
+
+        expect(importer).to receive(:parallel_import)
+
+        importer.execute
+      end
+    end
+
+    context 'when running in sequential mode' do
+      it 'imports pull requests in sequence' do
+        importer = described_class.new(project, client, parallel: false)
+
+        expect(importer).to receive(:sequential_import)
+
+        importer.execute
+      end
+    end
+  end
+
+  describe '#sequential_import' do
+    it 'imports each pull request in sequence' do
+      importer = described_class.new(project, client, parallel: false)
+      pull_request_importer = double(:pull_request_importer)
+
+      allow(importer)
+        .to receive(:each_object_to_import)
+        .and_yield(pull_request)
+
+      expect(Gitlab::GithubImport::Importer::PullRequestImporter)
+        .to receive(:new)
+        .with(
+          an_instance_of(Gitlab::GithubImport::Representation::PullRequest),
+          project,
+          client
+        )
+        .and_return(pull_request_importer)
+
+      expect(pull_request_importer).to receive(:execute)
+
+      importer.sequential_import
+    end
+  end
+
+  describe '#parallel_import' do
+    it 'imports each note in parallel' do
+      importer = described_class.new(project, client)
+
+      allow(importer)
+        .to receive(:each_object_to_import)
+        .and_yield(pull_request)
+
+      expect(Gitlab::GithubImport::ImportPullRequestWorker)
+        .to receive(:perform_async)
+        .with(project.id, an_instance_of(Hash), an_instance_of(String))
+
+      waiter = importer.parallel_import
+
+      expect(waiter).to be_an_instance_of(Gitlab::JobWaiter)
+      expect(waiter.jobs_remaining).to eq(1)
+    end
+  end
+
+  describe '#each_object_to_import', :clean_gitlab_redis_cache do
+    let(:importer) { described_class.new(project, client) }
+
+    before do
+      page = double(:page, objects: [pull_request], number: 1)
+
+      expect(client)
+        .to receive(:each_page)
+        .with(
+          :pull_requests,
+          'foo/bar',
+          { state: 'all', sort: 'created', direction: 'asc', page: 1 }
+        )
+        .and_yield(page)
+    end
+
+    it 'yields every pull request to the supplied block' do
+      expect { |b| importer.each_object_to_import(&b) }
+        .to yield_with_args(pull_request)
+    end
+
+    it 'updates the repository if a pull request was updated after the last clone' do
+      expect(importer)
+        .to receive(:update_repository?)
+        .with(pull_request)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:update_repository)
+
+      importer.each_object_to_import { }
+    end
+  end
+
+  describe '#update_repository' do
+    it 'updates the repository' do
+      importer = described_class.new(project, client)
+
+      expect(project.repository)
+        .to receive(:fetch_remote)
+        .with('github', forced: false)
+
+      expect(Rails.logger)
+        .to receive(:info)
+        .with(an_instance_of(String))
+
+      expect(importer.repository_updates_counter)
+        .to receive(:increment)
+        .with(project: project.path_with_namespace)
+        .and_call_original
+
+      Timecop.freeze do
+        importer.update_repository
+
+        expect(project.last_repository_updated_at).to eq(Time.zone.now)
+      end
+    end
+  end
+
+  describe '#update_repository?' do
+    let(:importer) { described_class.new(project, client) }
+
+    context 'when the pull request was updated after the last update' do
+      let(:pr) do
+        double(
+          :pr,
+          updated_at: Time.zone.now,
+          head: double(:head, sha: '123'),
+          base: double(:base, sha: '456')
+        )
+      end
+
+      before do
+        allow(project)
+          .to receive(:last_repository_updated_at)
+          .and_return(1.year.ago)
+      end
+
+      it 'returns true when the head SHA is not present' do
+        expect(importer)
+          .to receive(:commit_exists?)
+          .with(pr.head.sha)
+          .and_return(false)
+
+        expect(importer.update_repository?(pr)).to eq(true)
+      end
+
+      it 'returns true when the base SHA is not present' do
+        expect(importer)
+          .to receive(:commit_exists?)
+          .with(pr.head.sha)
+          .and_return(true)
+
+        expect(importer)
+          .to receive(:commit_exists?)
+          .with(pr.base.sha)
+          .and_return(false)
+
+        expect(importer.update_repository?(pr)).to eq(true)
+      end
+
+      it 'returns false if both the head and base SHAs are present' do
+        expect(importer)
+          .to receive(:commit_exists?)
+          .with(pr.head.sha)
+          .and_return(true)
+
+        expect(importer)
+          .to receive(:commit_exists?)
+          .with(pr.base.sha)
+          .and_return(true)
+
+        expect(importer.update_repository?(pr)).to eq(false)
+      end
+    end
+
+    context 'when the pull request was updated before the last update' do
+      it 'returns false' do
+        pr = double(:pr, updated_at: 1.year.ago)
+
+        allow(project)
+          .to receive(:last_repository_updated_at)
+          .and_return(Time.zone.now)
+
+        expect(importer.update_repository?(pr)).to eq(false)
+      end
+    end
+  end
+
+  describe '#commit_exists?' do
+    let(:importer) { described_class.new(project, client) }
+
+    it 'returns true when a commit exists' do
+      expect(project.repository)
+        .to receive(:lookup)
+        .with('123')
+        .and_return(double(:commit))
+
+      expect(importer.commit_exists?('123')).to eq(true)
+    end
+
+    it 'returns false when a commit does not exist' do
+      expect(project.repository)
+        .to receive(:lookup)
+        .with('123')
+        .and_raise(Rugged::OdbError)
+
+      expect(importer.commit_exists?('123')).to eq(false)
+    end
+  end
+
+  describe '#id_for_already_imported_cache' do
+    it 'returns the PR number of the given PR' do
+      importer = described_class.new(project, client)
+
+      expect(importer.id_for_already_imported_cache(pull_request))
+        .to eq(42)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/releases_importer_spec.rb b/spec/lib/gitlab/github_import/importer/releases_importer_spec.rb
new file mode 100644
index 00000000000..23ae026fb14
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/releases_importer_spec.rb
@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::ReleasesImporter do
+  let(:project) { create(:project) }
+  let(:client) { double(:client) }
+  let(:importer) { described_class.new(project, client) }
+  let(:created_at) { Time.new(2017, 1, 1, 12, 00) }
+  let(:updated_at) { Time.new(2017, 1, 1, 12, 15) }
+
+  let(:release) do
+    double(
+      :release,
+      tag_name: '1.0',
+      body: 'This is my release',
+      created_at: created_at,
+      updated_at: updated_at
+    )
+  end
+
+  describe '#execute' do
+    it 'imports the releases in bulk' do
+      release_hash = {
+        tag_name: '1.0',
+        description: 'This is my release',
+        created_at: created_at,
+        updated_at: updated_at
+      }
+
+      expect(importer).to receive(:build_releases).and_return([release_hash])
+      expect(importer).to receive(:bulk_insert).with(Release, [release_hash])
+
+      importer.execute
+    end
+  end
+
+  describe '#build_releases' do
+    it 'returns an Array containnig release rows' do
+      expect(importer).to receive(:each_release).and_return([release])
+
+      rows = importer.build_releases
+
+      expect(rows.length).to eq(1)
+      expect(rows[0][:tag]).to eq('1.0')
+    end
+
+    it 'does not create releases that already exist' do
+      create(:release, project: project, tag: '1.0', description: '1.0')
+
+      expect(importer).to receive(:each_release).and_return([release])
+      expect(importer.build_releases).to be_empty
+    end
+
+    it 'uses a default release description if none is provided' do
+      expect(release).to receive(:body).and_return('')
+      expect(importer).to receive(:each_release).and_return([release])
+
+      release = importer.build_releases.first
+
+      expect(release[:description]).to eq('Release for tag 1.0')
+    end
+  end
+
+  describe '#build' do
+    let(:release_hash) { importer.build(release) }
+
+    it 'returns the attributes of the release as a Hash' do
+      expect(release_hash).to be_an_instance_of(Hash)
+    end
+
+    context 'the returned Hash' do
+      it 'includes the tag name' do
+        expect(release_hash[:tag]).to eq('1.0')
+      end
+
+      it 'includes the release description' do
+        expect(release_hash[:description]).to eq('This is my release')
+      end
+
+      it 'includes the project ID' do
+        expect(release_hash[:project_id]).to eq(project.id)
+      end
+
+      it 'includes the created timestamp' do
+        expect(release_hash[:created_at]).to eq(created_at)
+      end
+
+      it 'includes the updated timestamp' do
+        expect(release_hash[:updated_at]).to eq(updated_at)
+      end
+    end
+  end
+
+  describe '#each_release' do
+    let(:release) { double(:release) }
+
+    before do
+      allow(project).to receive(:import_source).and_return('foo/bar')
+
+      allow(client)
+        .to receive(:releases)
+        .with('foo/bar')
+        .and_return([release].to_enum)
+    end
+
+    it 'returns an Enumerator' do
+      expect(importer.each_release).to be_an_instance_of(Enumerator)
+    end
+
+    it 'yields every release to the Enumerator' do
+      expect(importer.each_release.next).to eq(release)
+    end
+  end
+
+  describe '#description_for' do
+    it 'returns the description when present' do
+      expect(importer.description_for(release)).to eq(release.body)
+    end
+
+    it 'returns a generated description when one is not present' do
+      allow(release).to receive(:body).and_return('')
+
+      expect(importer.description_for(release)).to eq('Release for tag 1.0')
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/importer/repository_importer_spec.rb b/spec/lib/gitlab/github_import/importer/repository_importer_spec.rb
new file mode 100644
index 00000000000..80539807711
--- /dev/null
+++ b/spec/lib/gitlab/github_import/importer/repository_importer_spec.rb
@@ -0,0 +1,264 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Importer::RepositoryImporter do
+  let(:repository) { double(:repository) }
+  let(:client) { double(:client) }
+
+  let(:project) do
+    double(
+      :project,
+      import_url: 'foo.git',
+      import_source: 'foo/bar',
+      repository_storage_path: 'foo',
+      disk_path: 'foo',
+      repository: repository
+    )
+  end
+
+  let(:importer) { described_class.new(project, client) }
+  let(:shell_adapter) { Gitlab::Shell.new }
+
+  before do
+    # The method "gitlab_shell" returns a new instance every call, making
+    # it harder to set expectations. To work around this we'll stub the method
+    # and return the same instance on every call.
+    allow(importer).to receive(:gitlab_shell).and_return(shell_adapter)
+  end
+
+  describe '#import_wiki?' do
+    it 'returns true if the wiki should be imported' do
+      repo = double(:repo, has_wiki: true)
+
+      expect(client)
+        .to receive(:repository)
+        .with('foo/bar')
+        .and_return(repo)
+
+      expect(project)
+        .to receive(:wiki_repository_exists?)
+        .and_return(false)
+
+      expect(importer.import_wiki?).to eq(true)
+    end
+
+    it 'returns false if the GitHub wiki is disabled' do
+      repo = double(:repo, has_wiki: false)
+
+      expect(client)
+        .to receive(:repository)
+        .with('foo/bar')
+        .and_return(repo)
+
+      expect(importer.import_wiki?).to eq(false)
+    end
+
+    it 'returns false if the wiki has already been imported' do
+      repo = double(:repo, has_wiki: true)
+
+      expect(client)
+        .to receive(:repository)
+        .with('foo/bar')
+        .and_return(repo)
+
+      expect(project)
+        .to receive(:wiki_repository_exists?)
+        .and_return(true)
+
+      expect(importer.import_wiki?).to eq(false)
+    end
+  end
+
+  describe '#execute' do
+    it 'imports the repository and wiki' do
+      expect(repository)
+        .to receive(:empty_repo?)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:import_wiki?)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:import_repository)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:import_wiki_repository)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:update_clone_time)
+
+      expect(importer.execute).to eq(true)
+    end
+
+    it 'does not import the repository if it already exists' do
+      expect(repository)
+        .to receive(:empty_repo?)
+        .and_return(false)
+
+      expect(importer)
+        .to receive(:import_wiki?)
+        .and_return(true)
+
+      expect(importer)
+        .not_to receive(:import_repository)
+
+      expect(importer)
+        .to receive(:import_wiki_repository)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:update_clone_time)
+
+      expect(importer.execute).to eq(true)
+    end
+
+    it 'does not import the wiki if it is disabled' do
+      expect(repository)
+        .to receive(:empty_repo?)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:import_wiki?)
+        .and_return(false)
+
+      expect(importer)
+        .to receive(:import_repository)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:update_clone_time)
+
+      expect(importer)
+        .not_to receive(:import_wiki_repository)
+
+      expect(importer.execute).to eq(true)
+    end
+
+    it 'does not import the wiki if the repository could not be imported' do
+      expect(repository)
+        .to receive(:empty_repo?)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:import_wiki?)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:import_repository)
+        .and_return(false)
+
+      expect(importer)
+        .not_to receive(:update_clone_time)
+
+      expect(importer)
+        .not_to receive(:import_wiki_repository)
+
+      expect(importer.execute).to eq(false)
+    end
+  end
+
+  describe '#import_repository' do
+    it 'imports the repository' do
+      expect(project)
+        .to receive(:ensure_repository)
+
+      expect(importer)
+        .to receive(:configure_repository_remote)
+
+      expect(repository)
+        .to receive(:fetch_remote)
+        .with('github', forced: true)
+
+      expect(importer.import_repository).to eq(true)
+    end
+
+    it 'marks the import as failed when an error was raised' do
+      expect(project).to receive(:ensure_repository)
+        .and_raise(Gitlab::Git::Repository::NoRepository)
+
+      expect(importer)
+        .to receive(:fail_import)
+        .and_return(false)
+
+      expect(importer.import_repository).to eq(false)
+    end
+  end
+
+  describe '#configure_repository_remote' do
+    it 'configures the remote details' do
+      expect(repository)
+        .to receive(:remote_exists?)
+        .with('github')
+        .and_return(false)
+
+      expect(repository)
+        .to receive(:add_remote)
+        .with('github', 'foo.git')
+
+      expect(repository)
+        .to receive(:set_import_remote_as_mirror)
+        .with('github')
+
+      expect(repository)
+        .to receive(:add_remote_fetch_config)
+
+      importer.configure_repository_remote
+    end
+
+    it 'does not configure the remote if already configured' do
+      expect(repository)
+        .to receive(:remote_exists?)
+        .with('github')
+        .and_return(true)
+
+      expect(repository)
+        .not_to receive(:add_remote)
+
+      importer.configure_repository_remote
+    end
+  end
+
+  describe '#import_wiki_repository' do
+    it 'imports the wiki repository' do
+      expect(importer.gitlab_shell)
+        .to receive(:import_repository)
+        .with('foo', 'foo.wiki', 'foo.wiki.git')
+
+      expect(importer.import_wiki_repository).to eq(true)
+    end
+
+    it 'marks the import as failed if an error was raised' do
+      expect(importer.gitlab_shell)
+        .to receive(:import_repository)
+        .and_raise(Gitlab::Shell::Error)
+
+      expect(importer)
+        .to receive(:fail_import)
+        .and_return(false)
+
+      expect(importer.import_wiki_repository).to eq(false)
+    end
+  end
+
+  describe '#fail_import' do
+    it 'marks the import as failed' do
+      expect(project).to receive(:mark_import_as_failed).with('foo')
+
+      expect(importer.fail_import('foo')).to eq(false)
+    end
+  end
+
+  describe '#update_clone_time' do
+    it 'sets the timestamp for when the cloning process finished' do
+      Timecop.freeze do
+        expect(project)
+          .to receive(:update_column)
+          .with(:last_repository_updated_at, Time.zone.now)
+
+        importer.update_clone_time
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/issuable_finder_spec.rb b/spec/lib/gitlab/github_import/issuable_finder_spec.rb
new file mode 100644
index 00000000000..da69911812a
--- /dev/null
+++ b/spec/lib/gitlab/github_import/issuable_finder_spec.rb
@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::IssuableFinder, :clean_gitlab_redis_cache do
+  let(:project) { double(:project, id: 4) }
+  let(:issue) do
+    double(:issue, issuable_type: MergeRequest, iid: 1)
+  end
+
+  let(:finder) { described_class.new(project, issue) }
+
+  describe '#database_id' do
+    it 'returns nil when no cache is in place' do
+      expect(finder.database_id).to be_nil
+    end
+
+    it 'returns the ID of an issuable when the cache is in place' do
+      finder.cache_database_id(10)
+
+      expect(finder.database_id).to eq(10)
+    end
+
+    it 'raises TypeError when the object is not supported' do
+      finder = described_class.new(project, double(:issue))
+
+      expect { finder.database_id }.to raise_error(TypeError)
+    end
+  end
+
+  describe '#cache_database_id' do
+    it 'caches the ID of a database row' do
+      expect(Gitlab::GithubImport::Caching)
+        .to receive(:write)
+        .with('github-import/issuable-finder/4/MergeRequest/1', 10)
+
+      finder.cache_database_id(10)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/label_finder_spec.rb b/spec/lib/gitlab/github_import/label_finder_spec.rb
new file mode 100644
index 00000000000..8ba766944d6
--- /dev/null
+++ b/spec/lib/gitlab/github_import/label_finder_spec.rb
@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::LabelFinder, :clean_gitlab_redis_cache do
+  let(:project) { create(:project) }
+  let(:finder) { described_class.new(project) }
+  let!(:bug) { create(:label, project: project, name: 'Bug') }
+  let!(:feature) { create(:label, project: project, name: 'Feature') }
+
+  describe '#id_for' do
+    context 'with a cache in place' do
+      before do
+        finder.build_cache
+      end
+
+      it 'returns the ID of the given label' do
+        expect(finder.id_for(feature.name)).to eq(feature.id)
+      end
+
+      it 'returns nil for an empty cache key' do
+        key = finder.cache_key_for(bug.name)
+
+        Gitlab::GithubImport::Caching.write(key, '')
+
+        expect(finder.id_for(bug.name)).to be_nil
+      end
+
+      it 'returns nil for a non existing label name' do
+        expect(finder.id_for('kittens')).to be_nil
+      end
+    end
+
+    context 'without a cache in place' do
+      it 'returns nil for a label' do
+        expect(finder.id_for(feature.name)).to be_nil
+      end
+    end
+  end
+
+  describe '#build_cache' do
+    it 'builds the cache of all project labels' do
+      expect(Gitlab::GithubImport::Caching)
+        .to receive(:write_multiple)
+        .with(
+          {
+            "github-import/label-finder/#{project.id}/Bug" => bug.id,
+            "github-import/label-finder/#{project.id}/Feature" => feature.id
+          }
+        )
+        .and_call_original
+
+      finder.build_cache
+    end
+  end
+
+  describe '#cache_key_for' do
+    it 'returns the cache key for a label name' do
+      expect(finder.cache_key_for('foo'))
+        .to eq("github-import/label-finder/#{project.id}/foo")
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/markdown_text_spec.rb b/spec/lib/gitlab/github_import/markdown_text_spec.rb
new file mode 100644
index 00000000000..1ff5b9d66b3
--- /dev/null
+++ b/spec/lib/gitlab/github_import/markdown_text_spec.rb
@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::MarkdownText do
+  describe '.format' do
+    it 'formats the text' do
+      author = double(:author, login: 'Alice')
+      text = described_class.format('Hello', author)
+
+      expect(text).to eq("*Created by: Alice*\n\nHello")
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the text when the author was found' do
+      author = double(:author, login: 'Alice')
+      text = described_class.new('Hello', author, true)
+
+      expect(text.to_s).to eq('Hello')
+    end
+
+    it 'returns the text with an extra header when the author was not found' do
+      author = double(:author, login: 'Alice')
+      text = described_class.new('Hello', author)
+
+      expect(text.to_s).to eq("*Created by: Alice*\n\nHello")
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/milestone_finder_spec.rb b/spec/lib/gitlab/github_import/milestone_finder_spec.rb
new file mode 100644
index 00000000000..dff931a2fe8
--- /dev/null
+++ b/spec/lib/gitlab/github_import/milestone_finder_spec.rb
@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::MilestoneFinder, :clean_gitlab_redis_cache do
+  let!(:project) { create(:project) }
+  let!(:milestone) { create(:milestone, project: project) }
+  let(:finder) { described_class.new(project) }
+
+  describe '#id_for' do
+    let(:issuable) { double(:issuable, milestone_number: milestone.iid) }
+
+    context 'with a cache in place' do
+      before do
+        finder.build_cache
+      end
+
+      it 'returns the milestone ID of the given issuable' do
+        expect(finder.id_for(issuable)).to eq(milestone.id)
+      end
+
+      it 'returns nil for an empty cache key' do
+        key = finder.cache_key_for(milestone.iid)
+
+        Gitlab::GithubImport::Caching.write(key, '')
+
+        expect(finder.id_for(issuable)).to be_nil
+      end
+
+      it 'returns nil for an issuable with a non-existing milestone' do
+        expect(finder.id_for(double(:issuable, milestone_number: 5))).to be_nil
+      end
+    end
+
+    context 'without a cache in place' do
+      it 'returns nil' do
+        expect(finder.id_for(issuable)).to be_nil
+      end
+    end
+  end
+
+  describe '#build_cache' do
+    it 'builds the cache of all project milestones' do
+      expect(Gitlab::GithubImport::Caching)
+        .to receive(:write_multiple)
+        .with("github-import/milestone-finder/#{project.id}/1" => milestone.id)
+        .and_call_original
+
+      finder.build_cache
+    end
+  end
+
+  describe '#cache_key_for' do
+    it 'returns the cache key for an IID' do
+      expect(finder.cache_key_for(10))
+        .to eq("github-import/milestone-finder/#{project.id}/10")
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/page_counter_spec.rb b/spec/lib/gitlab/github_import/page_counter_spec.rb
new file mode 100644
index 00000000000..c2613a9a415
--- /dev/null
+++ b/spec/lib/gitlab/github_import/page_counter_spec.rb
@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::PageCounter, :clean_gitlab_redis_cache do
+  let(:project) { double(:project, id: 1) }
+  let(:counter) { described_class.new(project, :issues) }
+
+  describe '#initialize' do
+    it 'sets the initial page number to 1 when no value is cached' do
+      expect(counter.current).to eq(1)
+    end
+
+    it 'sets the initial page number to the cached value when one is present' do
+      Gitlab::GithubImport::Caching.write(counter.cache_key, 2)
+
+      expect(described_class.new(project, :issues).current).to eq(2)
+    end
+  end
+
+  describe '#set' do
+    it 'overwrites the page number when the given number is greater than the current number' do
+      counter.set(4)
+      expect(counter.current).to eq(4)
+    end
+
+    it 'does not overwrite the page number when the given number is lower than the current number' do
+      counter.set(2)
+      counter.set(1)
+
+      expect(counter.current).to eq(2)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/parallel_importer_spec.rb b/spec/lib/gitlab/github_import/parallel_importer_spec.rb
new file mode 100644
index 00000000000..e2a821d4d5c
--- /dev/null
+++ b/spec/lib/gitlab/github_import/parallel_importer_spec.rb
@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::ParallelImporter do
+  describe '.async?' do
+    it 'returns true' do
+      expect(described_class).to be_async
+    end
+  end
+
+  describe '#execute', :clean_gitlab_redis_shared_state do
+    let(:project) { create(:project) }
+    let(:importer) { described_class.new(project) }
+
+    before do
+      expect(Gitlab::GithubImport::Stage::ImportRepositoryWorker)
+        .to receive(:perform_async)
+        .with(project.id)
+        .and_return('123')
+    end
+
+    it 'schedules the importing of the repository' do
+      expect(importer.execute).to eq(true)
+    end
+
+    it 'sets the JID in Redis' do
+      expect(Gitlab::SidekiqStatus)
+        .to receive(:set)
+        .with("github-importer/#{project.id}", StuckImportJobsWorker::IMPORT_JOBS_EXPIRATION)
+        .and_call_original
+
+      importer.execute
+    end
+
+    it 'updates the import JID of the project' do
+      importer.execute
+
+      expect(project.import_jid).to eq("github-importer/#{project.id}")
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/parallel_scheduling_spec.rb b/spec/lib/gitlab/github_import/parallel_scheduling_spec.rb
new file mode 100644
index 00000000000..98205d3ee25
--- /dev/null
+++ b/spec/lib/gitlab/github_import/parallel_scheduling_spec.rb
@@ -0,0 +1,296 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::ParallelScheduling do
+  let(:importer_class) do
+    Class.new do
+      include(Gitlab::GithubImport::ParallelScheduling)
+
+      def collection_method
+        :issues
+      end
+    end
+  end
+
+  let(:project) { double(:project, id: 4, import_source: 'foo/bar') }
+  let(:client) { double(:client) }
+
+  describe '#parallel?' do
+    it 'returns true when running in parallel mode' do
+      expect(importer_class.new(project, client)).to be_parallel
+    end
+
+    it 'returns false when running in sequential mode' do
+      importer = importer_class.new(project, client, parallel: false)
+
+      expect(importer).not_to be_parallel
+    end
+  end
+
+  describe '#execute' do
+    it 'imports data in parallel when running in parallel mode' do
+      importer = importer_class.new(project, client)
+      waiter = double(:waiter)
+
+      expect(importer)
+        .to receive(:parallel_import)
+        .and_return(waiter)
+
+      expect(importer.execute)
+        .to eq(waiter)
+    end
+
+    it 'imports data in parallel when running in sequential mode' do
+      importer = importer_class.new(project, client, parallel: false)
+
+      expect(importer)
+        .to receive(:sequential_import)
+        .and_return([])
+
+      expect(importer.execute)
+        .to eq([])
+    end
+
+    it 'expires the cache used for tracking already imported objects' do
+      importer = importer_class.new(project, client)
+
+      expect(importer).to receive(:parallel_import)
+
+      expect(Gitlab::GithubImport::Caching)
+        .to receive(:expire)
+        .with(importer.already_imported_cache_key, a_kind_of(Numeric))
+
+      importer.execute
+    end
+  end
+
+  describe '#sequential_import' do
+    let(:importer) { importer_class.new(project, client, parallel: false) }
+
+    it 'imports data in sequence' do
+      repr_class = double(:representation_class)
+      repr_instance = double(:representation_instance)
+      gh_importer = double(:github_importer)
+      gh_importer_instance = double(:github_importer_instance)
+      object = double(:object)
+
+      expect(importer)
+        .to receive(:each_object_to_import)
+        .and_yield(object)
+
+      expect(importer)
+        .to receive(:representation_class)
+        .and_return(repr_class)
+
+      expect(repr_class)
+        .to receive(:from_api_response)
+        .with(object)
+        .and_return(repr_instance)
+
+      expect(importer)
+        .to receive(:importer_class)
+        .and_return(gh_importer)
+
+      expect(gh_importer)
+        .to receive(:new)
+        .with(repr_instance, project, client)
+        .and_return(gh_importer_instance)
+
+      expect(gh_importer_instance)
+        .to receive(:execute)
+
+      importer.sequential_import
+    end
+  end
+
+  describe '#parallel_import' do
+    let(:importer) { importer_class.new(project, client) }
+
+    it 'imports data in parallel' do
+      repr_class = double(:representation)
+      worker_class = double(:worker)
+      object = double(:object)
+
+      expect(importer)
+        .to receive(:each_object_to_import)
+        .and_yield(object)
+
+      expect(importer)
+        .to receive(:representation_class)
+        .and_return(repr_class)
+
+      expect(importer)
+        .to receive(:sidekiq_worker_class)
+        .and_return(worker_class)
+
+      expect(repr_class)
+        .to receive(:from_api_response)
+        .with(object)
+        .and_return({ title: 'Foo' })
+
+      expect(worker_class)
+        .to receive(:perform_async)
+        .with(project.id, { title: 'Foo' }, an_instance_of(String))
+
+      expect(importer.parallel_import)
+        .to be_an_instance_of(Gitlab::JobWaiter)
+    end
+  end
+
+  describe '#each_object_to_import' do
+    let(:importer) { importer_class.new(project, client) }
+    let(:object) { double(:object) }
+
+    before do
+      expect(importer)
+        .to receive(:collection_options)
+        .and_return({ state: 'all' })
+    end
+
+    it 'yields every object to import' do
+      page = double(:page, objects: [object], number: 1)
+
+      expect(client)
+        .to receive(:each_page)
+        .with(:issues, 'foo/bar', { state: 'all', page: 1 })
+        .and_yield(page)
+
+      expect(importer.page_counter)
+        .to receive(:set)
+        .with(1)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:already_imported?)
+        .with(object)
+        .and_return(false)
+
+      expect(importer)
+        .to receive(:mark_as_imported)
+        .with(object)
+
+      expect { |b| importer.each_object_to_import(&b) }
+        .to yield_with_args(object)
+    end
+
+    it 'resumes from the last page' do
+      page = double(:page, objects: [object], number: 2)
+
+      expect(importer.page_counter)
+        .to receive(:current)
+        .and_return(2)
+
+      expect(client)
+        .to receive(:each_page)
+        .with(:issues, 'foo/bar', { state: 'all', page: 2 })
+        .and_yield(page)
+
+      expect(importer.page_counter)
+        .to receive(:set)
+        .with(2)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:already_imported?)
+        .with(object)
+        .and_return(false)
+
+      expect(importer)
+        .to receive(:mark_as_imported)
+        .with(object)
+
+      expect { |b| importer.each_object_to_import(&b) }
+        .to yield_with_args(object)
+    end
+
+    it 'does not yield any objects if the page number was not set' do
+      page = double(:page, objects: [object], number: 1)
+
+      expect(client)
+        .to receive(:each_page)
+        .with(:issues, 'foo/bar', { state: 'all', page: 1 })
+        .and_yield(page)
+
+      expect(importer.page_counter)
+        .to receive(:set)
+        .with(1)
+        .and_return(false)
+
+      expect { |b| importer.each_object_to_import(&b) }
+        .not_to yield_control
+    end
+
+    it 'does not yield the object if it was already imported' do
+      page = double(:page, objects: [object], number: 1)
+
+      expect(client)
+        .to receive(:each_page)
+        .with(:issues, 'foo/bar', { state: 'all', page: 1 })
+        .and_yield(page)
+
+      expect(importer.page_counter)
+        .to receive(:set)
+        .with(1)
+        .and_return(true)
+
+      expect(importer)
+        .to receive(:already_imported?)
+        .with(object)
+        .and_return(true)
+
+      expect(importer)
+        .not_to receive(:mark_as_imported)
+
+      expect { |b| importer.each_object_to_import(&b) }
+        .not_to yield_control
+    end
+  end
+
+  describe '#already_imported?', :clean_gitlab_redis_cache do
+    let(:importer) { importer_class.new(project, client) }
+
+    it 'returns false when an object has not yet been imported' do
+      object = double(:object, id: 10)
+
+      expect(importer)
+        .to receive(:id_for_already_imported_cache)
+        .with(object)
+        .and_return(object.id)
+
+      expect(importer.already_imported?(object))
+        .to eq(false)
+    end
+
+    it 'returns true when an object has already been imported' do
+      object = double(:object, id: 10)
+
+      allow(importer)
+        .to receive(:id_for_already_imported_cache)
+        .with(object)
+        .and_return(object.id)
+
+      importer.mark_as_imported(object)
+
+      expect(importer.already_imported?(object))
+        .to eq(true)
+    end
+  end
+
+  describe '#mark_as_imported', :clean_gitlab_redis_cache do
+    it 'marks an object as already imported' do
+      object = double(:object, id: 10)
+      importer = importer_class.new(project, client)
+
+      expect(importer)
+        .to receive(:id_for_already_imported_cache)
+        .with(object)
+        .and_return(object.id)
+
+      expect(Gitlab::GithubImport::Caching)
+        .to receive(:set_add)
+        .with(importer.already_imported_cache_key, object.id)
+        .and_call_original
+
+      importer.mark_as_imported(object)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/representation/diff_note_spec.rb b/spec/lib/gitlab/github_import/representation/diff_note_spec.rb
new file mode 100644
index 00000000000..7b0a1ea4948
--- /dev/null
+++ b/spec/lib/gitlab/github_import/representation/diff_note_spec.rb
@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Representation::DiffNote do
+  let(:hunk) do
+    '@@ -1 +1 @@
+    -Hello
+    +Hello world'
+  end
+
+  let(:created_at) { Time.new(2017, 1, 1, 12, 00) }
+  let(:updated_at) { Time.new(2017, 1, 1, 12, 15) }
+
+  shared_examples 'a DiffNote' do
+    it 'returns an instance of DiffNote' do
+      expect(note).to be_an_instance_of(described_class)
+    end
+
+    context 'the returned DiffNote' do
+      it 'includes the number of the note' do
+        expect(note.noteable_id).to eq(42)
+      end
+
+      it 'includes the file path of the diff' do
+        expect(note.file_path).to eq('README.md')
+      end
+
+      it 'includes the commit ID' do
+        expect(note.commit_id).to eq('123abc')
+      end
+
+      it 'includes the user details' do
+        expect(note.author)
+          .to be_an_instance_of(Gitlab::GithubImport::Representation::User)
+
+        expect(note.author.id).to eq(4)
+        expect(note.author.login).to eq('alice')
+      end
+
+      it 'includes the note body' do
+        expect(note.note).to eq('Hello world')
+      end
+
+      it 'includes the created timestamp' do
+        expect(note.created_at).to eq(created_at)
+      end
+
+      it 'includes the updated timestamp' do
+        expect(note.updated_at).to eq(updated_at)
+      end
+
+      it 'includes the GitHub ID' do
+        expect(note.github_id).to eq(1)
+      end
+
+      it 'returns the noteable type' do
+        expect(note.noteable_type).to eq('MergeRequest')
+      end
+    end
+  end
+
+  describe '.from_api_response' do
+    let(:response) do
+      double(
+        :response,
+        html_url: 'https://github.com/foo/bar/pull/42',
+        path: 'README.md',
+        commit_id: '123abc',
+        diff_hunk: hunk,
+        user: double(:user, id: 4, login: 'alice'),
+        body: 'Hello world',
+        created_at: created_at,
+        updated_at: updated_at,
+        id: 1
+      )
+    end
+
+    it_behaves_like 'a DiffNote' do
+      let(:note) { described_class.from_api_response(response) }
+    end
+
+    it 'does not set the user if the response did not include a user' do
+      allow(response)
+        .to receive(:user)
+        .and_return(nil)
+
+      note = described_class.from_api_response(response)
+
+      expect(note.author).to be_nil
+    end
+  end
+
+  describe '.from_json_hash' do
+    it_behaves_like 'a DiffNote' do
+      let(:hash) do
+        {
+          'noteable_type' => 'MergeRequest',
+          'noteable_id' => 42,
+          'file_path' => 'README.md',
+          'commit_id' => '123abc',
+          'diff_hunk' => hunk,
+          'author' => { 'id' => 4, 'login' => 'alice' },
+          'note' => 'Hello world',
+          'created_at' => created_at.to_s,
+          'updated_at' => updated_at.to_s,
+          'github_id' => 1
+        }
+      end
+
+      let(:note) { described_class.from_json_hash(hash) }
+    end
+
+    it 'does not convert the author if it was not specified' do
+      hash = {
+        'noteable_type' => 'MergeRequest',
+        'noteable_id' => 42,
+        'file_path' => 'README.md',
+        'commit_id' => '123abc',
+        'diff_hunk' => hunk,
+        'note' => 'Hello world',
+        'created_at' => created_at.to_s,
+        'updated_at' => updated_at.to_s,
+        'github_id' => 1
+      }
+
+      note = described_class.from_json_hash(hash)
+
+      expect(note.author).to be_nil
+    end
+  end
+
+  describe '#line_code' do
+    it 'returns a String' do
+      note = described_class.new(diff_hunk: hunk, file_path: 'README.md')
+
+      expect(note.line_code).to be_an_instance_of(String)
+    end
+  end
+
+  describe '#diff_hash' do
+    it 'returns a Hash containing the diff details' do
+      note = described_class.from_json_hash(
+        'noteable_type' => 'MergeRequest',
+        'noteable_id' => 42,
+        'file_path' => 'README.md',
+        'commit_id' => '123abc',
+        'diff_hunk' => hunk,
+        'author' => { 'id' => 4, 'login' => 'alice' },
+        'note' => 'Hello world',
+        'created_at' => created_at.to_s,
+        'updated_at' => updated_at.to_s,
+        'github_id' => 1
+      )
+
+      expect(note.diff_hash).to eq(
+        diff: hunk,
+        new_path: 'README.md',
+        old_path: 'README.md',
+        a_mode: '100644',
+        b_mode: '100644',
+        new_file: false
+      )
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/representation/expose_attribute_spec.rb b/spec/lib/gitlab/github_import/representation/expose_attribute_spec.rb
new file mode 100644
index 00000000000..15de0fe49ff
--- /dev/null
+++ b/spec/lib/gitlab/github_import/representation/expose_attribute_spec.rb
@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Representation::ExposeAttribute do
+  it 'defines a getter method that returns an attribute value' do
+    klass = Class.new do
+      include Gitlab::GithubImport::Representation::ExposeAttribute
+
+      expose_attribute :number
+
+      attr_reader :attributes
+
+      def initialize
+        @attributes = { number: 42 }
+      end
+    end
+
+    expect(klass.new.number).to eq(42)
+  end
+end
diff --git a/spec/lib/gitlab/github_import/representation/issue_spec.rb b/spec/lib/gitlab/github_import/representation/issue_spec.rb
new file mode 100644
index 00000000000..99330ce42cb
--- /dev/null
+++ b/spec/lib/gitlab/github_import/representation/issue_spec.rb
@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Representation::Issue do
+  let(:created_at) { Time.new(2017, 1, 1, 12, 00) }
+  let(:updated_at) { Time.new(2017, 1, 1, 12, 15) }
+
+  shared_examples 'an Issue' do
+    it 'returns an instance of Issue' do
+      expect(issue).to be_an_instance_of(described_class)
+    end
+
+    context 'the returned Issue' do
+      it 'includes the issue number' do
+        expect(issue.iid).to eq(42)
+      end
+
+      it 'includes the issue title' do
+        expect(issue.title).to eq('My Issue')
+      end
+
+      it 'includes the issue description' do
+        expect(issue.description).to eq('This is my issue')
+      end
+
+      it 'includes the milestone number' do
+        expect(issue.milestone_number).to eq(4)
+      end
+
+      it 'includes the issue state' do
+        expect(issue.state).to eq(:opened)
+      end
+
+      it 'includes the issue assignees' do
+        expect(issue.assignees[0])
+          .to be_an_instance_of(Gitlab::GithubImport::Representation::User)
+
+        expect(issue.assignees[0].id).to eq(4)
+        expect(issue.assignees[0].login).to eq('alice')
+      end
+
+      it 'includes the label names' do
+        expect(issue.label_names).to eq(%w[bug])
+      end
+
+      it 'includes the author details' do
+        expect(issue.author)
+          .to be_an_instance_of(Gitlab::GithubImport::Representation::User)
+
+        expect(issue.author.id).to eq(4)
+        expect(issue.author.login).to eq('alice')
+      end
+
+      it 'includes the created timestamp' do
+        expect(issue.created_at).to eq(created_at)
+      end
+
+      it 'includes the updated timestamp' do
+        expect(issue.updated_at).to eq(updated_at)
+      end
+
+      it 'is not a pull request' do
+        expect(issue.pull_request?).to eq(false)
+      end
+    end
+  end
+
+  describe '.from_api_response' do
+    let(:response) do
+      double(
+        :response,
+        number: 42,
+        title: 'My Issue',
+        body: 'This is my issue',
+        milestone: double(:milestone, number: 4),
+        state: 'open',
+        assignees: [double(:user, id: 4, login: 'alice')],
+        labels: [double(:label, name: 'bug')],
+        user: double(:user, id: 4, login: 'alice'),
+        created_at: created_at,
+        updated_at: updated_at,
+        pull_request: false
+      )
+    end
+
+    it_behaves_like 'an Issue' do
+      let(:issue) { described_class.from_api_response(response) }
+    end
+
+    it 'does not set the user if the response did not include a user' do
+      allow(response)
+        .to receive(:user)
+        .and_return(nil)
+
+      issue = described_class.from_api_response(response)
+
+      expect(issue.author).to be_nil
+    end
+  end
+
+  describe '.from_json_hash' do
+    it_behaves_like 'an Issue' do
+      let(:hash) do
+        {
+          'iid' => 42,
+          'title' => 'My Issue',
+          'description' => 'This is my issue',
+          'milestone_number' => 4,
+          'state' => 'opened',
+          'assignees' => [{ 'id' => 4, 'login' => 'alice' }],
+          'label_names' => %w[bug],
+          'author' => { 'id' => 4, 'login' => 'alice' },
+          'created_at' => created_at.to_s,
+          'updated_at' => updated_at.to_s,
+          'pull_request' => false
+        }
+      end
+
+      let(:issue) { described_class.from_json_hash(hash) }
+    end
+
+    it 'does not convert the author if it was not specified' do
+      hash = {
+        'iid' => 42,
+        'title' => 'My Issue',
+        'description' => 'This is my issue',
+        'milestone_number' => 4,
+        'state' => 'opened',
+        'assignees' => [{ 'id' => 4, 'login' => 'alice' }],
+        'label_names' => %w[bug],
+        'created_at' => created_at.to_s,
+        'updated_at' => updated_at.to_s,
+        'pull_request' => false
+      }
+
+      issue = described_class.from_json_hash(hash)
+
+      expect(issue.author).to be_nil
+    end
+  end
+
+  describe '#labels?' do
+    it 'returns true when the issue has labels assigned' do
+      issue = described_class.new(label_names: %w[bug])
+
+      expect(issue.labels?).to eq(true)
+    end
+
+    it 'returns false when the issue has no labels assigned' do
+      issue = described_class.new(label_names: [])
+
+      expect(issue.labels?).to eq(false)
+    end
+  end
+
+  describe '#pull_request?' do
+    it 'returns false for an issue' do
+      issue = described_class.new(pull_request: false)
+
+      expect(issue.pull_request?).to eq(false)
+    end
+
+    it 'returns true for a pull request' do
+      issue = described_class.new(pull_request: true)
+
+      expect(issue.pull_request?).to eq(true)
+    end
+  end
+
+  describe '#truncated_title' do
+    it 'truncates the title to 255 characters' do
+      object = described_class.new(title: 'm' * 300)
+
+      expect(object.truncated_title.length).to eq(255)
+    end
+
+    it 'does not truncate the title if it is shorter than 255 characters' do
+      object = described_class.new(title: 'foo')
+
+      expect(object.truncated_title).to eq('foo')
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/representation/note_spec.rb b/spec/lib/gitlab/github_import/representation/note_spec.rb
new file mode 100644
index 00000000000..f2c1c66b357
--- /dev/null
+++ b/spec/lib/gitlab/github_import/representation/note_spec.rb
@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Representation::Note do
+  let(:created_at) { Time.new(2017, 1, 1, 12, 00) }
+  let(:updated_at) { Time.new(2017, 1, 1, 12, 15) }
+
+  shared_examples 'a Note' do
+    it 'returns an instance of Note' do
+      expect(note).to be_an_instance_of(described_class)
+    end
+
+    context 'the returned Note' do
+      it 'includes the noteable ID' do
+        expect(note.noteable_id).to eq(42)
+      end
+
+      it 'includes the noteable type' do
+        expect(note.noteable_type).to eq('Issue')
+      end
+
+      it 'includes the author details' do
+        expect(note.author)
+          .to be_an_instance_of(Gitlab::GithubImport::Representation::User)
+
+        expect(note.author.id).to eq(4)
+        expect(note.author.login).to eq('alice')
+      end
+
+      it 'includes the note body' do
+        expect(note.note).to eq('Hello world')
+      end
+
+      it 'includes the created timestamp' do
+        expect(note.created_at).to eq(created_at)
+      end
+
+      it 'includes the updated timestamp' do
+        expect(note.updated_at).to eq(updated_at)
+      end
+
+      it 'includes the GitHub ID' do
+        expect(note.github_id).to eq(1)
+      end
+    end
+  end
+
+  describe '.from_api_response' do
+    let(:response) do
+      double(
+        :response,
+        html_url: 'https://github.com/foo/bar/issues/42',
+        user: double(:user, id: 4, login: 'alice'),
+        body: 'Hello world',
+        created_at: created_at,
+        updated_at: updated_at,
+        id: 1
+      )
+    end
+
+    it_behaves_like 'a Note' do
+      let(:note) { described_class.from_api_response(response) }
+    end
+
+    it 'does not set the user if the response did not include a user' do
+      allow(response)
+        .to receive(:user)
+        .and_return(nil)
+
+      note = described_class.from_api_response(response)
+
+      expect(note.author).to be_nil
+    end
+  end
+
+  describe '.from_json_hash' do
+    it_behaves_like 'a Note' do
+      let(:hash) do
+        {
+          'noteable_id' => 42,
+          'noteable_type' => 'Issue',
+          'author' => { 'id' => 4, 'login' => 'alice' },
+          'note' => 'Hello world',
+          'created_at' => created_at.to_s,
+          'updated_at' => updated_at.to_s,
+          'github_id' => 1
+        }
+      end
+
+      let(:note) { described_class.from_json_hash(hash) }
+    end
+
+    it 'does not convert the author if it was not specified' do
+      hash = {
+        'noteable_id' => 42,
+        'noteable_type' => 'Issue',
+        'note' => 'Hello world',
+        'created_at' => created_at.to_s,
+        'updated_at' => updated_at.to_s,
+        'github_id' => 1
+      }
+
+      note = described_class.from_json_hash(hash)
+
+      expect(note.author).to be_nil
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/representation/pull_request_spec.rb b/spec/lib/gitlab/github_import/representation/pull_request_spec.rb
new file mode 100644
index 00000000000..33f6ff0ae6a
--- /dev/null
+++ b/spec/lib/gitlab/github_import/representation/pull_request_spec.rb
@@ -0,0 +1,288 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Representation::PullRequest do
+  let(:created_at) { Time.new(2017, 1, 1, 12, 00) }
+  let(:updated_at) { Time.new(2017, 1, 1, 12, 15) }
+  let(:merged_at) { Time.new(2017, 1, 1, 12, 17) }
+
+  shared_examples 'a PullRequest' do
+    it 'returns an instance of PullRequest' do
+      expect(pr).to be_an_instance_of(described_class)
+    end
+
+    context 'the returned PullRequest' do
+      it 'includes the pull request number' do
+        expect(pr.iid).to eq(42)
+      end
+
+      it 'includes the pull request title' do
+        expect(pr.title).to eq('My Pull Request')
+      end
+
+      it 'includes the pull request description' do
+        expect(pr.description).to eq('This is my pull request')
+      end
+
+      it 'includes the source branch name' do
+        expect(pr.source_branch).to eq('my-feature')
+      end
+
+      it 'includes the source branch SHA' do
+        expect(pr.source_branch_sha).to eq('123abc')
+      end
+
+      it 'includes the target branch name' do
+        expect(pr.target_branch).to eq('master')
+      end
+
+      it 'includes the target branch SHA' do
+        expect(pr.target_branch_sha).to eq('456def')
+      end
+
+      it 'includes the milestone number' do
+        expect(pr.milestone_number).to eq(4)
+      end
+
+      it 'includes the user details' do
+        expect(pr.author)
+          .to be_an_instance_of(Gitlab::GithubImport::Representation::User)
+
+        expect(pr.author.id).to eq(4)
+        expect(pr.author.login).to eq('alice')
+      end
+
+      it 'includes the assignee details' do
+        expect(pr.assignee)
+          .to be_an_instance_of(Gitlab::GithubImport::Representation::User)
+
+        expect(pr.assignee.id).to eq(4)
+        expect(pr.assignee.login).to eq('alice')
+      end
+
+      it 'includes the created timestamp' do
+        expect(pr.created_at).to eq(created_at)
+      end
+
+      it 'includes the updated timestamp' do
+        expect(pr.updated_at).to eq(updated_at)
+      end
+
+      it 'includes the merged timestamp' do
+        expect(pr.merged_at).to eq(merged_at)
+      end
+
+      it 'includes the source repository ID' do
+        expect(pr.source_repository_id).to eq(400)
+      end
+
+      it 'includes the target repository ID' do
+        expect(pr.target_repository_id).to eq(200)
+      end
+
+      it 'includes the source repository owner name' do
+        expect(pr.source_repository_owner).to eq('alice')
+      end
+
+      it 'includes the pull request state' do
+        expect(pr.state).to eq(:merged)
+      end
+    end
+  end
+
+  describe '.from_api_response' do
+    let(:response) do
+      double(
+        :response,
+        number: 42,
+        title: 'My Pull Request',
+        body: 'This is my pull request',
+        state: 'closed',
+        head: double(
+          :head,
+          sha: '123abc',
+          ref: 'my-feature',
+          repo: double(:repo, id: 400),
+          user: double(:user, id: 4, login: 'alice')
+        ),
+        base: double(
+          :base,
+          sha: '456def',
+          ref: 'master',
+          repo: double(:repo, id: 200)
+        ),
+        milestone: double(:milestone, number: 4),
+        user: double(:user, id: 4, login: 'alice'),
+        assignee: double(:user, id: 4, login: 'alice'),
+        created_at: created_at,
+        updated_at: updated_at,
+        merged_at: merged_at
+      )
+    end
+
+    it_behaves_like 'a PullRequest' do
+      let(:pr) { described_class.from_api_response(response) }
+    end
+
+    it 'does not set the user if the response did not include a user' do
+      allow(response)
+        .to receive(:user)
+        .and_return(nil)
+
+      pr = described_class.from_api_response(response)
+
+      expect(pr.author).to be_nil
+    end
+  end
+
+  describe '.from_json_hash' do
+    it_behaves_like 'a PullRequest' do
+      let(:hash) do
+        {
+          'iid' => 42,
+          'title' => 'My Pull Request',
+          'description' => 'This is my pull request',
+          'source_branch' => 'my-feature',
+          'source_branch_sha' => '123abc',
+          'target_branch' => 'master',
+          'target_branch_sha' => '456def',
+          'source_repository_id' => 400,
+          'target_repository_id' => 200,
+          'source_repository_owner' => 'alice',
+          'state' => 'closed',
+          'milestone_number' => 4,
+          'author' => { 'id' => 4, 'login' => 'alice' },
+          'assignee' => { 'id' => 4, 'login' => 'alice' },
+          'created_at' => created_at.to_s,
+          'updated_at' => updated_at.to_s,
+          'merged_at' => merged_at.to_s
+        }
+      end
+
+      let(:pr) { described_class.from_json_hash(hash) }
+    end
+
+    it 'does not convert the author if it was not specified' do
+      hash = {
+        'iid' => 42,
+        'title' => 'My Pull Request',
+        'description' => 'This is my pull request',
+        'source_branch' => 'my-feature',
+        'source_branch_sha' => '123abc',
+        'target_branch' => 'master',
+        'target_branch_sha' => '456def',
+        'source_repository_id' => 400,
+        'target_repository_id' => 200,
+        'source_repository_owner' => 'alice',
+        'state' => 'closed',
+        'milestone_number' => 4,
+        'assignee' => { 'id' => 4, 'login' => 'alice' },
+        'created_at' => created_at.to_s,
+        'updated_at' => updated_at.to_s,
+        'merged_at' => merged_at.to_s
+      }
+
+      pr = described_class.from_json_hash(hash)
+
+      expect(pr.author).to be_nil
+    end
+  end
+
+  describe '#state' do
+    it 'returns :opened for an open pull request' do
+      pr = described_class.new(state: :opened)
+
+      expect(pr.state).to eq(:opened)
+    end
+
+    it 'returns :closed for a closed pull request' do
+      pr = described_class.new(state: :closed)
+
+      expect(pr.state).to eq(:closed)
+    end
+
+    it 'returns :merged for a merged pull request' do
+      pr = described_class.new(state: :closed, merged_at: merged_at)
+
+      expect(pr.state).to eq(:merged)
+    end
+  end
+
+  describe '#cross_project?' do
+    it 'returns false for a pull request submitted from the target project' do
+      pr = described_class.new(source_repository_id: 1, target_repository_id: 1)
+
+      expect(pr).not_to be_cross_project
+    end
+
+    it 'returns true for a pull request submitted from a different project' do
+      pr = described_class.new(source_repository_id: 1, target_repository_id: 2)
+
+      expect(pr).to be_cross_project
+    end
+
+    it 'returns true if no source repository is present' do
+      pr = described_class.new(target_repository_id: 2)
+
+      expect(pr).to be_cross_project
+    end
+  end
+
+  describe '#formatted_source_branch' do
+    context 'for a cross-project pull request' do
+      it 'includes the owner name in the branch name' do
+        pr = described_class.new(
+          source_repository_owner: 'foo',
+          source_branch: 'branch',
+          target_branch: 'master',
+          source_repository_id: 1,
+          target_repository_id: 2
+        )
+
+        expect(pr.formatted_source_branch).to eq('foo:branch')
+      end
+    end
+
+    context 'for a regular pull request' do
+      it 'returns the source branch name' do
+        pr = described_class.new(
+          source_repository_owner: 'foo',
+          source_branch: 'branch',
+          target_branch: 'master',
+          source_repository_id: 1,
+          target_repository_id: 1
+        )
+
+        expect(pr.formatted_source_branch).to eq('branch')
+      end
+    end
+
+    context 'for a pull request with the same source and target branches' do
+      it 'returns a generated source branch name' do
+        pr = described_class.new(
+          iid: 1,
+          source_repository_owner: 'foo',
+          source_branch: 'branch',
+          target_branch: 'branch',
+          source_repository_id: 1,
+          target_repository_id: 1
+        )
+
+        expect(pr.formatted_source_branch).to eq('branch-1')
+      end
+    end
+  end
+
+  describe '#truncated_title' do
+    it 'truncates the title to 255 characters' do
+      object = described_class.new(title: 'm' * 300)
+
+      expect(object.truncated_title.length).to eq(255)
+    end
+
+    it 'does not truncate the title if it is shorter than 255 characters' do
+      object = described_class.new(title: 'foo')
+
+      expect(object.truncated_title).to eq('foo')
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/representation/to_hash_spec.rb b/spec/lib/gitlab/github_import/representation/to_hash_spec.rb
new file mode 100644
index 00000000000..c296aa0a45b
--- /dev/null
+++ b/spec/lib/gitlab/github_import/representation/to_hash_spec.rb
@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Representation::ToHash do
+  describe '#to_hash' do
+    let(:user) { double(:user, attributes: { login: 'alice' }) }
+
+    let(:issue) do
+      double(
+        :issue,
+        attributes: { user: user, assignees: [user], number: 42 }
+      )
+    end
+
+    let(:issue_hash) { issue.to_hash }
+
+    before do
+      user.extend(described_class)
+      issue.extend(described_class)
+    end
+
+    it 'converts an object to a Hash' do
+      expect(issue_hash).to be_an_instance_of(Hash)
+    end
+
+    it 'converts nested objects to Hashes' do
+      expect(issue_hash[:user]).to eq({ login: 'alice' })
+    end
+
+    it 'converts Array values to Hashes' do
+      expect(issue_hash[:assignees]).to eq([{ login: 'alice' }])
+    end
+
+    it 'keeps values as-is if they do not respond to #to_hash' do
+      expect(issue_hash[:number]).to eq(42)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/representation/user_spec.rb b/spec/lib/gitlab/github_import/representation/user_spec.rb
new file mode 100644
index 00000000000..4e63e8ea568
--- /dev/null
+++ b/spec/lib/gitlab/github_import/representation/user_spec.rb
@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Representation::User do
+  shared_examples 'a User' do
+    it 'returns an instance of User' do
+      expect(user).to be_an_instance_of(described_class)
+    end
+
+    context 'the returned User' do
+      it 'includes the user ID' do
+        expect(user.id).to eq(42)
+      end
+
+      it 'includes the username' do
+        expect(user.login).to eq('alice')
+      end
+    end
+  end
+
+  describe '.from_api_response' do
+    it_behaves_like 'a User' do
+      let(:response) { double(:response, id: 42, login: 'alice') }
+      let(:user) { described_class.from_api_response(response) }
+    end
+  end
+
+  describe '.from_json_hash' do
+    it_behaves_like 'a User' do
+      let(:hash) { { 'id' => 42, 'login' => 'alice' } }
+      let(:user) { described_class.from_json_hash(hash) }
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/representation_spec.rb b/spec/lib/gitlab/github_import/representation_spec.rb
new file mode 100644
index 00000000000..0b0610817b0
--- /dev/null
+++ b/spec/lib/gitlab/github_import/representation_spec.rb
@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Representation do
+  describe '.symbolize_hash' do
+    it 'returns a Hash with the keys as Symbols' do
+      hash = described_class.symbolize_hash('number' => 10)
+
+      expect(hash).to eq({ number: 10 })
+    end
+
+    it 'parses timestamp fields into Time instances' do
+      hash = described_class.symbolize_hash('created_at' => '2017-01-01 12:00')
+
+      expect(hash[:created_at]).to be_an_instance_of(Time)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/sequential_importer_spec.rb b/spec/lib/gitlab/github_import/sequential_importer_spec.rb
new file mode 100644
index 00000000000..6089b0b751f
--- /dev/null
+++ b/spec/lib/gitlab/github_import/sequential_importer_spec.rb
@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::SequentialImporter do
+  describe '#execute' do
+    it 'imports a project in sequence' do
+      repository = double(:repository)
+      project = double(:project, id: 1, repository: repository)
+      importer = described_class.new(project, token: 'foo')
+
+      expect_any_instance_of(Gitlab::GithubImport::Importer::RepositoryImporter)
+        .to receive(:execute)
+
+      described_class::SEQUENTIAL_IMPORTERS.each do |klass|
+        instance = double(:instance)
+
+        expect(klass).to receive(:new)
+          .with(project, importer.client)
+          .and_return(instance)
+
+        expect(instance).to receive(:execute)
+      end
+
+      described_class::PARALLEL_IMPORTERS.each do |klass|
+        instance = double(:instance)
+
+        expect(klass).to receive(:new)
+          .with(project, importer.client, parallel: false)
+          .and_return(instance)
+
+        expect(instance).to receive(:execute)
+      end
+
+      expect(repository).to receive(:after_import)
+      expect(importer.execute).to eq(true)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/user_finder_spec.rb b/spec/lib/gitlab/github_import/user_finder_spec.rb
new file mode 100644
index 00000000000..29f4c00d9c7
--- /dev/null
+++ b/spec/lib/gitlab/github_import/user_finder_spec.rb
@@ -0,0 +1,333 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::UserFinder, :clean_gitlab_redis_cache do
+  let(:project) { create(:project) }
+  let(:client) { double(:client) }
+  let(:finder) { described_class.new(project, client) }
+
+  describe '#author_id_for' do
+    it 'returns the user ID for the author of an object' do
+      user = double(:user, id: 4, login: 'kittens')
+      note = double(:note, author: user)
+
+      expect(finder).to receive(:user_id_for).with(user).and_return(42)
+
+      expect(finder.author_id_for(note)).to eq([42, true])
+    end
+
+    it 'returns the ID of the project creator if no user ID could be found' do
+      user = double(:user, id: 4, login: 'kittens')
+      note = double(:note, author: user)
+
+      expect(finder).to receive(:user_id_for).with(user).and_return(nil)
+
+      expect(finder.author_id_for(note)).to eq([project.creator_id, false])
+    end
+
+    it 'returns the ID of the ghost user when the object has no user' do
+      note = double(:note, author: nil)
+
+      expect(finder.author_id_for(note)).to eq([User.ghost.id, true])
+    end
+
+    it 'returns the ID of the ghost user when the given object is nil' do
+      expect(finder.author_id_for(nil)).to eq([User.ghost.id, true])
+    end
+  end
+
+  describe '#assignee_id_for' do
+    it 'returns the user ID for the assignee of an issuable' do
+      user = double(:user, id: 4, login: 'kittens')
+      issue = double(:issue, assignee: user)
+
+      expect(finder).to receive(:user_id_for).with(user).and_return(42)
+      expect(finder.assignee_id_for(issue)).to eq(42)
+    end
+
+    it 'returns nil if the issuable does not have an assignee' do
+      issue = double(:issue, assignee: nil)
+
+      expect(finder).not_to receive(:user_id_for)
+      expect(finder.assignee_id_for(issue)).to be_nil
+    end
+  end
+
+  describe '#user_id_for' do
+    it 'returns the user ID for the given user' do
+      user = double(:user, id: 4, login: 'kittens')
+
+      expect(finder).to receive(:find).with(user.id, user.login).and_return(42)
+      expect(finder.user_id_for(user)).to eq(42)
+    end
+  end
+
+  describe '#find' do
+    let(:user) { create(:user) }
+
+    before do
+      allow(finder).to receive(:email_for_github_username)
+        .and_return(user.email)
+    end
+
+    context 'without a cache' do
+      before do
+        allow(finder).to receive(:find_from_cache).and_return([false, nil])
+        expect(finder).to receive(:find_id_from_database).and_call_original
+      end
+
+      it 'finds a GitLab user for a GitHub user ID' do
+        user.identities.create!(provider: :github, extern_uid: 42)
+
+        expect(finder.find(42, user.username)).to eq(user.id)
+      end
+
+      it 'finds a GitLab user for a GitHub Email address' do
+        expect(finder.find(42, user.username)).to eq(user.id)
+      end
+    end
+
+    context 'with a cache' do
+      it 'returns the cached user ID' do
+        expect(finder).to receive(:find_from_cache).and_return([true, user.id])
+        expect(finder).not_to receive(:find_id_from_database)
+
+        expect(finder.find(42, user.username)).to eq(user.id)
+      end
+
+      it 'does not query the database if the cache key exists but is empty' do
+        expect(finder).to receive(:find_from_cache).and_return([true, nil])
+        expect(finder).not_to receive(:find_id_from_database)
+
+        expect(finder.find(42, user.username)).to be_nil
+      end
+    end
+  end
+
+  describe '#find_from_cache' do
+    it 'retrieves a GitLab user ID for a GitHub user ID' do
+      expect(finder)
+        .to receive(:cached_id_for_github_id)
+        .with(42)
+        .and_return([true, 4])
+
+      expect(finder.find_from_cache(42)).to eq([true, 4])
+    end
+
+    it 'retrieves a GitLab user ID for a GitHub Email address' do
+      email = 'kittens@example.com'
+
+      expect(finder)
+        .to receive(:cached_id_for_github_id)
+        .with(42)
+        .and_return([false, nil])
+
+      expect(finder)
+        .to receive(:cached_id_for_github_email)
+        .with(email)
+        .and_return([true, 4])
+
+      expect(finder.find_from_cache(42, email)).to eq([true, 4])
+    end
+
+    it 'does not query the cache for an Email address when none is given' do
+      expect(finder)
+        .to receive(:cached_id_for_github_id)
+        .with(42)
+        .and_return([false, nil])
+
+      expect(finder).not_to receive(:cached_id_for_github_id)
+
+      expect(finder.find_from_cache(42)).to eq([false])
+    end
+  end
+
+  describe '#find_id_from_database' do
+    let(:user) { create(:user) }
+
+    it 'returns the GitLab user ID for a GitHub user ID' do
+      user.identities.create!(provider: :github, extern_uid: 42)
+
+      expect(finder.find_id_from_database(42, user.email)).to eq(user.id)
+    end
+
+    it 'returns the GitLab user ID for a GitHub Email address' do
+      expect(finder.find_id_from_database(42, user.email)).to eq(user.id)
+    end
+  end
+
+  describe '#email_for_github_username' do
+    let(:email) { 'kittens@example.com' }
+
+    context 'when an Email address is cached' do
+      it 'reads the Email address from the cache' do
+        expect(Gitlab::GithubImport::Caching)
+          .to receive(:read)
+          .and_return(email)
+
+        expect(client).not_to receive(:user)
+        expect(finder.email_for_github_username('kittens')).to eq(email)
+      end
+    end
+
+    context 'when an Email address is not cached' do
+      let(:user) { double(:user, email: email) }
+
+      it 'retrieves the Email address from the GitHub API' do
+        expect(client).to receive(:user).with('kittens').and_return(user)
+        expect(finder.email_for_github_username('kittens')).to eq(email)
+      end
+
+      it 'caches the Email address when an Email address is available' do
+        expect(client).to receive(:user).with('kittens').and_return(user)
+
+        expect(Gitlab::GithubImport::Caching)
+          .to receive(:write)
+          .with(an_instance_of(String), email)
+
+        finder.email_for_github_username('kittens')
+      end
+
+      it 'returns nil if the user does not exist' do
+        expect(client)
+          .to receive(:user)
+          .with('kittens')
+          .and_return(nil)
+
+        expect(Gitlab::GithubImport::Caching)
+          .not_to receive(:write)
+
+        expect(finder.email_for_github_username('kittens')).to be_nil
+      end
+    end
+  end
+
+  describe '#cached_id_for_github_id' do
+    let(:id) { 4 }
+
+    it 'reads a user ID from the cache' do
+      Gitlab::GithubImport::Caching
+        .write(described_class::ID_CACHE_KEY % id, 4)
+
+      expect(finder.cached_id_for_github_id(id)).to eq([true, 4])
+    end
+
+    it 'reads a non existing cache key' do
+      expect(finder.cached_id_for_github_id(id)).to eq([false, nil])
+    end
+  end
+
+  describe '#cached_id_for_github_email' do
+    let(:email) { 'kittens@example.com' }
+
+    it 'reads a user ID from the cache' do
+      Gitlab::GithubImport::Caching
+        .write(described_class::ID_FOR_EMAIL_CACHE_KEY % email, 4)
+
+      expect(finder.cached_id_for_github_email(email)).to eq([true, 4])
+    end
+
+    it 'reads a non existing cache key' do
+      expect(finder.cached_id_for_github_email(email)).to eq([false, nil])
+    end
+  end
+
+  describe '#id_for_github_id' do
+    let(:id) { 4 }
+
+    it 'queries and caches the user ID for a given GitHub ID' do
+      expect(finder).to receive(:query_id_for_github_id)
+        .with(id)
+        .and_return(42)
+
+      expect(Gitlab::GithubImport::Caching)
+        .to receive(:write)
+        .with(described_class::ID_CACHE_KEY % id, 42)
+
+      finder.id_for_github_id(id)
+    end
+
+    it 'caches a nil value if no ID could be found' do
+      expect(finder).to receive(:query_id_for_github_id)
+        .with(id)
+        .and_return(nil)
+
+      expect(Gitlab::GithubImport::Caching)
+        .to receive(:write)
+        .with(described_class::ID_CACHE_KEY % id, nil)
+
+      finder.id_for_github_id(id)
+    end
+  end
+
+  describe '#id_for_github_email' do
+    let(:email) { 'kittens@example.com' }
+
+    it 'queries and caches the user ID for a given Email address' do
+      expect(finder).to receive(:query_id_for_github_email)
+        .with(email)
+        .and_return(42)
+
+      expect(Gitlab::GithubImport::Caching)
+        .to receive(:write)
+        .with(described_class::ID_FOR_EMAIL_CACHE_KEY % email, 42)
+
+      finder.id_for_github_email(email)
+    end
+
+    it 'caches a nil value if no ID could be found' do
+      expect(finder).to receive(:query_id_for_github_email)
+        .with(email)
+        .and_return(nil)
+
+      expect(Gitlab::GithubImport::Caching)
+        .to receive(:write)
+        .with(described_class::ID_FOR_EMAIL_CACHE_KEY % email, nil)
+
+      finder.id_for_github_email(email)
+    end
+  end
+
+  describe '#query_id_for_github_id' do
+    it 'returns the ID of the user for the given GitHub user ID' do
+      user = create(:user)
+
+      user.identities.create!(provider: :github, extern_uid: '42')
+
+      expect(finder.query_id_for_github_id(42)).to eq(user.id)
+    end
+
+    it 'returns nil when no user ID could be found' do
+      expect(finder.query_id_for_github_id(42)).to be_nil
+    end
+  end
+
+  describe '#query_id_for_github_email' do
+    it 'returns the ID of the user for the given Email address' do
+      user = create(:user, email: 'kittens@example.com')
+
+      expect(finder.query_id_for_github_email(user.email)).to eq(user.id)
+    end
+
+    it 'returns nil if no user ID could be found' do
+      expect(finder.query_id_for_github_email('kittens@example.com')).to be_nil
+    end
+  end
+
+  describe '#read_id_from_cache' do
+    it 'reads an ID from the cache' do
+      Gitlab::GithubImport::Caching.write('foo', 10)
+
+      expect(finder.read_id_from_cache('foo')).to eq([true, 10])
+    end
+
+    it 'reads a cache key with an empty value' do
+      Gitlab::GithubImport::Caching.write('foo', nil)
+
+      expect(finder.read_id_from_cache('foo')).to eq([true, nil])
+    end
+
+    it 'reads a cache key that does not exist' do
+      expect(finder.read_id_from_cache('foo')).to eq([false, nil])
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import_spec.rb b/spec/lib/gitlab/github_import_spec.rb
new file mode 100644
index 00000000000..51414800e8c
--- /dev/null
+++ b/spec/lib/gitlab/github_import_spec.rb
@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport do
+  let(:project) { double(:project) }
+
+  describe '.new_client_for' do
+    it 'returns a new Client with a custom token' do
+      expect(described_class::Client)
+        .to receive(:new)
+        .with('123', parallel: true)
+
+      described_class.new_client_for(project, token: '123')
+    end
+
+    it 'returns a new Client with a token stored in the import data' do
+      import_data = double(:import_data, credentials: { user: '123' })
+
+      expect(project)
+        .to receive(:import_data)
+        .and_return(import_data)
+
+      expect(described_class::Client)
+        .to receive(:new)
+        .with('123', parallel: true)
+
+      described_class.new_client_for(project)
+    end
+  end
+
+  describe '.insert_and_return_id' do
+    let(:attributes) { { iid: 1, title: 'foo' } }
+    let(:project) { create(:project) }
+
+    context 'on PostgreSQL' do
+      it 'returns the ID returned by the query' do
+        expect(Gitlab::Database)
+          .to receive(:bulk_insert)
+          .with(Issue.table_name, [attributes], return_ids: true)
+          .and_return([10])
+
+        id = described_class.insert_and_return_id(attributes, project.issues)
+
+        expect(id).to eq(10)
+      end
+    end
+
+    context 'on MySQL' do
+      it 'uses a separate query to retrieve the ID' do
+        issue = create(:issue, project: project, iid: attributes[:iid])
+
+        expect(Gitlab::Database)
+          .to receive(:bulk_insert)
+          .with(Issue.table_name, [attributes], return_ids: true)
+          .and_return([])
+
+        id = described_class.insert_and_return_id(attributes, project.issues)
+
+        expect(id).to eq(issue.id)
+      end
+    end
+  end
+
+  describe '.ghost_user_id', :clean_gitlab_redis_cache do
+    it 'returns the ID of the ghost user' do
+      expect(described_class.ghost_user_id).to eq(User.ghost.id)
+    end
+
+    it 'caches the ghost user ID' do
+      expect(Gitlab::GithubImport::Caching)
+        .to receive(:write)
+        .once
+        .and_call_original
+
+      2.times do
+        described_class.ghost_user_id
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/hook_data/issuable_builder_spec.rb b/spec/lib/gitlab/hook_data/issuable_builder_spec.rb
index 30da56bec16..26529c4759d 100644
--- a/spec/lib/gitlab/hook_data/issuable_builder_spec.rb
+++ b/spec/lib/gitlab/hook_data/issuable_builder_spec.rb
@@ -41,7 +41,8 @@ describe Gitlab::HookData::IssuableBuilder do
             labels: [
               [{ id: 1, title: 'foo' }],
               [{ id: 1, title: 'foo' }, { id: 2, title: 'bar' }]
-            ]
+            ],
+            total_time_spent: [1, 2]
           }
         end
         let(:data) { builder.build(user: user, changes: changes) }
@@ -53,6 +54,10 @@ describe Gitlab::HookData::IssuableBuilder do
             labels: {
               previous: [{ id: 1, title: 'foo' }],
               current: [{ id: 1, title: 'foo' }, { id: 2, title: 'bar' }]
+            },
+            total_time_spent: {
+              previous: 1,
+              current: 2
             }
           }))
         end
diff --git a/spec/lib/gitlab/hook_data/issue_builder_spec.rb b/spec/lib/gitlab/hook_data/issue_builder_spec.rb
index 6c529cdd051..aeacd577d18 100644
--- a/spec/lib/gitlab/hook_data/issue_builder_spec.rb
+++ b/spec/lib/gitlab/hook_data/issue_builder_spec.rb
@@ -11,7 +11,6 @@ describe Gitlab::HookData::IssueBuilder do
       %w[
         assignee_id
         author_id
-        branch_name
         closed_at
         confidential
         created_at
diff --git a/spec/lib/gitlab/hook_data/merge_request_builder_spec.rb b/spec/lib/gitlab/hook_data/merge_request_builder_spec.rb
index 92bf87bbad4..78475403f9e 100644
--- a/spec/lib/gitlab/hook_data/merge_request_builder_spec.rb
+++ b/spec/lib/gitlab/hook_data/merge_request_builder_spec.rb
@@ -26,7 +26,6 @@ describe Gitlab::HookData::MergeRequestBuilder do
         merge_user_id
         merge_when_pipeline_succeeds
         milestone_id
-        ref_fetched
         source_branch
         source_project_id
         state
diff --git a/spec/lib/gitlab/import_export/all_models.yml b/spec/lib/gitlab/import_export/all_models.yml
index 6c6b9154a0a..bf1e97654e5 100644
--- a/spec/lib/gitlab/import_export/all_models.yml
+++ b/spec/lib/gitlab/import_export/all_models.yml
@@ -147,10 +147,6 @@ deploy_keys:
 - user
 - deploy_keys_projects
 - projects
-cluster:
-- project
-- user
-- service
 services:
 - project
 - service_hook
@@ -182,6 +178,8 @@ project:
 - tags
 - chat_services
 - cluster
+- clusters
+- cluster_project
 - creator
 - group
 - namespace
@@ -276,6 +274,7 @@ project:
 - root_of_fork_network
 - fork_network_member
 - fork_network
+- custom_attributes
 award_emoji:
 - awardable
 - user
@@ -289,4 +288,4 @@ push_event_payload:
 - event
 issue_assignees:
 - issue
-- assignee
\ No newline at end of file
+- assignee
diff --git a/spec/lib/gitlab/import_export/fork_spec.rb b/spec/lib/gitlab/import_export/fork_spec.rb
index dd0ce0dae41..cfb15ee7e8b 100644
--- a/spec/lib/gitlab/import_export/fork_spec.rb
+++ b/spec/lib/gitlab/import_export/fork_spec.rb
@@ -46,7 +46,7 @@ describe 'forked project import' do
   end
 
   it 'can access the MR' do
-    project.merge_requests.first.ensure_ref_fetched
+    project.merge_requests.first.fetch_ref!
 
     expect(project.repository.ref_exists?('refs/merge-requests/1/head')).to be_truthy
   end
diff --git a/spec/lib/gitlab/import_export/merge_request_parser_spec.rb b/spec/lib/gitlab/import_export/merge_request_parser_spec.rb
index 473ba40fae7..b793636c4d6 100644
--- a/spec/lib/gitlab/import_export/merge_request_parser_spec.rb
+++ b/spec/lib/gitlab/import_export/merge_request_parser_spec.rb
@@ -13,7 +13,7 @@ describe Gitlab::ImportExport::MergeRequestParser do
 
   let(:parsed_merge_request) do
     described_class.new(project,
-                        merge_request.diff_head_sha,
+                        'abcd',
                         merge_request,
                         merge_request.as_json).parse!
   end
@@ -29,4 +29,14 @@ describe Gitlab::ImportExport::MergeRequestParser do
   it 'has a target branch' do
     expect(project.repository.branch_exists?(parsed_merge_request.target_branch)).to be true
   end
+
+  it 'parses a MR that has no source branch' do
+    allow_any_instance_of(described_class).to receive(:branch_exists?).and_call_original
+    allow_any_instance_of(described_class).to receive(:branch_exists?).with(merge_request.source_branch).and_return(false)
+    allow_any_instance_of(described_class).to receive(:fork_merge_request?).and_return(true)
+    allow(Gitlab::GitalyClient).to receive(:migrate).and_call_original
+    allow(Gitlab::GitalyClient).to receive(:migrate).with(:fetch_ref).and_return([nil, 0])
+
+    expect(parsed_merge_request).to eq(merge_request)
+  end
 end
diff --git a/spec/lib/gitlab/import_export/project.json b/spec/lib/gitlab/import_export/project.json
index 9a68bbb379c..f7c90093bde 100644
--- a/spec/lib/gitlab/import_export/project.json
+++ b/spec/lib/gitlab/import_export/project.json
@@ -7408,5 +7408,23 @@
     "snippets_access_level": 20,
     "updated_at": "2016-09-23T11:58:28.000Z",
     "wiki_access_level": 20
-  }
+  },
+  "custom_attributes": [
+    {
+      "id": 1,
+      "created_at": "2017-10-19T15:36:23.466Z",
+      "updated_at": "2017-10-19T15:36:23.466Z",
+      "project_id": 5,
+      "key": "foo",
+      "value": "foo"
+    },
+    {
+      "id": 2,
+      "created_at": "2017-10-19T15:37:21.904Z",
+      "updated_at": "2017-10-19T15:37:21.904Z",
+      "project_id": 5,
+      "key": "bar",
+      "value": "bar"
+    }
+  ]
 }
diff --git a/spec/lib/gitlab/import_export/project_tree_restorer_spec.rb b/spec/lib/gitlab/import_export/project_tree_restorer_spec.rb
index 76b01b6a1ec..e4b4cf5ba85 100644
--- a/spec/lib/gitlab/import_export/project_tree_restorer_spec.rb
+++ b/spec/lib/gitlab/import_export/project_tree_restorer_spec.rb
@@ -133,6 +133,10 @@ describe Gitlab::ImportExport::ProjectTreeRestorer do
         expect(@project.project_feature).not_to be_nil
       end
 
+      it 'has custom attributes' do
+        expect(@project.custom_attributes.count).to eq(2)
+      end
+
       it 'restores the correct service' do
         expect(CustomIssueTrackerService.first).not_to be_nil
       end
diff --git a/spec/lib/gitlab/import_export/project_tree_saver_spec.rb b/spec/lib/gitlab/import_export/project_tree_saver_spec.rb
index 8da768ebd07..ee173afbd50 100644
--- a/spec/lib/gitlab/import_export/project_tree_saver_spec.rb
+++ b/spec/lib/gitlab/import_export/project_tree_saver_spec.rb
@@ -168,6 +168,10 @@ describe Gitlab::ImportExport::ProjectTreeSaver do
         expect(project_feature["builds_access_level"]).to eq(ProjectFeature::PRIVATE)
       end
 
+      it 'has custom attributes' do
+        expect(saved_project_json['custom_attributes'].count).to eq(2)
+      end
+
       it 'does not complain about non UTF-8 characters in MR diffs' do
         ActiveRecord::Base.connection.execute("UPDATE merge_request_diffs SET st_diffs = '---\n- :diff: !binary |-\n    LS0tIC9kZXYvbnVsbAorKysgYi9pbWFnZXMvbnVjb3IucGRmCkBAIC0wLDAg\n    KzEsMTY3OSBAQAorJVBERi0xLjUNJeLjz9MNCisxIDAgb2JqDTw8L01ldGFk\n    YXR'")
 
@@ -279,6 +283,9 @@ describe Gitlab::ImportExport::ProjectTreeSaver do
     create(:event, :created, target: milestone, project: project, author: user)
     create(:service, project: project, type: 'CustomIssueTrackerService', category: 'issue_tracker')
 
+    create(:project_custom_attribute, project: project)
+    create(:project_custom_attribute, project: project)
+
     project
   end
 
diff --git a/spec/lib/gitlab/import_export/safe_model_attributes.yml b/spec/lib/gitlab/import_export/safe_model_attributes.yml
index 89d30407077..4e36af18aa7 100644
--- a/spec/lib/gitlab/import_export/safe_model_attributes.yml
+++ b/spec/lib/gitlab/import_export/safe_model_attributes.yml
@@ -313,30 +313,47 @@ Ci::PipelineSchedule:
 - deleted_at
 - created_at
 - updated_at
-Gcp::Cluster:
+Clusters::Cluster:
 - id
-- project_id
 - user_id
-- service_id
 - enabled
+- name
+- provider_type
+- platform_type
+- created_at
+- updated_at
+Clusters::Project:
+- id
+- project_id
+- cluster_id
+- created_at
+- updated_at
+Clusters::Providers::Gcp:
+- id
+- cluster_id
 - status
 - status_reason
-- project_namespace
+- gcp_project_id
+- zone
+- num_nodes
+- machine_type
+- operation_id
 - endpoint
+- encrypted_access_token
+- encrypted_access_token_iv
+- created_at
+- updated_at
+Clusters::Platforms::Kubernetes:
+- id
+- cluster_id
+- api_url
 - ca_cert
-- encrypted_kubernetes_token
-- encrypted_kubernetes_token_iv
+- namespace
 - username
 - encrypted_password
 - encrypted_password_iv
-- gcp_project_id
-- gcp_cluster_zone
-- gcp_cluster_name
-- gcp_cluster_size
-- gcp_machine_type
-- gcp_operation_id
-- encrypted_gcp_token
-- encrypted_gcp_token_iv
+- encrypted_token
+- encrypted_token_iv
 - created_at
 - updated_at
 DeployKey:
@@ -508,4 +525,11 @@ ProjectAutoDevops:
 - updated_at
 IssueAssignee:
 - user_id
-- issue_id
\ No newline at end of file
+- issue_id
+ProjectCustomAttribute:
+- id
+- created_at
+- updated_at
+- project_id
+- key
+- value
diff --git a/spec/lib/gitlab/import_sources_spec.rb b/spec/lib/gitlab/import_sources_spec.rb
index c5725f47453..f2fa315e3ec 100644
--- a/spec/lib/gitlab/import_sources_spec.rb
+++ b/spec/lib/gitlab/import_sources_spec.rb
@@ -56,14 +56,14 @@ describe Gitlab::ImportSources do
 
   describe '.importer' do
     import_sources = {
-      'github' => Github::Import,
+      'github' => Gitlab::GithubImport::ParallelImporter,
       'bitbucket' => Gitlab::BitbucketImport::Importer,
       'gitlab' => Gitlab::GitlabImport::Importer,
       'google_code' => Gitlab::GoogleCodeImport::Importer,
       'fogbugz' => Gitlab::FogbugzImport::Importer,
       'git' => nil,
       'gitlab_project' => Gitlab::ImportExport::Importer,
-      'gitea' => Gitlab::GithubImport::Importer
+      'gitea' => Gitlab::LegacyGithubImport::Importer
     }
 
     import_sources.each do |name, klass|
diff --git a/spec/lib/gitlab/issuable_metadata_spec.rb b/spec/lib/gitlab/issuable_metadata_spec.rb
index 2455969a183..42635a68ee1 100644
--- a/spec/lib/gitlab/issuable_metadata_spec.rb
+++ b/spec/lib/gitlab/issuable_metadata_spec.rb
@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Gitlab::IssuableMetadata do
-  let(:user)        { create(:user) }
-  let!(:project)    { create(:project, :public, :repository, creator: user, namespace: user.namespace) }
+  let(:user)     { create(:user) }
+  let!(:project) { create(:project, :public, :repository, creator: user, namespace: user.namespace) }
 
   subject { Class.new { include Gitlab::IssuableMetadata }.new }
 
@@ -10,6 +10,10 @@ describe Gitlab::IssuableMetadata do
     expect(subject.issuable_meta_data(Issue.none, 'Issue')).to eq({})
   end
 
+  it 'raises an error when given a collection with no limit' do
+    expect { subject.issuable_meta_data(Issue.all, 'Issue') }.to raise_error(/must have a limit/)
+  end
+
   context 'issues' do
     let!(:issue) { create(:issue, author: user, project: project) }
     let!(:closed_issue) { create(:issue, state: :closed, author: user, project: project) }
@@ -19,7 +23,7 @@ describe Gitlab::IssuableMetadata do
     let!(:closing_issues) { create(:merge_requests_closing_issues, issue: issue, merge_request: merge_request) }
 
     it 'aggregates stats on issues' do
-      data = subject.issuable_meta_data(Issue.all, 'Issue')
+      data = subject.issuable_meta_data(Issue.all.limit(10), 'Issue')
 
       expect(data.count).to eq(2)
       expect(data[issue.id].upvotes).to eq(1)
@@ -42,7 +46,7 @@ describe Gitlab::IssuableMetadata do
     let!(:note) { create(:note_on_merge_request, author: user, project: project, noteable: merge_request, note: "a comment on a MR") }
 
     it 'aggregates stats on merge requests' do
-      data = subject.issuable_meta_data(MergeRequest.all, 'MergeRequest')
+      data = subject.issuable_meta_data(MergeRequest.all.limit(10), 'MergeRequest')
 
       expect(data.count).to eq(2)
       expect(data[merge_request.id].upvotes).to eq(1)
diff --git a/spec/lib/gitlab/kubernetes/helm_spec.rb b/spec/lib/gitlab/kubernetes/helm_spec.rb
new file mode 100644
index 00000000000..15f99b0401f
--- /dev/null
+++ b/spec/lib/gitlab/kubernetes/helm_spec.rb
@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Gitlab::Kubernetes::Helm do
+  let(:client) { double('kubernetes client') }
+  let(:helm) { described_class.new(client) }
+  let(:namespace) { Gitlab::Kubernetes::Namespace.new(described_class::NAMESPACE, client) }
+  let(:install_helm) { true }
+  let(:chart) { 'stable/a_chart' }
+  let(:application_name) { 'app_name' }
+  let(:command) { Gitlab::Kubernetes::Helm::InstallCommand.new(application_name, install_helm, chart) }
+  subject { helm }
+
+  before do
+    allow(Gitlab::Kubernetes::Namespace).to receive(:new).with(described_class::NAMESPACE, client).and_return(namespace)
+  end
+
+  describe '#initialize' do
+    it 'creates a namespace object' do
+      expect(Gitlab::Kubernetes::Namespace).to receive(:new).with(described_class::NAMESPACE, client)
+
+      subject
+    end
+  end
+
+  describe '#install' do
+    before do
+      allow(client).to receive(:create_pod).and_return(nil)
+      allow(namespace).to receive(:ensure_exists!).once
+    end
+
+    it 'ensures the namespace exists before creating the POD' do
+      expect(namespace).to receive(:ensure_exists!).once.ordered
+      expect(client).to receive(:create_pod).once.ordered
+
+      subject.install(command)
+    end
+  end
+
+  describe '#installation_status' do
+    let(:phase) { Gitlab::Kubernetes::Pod::RUNNING }
+    let(:pod) { Kubeclient::Resource.new(status: { phase: phase }) } # partial representation
+
+    it 'fetches POD phase from kubernetes cluster' do
+      expect(client).to receive(:get_pod).with(command.pod_name, described_class::NAMESPACE).once.and_return(pod)
+
+      expect(subject.installation_status(command.pod_name)).to eq(phase)
+    end
+  end
+
+  describe '#installation_log' do
+    let(:log) { 'some output' }
+    let(:response) { RestClient::Response.new(log) }
+
+    it 'fetches POD phase from kubernetes cluster' do
+      expect(client).to receive(:get_pod_log).with(command.pod_name, described_class::NAMESPACE).once.and_return(response)
+
+      expect(subject.installation_log(command.pod_name)).to eq(log)
+    end
+  end
+
+  describe '#delete_installation_pod!' do
+    it 'deletes the POD from kubernetes cluster' do
+      expect(client).to receive(:delete_pod).with(command.pod_name, described_class::NAMESPACE).once
+
+      subject.delete_installation_pod!(command.pod_name)
+    end
+  end
+
+  describe '#helm_init_command' do
+    subject { helm.send(:helm_init_command, command) }
+
+    context 'when command.install_helm is true' do
+      let(:install_helm) { true }
+
+      it { is_expected.to eq('helm init >/dev/null') }
+    end
+
+    context 'when command.install_helm is false' do
+      let(:install_helm) { false }
+
+      it { is_expected.to eq('helm init --client-only >/dev/null') }
+    end
+  end
+
+  describe '#helm_install_command' do
+    subject { helm.send(:helm_install_command, command) }
+
+    context 'when command.chart is nil' do
+      let(:chart) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when command.chart is set' do
+      let(:chart) { 'stable/a_chart' }
+
+      it { is_expected.to eq("helm install #{chart} --name #{application_name} --namespace #{namespace.name} >/dev/null")}
+    end
+  end
+end
diff --git a/spec/lib/gitlab/kubernetes/namespace_spec.rb b/spec/lib/gitlab/kubernetes/namespace_spec.rb
new file mode 100644
index 00000000000..b3c987f9344
--- /dev/null
+++ b/spec/lib/gitlab/kubernetes/namespace_spec.rb
@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Gitlab::Kubernetes::Namespace do
+  let(:name) { 'a_namespace' }
+  let(:client) { double('kubernetes client') }
+  subject { described_class.new(name, client) }
+
+  it { expect(subject.name).to eq(name) }
+
+  describe '#exists?' do
+    context 'when namespace do not exits' do
+      let(:exception) { ::KubeException.new(404, "namespace #{name} not found", nil) }
+
+      it 'returns false' do
+        expect(client).to receive(:get_namespace).with(name).once.and_raise(exception)
+
+        expect(subject.exists?).to be_falsey
+      end
+    end
+
+    context 'when namespace exits' do
+      let(:namespace) { ::Kubeclient::Resource.new(kind: 'Namespace', metadata: { name: name }) } # partial representation
+
+      it 'returns true' do
+        expect(client).to receive(:get_namespace).with(name).once.and_return(namespace)
+
+        expect(subject.exists?).to be_truthy
+      end
+    end
+
+    context 'when cluster cannot be reached' do
+      let(:exception) { Errno::ECONNREFUSED.new }
+
+      it 'raises exception' do
+        expect(client).to receive(:get_namespace).with(name).once.and_raise(exception)
+
+        expect { subject.exists? }.to raise_error(exception)
+      end
+    end
+  end
+
+  describe '#create!' do
+    it 'creates a namespace' do
+      matcher = have_attributes(metadata: have_attributes(name: name))
+      expect(client).to receive(:create_namespace).with(matcher).once
+
+      expect { subject.create! }.not_to raise_error
+    end
+  end
+
+  describe '#ensure_exists!' do
+    it 'checks for existing namespace before creating' do
+      expect(subject).to receive(:exists?).once.ordered.and_return(false)
+      expect(subject).to receive(:create!).once.ordered
+
+      subject.ensure_exists!
+    end
+
+    it 'do not re-create an existing namespace' do
+      expect(subject).to receive(:exists?).once.and_return(true)
+      expect(subject).not_to receive(:create!)
+
+      subject.ensure_exists!
+    end
+  end
+end
diff --git a/spec/lib/gitlab/github_import/branch_formatter_spec.rb b/spec/lib/gitlab/legacy_github_import/branch_formatter_spec.rb
index 426b43f8b51..48655851140 100644
--- a/spec/lib/gitlab/github_import/branch_formatter_spec.rb
+++ b/spec/lib/gitlab/legacy_github_import/branch_formatter_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GithubImport::BranchFormatter do
+describe Gitlab::LegacyGithubImport::BranchFormatter do
   let(:project) { create(:project, :repository) }
   let(:commit) { create(:commit, project: project) }
   let(:repo) { double }
diff --git a/spec/lib/gitlab/legacy_github_import/client_spec.rb b/spec/lib/gitlab/legacy_github_import/client_spec.rb
new file mode 100644
index 00000000000..80b767abce0
--- /dev/null
+++ b/spec/lib/gitlab/legacy_github_import/client_spec.rb
@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Gitlab::LegacyGithubImport::Client do
+  let(:token) { '123456' }
+  let(:github_provider) { Settingslogic.new('app_id' => 'asd123', 'app_secret' => 'asd123', 'name' => 'github', 'args' => { 'client_options' => {} }) }
+
+  subject(:client) { described_class.new(token) }
+
+  before do
+    allow(Gitlab.config.omniauth).to receive(:providers).and_return([github_provider])
+  end
+
+  it 'convert OAuth2 client options to symbols' do
+    client.client.options.keys.each do |key|
+      expect(key).to be_kind_of(Symbol)
+    end
+  end
+
+  it 'does not crash (e.g. Settingslogic::MissingSetting) when verify_ssl config is not present' do
+    expect { client.api }.not_to raise_error
+  end
+
+  context 'when config is missing' do
+    before do
+      allow(Gitlab.config.omniauth).to receive(:providers).and_return([])
+    end
+
+    it 'is still possible to get an Octokit client' do
+      expect { client.api }.not_to raise_error
+    end
+
+    it 'is not be possible to get an OAuth2 client' do
+      expect { client.client }.to raise_error(Projects::ImportService::Error)
+    end
+  end
+
+  context 'allow SSL verification to be configurable on API' do
+    before do
+      github_provider['verify_ssl'] = false
+    end
+
+    it 'uses supplied value' do
+      expect(client.client.options[:connection_opts][:ssl]).to eq({ verify: false })
+      expect(client.api.connection_options[:ssl]).to eq({ verify: false })
+    end
+  end
+
+  describe '#api_endpoint' do
+    context 'when provider does not specity an API endpoint' do
+      it 'uses GitHub root API endpoint' do
+        expect(client.api.api_endpoint).to eq 'https://api.github.com/'
+      end
+    end
+
+    context 'when provider specify a custom API endpoint' do
+      before do
+        github_provider['args']['client_options']['site'] = 'https://github.company.com/'
+      end
+
+      it 'uses the custom API endpoint' do
+        expect(OmniAuth::Strategies::GitHub).not_to receive(:default_options)
+        expect(client.api.api_endpoint).to eq 'https://github.company.com/'
+      end
+    end
+
+    context 'when given a host' do
+      subject(:client) { described_class.new(token, host: 'https://try.gitea.io/') }
+
+      it 'builds a endpoint with the given host and the default API version' do
+        expect(client.api.api_endpoint).to eq 'https://try.gitea.io/api/v3/'
+      end
+    end
+
+    context 'when given an API version' do
+      subject(:client) { described_class.new(token, api_version: 'v3') }
+
+      it 'does not use the API version without a host' do
+        expect(client.api.api_endpoint).to eq 'https://api.github.com/'
+      end
+    end
+
+    context 'when given a host and version' do
+      subject(:client) { described_class.new(token, host: 'https://try.gitea.io/', api_version: 'v3') }
+
+      it 'builds a endpoint with the given options' do
+        expect(client.api.api_endpoint).to eq 'https://try.gitea.io/api/v3/'
+      end
+    end
+  end
+
+  it 'does not raise error when rate limit is disabled' do
+    stub_request(:get, /api.github.com/)
+    allow(client.api).to receive(:rate_limit!).and_raise(Octokit::NotFound)
+
+    expect { client.issues {} }.not_to raise_error
+  end
+end
diff --git a/spec/lib/gitlab/github_import/comment_formatter_spec.rb b/spec/lib/gitlab/legacy_github_import/comment_formatter_spec.rb
index 035ac8c7c1f..413654e108c 100644
--- a/spec/lib/gitlab/github_import/comment_formatter_spec.rb
+++ b/spec/lib/gitlab/legacy_github_import/comment_formatter_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GithubImport::CommentFormatter do
+describe Gitlab::LegacyGithubImport::CommentFormatter do
   let(:client) { double }
   let(:project) { create(:project) }
   let(:octocat) { double(id: 123456, login: 'octocat', email: 'octocat@example.com') }
diff --git a/spec/lib/gitlab/github_import/importer_spec.rb b/spec/lib/gitlab/legacy_github_import/importer_spec.rb
index d570f34985b..20514486727 100644
--- a/spec/lib/gitlab/github_import/importer_spec.rb
+++ b/spec/lib/gitlab/legacy_github_import/importer_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Gitlab::GithubImport::Importer do
-  shared_examples 'Gitlab::GithubImport::Importer#execute' do
+describe Gitlab::LegacyGithubImport::Importer do
+  shared_examples 'Gitlab::LegacyGithubImport::Importer#execute' do
     let(:expected_not_called) { [] }
 
     before do
@@ -35,7 +35,7 @@ describe Gitlab::GithubImport::Importer do
     end
   end
 
-  shared_examples 'Gitlab::GithubImport::Importer#execute an error occurs' do
+  shared_examples 'Gitlab::LegacyGithubImport::Importer#execute an error occurs' do
     before do
       allow(project).to receive(:import_data).and_return(double.as_null_object)
 
@@ -178,7 +178,7 @@ describe Gitlab::GithubImport::Importer do
     end
   end
 
-  shared_examples 'Gitlab::GithubImport unit-testing' do
+  shared_examples 'Gitlab::LegacyGithubImport unit-testing' do
     describe '#clean_up_restored_branches' do
       subject { described_class.new(project) }
 
@@ -188,7 +188,7 @@ describe Gitlab::GithubImport::Importer do
       end
 
       context 'when pull request stills open' do
-        let(:gh_pull_request) { Gitlab::GithubImport::PullRequestFormatter.new(project, pull_request) }
+        let(:gh_pull_request) { Gitlab::LegacyGithubImport::PullRequestFormatter.new(project, pull_request) }
 
         it 'does not remove branches' do
           expect(subject).not_to receive(:remove_branch)
@@ -197,7 +197,7 @@ describe Gitlab::GithubImport::Importer do
       end
 
       context 'when pull request is closed' do
-        let(:gh_pull_request) { Gitlab::GithubImport::PullRequestFormatter.new(project, closed_pull_request) }
+        let(:gh_pull_request) { Gitlab::LegacyGithubImport::PullRequestFormatter.new(project, closed_pull_request) }
 
         it 'does remove branches' do
           expect(subject).to receive(:remove_branch).at_least(2).times
@@ -262,14 +262,14 @@ describe Gitlab::GithubImport::Importer do
     let(:repo_root) { 'https://github.com' }
     subject { described_class.new(project) }
 
-    it_behaves_like 'Gitlab::GithubImport::Importer#execute'
-    it_behaves_like 'Gitlab::GithubImport::Importer#execute an error occurs'
-    it_behaves_like 'Gitlab::GithubImport unit-testing'
+    it_behaves_like 'Gitlab::LegacyGithubImport::Importer#execute'
+    it_behaves_like 'Gitlab::LegacyGithubImport::Importer#execute an error occurs'
+    it_behaves_like 'Gitlab::LegacyGithubImport unit-testing'
 
     describe '#client' do
       it 'instantiates a Client' do
         allow(project).to receive(:import_data).and_return(double(credentials: credentials))
-        expect(Gitlab::GithubImport::Client).to receive(:new).with(
+        expect(Gitlab::LegacyGithubImport::Client).to receive(:new).with(
           credentials[:user],
           {}
         )
@@ -288,16 +288,16 @@ describe Gitlab::GithubImport::Importer do
       project.update(import_type: 'gitea', import_url: "#{repo_root}/foo/group/project.git")
     end
 
-    it_behaves_like 'Gitlab::GithubImport::Importer#execute' do
+    it_behaves_like 'Gitlab::LegacyGithubImport::Importer#execute' do
       let(:expected_not_called) { [:import_releases] }
     end
-    it_behaves_like 'Gitlab::GithubImport::Importer#execute an error occurs'
-    it_behaves_like 'Gitlab::GithubImport unit-testing'
+    it_behaves_like 'Gitlab::LegacyGithubImport::Importer#execute an error occurs'
+    it_behaves_like 'Gitlab::LegacyGithubImport unit-testing'
 
     describe '#client' do
       it 'instantiates a Client' do
         allow(project).to receive(:import_data).and_return(double(credentials: credentials))
-        expect(Gitlab::GithubImport::Client).to receive(:new).with(
+        expect(Gitlab::LegacyGithubImport::Client).to receive(:new).with(
           credentials[:user],
           { host: "#{repo_root}:443/foo", api_version: 'v1' }
         )
diff --git a/spec/lib/gitlab/github_import/issuable_formatter_spec.rb b/spec/lib/gitlab/legacy_github_import/issuable_formatter_spec.rb
index 05294d227bd..3b5d8945344 100644
--- a/spec/lib/gitlab/github_import/issuable_formatter_spec.rb
+++ b/spec/lib/gitlab/legacy_github_import/issuable_formatter_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GithubImport::IssuableFormatter do
+describe Gitlab::LegacyGithubImport::IssuableFormatter do
   let(:raw_data) do
     double(number: 42)
   end
diff --git a/spec/lib/gitlab/github_import/issue_formatter_spec.rb b/spec/lib/gitlab/legacy_github_import/issue_formatter_spec.rb
index 0fc56d92aa6..1a4d5dbfb70 100644
--- a/spec/lib/gitlab/github_import/issue_formatter_spec.rb
+++ b/spec/lib/gitlab/legacy_github_import/issue_formatter_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GithubImport::IssueFormatter do
+describe Gitlab::LegacyGithubImport::IssueFormatter do
   let(:client) { double }
   let!(:project) { create(:project, namespace: create(:namespace, path: 'octocat')) }
   let(:octocat) { double(id: 123456, login: 'octocat', email: 'octocat@example.com') }
@@ -30,7 +30,7 @@ describe Gitlab::GithubImport::IssueFormatter do
     allow(client).to receive(:user).and_return(octocat)
   end
 
-  shared_examples 'Gitlab::GithubImport::IssueFormatter#attributes' do
+  shared_examples 'Gitlab::LegacyGithubImport::IssueFormatter#attributes' do
     context 'when issue is open' do
       let(:raw_data) { double(base_data.merge(state: 'open')) }
 
@@ -135,7 +135,7 @@ describe Gitlab::GithubImport::IssueFormatter do
     end
   end
 
-  shared_examples 'Gitlab::GithubImport::IssueFormatter#number' do
+  shared_examples 'Gitlab::LegacyGithubImport::IssueFormatter#number' do
     let(:raw_data) { double(base_data.merge(number: 1347)) }
 
     it 'returns issue number' do
@@ -144,8 +144,8 @@ describe Gitlab::GithubImport::IssueFormatter do
   end
 
   context 'when importing a GitHub project' do
-    it_behaves_like 'Gitlab::GithubImport::IssueFormatter#attributes'
-    it_behaves_like 'Gitlab::GithubImport::IssueFormatter#number'
+    it_behaves_like 'Gitlab::LegacyGithubImport::IssueFormatter#attributes'
+    it_behaves_like 'Gitlab::LegacyGithubImport::IssueFormatter#number'
   end
 
   context 'when importing a Gitea project' do
@@ -153,8 +153,8 @@ describe Gitlab::GithubImport::IssueFormatter do
       project.update(import_type: 'gitea')
     end
 
-    it_behaves_like 'Gitlab::GithubImport::IssueFormatter#attributes'
-    it_behaves_like 'Gitlab::GithubImport::IssueFormatter#number'
+    it_behaves_like 'Gitlab::LegacyGithubImport::IssueFormatter#attributes'
+    it_behaves_like 'Gitlab::LegacyGithubImport::IssueFormatter#number'
   end
 
   describe '#has_comments?' do
diff --git a/spec/lib/gitlab/github_import/label_formatter_spec.rb b/spec/lib/gitlab/legacy_github_import/label_formatter_spec.rb
index 83fdd2cc415..0d1d04f1bf6 100644
--- a/spec/lib/gitlab/github_import/label_formatter_spec.rb
+++ b/spec/lib/gitlab/legacy_github_import/label_formatter_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GithubImport::LabelFormatter do
+describe Gitlab::LegacyGithubImport::LabelFormatter do
   let(:project) { create(:project) }
   let(:raw) { double(name: 'improvements', color: 'e6e6e6') }
 
diff --git a/spec/lib/gitlab/github_import/milestone_formatter_spec.rb b/spec/lib/gitlab/legacy_github_import/milestone_formatter_spec.rb
index 683fa51b78e..1db4bbb568c 100644
--- a/spec/lib/gitlab/github_import/milestone_formatter_spec.rb
+++ b/spec/lib/gitlab/legacy_github_import/milestone_formatter_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GithubImport::MilestoneFormatter do
+describe Gitlab::LegacyGithubImport::MilestoneFormatter do
   let(:project) { create(:project) }
   let(:created_at) { DateTime.strptime('2011-01-26T19:01:12Z') }
   let(:updated_at) { DateTime.strptime('2011-01-27T19:01:12Z') }
@@ -19,7 +19,7 @@ describe Gitlab::GithubImport::MilestoneFormatter do
 
   subject(:formatter) { described_class.new(project, raw_data) }
 
-  shared_examples 'Gitlab::GithubImport::MilestoneFormatter#attributes' do
+  shared_examples 'Gitlab::LegacyGithubImport::MilestoneFormatter#attributes' do
     let(:data) { base_data.merge(iid_attr => 1347) }
 
     context 'when milestone is open' do
@@ -82,7 +82,7 @@ describe Gitlab::GithubImport::MilestoneFormatter do
   end
 
   context 'when importing a GitHub project' do
-    it_behaves_like 'Gitlab::GithubImport::MilestoneFormatter#attributes'
+    it_behaves_like 'Gitlab::LegacyGithubImport::MilestoneFormatter#attributes'
   end
 
   context 'when importing a Gitea project' do
@@ -91,6 +91,6 @@ describe Gitlab::GithubImport::MilestoneFormatter do
       project.update(import_type: 'gitea')
     end
 
-    it_behaves_like 'Gitlab::GithubImport::MilestoneFormatter#attributes'
+    it_behaves_like 'Gitlab::LegacyGithubImport::MilestoneFormatter#attributes'
   end
 end
diff --git a/spec/lib/gitlab/github_import/project_creator_spec.rb b/spec/lib/gitlab/legacy_github_import/project_creator_spec.rb
index 948e7469a18..737c9a624e0 100644
--- a/spec/lib/gitlab/github_import/project_creator_spec.rb
+++ b/spec/lib/gitlab/legacy_github_import/project_creator_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GithubImport::ProjectCreator do
+describe Gitlab::LegacyGithubImport::ProjectCreator do
   let(:user) { create(:user) }
   let(:namespace) { create(:group, owner: user) }
 
diff --git a/spec/lib/gitlab/github_import/pull_request_formatter_spec.rb b/spec/lib/gitlab/legacy_github_import/pull_request_formatter_spec.rb
index 2e42f6239b7..267a41e3f32 100644
--- a/spec/lib/gitlab/github_import/pull_request_formatter_spec.rb
+++ b/spec/lib/gitlab/legacy_github_import/pull_request_formatter_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GithubImport::PullRequestFormatter do
+describe Gitlab::LegacyGithubImport::PullRequestFormatter do
   let(:client) { double }
   let(:project) { create(:project, :repository) }
   let(:source_sha) { create(:commit, project: project).id }
@@ -44,7 +44,7 @@ describe Gitlab::GithubImport::PullRequestFormatter do
     allow(client).to receive(:user).and_return(octocat)
   end
 
-  shared_examples 'Gitlab::GithubImport::PullRequestFormatter#attributes' do
+  shared_examples 'Gitlab::LegacyGithubImport::PullRequestFormatter#attributes' do
     context 'when pull request is open' do
       let(:raw_data) { double(base_data.merge(state: 'open')) }
 
@@ -189,7 +189,7 @@ describe Gitlab::GithubImport::PullRequestFormatter do
     end
   end
 
-  shared_examples 'Gitlab::GithubImport::PullRequestFormatter#number' do
+  shared_examples 'Gitlab::LegacyGithubImport::PullRequestFormatter#number' do
     let(:raw_data) { double(base_data) }
 
     it 'returns pull request number' do
@@ -197,7 +197,7 @@ describe Gitlab::GithubImport::PullRequestFormatter do
     end
   end
 
-  shared_examples 'Gitlab::GithubImport::PullRequestFormatter#source_branch_name' do
+  shared_examples 'Gitlab::LegacyGithubImport::PullRequestFormatter#source_branch_name' do
     context 'when source branch exists' do
       let(:raw_data) { double(base_data) }
 
@@ -231,7 +231,7 @@ describe Gitlab::GithubImport::PullRequestFormatter do
     end
   end
 
-  shared_examples 'Gitlab::GithubImport::PullRequestFormatter#target_branch_name' do
+  shared_examples 'Gitlab::LegacyGithubImport::PullRequestFormatter#target_branch_name' do
     context 'when target branch exists' do
       let(:raw_data) { double(base_data) }
 
@@ -250,10 +250,10 @@ describe Gitlab::GithubImport::PullRequestFormatter do
   end
 
   context 'when importing a GitHub project' do
-    it_behaves_like 'Gitlab::GithubImport::PullRequestFormatter#attributes'
-    it_behaves_like 'Gitlab::GithubImport::PullRequestFormatter#number'
-    it_behaves_like 'Gitlab::GithubImport::PullRequestFormatter#source_branch_name'
-    it_behaves_like 'Gitlab::GithubImport::PullRequestFormatter#target_branch_name'
+    it_behaves_like 'Gitlab::LegacyGithubImport::PullRequestFormatter#attributes'
+    it_behaves_like 'Gitlab::LegacyGithubImport::PullRequestFormatter#number'
+    it_behaves_like 'Gitlab::LegacyGithubImport::PullRequestFormatter#source_branch_name'
+    it_behaves_like 'Gitlab::LegacyGithubImport::PullRequestFormatter#target_branch_name'
   end
 
   context 'when importing a Gitea project' do
@@ -261,10 +261,10 @@ describe Gitlab::GithubImport::PullRequestFormatter do
       project.update(import_type: 'gitea')
     end
 
-    it_behaves_like 'Gitlab::GithubImport::PullRequestFormatter#attributes'
-    it_behaves_like 'Gitlab::GithubImport::PullRequestFormatter#number'
-    it_behaves_like 'Gitlab::GithubImport::PullRequestFormatter#source_branch_name'
-    it_behaves_like 'Gitlab::GithubImport::PullRequestFormatter#target_branch_name'
+    it_behaves_like 'Gitlab::LegacyGithubImport::PullRequestFormatter#attributes'
+    it_behaves_like 'Gitlab::LegacyGithubImport::PullRequestFormatter#number'
+    it_behaves_like 'Gitlab::LegacyGithubImport::PullRequestFormatter#source_branch_name'
+    it_behaves_like 'Gitlab::LegacyGithubImport::PullRequestFormatter#target_branch_name'
   end
 
   describe '#valid?' do
diff --git a/spec/lib/gitlab/github_import/release_formatter_spec.rb b/spec/lib/gitlab/legacy_github_import/release_formatter_spec.rb
index 926bf725d6a..082e3b36dd0 100644
--- a/spec/lib/gitlab/github_import/release_formatter_spec.rb
+++ b/spec/lib/gitlab/legacy_github_import/release_formatter_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GithubImport::ReleaseFormatter do
+describe Gitlab::LegacyGithubImport::ReleaseFormatter do
   let!(:project) { create(:project, namespace: create(:namespace, path: 'octocat')) }
   let(:octocat) { double(id: 123456, login: 'octocat') }
   let(:created_at) { DateTime.strptime('2011-01-26T19:01:12Z') }
diff --git a/spec/lib/gitlab/github_import/user_formatter_spec.rb b/spec/lib/gitlab/legacy_github_import/user_formatter_spec.rb
index 98e3a7c28b9..3cd096eb0ad 100644
--- a/spec/lib/gitlab/github_import/user_formatter_spec.rb
+++ b/spec/lib/gitlab/legacy_github_import/user_formatter_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GithubImport::UserFormatter do
+describe Gitlab::LegacyGithubImport::UserFormatter do
   let(:client) { double }
   let(:octocat) { double(id: 123456, login: 'octocat', email: 'octocat@example.com') }
 
diff --git a/spec/lib/gitlab/github_import/wiki_formatter_spec.rb b/spec/lib/gitlab/legacy_github_import/wiki_formatter_spec.rb
index 2662cc20b32..7723533aee2 100644
--- a/spec/lib/gitlab/github_import/wiki_formatter_spec.rb
+++ b/spec/lib/gitlab/legacy_github_import/wiki_formatter_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::GithubImport::WikiFormatter do
+describe Gitlab::LegacyGithubImport::WikiFormatter do
   let(:project) do
     create(:project,
            namespace: create(:namespace, path: 'gitlabhq'),
diff --git a/spec/lib/gitlab/metrics/background_transaction_spec.rb b/spec/lib/gitlab/metrics/background_transaction_spec.rb
new file mode 100644
index 00000000000..17445fe6de5
--- /dev/null
+++ b/spec/lib/gitlab/metrics/background_transaction_spec.rb
@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Gitlab::Metrics::BackgroundTransaction do
+  let(:test_worker_class) { double(:class, name: 'TestWorker') }
+
+  subject { described_class.new(test_worker_class) }
+
+  describe '#action' do
+    it 'returns transaction action name' do
+      expect(subject.action).to eq('TestWorker#perform')
+    end
+  end
+
+  describe '#label' do
+    it 'returns labels based on class name' do
+      expect(subject.labels).to eq(controller: 'TestWorker', action: 'perform')
+    end
+  end
+end
diff --git a/spec/lib/gitlab/metrics/instrumentation_spec.rb b/spec/lib/gitlab/metrics/instrumentation_spec.rb
index 4b19ee19103..977bc250049 100644
--- a/spec/lib/gitlab/metrics/instrumentation_spec.rb
+++ b/spec/lib/gitlab/metrics/instrumentation_spec.rb
@@ -1,7 +1,8 @@
 require 'spec_helper'
 
 describe Gitlab::Metrics::Instrumentation do
-  let(:transaction) { Gitlab::Metrics::Transaction.new }
+  let(:env) { {} }
+  let(:transaction) { Gitlab::Metrics::WebTransaction.new(env) }
 
   before do
     @dummy = Class.new do
diff --git a/spec/lib/gitlab/metrics/method_call_spec.rb b/spec/lib/gitlab/metrics/method_call_spec.rb
index a247f03b2da..f1e9e414e0d 100644
--- a/spec/lib/gitlab/metrics/method_call_spec.rb
+++ b/spec/lib/gitlab/metrics/method_call_spec.rb
@@ -1,7 +1,8 @@
 require 'spec_helper'
 
 describe Gitlab::Metrics::MethodCall do
-  let(:method_call) { described_class.new('Foo#bar', 'foo') }
+  let(:transaction) { double(:transaction, labels: {}) }
+  let(:method_call) { described_class.new('Foo#bar', :Foo, '#bar', transaction) }
 
   describe '#measure' do
     it 'measures the performance of the supplied block' do
@@ -11,6 +12,18 @@ describe Gitlab::Metrics::MethodCall do
       expect(method_call.cpu_time).to be_a_kind_of(Numeric)
       expect(method_call.call_count).to eq(1)
     end
+
+    it 'observes the performance of the supplied block' do
+      expect(described_class.call_real_duration_histogram)
+        .to receive(:observe)
+              .with({ module: :Foo, method: '#bar' }, be_a_kind_of(Numeric))
+
+      expect(described_class.call_cpu_duration_histogram)
+        .to receive(:observe)
+              .with({ module: :Foo, method: '#bar' }, be_a_kind_of(Numeric))
+
+      method_call.measure { 'foo' }
+    end
   end
 
   describe '#to_metric' do
@@ -19,7 +32,7 @@ describe Gitlab::Metrics::MethodCall do
       metric = method_call.to_metric
 
       expect(metric).to be_an_instance_of(Gitlab::Metrics::Metric)
-      expect(metric.series).to eq('foo')
+      expect(metric.series).to eq('rails_method_calls')
 
       expect(metric.values[:duration]).to be_a_kind_of(Numeric)
       expect(metric.values[:cpu_duration]).to be_a_kind_of(Numeric)
diff --git a/spec/lib/gitlab/metrics/rack_middleware_spec.rb b/spec/lib/gitlab/metrics/rack_middleware_spec.rb
index ec415f2bd85..b84387204ee 100644
--- a/spec/lib/gitlab/metrics/rack_middleware_spec.rb
+++ b/spec/lib/gitlab/metrics/rack_middleware_spec.rb
@@ -18,34 +18,6 @@ describe Gitlab::Metrics::RackMiddleware do
       expect(middleware.call(env)).to eq('yay')
     end
 
-    it 'tags a transaction with the name and action of a controller' do
-      klass      = double(:klass, name: 'TestController', content_type: 'text/html')
-      controller = double(:controller, class: klass, action_name: 'show')
-
-      env['action_controller.instance'] = controller
-
-      allow(app).to receive(:call).with(env)
-
-      expect(middleware).to receive(:tag_controller)
-        .with(an_instance_of(Gitlab::Metrics::Transaction), env)
-
-      middleware.call(env)
-    end
-
-    it 'tags a transaction with the method and path of the route in the grape endpoint' do
-      route    = double(:route, request_method: "GET", path: "/:version/projects/:id/archive(.:format)")
-      endpoint = double(:endpoint, route: route)
-
-      env['api.endpoint'] = endpoint
-
-      allow(app).to receive(:call).with(env)
-
-      expect(middleware).to receive(:tag_endpoint)
-        .with(an_instance_of(Gitlab::Metrics::Transaction), env)
-
-      middleware.call(env)
-    end
-
     it 'tracks any raised exceptions' do
       expect(app).to receive(:call).with(env).and_raise(RuntimeError)
 
@@ -60,7 +32,7 @@ describe Gitlab::Metrics::RackMiddleware do
     let(:transaction) { middleware.transaction_from_env(env) }
 
     it 'returns a Transaction' do
-      expect(transaction).to be_an_instance_of(Gitlab::Metrics::Transaction)
+      expect(transaction).to be_an_instance_of(Gitlab::Metrics::WebTransaction)
     end
 
     it 'stores the request method and URI in the transaction as values' do
@@ -84,58 +56,4 @@ describe Gitlab::Metrics::RackMiddleware do
       end
     end
   end
-
-  describe '#tag_controller' do
-    let(:transaction) { middleware.transaction_from_env(env) }
-    let(:content_type) { 'text/html' }
-
-    before do
-      klass      = double(:klass, name: 'TestController')
-      controller = double(:controller, class: klass, action_name: 'show', content_type: content_type)
-
-      env['action_controller.instance'] = controller
-    end
-
-    it 'tags a transaction with the name and action of a controller' do
-      middleware.tag_controller(transaction, env)
-
-      expect(transaction.action).to eq('TestController#show')
-    end
-
-    context 'when the response content type is not :html' do
-      let(:content_type) { 'application/json' }
-
-      it 'appends the mime type to the transaction action' do
-        middleware.tag_controller(transaction, env)
-
-        expect(transaction.action).to eq('TestController#show.json')
-      end
-    end
-  end
-
-  describe '#tag_endpoint' do
-    let(:transaction) { middleware.transaction_from_env(env) }
-
-    it 'tags a transaction with the method and path of the route in the grape endpount' do
-      route    = double(:route, request_method: "GET", path: "/:version/projects/:id/archive(.:format)")
-      endpoint = double(:endpoint, route: route)
-
-      env['api.endpoint'] = endpoint
-
-      middleware.tag_endpoint(transaction, env)
-
-      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/metrics/influx_sampler_spec.rb b/spec/lib/gitlab/metrics/samplers/influx_sampler_spec.rb
index 999a9536d82..667e4747897 100644
--- a/spec/lib/gitlab/metrics/influx_sampler_spec.rb
+++ b/spec/lib/gitlab/metrics/samplers/influx_sampler_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::Metrics::InfluxSampler do
+describe Gitlab::Metrics::Samplers::InfluxSampler do
   let(:sampler) { described_class.new(5) }
 
   after do
diff --git a/spec/lib/gitlab/metrics/samplers/ruby_sampler_spec.rb b/spec/lib/gitlab/metrics/samplers/ruby_sampler_spec.rb
new file mode 100644
index 00000000000..53699327da1
--- /dev/null
+++ b/spec/lib/gitlab/metrics/samplers/ruby_sampler_spec.rb
@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Gitlab::Metrics::Samplers::RubySampler do
+  let(:sampler) { described_class.new(5) }
+
+  after do
+    Allocations.stop if Gitlab::Metrics.mri?
+  end
+
+  describe '#sample' do
+    it 'samples various statistics' do
+      expect(Gitlab::Metrics::System).to receive(:memory_usage)
+      expect(Gitlab::Metrics::System).to receive(:file_descriptor_count)
+      expect(sampler).to receive(:sample_objects)
+      expect(sampler).to receive(:sample_gc)
+
+      sampler.sample
+    end
+
+    it 'adds a metric containing the memory usage' do
+      expect(Gitlab::Metrics::System).to receive(:memory_usage)
+                                           .and_return(9000)
+
+      expect(sampler.metrics[:memory_usage]).to receive(:set)
+                                                  .with({}, 9000)
+                                                  .and_call_original
+
+      sampler.sample
+    end
+
+    it 'adds a metric containing the amount of open file descriptors' do
+      expect(Gitlab::Metrics::System).to receive(:file_descriptor_count)
+                                           .and_return(4)
+
+      expect(sampler.metrics[:file_descriptors]).to receive(:set)
+                                                      .with({}, 4)
+                                                      .and_call_original
+
+      sampler.sample
+    end
+
+    it 'clears any GC profiles' do
+      expect(GC::Profiler).to receive(:clear)
+
+      sampler.sample
+    end
+  end
+
+  describe '#sample_gc' do
+    it 'adds a metric containing garbage collection time statistics' do
+      expect(GC::Profiler).to receive(:total_time).and_return(0.24)
+
+      expect(sampler.metrics[:total_time]).to receive(:set)
+                                                .with({}, 240)
+                                                .and_call_original
+
+      sampler.sample
+    end
+
+    it 'adds a metric containing garbage collection statistics' do
+      GC.stat.keys.each do |key|
+        expect(sampler.metrics[key]).to receive(:set).with({}, anything).and_call_original
+      end
+
+      sampler.sample
+    end
+  end
+
+  if Gitlab::Metrics.mri?
+    describe '#sample_objects' do
+      it 'adds a metric containing the amount of allocated objects' do
+        expect(sampler.metrics[:objects_total]).to receive(:set)
+                                                     .with(include(class: anything), be > 0)
+                                                     .at_least(:once)
+                                                     .and_call_original
+
+        sampler.sample
+      end
+
+      it 'ignores classes without a name' do
+        expect(Allocations).to receive(:to_hash).and_return({ Class.new => 4 })
+
+        expect(sampler.metrics[:objects_total]).not_to receive(:set)
+                                                         .with(include(class: 'object_counts'), anything)
+
+        sampler.sample
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/metrics/unicorn_sampler_spec.rb b/spec/lib/gitlab/metrics/samplers/unicorn_sampler_spec.rb
index dc0d1f2e940..771b633a2b9 100644
--- a/spec/lib/gitlab/metrics/unicorn_sampler_spec.rb
+++ b/spec/lib/gitlab/metrics/samplers/unicorn_sampler_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Gitlab::Metrics::UnicornSampler do
+describe Gitlab::Metrics::Samplers::UnicornSampler do
   subject { described_class.new(1.second) }
 
   describe '#sample' do
diff --git a/spec/lib/gitlab/metrics/sidekiq_middleware_spec.rb b/spec/lib/gitlab/metrics/sidekiq_middleware_spec.rb
index 0803ce42fac..ae1d8b47fe9 100644
--- a/spec/lib/gitlab/metrics/sidekiq_middleware_spec.rb
+++ b/spec/lib/gitlab/metrics/sidekiq_middleware_spec.rb
@@ -4,30 +4,35 @@ describe Gitlab::Metrics::SidekiqMiddleware do
   let(:middleware) { described_class.new }
   let(:message) { { 'args' => ['test'], 'enqueued_at' => Time.new(2016, 6, 23, 6, 59).to_f } }
 
-  def run(worker, message)
-    expect(Gitlab::Metrics::Transaction).to receive(:new)
-      .with('TestWorker#perform')
-      .and_call_original
-
-    expect_any_instance_of(Gitlab::Metrics::Transaction).to receive(:set)
-      .with(:sidekiq_queue_duration, instance_of(Float))
-
-    expect_any_instance_of(Gitlab::Metrics::Transaction).to receive(:finish)
-
-    middleware.call(worker, message, :test) { nil }
-  end
-
   describe '#call' do
     it 'tracks the transaction' do
       worker = double(:worker, class: double(:class, name: 'TestWorker'))
 
-      run(worker, message)
+      expect(Gitlab::Metrics::BackgroundTransaction).to receive(:new)
+        .with(worker.class)
+        .and_call_original
+
+      expect_any_instance_of(Gitlab::Metrics::Transaction).to receive(:set)
+        .with(:sidekiq_queue_duration, instance_of(Float))
+
+      expect_any_instance_of(Gitlab::Metrics::Transaction).to receive(:finish)
+
+      middleware.call(worker, message, :test) { nil }
     end
 
     it 'tracks the transaction (for messages without `enqueued_at`)' do
       worker = double(:worker, class: double(:class, name: 'TestWorker'))
 
-      run(worker, {})
+      expect(Gitlab::Metrics::BackgroundTransaction).to receive(:new)
+        .with(worker.class)
+        .and_call_original
+
+      expect_any_instance_of(Gitlab::Metrics::Transaction).to receive(:set)
+        .with(:sidekiq_queue_duration, instance_of(Float))
+
+      expect_any_instance_of(Gitlab::Metrics::Transaction).to receive(:finish)
+
+      middleware.call(worker, {}, :test) { nil }
     end
 
     it 'tracks any raised exceptions' do
@@ -45,18 +50,5 @@ describe Gitlab::Metrics::SidekiqMiddleware do
       expect { middleware.call(worker, message, :test) }
         .to raise_error(RuntimeError)
     end
-
-    it 'tags the metrics accordingly' do
-      tags = { one: 1, two: 2 }
-      worker = double(:worker, class: double(:class, name: 'TestWorker'))
-      allow(worker).to receive(:metrics_tags).and_return(tags)
-
-      tags.each do |tag, value|
-        expect_any_instance_of(Gitlab::Metrics::Transaction).to receive(:add_tag)
-          .with(tag, value)
-      end
-
-      run(worker, message)
-    end
   end
 end
diff --git a/spec/lib/gitlab/metrics/subscribers/action_view_spec.rb b/spec/lib/gitlab/metrics/subscribers/action_view_spec.rb
index e7b595405a8..eca75a4fac1 100644
--- a/spec/lib/gitlab/metrics/subscribers/action_view_spec.rb
+++ b/spec/lib/gitlab/metrics/subscribers/action_view_spec.rb
@@ -1,7 +1,8 @@
 require 'spec_helper'
 
 describe Gitlab::Metrics::Subscribers::ActionView do
-  let(:transaction) { Gitlab::Metrics::Transaction.new }
+  let(:env) { {} }
+  let(:transaction) { Gitlab::Metrics::WebTransaction.new(env) }
 
   let(:subscriber) { described_class.new }
 
@@ -29,5 +30,13 @@ describe Gitlab::Metrics::Subscribers::ActionView do
 
       subscriber.render_template(event)
     end
+
+    it 'observes view rendering time' do
+      expect(subscriber.send(:metric_view_rendering_duration_seconds))
+        .to receive(:observe)
+              .with({ view: 'app/views/x.html.haml' }, 2.1)
+
+      subscriber.render_template(event)
+    end
   end
 end
diff --git a/spec/lib/gitlab/metrics/subscribers/active_record_spec.rb b/spec/lib/gitlab/metrics/subscribers/active_record_spec.rb
index ce6587e993f..9b3698fb4a8 100644
--- a/spec/lib/gitlab/metrics/subscribers/active_record_spec.rb
+++ b/spec/lib/gitlab/metrics/subscribers/active_record_spec.rb
@@ -1,11 +1,12 @@
 require 'spec_helper'
 
 describe Gitlab::Metrics::Subscribers::ActiveRecord do
-  let(:transaction) { Gitlab::Metrics::Transaction.new }
+  let(:env) { {} }
+  let(:transaction) { Gitlab::Metrics::WebTransaction.new(env) }
   let(:subscriber)  { described_class.new }
 
   let(:event) do
-    double(:event, duration: 0.2,
+    double(:event, duration: 2,
                    payload:  { sql: 'SELECT * FROM users WHERE id = 10' })
   end
 
@@ -20,16 +21,24 @@ describe Gitlab::Metrics::Subscribers::ActiveRecord do
     end
 
     describe 'with a current transaction' do
+      it 'observes sql_duration metric' do
+        expect(subscriber).to receive(:current_transaction)
+                                .at_least(:once)
+                                .and_return(transaction)
+        expect(subscriber.send(:metric_sql_duration_seconds)).to receive(:observe).with({}, 0.002)
+        subscriber.sql(event)
+      end
+
       it 'increments the :sql_duration value' do
         expect(subscriber).to receive(:current_transaction)
           .at_least(:once)
           .and_return(transaction)
 
         expect(transaction).to receive(:increment)
-          .with(:sql_duration, 0.2)
+          .with(:sql_duration, 2, false)
 
         expect(transaction).to receive(:increment)
-          .with(:sql_count, 1)
+          .with(:sql_count, 1, false)
 
         subscriber.sql(event)
       end
diff --git a/spec/lib/gitlab/metrics/subscribers/rails_cache_spec.rb b/spec/lib/gitlab/metrics/subscribers/rails_cache_spec.rb
index f04dc8dcc02..58e28592cf9 100644
--- a/spec/lib/gitlab/metrics/subscribers/rails_cache_spec.rb
+++ b/spec/lib/gitlab/metrics/subscribers/rails_cache_spec.rb
@@ -1,15 +1,16 @@
 require 'spec_helper'
 
 describe Gitlab::Metrics::Subscribers::RailsCache do
-  let(:transaction) { Gitlab::Metrics::Transaction.new }
+  let(:env) { {} }
+  let(:transaction) { Gitlab::Metrics::WebTransaction.new(env) }
   let(:subscriber) { described_class.new }
 
   let(:event) { double(:event, duration: 15.2) }
 
   describe '#cache_read' do
     it 'increments the cache_read duration' do
-      expect(subscriber).to receive(:increment)
-        .with(:cache_read, event.duration)
+      expect(subscriber).to receive(:observe)
+                              .with(:read, event.duration)
 
       subscriber.cache_read(event)
     end
@@ -17,7 +18,7 @@ describe Gitlab::Metrics::Subscribers::RailsCache do
     context 'with a transaction' do
       before do
         allow(subscriber).to receive(:current_transaction)
-          .and_return(transaction)
+                               .and_return(transaction)
       end
 
       context 'with hit event' do
@@ -25,9 +26,9 @@ describe Gitlab::Metrics::Subscribers::RailsCache do
 
         it 'increments the cache_read_hit count' do
           expect(transaction).to receive(:increment)
-            .with(:cache_read_hit_count, 1)
+                                   .with(:cache_read_hit_count, 1, false)
           expect(transaction).to receive(:increment)
-            .with(any_args).at_least(1) # Other calls
+                                   .with(any_args).at_least(1) # Other calls
 
           subscriber.cache_read(event)
         end
@@ -37,7 +38,7 @@ describe Gitlab::Metrics::Subscribers::RailsCache do
 
           it 'does not increment cache read miss' do
             expect(transaction).not_to receive(:increment)
-              .with(:cache_read_hit_count, 1)
+                                         .with(:cache_read_hit_count, 1)
 
             subscriber.cache_read(event)
           end
@@ -49,9 +50,15 @@ describe Gitlab::Metrics::Subscribers::RailsCache do
 
         it 'increments the cache_read_miss count' do
           expect(transaction).to receive(:increment)
-            .with(:cache_read_miss_count, 1)
+                                   .with(:cache_read_miss_count, 1, false)
           expect(transaction).to receive(:increment)
-            .with(any_args).at_least(1) # Other calls
+                                   .with(any_args).at_least(1) # Other calls
+
+          subscriber.cache_read(event)
+        end
+
+        it 'increments the cache_read_miss total' do
+          expect(subscriber.send(:metric_cache_misses_total)).to receive(:increment).with({})
 
           subscriber.cache_read(event)
         end
@@ -61,7 +68,13 @@ describe Gitlab::Metrics::Subscribers::RailsCache do
 
           it 'does not increment cache read miss' do
             expect(transaction).not_to receive(:increment)
-              .with(:cache_read_miss_count, 1)
+                                         .with(:cache_read_miss_count, 1)
+
+            subscriber.cache_read(event)
+          end
+
+          it 'does not increment cache_read_miss total' do
+            expect(subscriber.send(:metric_cache_misses_total)).not_to receive(:increment).with({})
 
             subscriber.cache_read(event)
           end
@@ -71,27 +84,27 @@ describe Gitlab::Metrics::Subscribers::RailsCache do
   end
 
   describe '#cache_write' do
-    it 'increments the cache_write duration' do
-      expect(subscriber).to receive(:increment)
-        .with(:cache_write, event.duration)
+    it 'observes write duration' do
+      expect(subscriber).to receive(:observe)
+                              .with(:write, event.duration)
 
       subscriber.cache_write(event)
     end
   end
 
   describe '#cache_delete' do
-    it 'increments the cache_delete duration' do
-      expect(subscriber).to receive(:increment)
-        .with(:cache_delete, event.duration)
+    it 'observes delete duration' do
+      expect(subscriber).to receive(:observe)
+                              .with(:delete, event.duration)
 
       subscriber.cache_delete(event)
     end
   end
 
   describe '#cache_exist?' do
-    it 'increments the cache_exists duration' do
-      expect(subscriber).to receive(:increment)
-        .with(:cache_exists, event.duration)
+    it 'observes the exists duration' do
+      expect(subscriber).to receive(:observe)
+                              .with(:exists, event.duration)
 
       subscriber.cache_exist?(event)
     end
@@ -109,12 +122,12 @@ describe Gitlab::Metrics::Subscribers::RailsCache do
     context 'with a transaction' do
       before do
         allow(subscriber).to receive(:current_transaction)
-          .and_return(transaction)
+                               .and_return(transaction)
       end
 
       it 'increments the cache_read_hit count' do
         expect(transaction).to receive(:increment)
-          .with(:cache_read_hit_count, 1)
+                                 .with(:cache_read_hit_count, 1)
 
         subscriber.cache_fetch_hit(event)
       end
@@ -133,47 +146,61 @@ describe Gitlab::Metrics::Subscribers::RailsCache do
     context 'with a transaction' do
       before do
         allow(subscriber).to receive(:current_transaction)
-          .and_return(transaction)
+                               .and_return(transaction)
       end
 
       it 'increments the cache_fetch_miss count' do
         expect(transaction).to receive(:increment)
-          .with(:cache_read_miss_count, 1)
+                                 .with(:cache_read_miss_count, 1)
+
+        subscriber.cache_generate(event)
+      end
+
+      it 'increments the cache_read_miss total' do
+        expect(subscriber.send(:metric_cache_misses_total)).to receive(:increment).with({})
 
         subscriber.cache_generate(event)
       end
     end
   end
 
-  describe '#increment' do
+  describe '#observe' do
     context 'without a transaction' do
       it 'returns' do
         expect(transaction).not_to receive(:increment)
 
-        subscriber.increment(:foo, 15.2)
+        subscriber.observe(:foo, 15.2)
       end
     end
 
     context 'with a transaction' do
       before do
         allow(subscriber).to receive(:current_transaction)
-          .and_return(transaction)
+                               .and_return(transaction)
       end
 
       it 'increments the total and specific cache duration' do
         expect(transaction).to receive(:increment)
-          .with(:cache_duration, event.duration)
+                                 .with(:cache_duration, event.duration, false)
 
         expect(transaction).to receive(:increment)
-          .with(:cache_count, 1)
+                                 .with(:cache_count, 1, false)
 
         expect(transaction).to receive(:increment)
-          .with(:cache_delete_duration, event.duration)
+                                 .with(:cache_delete_duration, event.duration, false)
 
         expect(transaction).to receive(:increment)
-          .with(:cache_delete_count, 1)
+                                 .with(:cache_delete_count, 1, false)
+
+        subscriber.observe(:delete, event.duration)
+      end
+
+      it 'observes cache metric' do
+        expect(subscriber.send(:metric_cache_operation_duration_seconds))
+          .to receive(:observe)
+                .with(transaction.labels.merge(operation: :delete), event.duration / 1000.0)
 
-        subscriber.increment(:cache_delete, event.duration)
+        subscriber.observe(:delete, event.duration)
       end
     end
   end
diff --git a/spec/lib/gitlab/metrics/transaction_spec.rb b/spec/lib/gitlab/metrics/web_transaction_spec.rb
index 3779af81512..1d162f53a13 100644
--- a/spec/lib/gitlab/metrics/transaction_spec.rb
+++ b/spec/lib/gitlab/metrics/web_transaction_spec.rb
@@ -1,7 +1,8 @@
 require 'spec_helper'
 
-describe Gitlab::Metrics::Transaction do
-  let(:transaction) { described_class.new }
+describe Gitlab::Metrics::WebTransaction do
+  let(:env) { {} }
+  let(:transaction) { described_class.new(env) }
 
   describe '#duration' do
     it 'returns the duration of a transaction in seconds' do
@@ -48,7 +49,7 @@ describe Gitlab::Metrics::Transaction do
 
   describe '#method_call_for' do
     it 'returns a MethodCall' do
-      method = transaction.method_call_for('Foo#bar')
+      method = transaction.method_call_for('Foo#bar', :Foo, '#bar')
 
       expect(method).to be_an_instance_of(Gitlab::Metrics::MethodCall)
     end
@@ -85,14 +86,6 @@ describe Gitlab::Metrics::Transaction do
     end
   end
 
-  describe '#add_tag' do
-    it 'adds a tag' do
-      transaction.add_tag(:foo, 'bar')
-
-      expect(transaction.tags).to eq({ foo: 'bar' })
-    end
-  end
-
   describe '#finish' do
     it 'tracks the transaction details and submits them to Sidekiq' do
       expect(transaction).to receive(:track_self)
@@ -127,7 +120,7 @@ describe Gitlab::Metrics::Transaction do
     end
 
     it 'adds the action as a tag for every metric' do
-      transaction.action = 'Foo#bar'
+      allow(transaction).to receive(:labels).and_return(controller: 'Foo', action: 'bar')
       transaction.track_self
 
       hash = {
@@ -144,7 +137,8 @@ describe Gitlab::Metrics::Transaction do
     end
 
     it 'does not add an action tag for events' do
-      transaction.action = 'Foo#bar'
+      allow(transaction).to receive(:labels).and_return(controller: 'Foo', action: 'bar')
+
       transaction.add_event(:meow)
 
       hash = {
@@ -161,6 +155,61 @@ describe Gitlab::Metrics::Transaction do
     end
   end
 
+  describe '#labels' do
+    context 'when request goes to Grape endpoint' do
+      before do
+        route = double(:route, request_method: 'GET', path: '/:version/projects/:id/archive(.:format)')
+        endpoint = double(:endpoint, route: route)
+
+        env['api.endpoint'] = endpoint
+      end
+      it 'provides labels with the method and path of the route in the grape endpoint' do
+        expect(transaction.labels).to eq({ controller: 'Grape', action: 'GET /projects/:id/archive' })
+        expect(transaction.action).to eq('Grape#GET /projects/:id/archive')
+      end
+
+      it 'does not provide labels if route infos are missing' do
+        endpoint = double(:endpoint)
+        allow(endpoint).to receive(:route).and_raise
+
+        env['api.endpoint'] = endpoint
+
+        expect(transaction.labels).to eq({})
+        expect(transaction.action).to be_nil
+      end
+    end
+
+    context 'when request goes to ActionController' do
+      let(:content_type) { 'text/html' }
+
+      before do
+        klass = double(:klass, name: 'TestController')
+        controller = double(:controller, class: klass, action_name: 'show', content_type: content_type)
+
+        env['action_controller.instance'] = controller
+      end
+
+      it 'tags a transaction with the name and action of a controller' do
+        expect(transaction.labels).to eq({ controller: 'TestController', action: 'show' })
+        expect(transaction.action).to eq('TestController#show')
+      end
+
+      context 'when the response content type is not :html' do
+        let(:content_type) { 'application/json' }
+
+        it 'appends the mime type to the transaction action' do
+          expect(transaction.labels).to eq({ controller: 'TestController', action: 'show.json' })
+          expect(transaction.action).to eq('TestController#show.json')
+        end
+      end
+    end
+
+    it 'returns no labels when no route information is present in env' do
+      expect(transaction.labels).to eq({})
+      expect(transaction.action).to eq(nil)
+    end
+  end
+
   describe '#add_event' do
     it 'adds a metric' do
       transaction.add_event(:meow)
diff --git a/spec/lib/gitlab/metrics_spec.rb b/spec/lib/gitlab/metrics_spec.rb
index 599b8807d8d..1619fbd88b1 100644
--- a/spec/lib/gitlab/metrics_spec.rb
+++ b/spec/lib/gitlab/metrics_spec.rb
@@ -115,7 +115,7 @@ describe Gitlab::Metrics do
     end
 
     context 'with a transaction' do
-      let(:transaction) { Gitlab::Metrics::Transaction.new }
+      let(:transaction) { Gitlab::Metrics::WebTransaction.new({}) }
 
       before do
         allow(described_class).to receive(:current_transaction)
@@ -124,13 +124,13 @@ describe Gitlab::Metrics do
 
       it 'adds a metric to the current transaction' do
         expect(transaction).to receive(:increment)
-          .with('foo_real_time', a_kind_of(Numeric))
+                                 .with('foo_real_time', a_kind_of(Numeric), false)
 
         expect(transaction).to receive(:increment)
-          .with('foo_cpu_time', a_kind_of(Numeric))
+                                 .with('foo_cpu_time', a_kind_of(Numeric), false)
 
         expect(transaction).to receive(:increment)
-          .with('foo_call_count', 1)
+                                 .with('foo_call_count', 1, false)
 
         described_class.measure(:foo) { 10 }
       end
@@ -143,31 +143,6 @@ describe Gitlab::Metrics do
     end
   end
 
-  describe '.tag_transaction' do
-    context 'without a transaction' do
-      it 'does nothing' do
-        expect_any_instance_of(Gitlab::Metrics::Transaction)
-          .not_to receive(:add_tag)
-
-        described_class.tag_transaction(:foo, 'bar')
-      end
-    end
-
-    context 'with a transaction' do
-      let(:transaction) { Gitlab::Metrics::Transaction.new }
-
-      it 'adds the tag to the transaction' do
-        expect(described_class).to receive(:current_transaction)
-          .and_return(transaction)
-
-        expect(transaction).to receive(:add_tag)
-          .with(:foo, 'bar')
-
-        described_class.tag_transaction(:foo, 'bar')
-      end
-    end
-  end
-
   describe '.action=' do
     context 'without a transaction' do
       it 'does nothing' do
@@ -180,7 +155,7 @@ describe Gitlab::Metrics do
 
     context 'with a transaction' do
       it 'sets the action of a transaction' do
-        trans = Gitlab::Metrics::Transaction.new
+        trans = Gitlab::Metrics::WebTransaction.new({})
 
         expect(described_class).to receive(:current_transaction)
           .and_return(trans)
@@ -210,7 +185,7 @@ describe Gitlab::Metrics do
 
     context 'with a transaction' do
       it 'adds an event' do
-        transaction = Gitlab::Metrics::Transaction.new
+        transaction = Gitlab::Metrics::WebTransaction.new({})
 
         expect(transaction).to receive(:add_event).with(:meow)
 
@@ -224,7 +199,7 @@ describe Gitlab::Metrics do
 
   shared_examples 'prometheus metrics API' do
     describe '#counter' do
-      subject { described_class.counter(:couter, 'doc') }
+      subject { described_class.counter(:counter, 'doc') }
 
       describe '#increment' do
         it 'successfully calls #increment without arguments' do
@@ -280,7 +255,7 @@ describe Gitlab::Metrics do
     it_behaves_like 'prometheus metrics API'
 
     describe '#null_metric' do
-      subject { described_class.provide_metric(:test) }
+      subject { described_class.send(:provide_metric, :test) }
 
       it { is_expected.to be_a(Gitlab::Metrics::NullMetric) }
     end
@@ -321,7 +296,7 @@ describe Gitlab::Metrics do
     it_behaves_like 'prometheus metrics API'
 
     describe '#null_metric' do
-      subject { described_class.provide_metric(:test) }
+      subject { described_class.send(:provide_metric, :test) }
 
       it { is_expected.to be_nil }
     end
diff --git a/spec/lib/gitlab/middleware/rails_queue_duration_spec.rb b/spec/lib/gitlab/middleware/rails_queue_duration_spec.rb
index 88107536c9e..14f2c3cb86f 100644
--- a/spec/lib/gitlab/middleware/rails_queue_duration_spec.rb
+++ b/spec/lib/gitlab/middleware/rails_queue_duration_spec.rb
@@ -4,7 +4,7 @@ describe Gitlab::Middleware::RailsQueueDuration do
   let(:app) { double(:app) }
   let(:middleware) { described_class.new(app) }
   let(:env) { {} }
-  let(:transaction) { double(:transaction) }
+  let(:transaction) { Gitlab::Metrics::WebTransaction.new(env) }
 
   before do
     expect(app).to receive(:call).with(env).and_return('yay')
@@ -30,6 +30,16 @@ describe Gitlab::Middleware::RailsQueueDuration do
         expect(transaction).to receive(:set).with(:rails_queue_duration, an_instance_of(Float))
         expect(middleware.call(env)).to eq('yay')
       end
+
+      it 'observes rails queue duration metrics and calls the app when the header is present' do
+        env['HTTP_GITLAB_WORKHORSE_PROXY_START'] = '2000000000'
+
+        expect(middleware.send(:metric_rails_queue_duration_seconds)).to receive(:observe).with(transaction.labels, 1)
+
+        Timecop.freeze(Time.at(3)) do
+          expect(middleware.call(env)).to eq('yay')
+        end
+      end
     end
   end
 end
diff --git a/spec/lib/gitlab/middleware/read_only_spec.rb b/spec/lib/gitlab/middleware/read_only_spec.rb
index 86be06ff595..b14735943a5 100644
--- a/spec/lib/gitlab/middleware/read_only_spec.rb
+++ b/spec/lib/gitlab/middleware/read_only_spec.rb
@@ -91,13 +91,6 @@ describe Gitlab::Middleware::ReadOnly do
     end
 
     context 'whitelisted requests' do
-      it 'expects DELETE request to logout to be allowed' do
-        response = request.delete('/users/sign_out')
-
-        expect(response).not_to be_a_redirect
-        expect(subject).not_to disallow_request
-      end
-
       it 'expects a POST internal request to be allowed' do
         response = request.post("/api/#{API::API.version}/internal")
 
diff --git a/spec/lib/gitlab/path_regex_spec.rb b/spec/lib/gitlab/path_regex_spec.rb
index ee63c9338c5..0ae90069b7f 100644
--- a/spec/lib/gitlab/path_regex_spec.rb
+++ b/spec/lib/gitlab/path_regex_spec.rb
@@ -45,21 +45,16 @@ describe Gitlab::PathRegex do
       Found new routes that could cause conflicts with existing namespaced routes
       for groups or projects.
 
-      Add <#{missing_words.join(', ')}> to `Gitlab::PathRegex::#{constant_name}
-      to make sure no projects or namespaces can be created with those paths.
-
-      To rename any existing records with those paths you can use the
-      `Gitlab::Database::RenameReservedpathsMigration::<VERSION>.#{migration_helper}`
-      migration helper.
-
-      Make sure to make a note of the renamed records in the release blog post.
+      Nest <#{missing_words.join(', ')}> in a route containing `-`, that way
+      we know there will be no conflicts with groups or projects created with those
+      paths.
 
       MISSING
     end
 
     if additional_words.any?
       message += <<-ADDITIONAL
-      Why are <#{additional_words.join(', ')}> in `#{constant_name}`?
+      Is <#{additional_words.join(', ')}> in `#{constant_name}` required?
       If they are really required, update these specs to reflect that.
 
       ADDITIONAL
@@ -157,16 +152,7 @@ describe Gitlab::PathRegex do
   let(:paths_after_group_id) do
     group_routes.map do |route|
       route.gsub(STARTING_WITH_GROUP, '').split('/').first
-    end.uniq + ee_paths_after_group_id
-  end
-
-  let(:ee_paths_after_group_id) do
-    %w(analytics
-       ldap
-       ldap_group_links
-       notification_setting
-       audit_events
-       pipeline_quota hooks)
+    end.uniq
   end
 
   describe 'TOP_LEVEL_ROUTES' do
@@ -225,8 +211,6 @@ describe Gitlab::PathRegex do
 
     it 'accepts group routes' do
       expect(subject).to match('activity/')
-      expect(subject).to match('group_members/')
-      expect(subject).to match('labels/')
     end
 
     it 'is not case sensitive' do
@@ -258,8 +242,6 @@ describe Gitlab::PathRegex do
 
         it 'accepts group routes' do
           expect(subject).to match('activity/')
-          expect(subject).to match('group_members/')
-          expect(subject).to match('labels/')
         end
       end
 
@@ -280,8 +262,6 @@ describe Gitlab::PathRegex do
 
         it 'accepts group routes' do
           expect(subject).to match('activity/more/')
-          expect(subject).to match('group_members/more/')
-          expect(subject).to match('labels/more/')
         end
       end
     end
@@ -303,9 +283,7 @@ describe Gitlab::PathRegex do
         end
 
         it 'rejects group routes' do
-          expect(subject).not_to match('root/activity/')
-          expect(subject).not_to match('root/group_members/')
-          expect(subject).not_to match('root/labels/')
+          expect(subject).not_to match('root/-/')
         end
       end
 
@@ -325,9 +303,7 @@ describe Gitlab::PathRegex do
         end
 
         it 'rejects group routes' do
-          expect(subject).not_to match('root/activity/more/')
-          expect(subject).not_to match('root/group_members/more/')
-          expect(subject).not_to match('root/labels/more/')
+          expect(subject).not_to match('root/-/')
         end
       end
     end
@@ -360,9 +336,7 @@ describe Gitlab::PathRegex do
     end
 
     it 'accepts group routes' do
-      expect(subject).to match('activity/')
-      expect(subject).to match('group_members/')
-      expect(subject).to match('labels/')
+      expect(subject).to match('analytics/')
     end
 
     it 'is not case sensitive' do
@@ -393,9 +367,7 @@ describe Gitlab::PathRegex do
     end
 
     it 'accepts group routes' do
-      expect(subject).to match('root/activity/')
-      expect(subject).to match('root/group_members/')
-      expect(subject).to match('root/labels/')
+      expect(subject).to match('root/analytics/')
     end
 
     it 'is not case sensitive' do
diff --git a/spec/lib/gitlab/url_blocker_spec.rb b/spec/lib/gitlab/url_blocker_spec.rb
index f18823b61ef..d9b3c2350b1 100644
--- a/spec/lib/gitlab/url_blocker_spec.rb
+++ b/spec/lib/gitlab/url_blocker_spec.rb
@@ -20,6 +20,22 @@ describe Gitlab::UrlBlocker do
       expect(described_class.blocked_url?('https://gitlab.com:25/foo/foo.git')).to be true
     end
 
+    it 'returns true for alternative version of 127.0.0.1 (0177.1)' do
+      expect(described_class.blocked_url?('https://0177.1:65535/foo/foo.git')).to be true
+    end
+
+    it 'returns true for alternative version of 127.0.0.1 (0x7f.1)' do
+      expect(described_class.blocked_url?('https://0x7f.1:65535/foo/foo.git')).to be true
+    end
+
+    it 'returns true for alternative version of 127.0.0.1 (2130706433)' do
+      expect(described_class.blocked_url?('https://2130706433:65535/foo/foo.git')).to be true
+    end
+
+    it 'returns true for alternative version of 127.0.0.1 (127.000.000.001)' do
+      expect(described_class.blocked_url?('https://127.000.000.001:65535/foo/foo.git')).to be true
+    end
+
     it 'returns true for a non-alphanumeric hostname' do
       stub_resolv
 
diff --git a/spec/lib/gitlab/usage_data_spec.rb b/spec/lib/gitlab/usage_data_spec.rb
index a7b65e94706..a4c1113ae37 100644
--- a/spec/lib/gitlab/usage_data_spec.rb
+++ b/spec/lib/gitlab/usage_data_spec.rb
@@ -60,9 +60,9 @@ describe Gitlab::UsageData do
         deploy_keys
         deployments
         environments
-        gcp_clusters
-        gcp_clusters_enabled
-        gcp_clusters_disabled
+        clusters
+        clusters_enabled
+        clusters_disabled
         in_review_folder
         groups
         issues
diff --git a/spec/lib/gitlab/utils/strong_memoize_spec.rb b/spec/lib/gitlab/utils/strong_memoize_spec.rb
new file mode 100644
index 00000000000..4a104ab6d97
--- /dev/null
+++ b/spec/lib/gitlab/utils/strong_memoize_spec.rb
@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Gitlab::Utils::StrongMemoize do
+  let(:klass) do
+    struct = Struct.new(:value) do
+      def method_name
+        strong_memoize(:method_name) do
+          trace << value
+          value
+        end
+      end
+
+      def trace
+        @trace ||= []
+      end
+    end
+
+    struct.include(described_class)
+    struct
+  end
+
+  subject(:object) { klass.new(value) }
+
+  shared_examples 'caching the value' do
+    it 'only calls the block once' do
+      value0 = object.method_name
+      value1 = object.method_name
+
+      expect(value0).to eq(value)
+      expect(value1).to eq(value)
+      expect(object.trace).to contain_exactly(value)
+    end
+
+    it 'returns and defines the instance variable for the exact value' do
+      returned_value = object.method_name
+      memoized_value = object.instance_variable_get(:@method_name)
+
+      expect(returned_value).to eql(value)
+      expect(memoized_value).to eql(value)
+    end
+  end
+
+  describe '#strong_memoize' do
+    [nil, false, true, 'value', 0, [0]].each do |value|
+      context "with value #{value}" do
+        let(:value) { value }
+
+        it_behaves_like 'caching the value'
+      end
+    end
+  end
+end
diff --git a/spec/lib/google_api/cloud_platform/client_spec.rb b/spec/lib/google_api/cloud_platform/client_spec.rb
index acc5bd1da35..fac23dce44d 100644
--- a/spec/lib/google_api/cloud_platform/client_spec.rb
+++ b/spec/lib/google_api/cloud_platform/client_spec.rb
@@ -69,7 +69,7 @@ describe GoogleApi::CloudPlatform::Client do
 
     let(:cluster_name) { 'test-cluster' }
     let(:cluster_size) { 1 }
-    let(:machine_type) { 'n1-standard-4' }
+    let(:machine_type) { 'n1-standard-2' }
     let(:operation) { double }
 
     before do
diff --git a/spec/mailers/notify_spec.rb b/spec/mailers/notify_spec.rb
index c832cee965b..f942a22b6d1 100644
--- a/spec/mailers/notify_spec.rb
+++ b/spec/mailers/notify_spec.rb
@@ -783,7 +783,25 @@ describe Notify do
       shared_examples 'an email for a note on a diff discussion' do  |model|
         let(:note) { create(model, author: note_author) }
 
-        it "includes diffs with character-level highlighting" do
+        context 'when note is on image' do
+          before do
+            allow_any_instance_of(DiffDiscussion).to receive(:on_image?).and_return(true)
+          end
+
+          it 'does not include diffs with character-level highlighting' do
+            is_expected.not_to have_body_text '<span class="p">}</span></span>'
+          end
+
+          it 'ends the intro with a dot' do
+            is_expected.to have_body_text "#{note.diff_file.file_path}</a>."
+          end
+        end
+
+        it 'ends the intro with a colon' do
+          is_expected.to have_body_text "#{note.diff_file.file_path}</a>:"
+        end
+
+        it 'includes diffs with character-level highlighting' do
           is_expected.to have_body_text '<span class="p">}</span></span>'
         end
 
diff --git a/spec/migrations/migrate_gcp_clusters_to_new_clusters_architectures_spec.rb b/spec/migrations/migrate_gcp_clusters_to_new_clusters_architectures_spec.rb
new file mode 100644
index 00000000000..9f41534441b
--- /dev/null
+++ b/spec/migrations/migrate_gcp_clusters_to_new_clusters_architectures_spec.rb
@@ -0,0 +1,166 @@
+require 'spec_helper'
+require Rails.root.join('db', 'post_migrate', '20171013104327_migrate_gcp_clusters_to_new_clusters_architectures.rb')
+
+describe MigrateGcpClustersToNewClustersArchitectures, :migration do
+  let(:project) { create(:project) }
+  let(:user) { create(:user) }
+  let(:service) { create(:kubernetes_service, project: project) }
+
+  context 'when cluster is being created' do
+    let(:project_id) { project.id }
+    let(:user_id) { user.id }
+    let(:service_id) { service.id }
+    let(:status) { 2 } # creating
+    let(:gcp_cluster_size) { 1 }
+    let(:created_at) { "'2017-10-17 20:24:02'" }
+    let(:updated_at) { "'2017-10-17 20:28:44'" }
+    let(:enabled) { true }
+    let(:status_reason) { "''" }
+    let(:project_namespace) { "'sample-app'" }
+    let(:endpoint) { 'NULL' }
+    let(:ca_cert) { 'NULL' }
+    let(:encrypted_kubernetes_token) { 'NULL' }
+    let(:encrypted_kubernetes_token_iv) { 'NULL' }
+    let(:username) { 'NULL' }
+    let(:encrypted_password) { 'NULL' }
+    let(:encrypted_password_iv) { 'NULL' }
+    let(:gcp_project_id) { "'gcp_project_id'" }
+    let(:gcp_cluster_zone) { "'gcp_cluster_zone'" }
+    let(:gcp_cluster_name) { "'gcp_cluster_name'" }
+    let(:gcp_machine_type) { "'gcp_machine_type'" }
+    let(:gcp_operation_id) { 'NULL' }
+    let(:encrypted_gcp_token) { "'encrypted_gcp_token'" }
+    let(:encrypted_gcp_token_iv) { "'encrypted_gcp_token_iv'" }
+
+    let(:cluster) { Clusters::Cluster.last }
+    let(:cluster_id) { cluster.id }
+
+    before do
+      ActiveRecord::Base.connection.execute <<-SQL
+        INSERT INTO gcp_clusters (project_id, user_id, service_id, status, gcp_cluster_size, created_at, updated_at, enabled, status_reason, project_namespace, endpoint, ca_cert, encrypted_kubernetes_token, encrypted_kubernetes_token_iv, username, encrypted_password, encrypted_password_iv, gcp_project_id, gcp_cluster_zone, gcp_cluster_name, gcp_machine_type, gcp_operation_id, encrypted_gcp_token, encrypted_gcp_token_iv)
+        VALUES (#{project_id}, #{user_id}, #{service_id}, #{status}, #{gcp_cluster_size}, #{created_at}, #{updated_at}, #{enabled}, #{status_reason}, #{project_namespace}, #{endpoint}, #{ca_cert}, #{encrypted_kubernetes_token}, #{encrypted_kubernetes_token_iv}, #{username}, #{encrypted_password}, #{encrypted_password_iv}, #{gcp_project_id}, #{gcp_cluster_zone}, #{gcp_cluster_name}, #{gcp_machine_type}, #{gcp_operation_id}, #{encrypted_gcp_token}, #{encrypted_gcp_token_iv});
+      SQL
+    end
+
+    it 'correctly migrate to new clusters architectures' do
+      migrate!
+
+      expect(Clusters::Cluster.count).to eq(1)
+      expect(Clusters::Project.count).to eq(1)
+      expect(Clusters::Providers::Gcp.count).to eq(1)
+      expect(Clusters::Platforms::Kubernetes.count).to eq(1)
+
+      expect(cluster.user).to eq(user)
+      expect(cluster.enabled).to be_truthy
+      expect(cluster.name).to eq(gcp_cluster_name.delete!("'"))
+      expect(cluster.provider_type).to eq('gcp')
+      expect(cluster.platform_type).to eq('kubernetes')
+
+      expect(cluster.project).to eq(project)
+      expect(project.cluster).to eq(cluster)
+
+      expect(cluster.provider_gcp.cluster).to eq(cluster)
+      expect(cluster.provider_gcp.status).to eq(status)
+      expect(cluster.provider_gcp.status_reason).to eq(tr(status_reason))
+      expect(cluster.provider_gcp.gcp_project_id).to eq(tr(gcp_project_id))
+      expect(cluster.provider_gcp.zone).to eq(tr(gcp_cluster_zone))
+      expect(cluster.provider_gcp.num_nodes).to eq(gcp_cluster_size)
+      expect(cluster.provider_gcp.machine_type).to eq(tr(gcp_machine_type))
+      expect(cluster.provider_gcp.operation_id).to be_nil
+      expect(cluster.provider_gcp.endpoint).to be_nil
+      expect(cluster.provider_gcp.encrypted_access_token).to eq(tr(encrypted_gcp_token))
+      expect(cluster.provider_gcp.encrypted_access_token_iv).to eq(tr(encrypted_gcp_token_iv))
+
+      expect(cluster.platform_kubernetes.cluster).to eq(cluster)
+      expect(cluster.platform_kubernetes.api_url).to be_nil
+      expect(cluster.platform_kubernetes.ca_cert).to be_nil
+      expect(cluster.platform_kubernetes.namespace).to eq(tr(project_namespace))
+      expect(cluster.platform_kubernetes.username).to be_nil
+      expect(cluster.platform_kubernetes.encrypted_password).to be_nil
+      expect(cluster.platform_kubernetes.encrypted_password_iv).to be_nil
+      expect(cluster.platform_kubernetes.encrypted_token).to be_nil
+      expect(cluster.platform_kubernetes.encrypted_token_iv).to be_nil
+    end
+  end
+
+  context 'when cluster has been created' do
+    let(:project_id) { project.id }
+    let(:user_id) { user.id }
+    let(:service_id) { service.id }
+    let(:status) { 3 } # created
+    let(:gcp_cluster_size) { 1 }
+    let(:created_at) { "'2017-10-17 20:24:02'" }
+    let(:updated_at) { "'2017-10-17 20:28:44'" }
+    let(:enabled) { true }
+    let(:status_reason) { "'general error'" }
+    let(:project_namespace) { "'sample-app'" }
+    let(:endpoint) { "'111.111.111.111'" }
+    let(:ca_cert) { "'ca_cert'" }
+    let(:encrypted_kubernetes_token) { "'encrypted_kubernetes_token'" }
+    let(:encrypted_kubernetes_token_iv) { "'encrypted_kubernetes_token_iv'" }
+    let(:username) { "'username'" }
+    let(:encrypted_password) { "'encrypted_password'" }
+    let(:encrypted_password_iv) { "'encrypted_password_iv'" }
+    let(:gcp_project_id) { "'gcp_project_id'" }
+    let(:gcp_cluster_zone) { "'gcp_cluster_zone'" }
+    let(:gcp_cluster_name) { "'gcp_cluster_name'" }
+    let(:gcp_machine_type) { "'gcp_machine_type'" }
+    let(:gcp_operation_id) { "'gcp_operation_id'" }
+    let(:encrypted_gcp_token) { "'encrypted_gcp_token'" }
+    let(:encrypted_gcp_token_iv) { "'encrypted_gcp_token_iv'" }
+
+    let(:cluster) { Clusters::Cluster.last }
+    let(:cluster_id) { cluster.id }
+
+    before do
+      ActiveRecord::Base.connection.execute <<-SQL
+        INSERT INTO gcp_clusters (project_id, user_id, service_id, status, gcp_cluster_size, created_at, updated_at, enabled, status_reason, project_namespace, endpoint, ca_cert, encrypted_kubernetes_token, encrypted_kubernetes_token_iv, username, encrypted_password, encrypted_password_iv, gcp_project_id, gcp_cluster_zone, gcp_cluster_name, gcp_machine_type, gcp_operation_id, encrypted_gcp_token, encrypted_gcp_token_iv)
+        VALUES (#{project_id}, #{user_id}, #{service_id}, #{status}, #{gcp_cluster_size}, #{created_at}, #{updated_at}, #{enabled}, #{status_reason}, #{project_namespace}, #{endpoint}, #{ca_cert}, #{encrypted_kubernetes_token}, #{encrypted_kubernetes_token_iv}, #{username}, #{encrypted_password}, #{encrypted_password_iv}, #{gcp_project_id}, #{gcp_cluster_zone}, #{gcp_cluster_name}, #{gcp_machine_type}, #{gcp_operation_id}, #{encrypted_gcp_token}, #{encrypted_gcp_token_iv});
+      SQL
+    end
+
+    it 'correctly migrate to new clusters architectures' do
+      migrate!
+
+      expect(Clusters::Cluster.count).to eq(1)
+      expect(Clusters::Project.count).to eq(1)
+      expect(Clusters::Providers::Gcp.count).to eq(1)
+      expect(Clusters::Platforms::Kubernetes.count).to eq(1)
+
+      expect(cluster.user).to eq(user)
+      expect(cluster.enabled).to be_truthy
+      expect(cluster.name).to eq(tr(gcp_cluster_name))
+      expect(cluster.provider_type).to eq('gcp')
+      expect(cluster.platform_type).to eq('kubernetes')
+
+      expect(cluster.project).to eq(project)
+      expect(project.cluster).to eq(cluster)
+
+      expect(cluster.provider_gcp.cluster).to eq(cluster)
+      expect(cluster.provider_gcp.status).to eq(status)
+      expect(cluster.provider_gcp.status_reason).to eq(tr(status_reason))
+      expect(cluster.provider_gcp.gcp_project_id).to eq(tr(gcp_project_id))
+      expect(cluster.provider_gcp.zone).to eq(tr(gcp_cluster_zone))
+      expect(cluster.provider_gcp.num_nodes).to eq(gcp_cluster_size)
+      expect(cluster.provider_gcp.machine_type).to eq(tr(gcp_machine_type))
+      expect(cluster.provider_gcp.operation_id).to eq(tr(gcp_operation_id))
+      expect(cluster.provider_gcp.endpoint).to eq(tr(endpoint))
+      expect(cluster.provider_gcp.encrypted_access_token).to eq(tr(encrypted_gcp_token))
+      expect(cluster.provider_gcp.encrypted_access_token_iv).to eq(tr(encrypted_gcp_token_iv))
+
+      expect(cluster.platform_kubernetes.cluster).to eq(cluster)
+      expect(cluster.platform_kubernetes.api_url).to eq('https://' + tr(endpoint))
+      expect(cluster.platform_kubernetes.ca_cert).to eq(tr(ca_cert))
+      expect(cluster.platform_kubernetes.namespace).to eq(tr(project_namespace))
+      expect(cluster.platform_kubernetes.username).to eq(tr(username))
+      expect(cluster.platform_kubernetes.encrypted_password).to eq(tr(encrypted_password))
+      expect(cluster.platform_kubernetes.encrypted_password_iv).to eq(tr(encrypted_password_iv))
+      expect(cluster.platform_kubernetes.encrypted_token).to eq(tr(encrypted_kubernetes_token))
+      expect(cluster.platform_kubernetes.encrypted_token_iv).to eq(tr(encrypted_kubernetes_token_iv))
+    end
+  end
+
+  def tr(s)
+    s.delete("'")
+  end
+end
diff --git a/spec/migrations/schedule_merge_request_diff_migrations_spec.rb b/spec/migrations/schedule_merge_request_diff_migrations_spec.rb
index f95bd6e3511..76afb6c19cf 100644
--- a/spec/migrations/schedule_merge_request_diff_migrations_spec.rb
+++ b/spec/migrations/schedule_merge_request_diff_migrations_spec.rb
@@ -2,19 +2,6 @@ require 'spec_helper'
 require Rails.root.join('db', 'post_migrate', '20170703130158_schedule_merge_request_diff_migrations')
 
 describe ScheduleMergeRequestDiffMigrations, :migration, :sidekiq do
-  matcher :be_scheduled_migration do |time, *expected|
-    match do |migration|
-      BackgroundMigrationWorker.jobs.any? do |job|
-        job['args'] == [migration, expected] &&
-          job['at'].to_i == time.to_i
-      end
-    end
-
-    failure_message do |migration|
-      "Migration `#{migration}` with args `#{expected.inspect}` not scheduled!"
-    end
-  end
-
   let(:merge_request_diffs) { table(:merge_request_diffs) }
   let(:merge_requests) { table(:merge_requests) }
   let(:projects) { table(:projects) }
@@ -37,9 +24,9 @@ describe ScheduleMergeRequestDiffMigrations, :migration, :sidekiq do
       Timecop.freeze do
         migrate!
 
-        expect(described_class::MIGRATION).to be_scheduled_migration(5.minutes.from_now, 1, 1)
-        expect(described_class::MIGRATION).to be_scheduled_migration(10.minutes.from_now, 2, 2)
-        expect(described_class::MIGRATION).to be_scheduled_migration(15.minutes.from_now, 4, 4)
+        expect(described_class::MIGRATION).to be_scheduled_migration(5.minutes, 1, 1)
+        expect(described_class::MIGRATION).to be_scheduled_migration(10.minutes, 2, 2)
+        expect(described_class::MIGRATION).to be_scheduled_migration(15.minutes, 4, 4)
         expect(BackgroundMigrationWorker.jobs.size).to eq 3
       end
     end
diff --git a/spec/migrations/schedule_merge_request_diff_migrations_take_two_spec.rb b/spec/migrations/schedule_merge_request_diff_migrations_take_two_spec.rb
index 4ab1bb67058..cf323973384 100644
--- a/spec/migrations/schedule_merge_request_diff_migrations_take_two_spec.rb
+++ b/spec/migrations/schedule_merge_request_diff_migrations_take_two_spec.rb
@@ -2,19 +2,6 @@ require 'spec_helper'
 require Rails.root.join('db', 'post_migrate', '20170926150348_schedule_merge_request_diff_migrations_take_two')
 
 describe ScheduleMergeRequestDiffMigrationsTakeTwo, :migration, :sidekiq do
-  matcher :be_scheduled_migration do |time, *expected|
-    match do |migration|
-      BackgroundMigrationWorker.jobs.any? do |job|
-        job['args'] == [migration, expected] &&
-          job['at'].to_i == time.to_i
-      end
-    end
-
-    failure_message do |migration|
-      "Migration `#{migration}` with args `#{expected.inspect}` not scheduled!"
-    end
-  end
-
   let(:merge_request_diffs) { table(:merge_request_diffs) }
   let(:merge_requests) { table(:merge_requests) }
   let(:projects) { table(:projects) }
@@ -37,9 +24,9 @@ describe ScheduleMergeRequestDiffMigrationsTakeTwo, :migration, :sidekiq do
       Timecop.freeze do
         migrate!
 
-        expect(described_class::MIGRATION).to be_scheduled_migration(10.minutes.from_now, 1, 1)
-        expect(described_class::MIGRATION).to be_scheduled_migration(20.minutes.from_now, 2, 2)
-        expect(described_class::MIGRATION).to be_scheduled_migration(30.minutes.from_now, 4, 4)
+        expect(described_class::MIGRATION).to be_scheduled_migration(10.minutes, 1, 1)
+        expect(described_class::MIGRATION).to be_scheduled_migration(20.minutes, 2, 2)
+        expect(described_class::MIGRATION).to be_scheduled_migration(30.minutes, 4, 4)
         expect(BackgroundMigrationWorker.jobs.size).to eq 3
       end
     end
diff --git a/spec/migrations/schedule_merge_request_latest_merge_request_diff_id_migrations_spec.rb b/spec/migrations/schedule_merge_request_latest_merge_request_diff_id_migrations_spec.rb
new file mode 100644
index 00000000000..158d0bc02ed
--- /dev/null
+++ b/spec/migrations/schedule_merge_request_latest_merge_request_diff_id_migrations_spec.rb
@@ -0,0 +1,64 @@
+require 'spec_helper'
+require Rails.root.join('db', 'post_migrate', '20171026082505_schedule_merge_request_latest_merge_request_diff_id_migrations')
+
+describe ScheduleMergeRequestLatestMergeRequestDiffIdMigrations, :migration, :sidekiq do
+  let(:projects_table) { table(:projects) }
+  let(:merge_requests_table) { table(:merge_requests) }
+  let(:merge_request_diffs_table) { table(:merge_request_diffs) }
+
+  let(:project) { projects_table.create!(name: 'gitlab', path: 'gitlab-org/gitlab-ce') }
+
+  let!(:merge_request_1) { create_mr!('mr_1', diffs: 1) }
+  let!(:merge_request_2) { create_mr!('mr_2', diffs: 2) }
+  let!(:merge_request_migrated) { create_mr!('merge_request_migrated', diffs: 3) }
+  let!(:merge_request_4) { create_mr!('mr_4', diffs: 3) }
+
+  def create_mr!(name, diffs: 0)
+    merge_request =
+      merge_requests_table.create!(target_project_id: project.id,
+                                   target_branch: 'master',
+                                   source_project_id: project.id,
+                                   source_branch: name,
+                                   title: name)
+
+    diffs.times do
+      merge_request_diffs_table.create!(merge_request_id: merge_request.id)
+    end
+
+    merge_request
+  end
+
+  def diffs_for(merge_request)
+    merge_request_diffs_table.where(merge_request_id: merge_request.id)
+  end
+
+  before do
+    stub_const("#{described_class.name}::BATCH_SIZE", 1)
+
+    diff_id = diffs_for(merge_request_migrated).minimum(:id)
+    merge_request_migrated.update!(latest_merge_request_diff_id: diff_id)
+  end
+
+  it 'correctly schedules background migrations' do
+    Sidekiq::Testing.fake! do
+      Timecop.freeze do
+        migrate!
+
+        expect(described_class::MIGRATION).to be_scheduled_migration(5.minutes, merge_request_1.id, merge_request_1.id)
+        expect(described_class::MIGRATION).to be_scheduled_migration(10.minutes, merge_request_2.id, merge_request_2.id)
+        expect(described_class::MIGRATION).to be_scheduled_migration(15.minutes, merge_request_4.id, merge_request_4.id)
+        expect(BackgroundMigrationWorker.jobs.size).to eq 3
+      end
+    end
+  end
+
+  it 'schedules background migrations' do
+    Sidekiq::Testing.inline! do
+      expect(merge_requests_table.where(latest_merge_request_diff_id: nil).count).to eq 3
+
+      migrate!
+
+      expect(merge_requests_table.where(latest_merge_request_diff_id: nil).count).to eq 0
+    end
+  end
+end
diff --git a/spec/models/ci/build_spec.rb b/spec/models/ci/build_spec.rb
index 5ed2e1ca99a..1795ee8e9a4 100644
--- a/spec/models/ci/build_spec.rb
+++ b/spec/models/ci/build_spec.rb
@@ -270,6 +270,23 @@ describe Ci::Build do
     end
   end
 
+  describe '#triggered_by?' do
+    subject { build.triggered_by?(user) }
+
+    context 'when user is owner' do
+      let(:build) { create(:ci_build, pipeline: pipeline, user: user) }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when user is not owner' do
+      let(:another_user) { create(:user) }
+      let(:build) { create(:ci_build, pipeline: pipeline, user: another_user) }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+
   describe '#detailed_status' do
     it 'returns a detailed status' do
       expect(build.detailed_status(user))
diff --git a/spec/models/clusters/applications/helm_spec.rb b/spec/models/clusters/applications/helm_spec.rb
new file mode 100644
index 00000000000..f8855079842
--- /dev/null
+++ b/spec/models/clusters/applications/helm_spec.rb
@@ -0,0 +1,102 @@
+require 'rails_helper'
+
+describe Clusters::Applications::Helm do
+  it { is_expected.to belong_to(:cluster) }
+  it { is_expected.to validate_presence_of(:cluster) }
+
+  describe '#name' do
+    it 'is .application_name' do
+      expect(subject.name).to eq(described_class.application_name)
+    end
+
+    it 'is recorded in Clusters::Cluster::APPLICATIONS' do
+      expect(Clusters::Cluster::APPLICATIONS[subject.name]).to eq(described_class)
+    end
+  end
+
+  describe '#version' do
+    it 'defaults to Gitlab::Kubernetes::Helm::HELM_VERSION' do
+      expect(subject.version).to eq(Gitlab::Kubernetes::Helm::HELM_VERSION)
+    end
+  end
+
+  describe '#status' do
+    let(:cluster) { create(:cluster) }
+
+    subject { described_class.new(cluster: cluster) }
+
+    it 'defaults to :not_installable' do
+      expect(subject.status_name).to be(:not_installable)
+    end
+
+    context 'when platform kubernetes is defined' do
+      let(:cluster) { create(:cluster, :provided_by_gcp) }
+
+      it 'defaults to :installable' do
+        expect(subject.status_name).to be(:installable)
+      end
+    end
+  end
+
+  describe '#install_command' do
+    it 'has all the needed information' do
+      expect(subject.install_command).to have_attributes(name: subject.name, install_helm: true, chart: nil)
+    end
+  end
+
+  describe 'status state machine' do
+    describe '#make_installing' do
+      subject { create(:cluster_applications_helm, :scheduled) }
+
+      it 'is installing' do
+        subject.make_installing!
+
+        expect(subject).to be_installing
+      end
+    end
+
+    describe '#make_installed' do
+      subject { create(:cluster_applications_helm, :installing) }
+
+      it 'is installed' do
+        subject.make_installed
+
+        expect(subject).to be_installed
+      end
+    end
+
+    describe '#make_errored' do
+      subject { create(:cluster_applications_helm, :installing) }
+      let(:reason) { 'some errors' }
+
+      it 'is errored' do
+        subject.make_errored(reason)
+
+        expect(subject).to be_errored
+        expect(subject.status_reason).to eq(reason)
+      end
+    end
+
+    describe '#make_scheduled' do
+      subject { create(:cluster_applications_helm, :installable) }
+
+      it 'is scheduled' do
+        subject.make_scheduled
+
+        expect(subject).to be_scheduled
+      end
+
+      describe 'when was errored' do
+        subject { create(:cluster_applications_helm, :errored) }
+
+        it 'clears #status_reason' do
+          expect(subject.status_reason).not_to be_nil
+
+          subject.make_scheduled!
+
+          expect(subject.status_reason).to be_nil
+        end
+      end
+    end
+  end
+end
diff --git a/spec/models/clusters/applications/ingress_spec.rb b/spec/models/clusters/applications/ingress_spec.rb
new file mode 100644
index 00000000000..b83472e1944
--- /dev/null
+++ b/spec/models/clusters/applications/ingress_spec.rb
@@ -0,0 +1,108 @@
+require 'rails_helper'
+
+describe Clusters::Applications::Ingress do
+  it { is_expected.to belong_to(:cluster) }
+  it { is_expected.to validate_presence_of(:cluster) }
+
+  describe '#name' do
+    it 'is .application_name' do
+      expect(subject.name).to eq(described_class.application_name)
+    end
+
+    it 'is recorded in Clusters::Cluster::APPLICATIONS' do
+      expect(Clusters::Cluster::APPLICATIONS[subject.name]).to eq(described_class)
+    end
+  end
+
+  describe '#status' do
+    let(:cluster) { create(:cluster, :provided_by_gcp) }
+
+    subject { described_class.new(cluster: cluster) }
+
+    it 'defaults to :not_installable' do
+      expect(subject.status_name).to be(:not_installable)
+    end
+
+    context 'when application helm is scheduled' do
+      before do
+        create(:cluster_applications_helm, :scheduled, cluster: cluster)
+      end
+
+      it 'defaults to :not_installable' do
+        expect(subject.status_name).to be(:not_installable)
+      end
+    end
+
+    context 'when application helm is installed' do
+      before do
+        create(:cluster_applications_helm, :installed, cluster: cluster)
+      end
+
+      it 'defaults to :installable' do
+        expect(subject.status_name).to be(:installable)
+      end
+    end
+  end
+
+  describe '#install_command' do
+    it 'has all the needed information' do
+      expect(subject.install_command).to have_attributes(name: subject.name, install_helm: false, chart: subject.chart)
+    end
+  end
+
+  describe 'status state machine' do
+    describe '#make_installing' do
+      subject { create(:cluster_applications_ingress, :scheduled) }
+
+      it 'is installing' do
+        subject.make_installing!
+
+        expect(subject).to be_installing
+      end
+    end
+
+    describe '#make_installed' do
+      subject { create(:cluster_applications_ingress, :installing) }
+
+      it 'is installed' do
+        subject.make_installed
+
+        expect(subject).to be_installed
+      end
+    end
+
+    describe '#make_errored' do
+      subject { create(:cluster_applications_ingress, :installing) }
+      let(:reason) { 'some errors' }
+
+      it 'is errored' do
+        subject.make_errored(reason)
+
+        expect(subject).to be_errored
+        expect(subject.status_reason).to eq(reason)
+      end
+    end
+
+    describe '#make_scheduled' do
+      subject { create(:cluster_applications_ingress, :installable) }
+
+      it 'is scheduled' do
+        subject.make_scheduled
+
+        expect(subject).to be_scheduled
+      end
+
+      describe 'when was errored' do
+        subject { create(:cluster_applications_ingress, :errored) }
+
+        it 'clears #status_reason' do
+          expect(subject.status_reason).not_to be_nil
+
+          subject.make_scheduled!
+
+          expect(subject.status_reason).to be_nil
+        end
+      end
+    end
+  end
+end
diff --git a/spec/models/clusters/cluster_spec.rb b/spec/models/clusters/cluster_spec.rb
new file mode 100644
index 00000000000..b91a5e7a272
--- /dev/null
+++ b/spec/models/clusters/cluster_spec.rb
@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe Clusters::Cluster do
+  it { is_expected.to belong_to(:user) }
+  it { is_expected.to have_many(:projects) }
+  it { is_expected.to have_one(:provider_gcp) }
+  it { is_expected.to have_one(:platform_kubernetes) }
+  it { is_expected.to delegate_method(:status).to(:provider) }
+  it { is_expected.to delegate_method(:status_reason).to(:provider) }
+  it { is_expected.to delegate_method(:status_name).to(:provider) }
+  it { is_expected.to delegate_method(:on_creation?).to(:provider) }
+  it { is_expected.to delegate_method(:update_kubernetes_integration!).to(:platform) }
+  it { is_expected.to respond_to :project }
+
+  describe '.enabled' do
+    subject { described_class.enabled }
+
+    let!(:cluster) { create(:cluster, enabled: true) }
+
+    before do
+      create(:cluster, enabled: false)
+    end
+
+    it { is_expected.to contain_exactly(cluster) }
+  end
+
+  describe '.disabled' do
+    subject { described_class.disabled }
+
+    let!(:cluster) { create(:cluster, enabled: false) }
+
+    before do
+      create(:cluster, enabled: true)
+    end
+
+    it { is_expected.to contain_exactly(cluster) }
+  end
+
+  describe 'validation' do
+    subject { cluster.valid? }
+
+    context 'when validates name' do
+      context 'when provided by user' do
+        let!(:cluster) { build(:cluster, :provided_by_user, name: name) }
+
+        context 'when name is empty' do
+          let(:name) { '' }
+
+          it { is_expected.to be_falsey }
+        end
+
+        context 'when name is nil' do
+          let(:name) { nil }
+
+          it { is_expected.to be_falsey }
+        end
+
+        context 'when name is present' do
+          let(:name) { 'cluster-name-1' }
+
+          it { is_expected.to be_truthy }
+        end
+      end
+
+      context 'when provided by gcp' do
+        let!(:cluster) { build(:cluster, :provided_by_gcp, name: name) }
+
+        context 'when name is shorter than 1' do
+          let(:name) { '' }
+
+          it { is_expected.to be_falsey }
+        end
+
+        context 'when name is longer than 63' do
+          let(:name) { 'a' * 64 }
+
+          it { is_expected.to be_falsey }
+        end
+
+        context 'when name includes invalid character' do
+          let(:name) { '!!!!!!' }
+
+          it { is_expected.to be_falsey }
+        end
+
+        context 'when name is present' do
+          let(:name) { 'cluster-name-1' }
+
+          it { is_expected.to be_truthy }
+        end
+
+        context 'when record is persisted' do
+          let(:name) { 'cluster-name-1' }
+
+          before do
+            cluster.save!
+          end
+
+          context 'when name is changed' do
+            before do
+              cluster.name = 'new-cluster-name'
+            end
+
+            it { is_expected.to be_falsey }
+          end
+
+          context 'when name is same' do
+            before do
+              cluster.name = name
+            end
+
+            it { is_expected.to be_truthy }
+          end
+        end
+      end
+    end
+
+    context 'when validates restrict_modification' do
+      context 'when creation is on going' do
+        let!(:cluster) { create(:cluster, :providing_by_gcp) }
+
+        it { expect(cluster.update(enabled: false)).to be_falsey }
+      end
+
+      context 'when creation is done' do
+        let!(:cluster) { create(:cluster, :provided_by_gcp) }
+
+        it { expect(cluster.update(enabled: false)).to be_truthy }
+      end
+    end
+  end
+
+  describe '#provider' do
+    subject { cluster.provider }
+
+    context 'when provider is gcp' do
+      let(:cluster) { create(:cluster, :provided_by_gcp) }
+
+      it 'returns a provider' do
+        is_expected.to eq(cluster.provider_gcp)
+        expect(subject.class.name.deconstantize).to eq(Clusters::Providers.to_s)
+      end
+    end
+
+    context 'when provider is user' do
+      let(:cluster) { create(:cluster, :provided_by_user) }
+
+      it { is_expected.to be_nil }
+    end
+  end
+
+  describe '#platform' do
+    subject { cluster.platform }
+
+    context 'when platform is kubernetes' do
+      let(:cluster) { create(:cluster, :provided_by_user) }
+
+      it 'returns a platform' do
+        is_expected.to eq(cluster.platform_kubernetes)
+        expect(subject.class.name.deconstantize).to eq(Clusters::Platforms.to_s)
+      end
+    end
+  end
+
+  describe '#first_project' do
+    subject { cluster.first_project }
+
+    context 'when cluster belongs to a project' do
+      let(:cluster) { create(:cluster, :project) }
+      let(:project) { Clusters::Project.find_by_cluster_id(cluster.id).project }
+
+      it { is_expected.to eq(project) }
+    end
+
+    context 'when cluster does not belong to projects' do
+      let(:cluster) { create(:cluster) }
+
+      it { is_expected.to be_nil }
+    end
+  end
+
+  describe '#applications' do
+    set(:cluster) { create(:cluster) }
+
+    subject { cluster.applications }
+
+    context 'when none of applications are created' do
+      it 'returns a list of a new objects' do
+        is_expected.not_to be_empty
+      end
+    end
+
+    context 'when applications are created' do
+      let!(:helm) { create(:cluster_applications_helm, cluster: cluster) }
+      let!(:ingress) { create(:cluster_applications_ingress, cluster: cluster) }
+
+      it 'returns a list of created applications' do
+        is_expected.to contain_exactly(helm, ingress)
+      end
+    end
+  end
+end
diff --git a/spec/models/clusters/platforms/kubernetes_spec.rb b/spec/models/clusters/platforms/kubernetes_spec.rb
new file mode 100644
index 00000000000..ed76be703a5
--- /dev/null
+++ b/spec/models/clusters/platforms/kubernetes_spec.rb
@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe Clusters::Platforms::Kubernetes, :use_clean_rails_memory_store_caching do
+  include KubernetesHelpers
+  include ReactiveCachingHelpers
+
+  it { is_expected.to belong_to(:cluster) }
+  it { is_expected.to respond_to :ca_pem }
+
+  describe 'before_validation' do
+    context 'when namespace includes upper case' do
+      let(:kubernetes) { create(:cluster_platform_kubernetes, :configured, namespace: namespace) }
+      let(:namespace) { 'ABC' }
+
+      it 'converts to lower case' do
+        expect(kubernetes.namespace).to eq('abc')
+      end
+    end
+  end
+
+  describe 'validation' do
+    subject { kubernetes.valid? }
+
+    context 'when validates namespace' do
+      let(:kubernetes) { build(:cluster_platform_kubernetes, :configured, namespace: namespace) }
+
+      context 'when namespace is blank' do
+        let(:namespace) { '' }
+
+        it { is_expected.to be_truthy }
+      end
+
+      context 'when namespace is longer than 63' do
+        let(:namespace) { 'a' * 64 }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context 'when namespace includes invalid character' do
+        let(:namespace) { '!!!!!!' }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context 'when namespace is vaild' do
+        let(:namespace) { 'namespace-123' }
+
+        it { is_expected.to be_truthy }
+      end
+    end
+
+    context 'when validates api_url' do
+      let(:kubernetes) { build(:cluster_platform_kubernetes, :configured) }
+
+      before do
+        kubernetes.api_url = api_url
+      end
+
+      context 'when api_url is invalid url' do
+        let(:api_url) { '!!!!!!' }
+
+        it { expect(kubernetes.save).to be_falsey }
+      end
+
+      context 'when api_url is nil' do
+        let(:api_url) { nil }
+
+        it { expect(kubernetes.save).to be_falsey }
+      end
+
+      context 'when api_url is valid url' do
+        let(:api_url) { 'https://111.111.111.111' }
+
+        it { expect(kubernetes.save).to be_truthy }
+      end
+    end
+
+    context 'when validates token' do
+      let(:kubernetes) { build(:cluster_platform_kubernetes, :configured) }
+
+      before do
+        kubernetes.token = token
+      end
+
+      context 'when token is nil' do
+        let(:token) { nil }
+
+        it { expect(kubernetes.save).to be_falsey }
+      end
+    end
+  end
+
+  describe 'after_save from Clusters::Cluster' do
+    context 'when platform_kubernetes is being cerated' do
+      let(:enabled) { true }
+      let(:project) { create(:project) }
+      let(:cluster) { build(:cluster, provider_type: :gcp, platform_type: :kubernetes, platform_kubernetes: platform, provider_gcp: provider, enabled: enabled, projects: [project]) }
+      let(:platform) { build(:cluster_platform_kubernetes, :configured) }
+      let(:provider) { build(:cluster_provider_gcp) }
+      let(:kubernetes_service) { project.kubernetes_service }
+
+      it 'updates KubernetesService' do
+        cluster.save!
+
+        expect(kubernetes_service.active).to eq(enabled)
+        expect(kubernetes_service.api_url).to eq(platform.api_url)
+        expect(kubernetes_service.namespace).to eq(platform.namespace)
+        expect(kubernetes_service.ca_pem).to eq(platform.ca_cert)
+      end
+    end
+
+    context 'when platform_kubernetes has been created' do
+      let(:enabled) { false }
+      let!(:project) { create(:project) }
+      let!(:cluster) { create(:cluster, :provided_by_gcp, projects: [project]) }
+      let(:platform) { cluster.platform }
+      let(:kubernetes_service) { project.kubernetes_service }
+
+      it 'updates KubernetesService' do
+        cluster.update(enabled: enabled)
+
+        expect(kubernetes_service.active).to eq(enabled)
+      end
+    end
+
+    context 'when kubernetes_service has been configured without cluster integration' do
+      let!(:project) { create(:project) }
+      let(:cluster) { build(:cluster, provider_type: :gcp, platform_type: :kubernetes, platform_kubernetes: platform, provider_gcp: provider, projects: [project]) }
+      let(:platform) { build(:cluster_platform_kubernetes, :configured, api_url: 'https://111.111.111.111') }
+      let(:provider) { build(:cluster_provider_gcp) }
+
+      before do
+        create(:kubernetes_service, project: project)
+      end
+
+      it 'raises an error' do
+        expect { cluster.save! }.to raise_error('Kubernetes service already configured')
+      end
+    end
+  end
+
+  describe '#actual_namespace' do
+    subject { kubernetes.actual_namespace }
+
+    let!(:cluster) { create(:cluster, :project, platform_kubernetes: kubernetes) }
+    let(:project) { cluster.project }
+    let(:kubernetes) { create(:cluster_platform_kubernetes, :configured, namespace: namespace) }
+
+    context 'when namespace is present' do
+      let(:namespace) { 'namespace-123' }
+
+      it { is_expected.to eq(namespace) }
+    end
+
+    context 'when namespace is not present' do
+      let(:namespace) { nil }
+
+      it { is_expected.to eq("#{project.path}-#{project.id}") }
+    end
+  end
+
+  describe '.namespace_for_project' do
+    subject { described_class.namespace_for_project(project) }
+
+    let(:project) { create(:project) }
+
+    it { is_expected.to eq("#{project.path}-#{project.id}") }
+  end
+
+  describe '#default_namespace' do
+    subject { kubernetes.default_namespace }
+
+    let(:kubernetes) { create(:cluster_platform_kubernetes, :configured) }
+
+    context 'when cluster belongs to a project' do
+      let!(:cluster) { create(:cluster, :project, platform_kubernetes: kubernetes) }
+      let(:project) { cluster.project }
+
+      it { is_expected.to eq("#{project.path}-#{project.id}") }
+    end
+
+    context 'when cluster belongs to nothing' do
+      let!(:cluster) { create(:cluster, platform_kubernetes: kubernetes) }
+
+      it { is_expected.to be_nil }
+    end
+  end
+end
diff --git a/spec/models/clusters/project_spec.rb b/spec/models/clusters/project_spec.rb
new file mode 100644
index 00000000000..7d75d6ab345
--- /dev/null
+++ b/spec/models/clusters/project_spec.rb
@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Clusters::Project do
+  it { is_expected.to belong_to(:cluster) }
+  it { is_expected.to belong_to(:project) }
+end
diff --git a/spec/models/clusters/providers/gcp_spec.rb b/spec/models/clusters/providers/gcp_spec.rb
new file mode 100644
index 00000000000..b38b5e6bcad
--- /dev/null
+++ b/spec/models/clusters/providers/gcp_spec.rb
@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+describe Clusters::Providers::Gcp do
+  it { is_expected.to belong_to(:cluster) }
+  it { is_expected.to validate_presence_of(:zone) }
+
+  describe 'default_value_for' do
+    let(:gcp) { build(:cluster_provider_gcp) }
+
+    it "has default value" do
+      expect(gcp.zone).to eq('us-central1-a')
+      expect(gcp.num_nodes).to eq(3)
+      expect(gcp.machine_type).to eq('n1-standard-2')
+    end
+  end
+
+  describe 'validation' do
+    subject { gcp.valid? }
+
+    context 'when validates gcp_project_id' do
+      let(:gcp) { build(:cluster_provider_gcp, gcp_project_id: gcp_project_id) }
+
+      context 'when gcp_project_id is shorter than 1' do
+        let(:gcp_project_id) { '' }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context 'when gcp_project_id is longer than 63' do
+        let(:gcp_project_id) { 'a' * 64 }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context 'when gcp_project_id includes invalid character' do
+        let(:gcp_project_id) { '!!!!!!' }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context 'when gcp_project_id is valid' do
+        let(:gcp_project_id) { 'gcp-project-1' }
+
+        it { is_expected.to be_truthy }
+      end
+    end
+
+    context 'when validates num_nodes' do
+      let(:gcp) { build(:cluster_provider_gcp, num_nodes: num_nodes) }
+
+      context 'when num_nodes is string' do
+        let(:num_nodes) { 'A3' }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context 'when num_nodes is nil' do
+        let(:num_nodes) { nil }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context 'when num_nodes is smaller than 1' do
+        let(:num_nodes) { 0 }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context 'when num_nodes is valid' do
+        let(:num_nodes) { 3 }
+
+        it { is_expected.to be_truthy }
+      end
+    end
+  end
+
+  describe '#state_machine' do
+    context 'when any => [:created]' do
+      let(:gcp) { build(:cluster_provider_gcp, :creating) }
+
+      before do
+        gcp.make_created
+      end
+
+      it 'nullify access_token and operation_id' do
+        expect(gcp.access_token).to be_nil
+        expect(gcp.operation_id).to be_nil
+        expect(gcp).to be_created
+      end
+    end
+
+    context 'when any => [:creating]' do
+      let(:gcp) { build(:cluster_provider_gcp) }
+
+      context 'when operation_id is present' do
+        let(:operation_id) { 'operation-xxx' }
+
+        before do
+          gcp.make_creating(operation_id)
+        end
+
+        it 'sets operation_id' do
+          expect(gcp.operation_id).to eq(operation_id)
+          expect(gcp).to be_creating
+        end
+      end
+
+      context 'when operation_id is nil' do
+        let(:operation_id) { nil }
+
+        it 'raises an error' do
+          expect { gcp.make_creating(operation_id) }
+            .to raise_error('operation_id is required')
+        end
+      end
+    end
+
+    context 'when any => [:errored]' do
+      let(:gcp) { build(:cluster_provider_gcp, :creating) }
+      let(:status_reason) { 'err msg' }
+
+      it 'nullify access_token and operation_id' do
+        gcp.make_errored(status_reason)
+
+        expect(gcp.access_token).to be_nil
+        expect(gcp.operation_id).to be_nil
+        expect(gcp.status_reason).to eq(status_reason)
+        expect(gcp).to be_errored
+      end
+
+      context 'when status_reason is nil' do
+        let(:gcp) { build(:cluster_provider_gcp, :errored) }
+
+        it 'does not set status_reason' do
+          gcp.make_errored(nil)
+
+          expect(gcp.status_reason).not_to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#on_creation?' do
+    subject { gcp.on_creation? }
+
+    context 'when status is creating' do
+      let(:gcp) { create(:cluster_provider_gcp, :creating) }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when status is created' do
+      let(:gcp) { create(:cluster_provider_gcp, :created) }
+
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe '#api_client' do
+    subject { gcp.api_client }
+
+    context 'when status is creating' do
+      let(:gcp) { build(:cluster_provider_gcp, :creating) }
+
+      it 'returns Cloud Platform API clinet' do
+        expect(subject).to be_an_instance_of(GoogleApi::CloudPlatform::Client)
+        expect(subject.access_token).to eq(gcp.access_token)
+      end
+    end
+
+    context 'when status is created' do
+      let(:gcp) { build(:cluster_provider_gcp, :created) }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when status is errored' do
+      let(:gcp) { build(:cluster_provider_gcp, :errored) }
+
+      it { is_expected.to be_nil }
+    end
+  end
+end
diff --git a/spec/models/commit_status_spec.rb b/spec/models/commit_status_spec.rb
index 858ec831200..c536dab2681 100644
--- a/spec/models/commit_status_spec.rb
+++ b/spec/models/commit_status_spec.rb
@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 describe CommitStatus do
-  let(:project) { create(:project, :repository) }
+  set(:project) { create(:project, :repository) }
 
-  let(:pipeline) do
+  set(:pipeline) do
     create(:ci_pipeline, project: project, sha: project.commit.id)
   end
 
@@ -464,4 +464,73 @@ describe CommitStatus do
       it { is_expected.to be_script_failure }
     end
   end
+
+  describe 'ensure stage assignment' do
+    context 'when commit status has a stage_id assigned' do
+      let!(:stage) do
+        create(:ci_stage_entity, project: project, pipeline: pipeline)
+      end
+
+      let(:commit_status) do
+        create(:commit_status, stage_id: stage.id, name: 'rspec', stage: 'test')
+      end
+
+      it 'does not create a new stage' do
+        expect { commit_status }.not_to change { Ci::Stage.count }
+        expect(commit_status.stage_id).to eq stage.id
+      end
+    end
+
+    context 'when commit status does not have a stage_id assigned' do
+      let(:commit_status) do
+        create(:commit_status, name: 'rspec', stage: 'test', status: :success)
+      end
+
+      let(:stage) { Ci::Stage.first }
+
+      it 'creates a new stage' do
+        expect { commit_status }.to change { Ci::Stage.count }.by(1)
+
+        expect(stage.name).to eq 'test'
+        expect(stage.project).to eq commit_status.project
+        expect(stage.pipeline).to eq commit_status.pipeline
+        expect(stage.status).to eq commit_status.status
+        expect(commit_status.stage_id).to eq stage.id
+      end
+    end
+
+    context 'when commit status does not have stage but it exists' do
+      let!(:stage) do
+        create(:ci_stage_entity, project: project,
+                                 pipeline: pipeline,
+                                 name: 'test')
+      end
+
+      let(:commit_status) do
+        create(:commit_status, project: project,
+                               pipeline: pipeline,
+                               name: 'rspec',
+                               stage: 'test',
+                               status: :success)
+      end
+
+      it 'uses existing stage' do
+        expect { commit_status }.not_to change { Ci::Stage.count }
+
+        expect(commit_status.stage_id).to eq stage.id
+        expect(stage.reload.status).to eq commit_status.status
+      end
+    end
+
+    context 'when commit status is being imported' do
+      let(:commit_status) do
+        create(:commit_status, name: 'rspec', stage: 'test', importing: true)
+      end
+
+      it 'does not create a new stage' do
+        expect { commit_status }.not_to change { Ci::Stage.count }
+        expect(commit_status.stage_id).not_to be_present
+      end
+    end
+  end
 end
diff --git a/spec/models/concerns/avatarable_spec.rb b/spec/models/concerns/avatarable_spec.rb
new file mode 100644
index 00000000000..cbdc438be0b
--- /dev/null
+++ b/spec/models/concerns/avatarable_spec.rb
@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Avatarable do
+  subject { create(:project, avatar: fixture_file_upload(File.join(Rails.root, 'spec/fixtures/dk.png'))) }
+
+  let(:gitlab_host) { "https://gitlab.example.com" }
+  let(:relative_url_root) { "/gitlab" }
+  let(:asset_host) { "https://gitlab-assets.example.com" }
+
+  before do
+    stub_config_setting(base_url: gitlab_host)
+    stub_config_setting(relative_url_root: relative_url_root)
+  end
+
+  describe '#avatar_path' do
+    using RSpec::Parameterized::TableSyntax
+
+    where(:has_asset_host, :visibility_level, :only_path, :avatar_path) do
+      true  | Project::PRIVATE  | true  | [gitlab_host, relative_url_root, subject.avatar.url]
+      true  | Project::PRIVATE  | false | [gitlab_host, relative_url_root, subject.avatar.url]
+      true  | Project::INTERNAL | true  | [gitlab_host, relative_url_root, subject.avatar.url]
+      true  | Project::INTERNAL | false | [gitlab_host, relative_url_root, subject.avatar.url]
+      true  | Project::PUBLIC   | true  | [subject.avatar.url]
+      true  | Project::PUBLIC   | false | [asset_host, subject.avatar.url]
+      false | Project::PRIVATE  | true  | [relative_url_root, subject.avatar.url]
+      false | Project::PRIVATE  | false | [gitlab_host, relative_url_root, subject.avatar.url]
+      false | Project::INTERNAL | true  | [relative_url_root, subject.avatar.url]
+      false | Project::INTERNAL | false | [gitlab_host, relative_url_root, subject.avatar.url]
+      false | Project::PUBLIC   | true  | [relative_url_root, subject.avatar.url]
+      false | Project::PUBLIC   | false | [gitlab_host, relative_url_root, subject.avatar.url]
+    end
+
+    with_them do
+      before do
+        allow(ActionController::Base).to receive(:asset_host).and_return(has_asset_host ? asset_host : nil)
+        subject.visibility_level = visibility_level
+      end
+
+      it 'returns the expected avatar path' do
+        expect(subject.avatar_path(only_path: only_path)).to eq(avatar_path.join)
+      end
+    end
+  end
+end
diff --git a/spec/models/concerns/ignorable_column_spec.rb b/spec/models/concerns/ignorable_column_spec.rb
index dba9fe43327..b70f2331a0e 100644
--- a/spec/models/concerns/ignorable_column_spec.rb
+++ b/spec/models/concerns/ignorable_column_spec.rb
@@ -5,7 +5,11 @@ describe IgnorableColumn do
     Class.new do
       def self.columns
         # This method does not have access to "double"
-        [Struct.new(:name).new('id'), Struct.new(:name).new('title')]
+        [
+          Struct.new(:name).new('id'),
+          Struct.new(:name).new('title'),
+          Struct.new(:name).new('date')
+        ]
       end
     end
   end
@@ -18,7 +22,7 @@ describe IgnorableColumn do
 
   describe '.columns' do
     it 'returns the columns, excluding the ignored ones' do
-      model.ignore_column(:title)
+      model.ignore_column(:title, :date)
 
       expect(model.columns.map(&:name)).to eq(%w(id))
     end
@@ -30,9 +34,9 @@ describe IgnorableColumn do
     end
 
     it 'returns the names of the ignored columns' do
-      model.ignore_column(:title)
+      model.ignore_column(:title, :date)
 
-      expect(model.ignored_columns).to eq(Set.new(%w(title)))
+      expect(model.ignored_columns).to eq(Set.new(%w(title date)))
     end
   end
 end
diff --git a/spec/models/concerns/issuable_spec.rb b/spec/models/concerns/issuable_spec.rb
index ba57301a3c9..4dfbb14952e 100644
--- a/spec/models/concerns/issuable_spec.rb
+++ b/spec/models/concerns/issuable_spec.rb
@@ -265,25 +265,44 @@ describe Issuable do
   end
 
   describe '#to_hook_data' do
+    let(:builder) { double }
+
     context 'labels are updated' do
       let(:labels) { create_list(:label, 2) }
 
       before do
         issue.update(labels: [labels[1]])
+        expect(Gitlab::HookData::IssuableBuilder)
+          .to receive(:new).with(issue).and_return(builder)
       end
 
       it 'delegates to Gitlab::HookData::IssuableBuilder#build' do
-        builder = double
+        expect(builder).to receive(:build).with(
+          user: user,
+          changes: hash_including(
+            'labels' => [[labels[0].hook_attrs], [labels[1].hook_attrs]]
+          ))
 
+        issue.to_hook_data(user, old_labels: [labels[0]])
+      end
+    end
+
+    context 'total_time_spent is updated' do
+      before do
+        issue.spend_time(duration: 2, user: user, spent_at: Time.now)
+        issue.save
         expect(Gitlab::HookData::IssuableBuilder)
           .to receive(:new).with(issue).and_return(builder)
+      end
+
+      it 'delegates to Gitlab::HookData::IssuableBuilder#build' do
         expect(builder).to receive(:build).with(
           user: user,
           changes: hash_including(
-            'labels' => [[labels[0].hook_attrs], [labels[1].hook_attrs]]
+            'total_time_spent' => [1, 2]
           ))
 
-        issue.to_hook_data(user, old_labels: [labels[0]])
+        issue.to_hook_data(user, old_total_time_spent: 1)
       end
     end
 
@@ -292,13 +311,11 @@ describe Issuable do
 
       before do
         issue.assignees << user << user2
+        expect(Gitlab::HookData::IssuableBuilder)
+          .to receive(:new).with(issue).and_return(builder)
       end
 
       it 'delegates to Gitlab::HookData::IssuableBuilder#build' do
-        builder = double
-
-        expect(Gitlab::HookData::IssuableBuilder)
-          .to receive(:new).with(issue).and_return(builder)
         expect(builder).to receive(:build).with(
           user: user,
           changes: hash_including(
@@ -316,13 +333,11 @@ describe Issuable do
       before do
         merge_request.update(assignee: user)
         merge_request.update(assignee: user2)
+        expect(Gitlab::HookData::IssuableBuilder)
+          .to receive(:new).with(merge_request).and_return(builder)
       end
 
       it 'delegates to Gitlab::HookData::IssuableBuilder#build' do
-        builder = double
-
-        expect(Gitlab::HookData::IssuableBuilder)
-          .to receive(:new).with(merge_request).and_return(builder)
         expect(builder).to receive(:build).with(
           user: user,
           changes: hash_including(
diff --git a/spec/models/concerns/milestoneish_spec.rb b/spec/models/concerns/milestoneish_spec.rb
index 66353935427..9048da0c73d 100644
--- a/spec/models/concerns/milestoneish_spec.rb
+++ b/spec/models/concerns/milestoneish_spec.rb
@@ -186,4 +186,21 @@ describe Milestone, 'Milestoneish' do
       expect(milestone.elapsed_days).to eq(2)
     end
   end
+
+  describe '#total_issue_time_spent' do
+    it 'calculates total issue time spent' do
+      closed_issue_1.spend_time(duration: 300, user: author)
+      closed_issue_1.save!
+      closed_issue_2.spend_time(duration: 600, user: assignee)
+      closed_issue_2.save!
+
+      expect(milestone.total_issue_time_spent).to eq(900)
+    end
+  end
+
+  describe '#human_total_issue_time_spent' do
+    it 'returns nil if no time has been spent' do
+      expect(milestone.human_total_issue_time_spent).to be_nil
+    end
+  end
 end
diff --git a/spec/models/diff_note_spec.rb b/spec/models/diff_note_spec.rb
index da972d2d86a..8389d5c5430 100644
--- a/spec/models/diff_note_spec.rb
+++ b/spec/models/diff_note_spec.rb
@@ -283,6 +283,12 @@ describe DiffNote do
         expect(diff_line).to be nil
         expect(subject).to be_valid
       end
+
+      it "does not update the position" do
+        expect(subject).not_to receive(:update_position)
+
+        subject.save
+      end
     end
 
     it "returns true for on_image?" do
diff --git a/spec/models/gcp/cluster_spec.rb b/spec/models/gcp/cluster_spec.rb
deleted file mode 100644
index 8f39fff6394..00000000000
--- a/spec/models/gcp/cluster_spec.rb
+++ /dev/null
@@ -1,264 +0,0 @@
-require 'spec_helper'
-
-describe Gcp::Cluster do
-  it { is_expected.to belong_to(:project) }
-  it { is_expected.to belong_to(:user) }
-  it { is_expected.to belong_to(:service) }
-
-  it { is_expected.to validate_presence_of(:gcp_cluster_zone) }
-
-  describe '.enabled' do
-    subject { described_class.enabled }
-
-    let!(:cluster) { create(:gcp_cluster, enabled: true) }
-
-    before do
-      create(:gcp_cluster, enabled: false)
-    end
-
-    it { is_expected.to contain_exactly(cluster) }
-  end
-
-  describe '.disabled' do
-    subject { described_class.disabled }
-
-    let!(:cluster) { create(:gcp_cluster, enabled: false) }
-
-    before do
-      create(:gcp_cluster, enabled: true)
-    end
-
-    it { is_expected.to contain_exactly(cluster) }
-  end
-
-  describe '#default_value_for' do
-    let(:cluster) { described_class.new }
-
-    it { expect(cluster.gcp_cluster_zone).to eq('us-central1-a') }
-    it { expect(cluster.gcp_cluster_size).to eq(3) }
-    it { expect(cluster.gcp_machine_type).to eq('n1-standard-4') }
-  end
-
-  describe '#validates' do
-    subject { cluster.valid? }
-
-    context 'when validates gcp_project_id' do
-      let(:cluster) { build(:gcp_cluster, gcp_project_id: gcp_project_id) }
-
-      context 'when valid' do
-        let(:gcp_project_id) { 'gcp-project-12345' }
-
-        it { is_expected.to be_truthy }
-      end
-
-      context 'when empty' do
-        let(:gcp_project_id) { '' }
-
-        it { is_expected.to be_falsey }
-      end
-
-      context 'when too long' do
-        let(:gcp_project_id) { 'A' * 64 }
-
-        it { is_expected.to be_falsey }
-      end
-
-      context 'when includes abnormal character' do
-        let(:gcp_project_id) { '!!!!!!' }
-
-        it { is_expected.to be_falsey }
-      end
-    end
-
-    context 'when validates gcp_cluster_name' do
-      let(:cluster) { build(:gcp_cluster, gcp_cluster_name: gcp_cluster_name) }
-
-      context 'when valid' do
-        let(:gcp_cluster_name) { 'test-cluster' }
-
-        it { is_expected.to be_truthy }
-      end
-
-      context 'when empty' do
-        let(:gcp_cluster_name) { '' }
-
-        it { is_expected.to be_falsey }
-      end
-
-      context 'when too long' do
-        let(:gcp_cluster_name) { 'A' * 64 }
-
-        it { is_expected.to be_falsey }
-      end
-
-      context 'when includes abnormal character' do
-        let(:gcp_cluster_name) { '!!!!!!' }
-
-        it { is_expected.to be_falsey }
-      end
-    end
-
-    context 'when validates gcp_cluster_size' do
-      let(:cluster) { build(:gcp_cluster, gcp_cluster_size: gcp_cluster_size) }
-
-      context 'when valid' do
-        let(:gcp_cluster_size) { 1 }
-
-        it { is_expected.to be_truthy }
-      end
-
-      context 'when zero' do
-        let(:gcp_cluster_size) { 0 }
-
-        it { is_expected.to be_falsey }
-      end
-    end
-
-    context 'when validates project_namespace' do
-      let(:cluster) { build(:gcp_cluster, project_namespace: project_namespace) }
-
-      context 'when valid' do
-        let(:project_namespace) { 'default-namespace' }
-
-        it { is_expected.to be_truthy }
-      end
-
-      context 'when empty' do
-        let(:project_namespace) { '' }
-
-        it { is_expected.to be_truthy }
-      end
-
-      context 'when too long' do
-        let(:project_namespace) { 'A' * 64 }
-
-        it { is_expected.to be_falsey }
-      end
-
-      context 'when includes abnormal character' do
-        let(:project_namespace) { '!!!!!!' }
-
-        it { is_expected.to be_falsey }
-      end
-    end
-
-    context 'when validates restrict_modification' do
-      let(:cluster) { create(:gcp_cluster) }
-
-      before do
-        cluster.make_creating!
-      end
-
-      context 'when created' do
-        before do
-          cluster.make_created!
-        end
-
-        it { is_expected.to be_truthy }
-      end
-
-      context 'when creating' do
-        it { is_expected.to be_falsey }
-      end
-    end
-  end
-
-  describe '#state_machine' do
-    let(:cluster) { build(:gcp_cluster) }
-
-    context 'when transits to created state' do
-      before do
-        cluster.gcp_token = 'tmp'
-        cluster.gcp_operation_id = 'tmp'
-        cluster.make_created!
-      end
-
-      it 'nullify gcp_token and gcp_operation_id' do
-        expect(cluster.gcp_token).to be_nil
-        expect(cluster.gcp_operation_id).to be_nil
-        expect(cluster).to be_created
-      end
-    end
-
-    context 'when transits to errored state' do
-      let(:reason) { 'something wrong' }
-
-      before do
-        cluster.make_errored!(reason)
-      end
-
-      it 'sets status_reason' do
-        expect(cluster.status_reason).to eq(reason)
-        expect(cluster).to be_errored
-      end
-    end
-  end
-
-  describe '#project_namespace_placeholder' do
-    subject { cluster.project_namespace_placeholder }
-
-    let(:cluster) { create(:gcp_cluster) }
-
-    it 'returns a placeholder' do
-      is_expected.to eq("#{cluster.project.path}-#{cluster.project.id}")
-    end
-  end
-
-  describe '#on_creation?' do
-    subject { cluster.on_creation? }
-
-    let(:cluster) { create(:gcp_cluster) }
-
-    context 'when status is creating' do
-      before do
-        cluster.make_creating!
-      end
-
-      it { is_expected.to be_truthy }
-    end
-
-    context 'when status is created' do
-      before do
-        cluster.make_created!
-      end
-
-      it { is_expected.to be_falsey }
-    end
-  end
-
-  describe '#api_url' do
-    subject { cluster.api_url }
-
-    let(:cluster) { create(:gcp_cluster, :created_on_gke) }
-    let(:api_url) { 'https://' + cluster.endpoint }
-
-    it { is_expected.to eq(api_url) }
-  end
-
-  describe '#restrict_modification' do
-    subject { cluster.restrict_modification }
-
-    let(:cluster) { create(:gcp_cluster) }
-
-    context 'when status is created' do
-      before do
-        cluster.make_created!
-      end
-
-      it { is_expected.to be_truthy }
-    end
-
-    context 'when status is creating' do
-      before do
-        cluster.make_creating!
-      end
-
-      it { is_expected.to be_falsey }
-
-      it 'sets error' do
-        is_expected.to be_falsey
-        expect(cluster.errors).not_to be_empty
-      end
-    end
-  end
-end
diff --git a/spec/models/group_custom_attribute_spec.rb b/spec/models/group_custom_attribute_spec.rb
new file mode 100644
index 00000000000..7ecb2022567
--- /dev/null
+++ b/spec/models/group_custom_attribute_spec.rb
@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe GroupCustomAttribute do
+  describe 'assocations' do
+    it { is_expected.to belong_to(:group) }
+  end
+
+  describe 'validations' do
+    subject { build :group_custom_attribute }
+
+    it { is_expected.to validate_presence_of(:group) }
+    it { is_expected.to validate_presence_of(:key) }
+    it { is_expected.to validate_presence_of(:value) }
+    it { is_expected.to validate_uniqueness_of(:key).scoped_to(:group_id) }
+  end
+end
diff --git a/spec/models/group_spec.rb b/spec/models/group_spec.rb
index 0e1a7fdce0b..5e82a2988ce 100644
--- a/spec/models/group_spec.rb
+++ b/spec/models/group_spec.rb
@@ -17,6 +17,7 @@ describe Group do
     it { is_expected.to have_many(:variables).class_name('Ci::GroupVariable') }
     it { is_expected.to have_many(:uploads).dependent(:destroy) }
     it { is_expected.to have_one(:chat_team) }
+    it { is_expected.to have_many(:custom_attributes).class_name('GroupCustomAttribute') }
 
     describe '#members & #requesters' do
       let(:requester) { create(:user) }
@@ -64,12 +65,6 @@ describe Group do
 
         expect(group).not_to be_valid
       end
-
-      it 'rejects reserved group paths' do
-        group = build(:group, path: 'activity', parent: create(:group))
-
-        expect(group).not_to be_valid
-      end
     end
 
     describe '#visibility_level_allowed_by_parent' do
@@ -252,8 +247,6 @@ describe Group do
   describe '#avatar_url' do
     let!(:group) { create(:group, :access_requestable, :with_avatar) }
     let(:user) { create(:user) }
-    let(:gitlab_host) { "http://#{Gitlab.config.gitlab.host}" }
-    let(:avatar_path) { "/uploads/-/system/group/avatar/#{group.id}/dk.png" }
 
     context 'when avatar file is uploaded' do
       before do
@@ -261,12 +254,8 @@ describe Group do
       end
 
       it 'shows correct avatar url' do
-        expect(group.avatar_url).to eq(avatar_path)
-        expect(group.avatar_url(only_path: false)).to eq([gitlab_host, avatar_path].join)
-
-        allow(ActionController::Base).to receive(:asset_host).and_return(gitlab_host)
-
-        expect(group.avatar_url).to eq([gitlab_host, avatar_path].join)
+        expect(group.avatar_url).to eq(group.avatar.url)
+        expect(group.avatar_url(only_path: false)).to eq([Gitlab.config.gitlab.url, group.avatar.url].join)
       end
     end
   end
diff --git a/spec/models/issue_spec.rb b/spec/models/issue_spec.rb
index bb5033c1628..5f901262598 100644
--- a/spec/models/issue_spec.rb
+++ b/spec/models/issue_spec.rb
@@ -765,22 +765,4 @@ describe Issue do
       expect(described_class.public_only).to eq([public_issue])
     end
   end
-
-  describe '#update_project_counter_caches?' do
-    it 'returns true when the state changes' do
-      subject.state = 'closed'
-
-      expect(subject.update_project_counter_caches?).to eq(true)
-    end
-
-    it 'returns true when the confidential flag changes' do
-      subject.confidential = true
-
-      expect(subject.update_project_counter_caches?).to eq(true)
-    end
-
-    it 'returns false when the state or confidential flag did not change' do
-      expect(subject.update_project_counter_caches?).to eq(false)
-    end
-  end
 end
diff --git a/spec/models/key_spec.rb b/spec/models/key_spec.rb
index 81c2057e175..4cd9e3f4f1d 100644
--- a/spec/models/key_spec.rb
+++ b/spec/models/key_spec.rb
@@ -166,4 +166,27 @@ describe Key, :mailer do
       expect(key.public_key.key_text).to eq(valid_key)
     end
   end
+
+  describe '#refresh_user_cache', :use_clean_rails_memory_store_caching do
+    context 'when the key belongs to a user' do
+      it 'refreshes the keys count cache for the user' do
+        expect_any_instance_of(Users::KeysCountService)
+          .to receive(:refresh_cache)
+          .and_call_original
+
+        key = create(:personal_key)
+
+        expect(Users::KeysCountService.new(key.user).count).to eq(1)
+      end
+    end
+
+    context 'when the key does not belong to a user' do
+      it 'does nothing' do
+        expect_any_instance_of(Users::KeysCountService)
+          .not_to receive(:refresh_cache)
+
+        create(:key)
+      end
+    end
+  end
 end
diff --git a/spec/models/merge_request_spec.rb b/spec/models/merge_request_spec.rb
index 476a2697605..d250ad50713 100644
--- a/spec/models/merge_request_spec.rb
+++ b/spec/models/merge_request_spec.rb
@@ -1755,39 +1755,12 @@ describe MergeRequest do
     end
   end
 
-  describe '#fetch_ref' do
-    it 'sets "ref_fetched" flag to true' do
-      subject.update!(ref_fetched: nil)
+  describe '#fetch_ref!' do
+    it 'fetches the ref correctly' do
+      expect { subject.target_project.repository.delete_refs(subject.ref_path) }.not_to raise_error
 
-      subject.fetch_ref
-
-      expect(subject.reload.ref_fetched).to be_truthy
-    end
-  end
-
-  describe '#ref_fetched?' do
-    it 'does not perform git operation when value is cached' do
-      subject.ref_fetched = true
-
-      expect_any_instance_of(Repository).not_to receive(:ref_exists?)
-      expect(subject.ref_fetched?).to be_truthy
-    end
-
-    it 'caches the value when ref exists but value is not cached' do
-      subject.update!(ref_fetched: nil)
-      allow_any_instance_of(Repository).to receive(:ref_exists?)
-        .and_return(true)
-
-      expect(subject.ref_fetched?).to be_truthy
-      expect(subject.reload.ref_fetched).to be_truthy
-    end
-
-    it 'returns false when ref does not exist' do
-      subject.update!(ref_fetched: nil)
-      allow_any_instance_of(Repository).to receive(:ref_exists?)
-        .and_return(false)
-
-      expect(subject.ref_fetched?).to be_falsey
+      subject.fetch_ref!
+      expect(subject.target_project.repository.ref_exists?(subject.ref_path)).to be_truthy
     end
   end
 
@@ -1799,16 +1772,4 @@ describe MergeRequest do
         .to change { project.open_merge_requests_count }.from(1).to(0)
     end
   end
-
-  describe '#update_project_counter_caches?' do
-    it 'returns true when the state changes' do
-      subject.state = 'closed'
-
-      expect(subject.update_project_counter_caches?).to eq(true)
-    end
-
-    it 'returns false when the state did not change' do
-      expect(subject.update_project_counter_caches?).to eq(false)
-    end
-  end
 end
diff --git a/spec/models/project_custom_attribute_spec.rb b/spec/models/project_custom_attribute_spec.rb
new file mode 100644
index 00000000000..669de5506bc
--- /dev/null
+++ b/spec/models/project_custom_attribute_spec.rb
@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe ProjectCustomAttribute do
+  describe 'assocations' do
+    it { is_expected.to belong_to(:project) }
+  end
+
+  describe 'validations' do
+    subject { build :project_custom_attribute }
+
+    it { is_expected.to validate_presence_of(:project) }
+    it { is_expected.to validate_presence_of(:key) }
+    it { is_expected.to validate_presence_of(:value) }
+    it { is_expected.to validate_uniqueness_of(:key).scoped_to(:project_id) }
+  end
+end
diff --git a/spec/models/project_services/chat_message/issue_message_spec.rb b/spec/models/project_services/chat_message/issue_message_spec.rb
index d37726dc3f1..f7a35fdc88a 100644
--- a/spec/models/project_services/chat_message/issue_message_spec.rb
+++ b/spec/models/project_services/chat_message/issue_message_spec.rb
@@ -66,6 +66,19 @@ describe ChatMessage::IssueMessage do
         expect(subject.attachments).to be_empty
       end
     end
+
+    context 'reopen' do
+      before do
+        args[:object_attributes][:action] = 'reopen'
+        args[:object_attributes][:state] = 'opened'
+      end
+
+      it 'returns a message regarding reopening of issues' do
+        expect(subject.pretext)
+          .to eq('[<http://somewhere.com|project_name>] Issue <http://url.com|#100 Issue title> opened by Test User (test.user)')
+        expect(subject.attachments).to be_empty
+      end
+    end
   end
 
   context 'with markdown' do
diff --git a/spec/models/project_services/kubernetes_service_spec.rb b/spec/models/project_services/kubernetes_service_spec.rb
index 00de536a18b..1c629155e1e 100644
--- a/spec/models/project_services/kubernetes_service_spec.rb
+++ b/spec/models/project_services/kubernetes_service_spec.rb
@@ -7,7 +7,7 @@ describe KubernetesService, :use_clean_rails_memory_store_caching do
   let(:project) { build_stubbed(:kubernetes_project) }
   let(:service) { project.kubernetes_service }
 
-  describe "Associations" do
+  describe 'Associations' do
     it { is_expected.to belong_to :project }
   end
 
@@ -145,7 +145,7 @@ describe KubernetesService, :use_clean_rails_memory_store_caching do
     let(:discovery_url) { 'https://kubernetes.example.com/api/v1' }
 
     before do
-      stub_kubeclient_discover
+      stub_kubeclient_discover(service.api_url)
     end
 
     context 'with path prefix in api_url' do
@@ -153,7 +153,7 @@ describe KubernetesService, :use_clean_rails_memory_store_caching do
 
       it 'tests with the prefix' do
         service.api_url = 'https://kubernetes.example.com/prefix'
-        stub_kubeclient_discover
+        stub_kubeclient_discover(service.api_url)
 
         expect(service.test[:success]).to be_truthy
         expect(WebMock).to have_requested(:get, discovery_url).once
diff --git a/spec/models/project_spec.rb b/spec/models/project_spec.rb
index e8588975118..f7f19d464d1 100644
--- a/spec/models/project_spec.rb
+++ b/spec/models/project_spec.rb
@@ -79,6 +79,7 @@ describe Project do
     it { is_expected.to have_many(:pipeline_schedules) }
     it { is_expected.to have_many(:members_and_requesters) }
     it { is_expected.to have_one(:cluster) }
+    it { is_expected.to have_many(:custom_attributes).class_name('ProjectCustomAttribute') }
 
     context 'after initialized' do
       it "has a project_feature" do
@@ -276,6 +277,12 @@ describe Project do
 
         expect(project).to be_valid
       end
+
+      it 'allows a path ending in a period' do
+        project = build(:project, path: 'foo.')
+
+        expect(project).to be_valid
+      end
     end
   end
 
@@ -876,20 +883,14 @@ describe Project do
 
     context 'when avatar file is uploaded' do
       let(:project) { create(:project, :public, :with_avatar) }
-      let(:avatar_path) { "/uploads/-/system/project/avatar/#{project.id}/dk.png" }
-      let(:gitlab_host) { "http://#{Gitlab.config.gitlab.host}" }
 
       it 'shows correct url' do
-        expect(project.avatar_url).to eq(avatar_path)
-        expect(project.avatar_url(only_path: false)).to eq([gitlab_host, avatar_path].join)
-
-        allow(ActionController::Base).to receive(:asset_host).and_return(gitlab_host)
-
-        expect(project.avatar_url).to eq([gitlab_host, avatar_path].join)
+        expect(project.avatar_url).to eq(project.avatar.url)
+        expect(project.avatar_url(only_path: false)).to eq([Gitlab.config.gitlab.url, project.avatar.url].join)
       end
     end
 
-    context 'When avatar file in git' do
+    context 'when avatar file in git' do
       before do
         allow(project).to receive(:avatar_in_git) { true }
       end
@@ -1937,6 +1938,24 @@ describe Project do
         expect(second_fork.fork_source).to eq(project)
       end
     end
+
+    describe '#lfs_storage_project' do
+      it 'returns self for non-forks' do
+        expect(project.lfs_storage_project).to eq project
+      end
+
+      it 'returns the fork network root for forks' do
+        second_fork = fork_project(forked_project)
+
+        expect(second_fork.lfs_storage_project).to eq project
+      end
+
+      it 'returns self when fork_source is nil' do
+        expect(forked_project).to receive(:fork_source).and_return(nil)
+
+        expect(forked_project.lfs_storage_project).to eq forked_project
+      end
+    end
   end
 
   describe '#pushes_since_gc' do
@@ -3009,4 +3028,77 @@ describe Project do
       end
     end
   end
+
+  describe '#after_import' do
+    let(:project) { build(:project) }
+
+    it 'runs the correct hooks' do
+      expect(project.repository).to receive(:after_import)
+      expect(project).to receive(:import_finish)
+      expect(project).to receive(:update_project_counter_caches)
+      expect(project).to receive(:remove_import_jid)
+
+      project.after_import
+    end
+  end
+
+  describe '#update_project_counter_caches' do
+    let(:project) { create(:project) }
+
+    it 'updates all project counter caches' do
+      expect_any_instance_of(Projects::OpenIssuesCountService)
+        .to receive(:refresh_cache)
+        .and_call_original
+
+      expect_any_instance_of(Projects::OpenMergeRequestsCountService)
+        .to receive(:refresh_cache)
+        .and_call_original
+
+      project.update_project_counter_caches
+    end
+  end
+
+  describe '#remove_import_jid', :clean_gitlab_redis_cache do
+    let(:project) {  }
+
+    context 'without an import JID' do
+      it 'does nothing' do
+        project = create(:project)
+
+        expect(Gitlab::SidekiqStatus)
+          .not_to receive(:unset)
+
+        project.remove_import_jid
+      end
+    end
+
+    context 'with an import JID' do
+      it 'unsets the import JID' do
+        project = create(:project, import_jid: '123')
+
+        expect(Gitlab::SidekiqStatus)
+          .to receive(:unset)
+          .with('123')
+          .and_call_original
+
+        project.remove_import_jid
+
+        expect(project.import_jid).to be_nil
+      end
+    end
+  end
+
+  describe '#wiki_repository_exists?' do
+    it 'returns true when the wiki repository exists' do
+      project = create(:project, :wiki_repo)
+
+      expect(project.wiki_repository_exists?).to eq(true)
+    end
+
+    it 'returns false when the wiki repository does not exist' do
+      project = create(:project)
+
+      expect(project.wiki_repository_exists?).to eq(false)
+    end
+  end
 end
diff --git a/spec/models/project_wiki_spec.rb b/spec/models/project_wiki_spec.rb
index 3d46434fc27..929086305ba 100644
--- a/spec/models/project_wiki_spec.rb
+++ b/spec/models/project_wiki_spec.rb
@@ -10,6 +10,10 @@ describe ProjectWiki do
 
   subject { project_wiki }
 
+  it { is_expected.to delegate_method(:empty?).to :pages }
+  it { is_expected.to delegate_method(:repository_storage_path).to :project }
+  it { is_expected.to delegate_method(:hashed_storage?).to :project }
+
   describe "#path_with_namespace" do
     it "returns the project path with namespace with the .wiki extension" do
       expect(subject.path_with_namespace).to eq(project.full_path + '.wiki')
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index e0896d64c8f..86647ddf6ce 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -642,16 +642,40 @@ describe User do
   end
 
   describe 'groups' do
+    let(:user) { create(:user) }
+    let(:group) { create(:group) }
+
     before do
-      @user = create :user
-      @group = create :group
-      @group.add_owner(@user)
+      group.add_owner(user)
     end
 
-    it { expect(@user.several_namespaces?).to be_truthy }
-    it { expect(@user.authorized_groups).to eq([@group]) }
-    it { expect(@user.owned_groups).to eq([@group]) }
-    it { expect(@user.namespaces).to match_array([@user.namespace, @group]) }
+    it { expect(user.several_namespaces?).to be_truthy }
+    it { expect(user.authorized_groups).to eq([group]) }
+    it { expect(user.owned_groups).to eq([group]) }
+    it { expect(user.namespaces).to contain_exactly(user.namespace, group) }
+    it { expect(user.manageable_namespaces).to contain_exactly(user.namespace, group) }
+
+    context 'with child groups', :nested_groups do
+      let!(:subgroup) { create(:group, parent: group) }
+
+      describe '#manageable_namespaces' do
+        it 'includes all the namespaces the user can manage' do
+          expect(user.manageable_namespaces).to contain_exactly(user.namespace, group, subgroup)
+        end
+      end
+
+      describe '#manageable_groups' do
+        it 'includes all the namespaces the user can manage' do
+          expect(user.manageable_groups).to contain_exactly(group, subgroup)
+        end
+
+        it 'does not include duplicates if a membership was added for the subgroup' do
+          subgroup.add_owner(user)
+
+          expect(user.manageable_groups).to contain_exactly(group, subgroup)
+        end
+      end
+    end
   end
 
   describe 'group multiple owners' do
@@ -788,21 +812,23 @@ describe User do
       end
 
       it "creates external user by default" do
-        user = build(:user)
+        user = create(:user)
 
         expect(user.external).to be_truthy
+        expect(user.can_create_group).to be_falsey
+        expect(user.projects_limit).to be 0
       end
 
       describe 'with default overrides' do
         it "creates a non-external user" do
-          user = build(:user, external: false)
+          user = create(:user, external: false)
 
           expect(user.external).to be_falsey
         end
       end
     end
 
-    describe '#require_ssh_key?' do
+    describe '#require_ssh_key?', :use_clean_rails_memory_store_caching do
       protocol_and_expectation = {
         'http' => false,
         'ssh' => true,
@@ -817,6 +843,12 @@ describe User do
           expect(user.require_ssh_key?).to eq(expected)
         end
       end
+
+      it 'returns false when the user has 1 or more SSH keys' do
+        key = create(:personal_key)
+
+        expect(key.user.require_ssh_key?).to eq(false)
+      end
     end
   end
 
@@ -839,6 +871,19 @@ describe User do
     end
   end
 
+  describe '.by_any_email' do
+    it 'returns an ActiveRecord::Relation' do
+      expect(described_class.by_any_email('foo@example.com'))
+        .to be_a_kind_of(ActiveRecord::Relation)
+    end
+
+    it 'returns a relation of users' do
+      user = create(:user)
+
+      expect(described_class.by_any_email(user.email)).to eq([user])
+    end
+  end
+
   describe '.search' do
     let!(:user) { create(:user, name: 'user', username: 'usern', email: 'email@gmail.com') }
     let!(:user2) { create(:user, name: 'user name', username: 'username', email: 'someemail@gmail.com') }
@@ -1134,16 +1179,9 @@ describe User do
     let(:user) { create(:user, :with_avatar) }
 
     context 'when avatar file is uploaded' do
-      let(:gitlab_host) { "http://#{Gitlab.config.gitlab.host}" }
-      let(:avatar_path) { "/uploads/-/system/user/avatar/#{user.id}/dk.png" }
-
       it 'shows correct avatar url' do
-        expect(user.avatar_url).to eq(avatar_path)
-        expect(user.avatar_url(only_path: false)).to eq([gitlab_host, avatar_path].join)
-
-        allow(ActionController::Base).to receive(:asset_host).and_return(gitlab_host)
-
-        expect(user.avatar_url).to eq([gitlab_host, avatar_path].join)
+        expect(user.avatar_url).to eq(user.avatar.url)
+        expect(user.avatar_url(only_path: false)).to eq([Gitlab.config.gitlab.url, user.avatar.url].join)
       end
     end
   end
diff --git a/spec/policies/ci/build_policy_spec.rb b/spec/policies/ci/build_policy_spec.rb
index 8e1bc3d1543..298a9d16425 100644
--- a/spec/policies/ci/build_policy_spec.rb
+++ b/spec/policies/ci/build_policy_spec.rb
@@ -150,5 +150,82 @@ describe Ci::BuildPolicy do
         end
       end
     end
+
+    describe 'rules for erase build' do
+      let(:project) { create(:project, :repository) }
+      let(:build) { create(:ci_build, pipeline: pipeline, ref: 'some-ref', user: owner) }
+
+      context 'when a developer erases a build' do
+        before do
+          project.add_developer(user)
+        end
+
+        context 'when developers can push to the branch' do
+          before do
+            create(:protected_branch, :developers_can_push,
+                   name: build.ref, project: project)
+          end
+
+          context 'when the build was created by the developer' do
+            let(:owner) { user }
+
+            it { expect(policy).to be_allowed :erase_build }
+          end
+
+          context 'when the build was created by the other' do
+            let(:owner) { create(:user) }
+
+            it { expect(policy).to be_disallowed :erase_build }
+          end
+        end
+
+        context 'when no one can push or merge to the branch' do
+          let(:owner) { user }
+
+          before do
+            create(:protected_branch, :no_one_can_push, :no_one_can_merge,
+                   name: build.ref, project: project)
+          end
+
+          it { expect(policy).to be_disallowed :erase_build }
+        end
+      end
+
+      context 'when a master erases a build' do
+        before do
+          project.add_master(user)
+        end
+
+        context 'when masters can push to the branch' do
+          before do
+            create(:protected_branch, :masters_can_push,
+                   name: build.ref, project: project)
+          end
+
+          context 'when the build was created by the master' do
+            let(:owner) { user }
+
+            it { expect(policy).to be_allowed :erase_build }
+          end
+
+          context 'when the build was created by the other' do
+            let(:owner) { create(:user) }
+
+            it { expect(policy).to be_allowed :erase_build }
+          end
+        end
+
+        context 'when no one can push or merge to the branch' do
+          let(:owner) { user }
+
+          before do
+            create(:protected_branch, :no_one_can_push, :no_one_can_merge,
+                   name: build.ref, project: project)
+          end
+
+          it { expect(policy).to be_disallowed :erase_build }
+        end
+      end
+    end
   end
 end
diff --git a/spec/policies/gcp/cluster_policy_spec.rb b/spec/policies/clusters/cluster_policy_spec.rb
index e213aa3d557..4207f42b07f 100644
--- a/spec/policies/gcp/cluster_policy_spec.rb
+++ b/spec/policies/clusters/cluster_policy_spec.rb
@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Gcp::ClusterPolicy, :models do
-  set(:project) { create(:project) }
-  set(:cluster) { create(:gcp_cluster, project: project) }
+describe Clusters::ClusterPolicy, :models do
+  let(:cluster) { create(:cluster, :project) }
+  let(:project) { cluster.project }
   let(:user) { create(:user) }
   let(:policy) { described_class.new(user, cluster) }
 
diff --git a/spec/presenters/gcp/cluster_presenter_spec.rb b/spec/presenters/clusters/cluster_presenter_spec.rb
index 8d86dc31582..48d4f3671c5 100644
--- a/spec/presenters/gcp/cluster_presenter_spec.rb
+++ b/spec/presenters/clusters/cluster_presenter_spec.rb
@@ -1,8 +1,7 @@
 require 'spec_helper'
 
-describe Gcp::ClusterPresenter do
-  let(:project) { create(:project) }
-  let(:cluster) { create(:gcp_cluster, project: project) }
+describe Clusters::ClusterPresenter do
+  let(:cluster) { create(:cluster, :provided_by_gcp) }
 
   subject(:presenter) do
     described_class.new(cluster)
@@ -22,14 +21,14 @@ describe Gcp::ClusterPresenter do
     end
 
     it 'forwards missing methods to cluster' do
-      expect(presenter.gcp_cluster_zone).to eq(cluster.gcp_cluster_zone)
+      expect(presenter.status).to eq(cluster.status)
     end
   end
 
   describe '#gke_cluster_url' do
     subject { described_class.new(cluster).gke_cluster_url }
 
-    it { is_expected.to include(cluster.gcp_cluster_zone) }
-    it { is_expected.to include(cluster.gcp_cluster_name) }
+    it { is_expected.to include(cluster.provider.zone) }
+    it { is_expected.to include(cluster.name) }
   end
 end
diff --git a/spec/requests/api/groups_spec.rb b/spec/requests/api/groups_spec.rb
index 8ce9fcc80bf..04a658cd6c3 100644
--- a/spec/requests/api/groups_spec.rb
+++ b/spec/requests/api/groups_spec.rb
@@ -427,6 +427,142 @@ describe API::Groups do
     end
   end
 
+  describe 'GET /groups/:id/subgroups', :nested_groups do
+    let!(:subgroup1) { create(:group, parent: group1) }
+    let!(:subgroup2) { create(:group, :private, parent: group1) }
+    let!(:subgroup3) { create(:group, :private, parent: group2) }
+
+    context 'when unauthenticated' do
+      it 'returns only public subgroups' do
+        get api("/groups/#{group1.id}/subgroups")
+
+        expect(response).to have_gitlab_http_status(200)
+        expect(response).to include_pagination_headers
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(1)
+        expect(json_response.first['id']).to eq(subgroup1.id)
+        expect(json_response.first['parent_id']).to eq(group1.id)
+      end
+
+      it 'returns 404 for a private group' do
+        get api("/groups/#{group2.id}/subgroups")
+
+        expect(response).to have_gitlab_http_status(404)
+      end
+    end
+
+    context 'when authenticated as user' do
+      context 'when user is not member of a public group' do
+        it 'returns no subgroups for the public group' do
+          get api("/groups/#{group1.id}/subgroups", user2)
+
+          expect(response).to have_gitlab_http_status(200)
+          expect(json_response).to be_an Array
+          expect(json_response.length).to eq(0)
+        end
+
+        context 'when using all_available in request' do
+          it 'returns public subgroups' do
+            get api("/groups/#{group1.id}/subgroups", user2), all_available: true
+
+            expect(response).to have_gitlab_http_status(200)
+            expect(json_response).to be_an Array
+            expect(json_response.length).to eq(1)
+            expect(json_response[0]['id']).to eq(subgroup1.id)
+            expect(json_response[0]['parent_id']).to eq(group1.id)
+          end
+        end
+      end
+
+      context 'when user is not member of a private group' do
+        it 'returns 404 for the private group' do
+          get api("/groups/#{group2.id}/subgroups", user1)
+
+          expect(response).to have_gitlab_http_status(404)
+        end
+      end
+
+      context 'when user is member of public group' do
+        before do
+          group1.add_guest(user2)
+        end
+
+        it 'returns private subgroups' do
+          get api("/groups/#{group1.id}/subgroups", user2)
+
+          expect(response).to have_gitlab_http_status(200)
+          expect(response).to include_pagination_headers
+          expect(json_response).to be_an Array
+          expect(json_response.length).to eq(2)
+          private_subgroups = json_response.select { |group| group['visibility'] == 'private' }
+          expect(private_subgroups.length).to eq(1)
+          expect(private_subgroups.first['id']).to eq(subgroup2.id)
+          expect(private_subgroups.first['parent_id']).to eq(group1.id)
+        end
+
+        context 'when using statistics in request' do
+          it 'does not include statistics' do
+            get api("/groups/#{group1.id}/subgroups", user2), statistics: true
+
+            expect(response).to have_gitlab_http_status(200)
+            expect(json_response).to be_an Array
+            expect(json_response.first).not_to include 'statistics'
+          end
+        end
+      end
+
+      context 'when user is member of private group' do
+        before do
+          group2.add_guest(user1)
+        end
+
+        it 'returns subgroups' do
+          get api("/groups/#{group2.id}/subgroups", user1)
+
+          expect(response).to have_gitlab_http_status(200)
+          expect(json_response).to be_an Array
+          expect(json_response.length).to eq(1)
+          expect(json_response.first['id']).to eq(subgroup3.id)
+          expect(json_response.first['parent_id']).to eq(group2.id)
+        end
+      end
+    end
+
+    context 'when authenticated as admin' do
+      it 'returns private subgroups of a public group' do
+        get api("/groups/#{group1.id}/subgroups", admin)
+
+        expect(response).to have_gitlab_http_status(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(2)
+      end
+
+      it 'returns subgroups of a private group' do
+        get api("/groups/#{group2.id}/subgroups", admin)
+
+        expect(response).to have_gitlab_http_status(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(1)
+      end
+
+      it 'does not include statistics by default' do
+        get api("/groups/#{group1.id}/subgroups", admin)
+
+        expect(response).to have_gitlab_http_status(200)
+        expect(json_response).to be_an Array
+        expect(json_response.first).not_to include('statistics')
+      end
+
+      it 'includes statistics if requested' do
+        get api("/groups/#{group1.id}/subgroups", admin), statistics: true
+
+        expect(response).to have_gitlab_http_status(200)
+        expect(json_response).to be_an Array
+        expect(json_response.first).to include('statistics')
+      end
+    end
+  end
+
   describe "POST /groups" do
     context "when authenticated as user without group permissions" do
       it "does not create group" do
@@ -618,4 +754,14 @@ describe API::Groups do
       end
     end
   end
+
+  it_behaves_like 'custom attributes endpoints', 'groups' do
+    let(:attributable) { group1 }
+    let(:other_attributable) { group2 }
+    let(:user) { user1 }
+
+    before do
+      group2.add_owner(user1)
+    end
+  end
 end
diff --git a/spec/requests/api/internal_spec.rb b/spec/requests/api/internal_spec.rb
index d919899282d..34ecdd1e164 100644
--- a/spec/requests/api/internal_spec.rb
+++ b/spec/requests/api/internal_spec.rb
@@ -203,18 +203,44 @@ describe API::Internal do
       end
 
       context 'with env passed as a JSON' do
-        it 'sets env in RequestStore' do
-          expect(Gitlab::Git::Env).to receive(:set).with({
-            'GIT_OBJECT_DIRECTORY' => 'foo',
-            'GIT_ALTERNATE_OBJECT_DIRECTORIES' => 'bar'
-          })
+        context 'when relative path envs are not set' do
+          it 'sets env in RequestStore' do
+            expect(Gitlab::Git::Env).to receive(:set).with({
+              'GIT_OBJECT_DIRECTORY' => 'foo',
+              'GIT_ALTERNATE_OBJECT_DIRECTORIES' => 'bar'
+            })
+
+            push(key, project.wiki, env: {
+              GIT_OBJECT_DIRECTORY: 'foo',
+              GIT_ALTERNATE_OBJECT_DIRECTORIES: 'bar'
+            }.to_json)
 
-          push(key, project.wiki, env: {
-            GIT_OBJECT_DIRECTORY: 'foo',
-            GIT_ALTERNATE_OBJECT_DIRECTORIES: 'bar'
-          }.to_json)
+            expect(response).to have_gitlab_http_status(200)
+          end
+        end
 
-          expect(response).to have_gitlab_http_status(200)
+        context 'when relative path envs are set' do
+          it 'sets env in RequestStore' do
+            obj_dir_relative = './objects'
+            alt_obj_dirs_relative = ['./alt-objects-1', './alt-objects-2']
+            repo_path = project.wiki.repository.path_to_repo
+
+            expect(Gitlab::Git::Env).to receive(:set).with({
+              'GIT_OBJECT_DIRECTORY' => File.join(repo_path, obj_dir_relative),
+              'GIT_ALTERNATE_OBJECT_DIRECTORIES' => alt_obj_dirs_relative.map { |d| File.join(repo_path, d) },
+              'GIT_OBJECT_DIRECTORY_RELATIVE' => obj_dir_relative,
+              'GIT_ALTERNATE_OBJECT_DIRECTORIES_RELATIVE' => alt_obj_dirs_relative
+            })
+
+            push(key, project.wiki, env: {
+              GIT_OBJECT_DIRECTORY: 'foo',
+              GIT_ALTERNATE_OBJECT_DIRECTORIES: 'bar',
+              GIT_OBJECT_DIRECTORY_RELATIVE: obj_dir_relative,
+              GIT_ALTERNATE_OBJECT_DIRECTORIES_RELATIVE: alt_obj_dirs_relative
+            }.to_json)
+
+            expect(response).to have_gitlab_http_status(200)
+          end
         end
       end
 
diff --git a/spec/requests/api/jobs_spec.rb b/spec/requests/api/jobs_spec.rb
index 1765907c1b4..2a83213e87a 100644
--- a/spec/requests/api/jobs_spec.rb
+++ b/spec/requests/api/jobs_spec.rb
@@ -500,7 +500,11 @@ describe API::Jobs do
   end
 
   describe 'POST /projects/:id/jobs/:job_id/erase' do
+    let(:role) { :master }
+
     before do
+      project.team << [user, role]
+
       post api("/projects/#{project.id}/jobs/#{job.id}/erase", user)
     end
 
@@ -529,6 +533,23 @@ describe API::Jobs do
         expect(response).to have_gitlab_http_status(403)
       end
     end
+
+    context 'when a developer erases a build' do
+      let(:role) { :developer }
+      let(:job) { create(:ci_build, :trace, :artifacts, :success, project: project, pipeline: pipeline, user: owner) }
+
+      context 'when the build was created by the developer' do
+        let(:owner) { user }
+
+        it { expect(response).to have_gitlab_http_status(201) }
+      end
+
+      context 'when the build was created by the other' do
+        let(:owner) { create(:user) }
+
+        it { expect(response).to have_gitlab_http_status(403) }
+      end
+    end
   end
 
   describe 'POST /projects/:id/jobs/:job_id/artifacts/keep' do
diff --git a/spec/requests/api/merge_requests_spec.rb b/spec/requests/api/merge_requests_spec.rb
index 024cfe8b372..a928ba79a4d 100644
--- a/spec/requests/api/merge_requests_spec.rb
+++ b/spec/requests/api/merge_requests_spec.rb
@@ -435,17 +435,7 @@ describe API::MergeRequests do
       expect(json_response['merge_status']).to eq('can_be_merged')
       expect(json_response['should_close_merge_request']).to be_falsy
       expect(json_response['force_close_merge_request']).to be_falsy
-    end
-
-    it "returns merge_request" do
-      get api("/projects/#{project.id}/merge_requests/#{merge_request.iid}", user)
-      expect(response).to have_gitlab_http_status(200)
-      expect(json_response['title']).to eq(merge_request.title)
-      expect(json_response['iid']).to eq(merge_request.iid)
-      expect(json_response['work_in_progress']).to eq(false)
-      expect(json_response['merge_status']).to eq('can_be_merged')
-      expect(json_response['should_close_merge_request']).to be_falsy
-      expect(json_response['force_close_merge_request']).to be_falsy
+      expect(json_response['changes_count']).to eq(merge_request.merge_request_diff.real_size)
     end
 
     it "returns a 404 error if merge_request_iid not found" do
@@ -462,12 +452,32 @@ describe API::MergeRequests do
     context 'Work in Progress' do
       let!(:merge_request_wip) { create(:merge_request, author: user, assignee: user, source_project: project, target_project: project, title: "WIP: Test", created_at: base_time + 1.second) }
 
-      it "returns merge_request" do
+      it "returns merge request" do
         get api("/projects/#{project.id}/merge_requests/#{merge_request_wip.iid}", user)
+
         expect(response).to have_gitlab_http_status(200)
         expect(json_response['work_in_progress']).to eq(true)
       end
     end
+
+    context 'when a merge request has more than the changes limit' do
+      it "returns a string indicating that more changes were made" do
+        stub_const('Commit::DIFF_HARD_LIMIT_FILES', 5)
+
+        merge_request_overflow = create(:merge_request, :simple,
+                                        author: user,
+                                        assignee: user,
+                                        source_project: project,
+                                        source_branch: 'expand-collapse-files',
+                                        target_project: project,
+                                        target_branch: 'master')
+
+        get api("/projects/#{project.id}/merge_requests/#{merge_request_overflow.iid}", user)
+
+        expect(response).to have_gitlab_http_status(200)
+        expect(json_response['changes_count']).to eq('5+')
+      end
+    end
   end
 
   describe 'GET /projects/:id/merge_requests/:merge_request_iid/commits' do
@@ -623,8 +633,6 @@ describe API::MergeRequests do
 
       before do
         forked_project.add_reporter(user2)
-
-        allow_any_instance_of(MergeRequest).to receive(:write_ref)
       end
 
       it "returns merge_request" do
diff --git a/spec/requests/api/pages_domains_spec.rb b/spec/requests/api/pages_domains_spec.rb
index d13b3a958c9..d412b045e9f 100644
--- a/spec/requests/api/pages_domains_spec.rb
+++ b/spec/requests/api/pages_domains_spec.rb
@@ -3,6 +3,7 @@ require 'rails_helper'
 describe API::PagesDomains do
   set(:project) { create(:project) }
   set(:user) { create(:user) }
+  set(:admin) { create(:admin) }
 
   set(:pages_domain) { create(:pages_domain, domain: 'www.domain.test', project: project) }
   set(:pages_domain_secure) { create(:pages_domain, :with_certificate, :with_key, domain: 'ssl.domain.test', project: project) }
@@ -23,12 +24,49 @@ describe API::PagesDomains do
     allow(Gitlab.config.pages).to receive(:enabled).and_return(true)
   end
 
+  describe 'GET /pages/domains' do
+    context 'when pages is disabled' do
+      before do
+        allow(Gitlab.config.pages).to receive(:enabled).and_return(false)
+      end
+
+      it_behaves_like '404 response' do
+        let(:request) { get api('/pages/domains', admin) }
+      end
+    end
+
+    context 'when pages is enabled' do
+      context 'when authenticated as an admin' do
+        it 'returns paginated all pages domains' do
+          get api('/pages/domains', admin)
+
+          expect(response).to have_gitlab_http_status(200)
+          expect(response).to match_response_schema('public_api/v4/pages_domain_basics')
+          expect(response).to include_pagination_headers
+          expect(json_response).to be_an Array
+          expect(json_response.size).to eq(3)
+          expect(json_response.last).to have_key('domain')
+          expect(json_response.last).to have_key('certificate_expiration')
+          expect(json_response.last['certificate_expiration']['expired']).to be true
+          expect(json_response.first).not_to have_key('certificate_expiration')
+        end
+      end
+
+      context 'when authenticated as a non-member' do
+        it_behaves_like '403 response' do
+          let(:request) { get api('/pages/domains', user) }
+        end
+      end
+    end
+  end
+
   describe 'GET /projects/:project_id/pages/domains' do
     shared_examples_for 'get pages domains' do
       it 'returns paginated pages domains' do
         get api(route, user)
 
         expect(response).to have_gitlab_http_status(200)
+        expect(response).to match_response_schema('public_api/v4/pages_domains')
         expect(response).to include_pagination_headers
         expect(json_response).to be_an Array
         expect(json_response.size).to eq(3)
@@ -99,6 +137,7 @@ describe API::PagesDomains do
         get api(route_domain, user)
 
         expect(response).to have_gitlab_http_status(200)
+        expect(response).to match_response_schema('public_api/v4/pages_domain/detail')
         expect(json_response['domain']).to eq(pages_domain.domain)
         expect(json_response['url']).to eq(pages_domain.url)
         expect(json_response['certificate']).to be_nil
@@ -108,6 +147,7 @@ describe API::PagesDomains do
         get api(route_secure_domain, user)
 
         expect(response).to have_gitlab_http_status(200)
+        expect(response).to match_response_schema('public_api/v4/pages_domain/detail')
         expect(json_response['domain']).to eq(pages_domain_secure.domain)
         expect(json_response['url']).to eq(pages_domain_secure.url)
         expect(json_response['certificate']['subject']).to eq(pages_domain_secure.subject)
@@ -118,6 +158,7 @@ describe API::PagesDomains do
         get api(route_expired_domain, user)
 
         expect(response).to have_gitlab_http_status(200)
+        expect(response).to match_response_schema('public_api/v4/pages_domain/detail')
         expect(json_response['certificate']['expired']).to be true
       end
     end
@@ -187,6 +228,7 @@ describe API::PagesDomains do
         pages_domain = PagesDomain.find_by(domain: json_response['domain'])
 
         expect(response).to have_gitlab_http_status(201)
+        expect(response).to match_response_schema('public_api/v4/pages_domain/detail')
         expect(pages_domain.domain).to eq(params[:domain])
         expect(pages_domain.certificate).to be_nil
         expect(pages_domain.key).to be_nil
@@ -197,6 +239,7 @@ describe API::PagesDomains do
         pages_domain = PagesDomain.find_by(domain: json_response['domain'])
 
         expect(response).to have_gitlab_http_status(201)
+        expect(response).to match_response_schema('public_api/v4/pages_domain/detail')
         expect(pages_domain.domain).to eq(params_secure[:domain])
         expect(pages_domain.certificate).to eq(params_secure[:certificate])
         expect(pages_domain.key).to eq(params_secure[:key])
@@ -270,6 +313,7 @@ describe API::PagesDomains do
         pages_domain_secure.reload
 
         expect(response).to have_gitlab_http_status(200)
+        expect(response).to match_response_schema('public_api/v4/pages_domain/detail')
         expect(pages_domain_secure.certificate).to be_nil
         expect(pages_domain_secure.key).to be_nil
       end
@@ -279,6 +323,7 @@ describe API::PagesDomains do
         pages_domain.reload
 
         expect(response).to have_gitlab_http_status(200)
+        expect(response).to match_response_schema('public_api/v4/pages_domain/detail')
         expect(pages_domain.certificate).to eq(params_secure[:certificate])
         expect(pages_domain.key).to eq(params_secure[:key])
       end
@@ -288,6 +333,7 @@ describe API::PagesDomains do
         pages_domain_expired.reload
 
         expect(response).to have_gitlab_http_status(200)
+        expect(response).to match_response_schema('public_api/v4/pages_domain/detail')
         expect(pages_domain_expired.certificate).to eq(params_secure[:certificate])
         expect(pages_domain_expired.key).to eq(params_secure[:key])
       end
@@ -297,6 +343,7 @@ describe API::PagesDomains do
         pages_domain_secure.reload
 
         expect(response).to have_gitlab_http_status(200)
+        expect(response).to match_response_schema('public_api/v4/pages_domain/detail')
         expect(pages_domain_secure.certificate).to eq(params_secure_nokey[:certificate])
       end
 
diff --git a/spec/requests/api/projects_spec.rb b/spec/requests/api/projects_spec.rb
index e095ba2af5d..50f6c8b7d64 100644
--- a/spec/requests/api/projects_spec.rb
+++ b/spec/requests/api/projects_spec.rb
@@ -50,6 +50,12 @@ describe API::Projects do
         expect(json_response).to be_an Array
         expect(json_response.map { |p| p['id'] }).to contain_exactly(*projects.map(&:id))
       end
+
+      it 'returns the proper security headers' do
+        get api('/projects', current_user), filter
+
+        expect(response).to include_security_headers
+      end
     end
 
     shared_examples_for 'projects response without N + 1 queries' do
@@ -1856,4 +1862,9 @@ describe API::Projects do
       end
     end
   end
+
+  it_behaves_like 'custom attributes endpoints', 'projects' do
+    let(:attributable) { project }
+    let(:other_attributable) { project2 }
+  end
 end
diff --git a/spec/requests/api/services_spec.rb b/spec/requests/api/services_spec.rb
index dfe48e45d49..ba697e2b305 100644
--- a/spec/requests/api/services_spec.rb
+++ b/spec/requests/api/services_spec.rb
@@ -175,4 +175,25 @@ describe API::Services do
       end
     end
   end
+
+  describe 'Mattermost service' do
+    let(:service_name) { 'mattermost' }
+    let(:params) do
+      { webhook: 'https://hook.example.com', username: 'username' }
+    end
+
+    before do
+      project.create_mattermost_service(
+        active: true,
+        properties: params
+      )
+    end
+
+    it 'accepts a username for update' do
+      put api("/projects/#{project.id}/services/mattermost", user), params.merge(username: 'new_username')
+
+      expect(response).to have_gitlab_http_status(200)
+      expect(json_response['properties']['username']).to eq('new_username')
+    end
+  end
 end
diff --git a/spec/requests/api/users_spec.rb b/spec/requests/api/users_spec.rb
index 634c8dae0ba..2aeae6f9ec7 100644
--- a/spec/requests/api/users_spec.rb
+++ b/spec/requests/api/users_spec.rb
@@ -1880,7 +1880,8 @@ describe API::Users do
     end
   end
 
-  include_examples 'custom attributes endpoints', 'users' do
+  it_behaves_like 'custom attributes endpoints', 'users' do
     let(:attributable) { user }
+    let(:other_attributable) { admin }
   end
 end
diff --git a/spec/requests/api/v3/builds_spec.rb b/spec/requests/api/v3/builds_spec.rb
index 3f58b7ef384..a73bb456b52 100644
--- a/spec/requests/api/v3/builds_spec.rb
+++ b/spec/requests/api/v3/builds_spec.rb
@@ -408,6 +408,8 @@ describe API::V3::Builds do
 
   describe 'POST /projects/:id/builds/:build_id/erase' do
     before do
+      project.add_master(user)
+
       post v3_api("/projects/#{project.id}/builds/#{build.id}/erase", user)
     end
 
diff --git a/spec/requests/api/v3/merge_requests_spec.rb b/spec/requests/api/v3/merge_requests_spec.rb
index 26251b95680..91897e5ee01 100644
--- a/spec/requests/api/v3/merge_requests_spec.rb
+++ b/spec/requests/api/v3/merge_requests_spec.rb
@@ -319,8 +319,6 @@ describe API::MergeRequests do
 
       before do
         forked_project.add_reporter(user2)
-
-        allow_any_instance_of(MergeRequest).to receive(:write_ref)
       end
 
       it "returns merge_request" do
diff --git a/spec/requests/lfs_http_spec.rb b/spec/requests/lfs_http_spec.rb
index 52e93e157f1..c597623bc4d 100644
--- a/spec/requests/lfs_http_spec.rb
+++ b/spec/requests/lfs_http_spec.rb
@@ -654,6 +654,20 @@ describe 'Git LFS API and storage' do
         }
       end
 
+      shared_examples 'pushes new LFS objects' do
+        let(:sample_size) { 150.megabytes }
+        let(:sample_oid) { '91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897' }
+
+        it 'responds with upload hypermedia link' do
+          expect(response).to have_gitlab_http_status(200)
+          expect(json_response['objects']).to be_kind_of(Array)
+          expect(json_response['objects'].first['oid']).to eq(sample_oid)
+          expect(json_response['objects'].first['size']).to eq(sample_size)
+          expect(json_response['objects'].first['actions']['upload']['href']).to eq("#{Gitlab.config.gitlab.url}/#{project.full_path}.git/gitlab-lfs/objects/#{sample_oid}/#{sample_size}")
+          expect(json_response['objects'].first['actions']['upload']['header']).to eq('Authorization' => authorization)
+        end
+      end
+
       describe 'when request is authenticated' do
         describe 'when user has project push access' do
           let(:authorization) { authorize_user }
@@ -684,27 +698,7 @@ describe 'Git LFS API and storage' do
           end
 
           context 'when pushing a lfs object that does not exist' do
-            let(:body) do
-              {
-                'operation' => 'upload',
-                'objects' => [
-                  { 'oid' => '91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897',
-                    'size' => 1575078 }
-                ]
-              }
-            end
-
-            it 'responds with status 200' do
-              expect(response).to have_gitlab_http_status(200)
-            end
-
-            it 'responds with upload hypermedia link' do
-              expect(json_response['objects']).to be_kind_of(Array)
-              expect(json_response['objects'].first['oid']).to eq("91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897")
-              expect(json_response['objects'].first['size']).to eq(1575078)
-              expect(json_response['objects'].first['actions']['upload']['href']).to eq("#{Gitlab.config.gitlab.url}/#{project.full_path}.git/gitlab-lfs/objects/91eff75a492a3ed0dfcb544d7f31326bc4014c8551849c192fd1e48d4dd2c897/1575078")
-              expect(json_response['objects'].first['actions']['upload']['header']).to eq('Authorization' => authorization)
-            end
+            it_behaves_like 'pushes new LFS objects'
           end
 
           context 'when pushing one new and one existing lfs object' do
@@ -785,6 +779,17 @@ describe 'Git LFS API and storage' do
             end
           end
         end
+
+        context 'when deploy key has project push access' do
+          let(:key) { create(:deploy_key, can_push: true) }
+          let(:authorization) { authorize_deploy_key }
+
+          let(:update_user_permissions) do
+            project.deploy_keys << key
+          end
+
+          it_behaves_like 'pushes new LFS objects'
+        end
       end
 
       context 'when user is not authenticated' do
diff --git a/spec/requests/openid_connect_spec.rb b/spec/requests/openid_connect_spec.rb
index 0b1f8ce6f6d..1a5ad9b04e4 100644
--- a/spec/requests/openid_connect_spec.rb
+++ b/spec/requests/openid_connect_spec.rb
@@ -107,6 +107,15 @@ describe 'OpenID Connect requests' do
       end
     end
 
+    # These 2 calls shouldn't actually throw, they should be handled as an
+    # unauthorized request, so we should be able to check the response.
+    #
+    # This was not possible due to an issue with Warden:
+    # https://github.com/hassox/warden/pull/162
+    #
+    # When the patch gets merged and we update Warden, these specs will need to
+    # updated to check the response instead of a raised exception.
+    # https://gitlab.com/gitlab-org/gitlab-ce/issues/40218
     context 'when user is blocked' do
       it 'returns authentication error' do
         access_grant
@@ -114,7 +123,7 @@ describe 'OpenID Connect requests' do
 
         expect do
           request_access_token
-        end.to throw_symbol :warden
+        end.to raise_error UncaughtThrowError
       end
     end
 
@@ -125,7 +134,7 @@ describe 'OpenID Connect requests' do
 
         expect do
           request_access_token
-        end.to throw_symbol :warden
+        end.to raise_error UncaughtThrowError
       end
     end
   end
diff --git a/spec/routing/group_routing_spec.rb b/spec/routing/group_routing_spec.rb
new file mode 100644
index 00000000000..7a4c8304e62
--- /dev/null
+++ b/spec/routing/group_routing_spec.rb
@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe "Groups", "routing" do
+  let(:group_path) { 'complex.group-namegit' }
+  let!(:group) { create(:group, path: group_path) }
+
+  it "to #show" do
+    expect(get("/groups/#{group_path}")).to route_to('groups#show', id: group_path)
+  end
+
+  it "also supports nested groups" do
+    nested_group = create(:group, parent: group)
+    expect(get("/#{group_path}/#{nested_group.path}")).to route_to('groups#show', id: "#{group_path}/#{nested_group.path}")
+  end
+
+  it "also display group#show on the short path" do
+    expect(get("/#{group_path}")).to route_to('groups#show', id: group_path)
+  end
+
+  it "to #activity" do
+    expect(get("/groups/#{group_path}/-/activity")).to route_to('groups#activity', id: group_path)
+  end
+
+  it "to #issues" do
+    expect(get("/groups/#{group_path}/-/issues")).to route_to('groups#issues', id: group_path)
+  end
+
+  it "to #members" do
+    expect(get("/groups/#{group_path}/-/group_members")).to route_to('groups/group_members#index', group_id: group_path)
+  end
+
+  it "to #labels" do
+    expect(get("/groups/#{group_path}/-/labels")).to route_to('groups/labels#index', group_id: group_path)
+  end
+
+  it "to #milestones" do
+    expect(get("/groups/#{group_path}/-/milestones")).to route_to('groups/milestones#index', group_id: group_path)
+  end
+
+  describe 'legacy redirection' do
+    describe 'labels' do
+      it_behaves_like 'redirecting a legacy path', "/groups/complex.group-namegit/labels", "/groups/complex.group-namegit/-/labels/" do
+        let(:resource) { create(:group, parent: group, path: 'labels') }
+      end
+    end
+
+    describe 'group_members' do
+      it_behaves_like 'redirecting a legacy path', "/groups/complex.group-namegit/group_members", "/groups/complex.group-namegit/-/group_members/" do
+        let(:resource) { create(:group, parent: group, path: 'group_members') }
+      end
+    end
+
+    describe 'avatar' do
+      it 'routes to the avatars controller' do
+        expect(delete("/groups/#{group_path}/-/avatar"))
+          .to route_to(group_id: group_path,
+                       controller: 'groups/avatars',
+                       action: 'destroy')
+      end
+    end
+
+    describe 'milestones' do
+      it_behaves_like 'redirecting a legacy path', "/groups/complex.group-namegit/milestones", "/groups/complex.group-namegit/-/milestones/" do
+        let(:resource) { create(:group, parent: group, path: 'milestones') }
+      end
+
+      context 'nested routes' do
+        include RSpec::Rails::RequestExampleGroup
+
+        let(:milestone) { create(:milestone, group: group) }
+
+        it 'redirects the nested routes' do
+          request = get("/groups/#{group_path}/milestones/#{milestone.id}/merge_requests")
+          expect(request).to redirect_to("/groups/#{group_path}/-/milestones/#{milestone.id}/merge_requests")
+        end
+      end
+
+      context 'with a query string' do
+        it_behaves_like 'redirecting a legacy path', "/groups/complex.group-namegit/milestones?hello=world", "/groups/complex.group-namegit/-/milestones/?hello=world" do
+          let(:resource) { create(:group, parent: group, path: 'milestones') }
+        end
+
+        it_behaves_like 'redirecting a legacy path', "/groups/complex.group-namegit/milestones?milestones=/milestones", "/groups/complex.group-namegit/-/milestones/?milestones=/milestones" do
+          let(:resource) { create(:group, parent: group, path: 'milestones') }
+        end
+      end
+    end
+
+    describe 'edit' do
+      it_behaves_like 'redirecting a legacy path', "/groups/complex.group-namegit/edit", "/groups/complex.group-namegit/-/edit/" do
+        let(:resource) do
+          pending('still rejected because of the wildcard reserved word')
+          create(:group, parent: group, path: 'edit')
+        end
+      end
+    end
+
+    describe 'issues' do
+      it_behaves_like 'redirecting a legacy path', "/groups/complex.group-namegit/issues", "/groups/complex.group-namegit/-/issues/" do
+        let(:resource) { create(:group, parent: group, path: 'issues') }
+      end
+    end
+
+    describe 'merge_requests' do
+      it_behaves_like 'redirecting a legacy path', "/groups/complex.group-namegit/merge_requests", "/groups/complex.group-namegit/-/merge_requests/" do
+        let(:resource) { create(:group, parent: group, path: 'merge_requests') }
+      end
+    end
+
+    describe 'projects' do
+      it_behaves_like 'redirecting a legacy path', "/groups/complex.group-namegit/projects", "/groups/complex.group-namegit/-/projects/" do
+        let(:resource) { create(:group, parent: group, path: 'projects') }
+      end
+    end
+
+    describe 'activity' do
+      it_behaves_like 'redirecting a legacy path', "/groups/complex.group-namegit/activity", "/groups/complex.group-namegit/-/activity/" do
+        let(:resource) { create(:group, parent: group, path: 'activity') }
+      end
+
+      it_behaves_like 'redirecting a legacy path', "/groups/activity/activity", "/groups/activity/-/activity/" do
+        let!(:parent) { create(:group, path: 'activity') }
+        let(:resource) { create(:group, parent: parent, path: 'activity') }
+      end
+    end
+  end
+end
diff --git a/spec/routing/routing_spec.rb b/spec/routing/routing_spec.rb
index 609481603af..91aefa84d0e 100644
--- a/spec/routing/routing_spec.rb
+++ b/spec/routing/routing_spec.rb
@@ -257,8 +257,10 @@ describe "Authentication", "routing" do
     expect(post("/users/sign_in")).to route_to('sessions#create')
   end
 
-  it "DELETE /users/sign_out" do
-    expect(delete("/users/sign_out")).to route_to('sessions#destroy')
+  # sign_out with GET instead of DELETE facilitates ad-hoc single-sign-out processes
+  # (https://gitlab.com/gitlab-org/gitlab-ce/issues/39708)
+  it "GET /users/sign_out" do
+    expect(get("/users/sign_out")).to route_to('sessions#destroy')
   end
 
   it "POST /users/password" do
@@ -278,36 +280,6 @@ describe "Authentication", "routing" do
   end
 end
 
-describe "Groups", "routing" do
-  let(:name) { 'complex.group-namegit' }
-  let!(:group) { create(:group, name: name) }
-
-  it "to #show" do
-    expect(get("/groups/#{name}")).to route_to('groups#show', id: name)
-  end
-
-  it "also supports nested groups" do
-    nested_group = create(:group, parent: group)
-    expect(get("/#{name}/#{nested_group.name}")).to route_to('groups#show', id: "#{name}/#{nested_group.name}")
-  end
-
-  it "also display group#show on the short path" do
-    expect(get("/#{name}")).to route_to('groups#show', id: name)
-  end
-
-  it "to #activity" do
-    expect(get("/groups/#{name}/activity")).to route_to('groups#activity', id: name)
-  end
-
-  it "to #issues" do
-    expect(get("/groups/#{name}/issues")).to route_to('groups#issues', id: name)
-  end
-
-  it "to #members" do
-    expect(get("/groups/#{name}/group_members")).to route_to('groups/group_members#index', group_id: name)
-  end
-end
-
 describe HealthCheckController, 'routing' do
   it 'to #index' do
     expect(get('/health_check')).to route_to('health_check#index')
diff --git a/spec/serializers/cluster_application_entity_spec.rb b/spec/serializers/cluster_application_entity_spec.rb
new file mode 100644
index 00000000000..87c7b2ad36e
--- /dev/null
+++ b/spec/serializers/cluster_application_entity_spec.rb
@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe ClusterApplicationEntity do
+  describe '#as_json' do
+    let(:application) { build(:cluster_applications_helm) }
+    subject { described_class.new(application).as_json }
+
+    it 'has name' do
+      expect(subject[:name]).to eq(application.name)
+    end
+
+    it 'has status' do
+      expect(subject[:status]).to eq(:not_installable)
+    end
+
+    it 'has no status_reason' do
+      expect(subject[:status_reason]).to be_nil
+    end
+
+    context 'when application is errored' do
+      let(:application) { build(:cluster_applications_helm, :errored) }
+
+      it 'has corresponded data' do
+        expect(subject[:status]).to eq(:errored)
+        expect(subject[:status_reason]).not_to be_nil
+        expect(subject[:status_reason]).to eq(application.status_reason)
+      end
+    end
+  end
+end
diff --git a/spec/serializers/cluster_entity_spec.rb b/spec/serializers/cluster_entity_spec.rb
index 2c7f49974f1..d6a43fd0f00 100644
--- a/spec/serializers/cluster_entity_spec.rb
+++ b/spec/serializers/cluster_entity_spec.rb
@@ -1,22 +1,51 @@
 require 'spec_helper'
 
 describe ClusterEntity do
-  set(:cluster) { create(:gcp_cluster, :errored) }
-  let(:request) { double('request') }
+  describe '#as_json' do
+    subject { described_class.new(cluster).as_json }
 
-  let(:entity) do
-    described_class.new(cluster)
-  end
+    context 'when provider type is gcp' do
+      let(:cluster) { create(:cluster, provider_type: :gcp, provider_gcp: provider) }
 
-  describe '#as_json' do
-    subject { entity.as_json }
+      context 'when status is creating' do
+        let(:provider) { create(:cluster_provider_gcp, :creating) }
+
+        it 'has corresponded data' do
+          expect(subject[:status]).to eq(:creating)
+          expect(subject[:status_reason]).to be_nil
+        end
+      end
+
+      context 'when status is errored' do
+        let(:provider) { create(:cluster_provider_gcp, :errored) }
 
-    it 'contains status' do
-      expect(subject[:status]).to eq(:errored)
+        it 'has corresponded data' do
+          expect(subject[:status]).to eq(:errored)
+          expect(subject[:status_reason]).to eq(provider.status_reason)
+        end
+      end
     end
 
-    it 'contains status reason' do
-      expect(subject[:status_reason]).to eq('general error')
+    context 'when provider type is user' do
+      let(:cluster) { create(:cluster, provider_type: :user) }
+
+      it 'has corresponded data' do
+        expect(subject[:status]).to eq(:created)
+        expect(subject[:status_reason]).to be_nil
+      end
+    end
+
+    context 'when no application has been installed' do
+      let(:cluster) { create(:cluster) }
+      subject { described_class.new(cluster).as_json[:applications]}
+
+      it 'contains helm as not_installable' do
+        expect(subject).not_to be_empty
+
+        helm = subject[0]
+        expect(helm[:name]).to eq('helm')
+        expect(helm[:status]).to eq(:not_installable)
+      end
     end
   end
 end
diff --git a/spec/serializers/cluster_serializer_spec.rb b/spec/serializers/cluster_serializer_spec.rb
index 1ac6784d28f..5e9f7a45891 100644
--- a/spec/serializers/cluster_serializer_spec.rb
+++ b/spec/serializers/cluster_serializer_spec.rb
@@ -1,18 +1,23 @@
 require 'spec_helper'
 
 describe ClusterSerializer do
-  let(:serializer) do
-    described_class.new
-  end
-
   describe '#represent_status' do
-    subject { serializer.represent_status(resource) }
+    subject { described_class.new.represent_status(cluster) }
+
+    context 'when provider type is gcp' do
+      let(:cluster) { create(:cluster, provider_type: :gcp, provider_gcp: provider) }
+      let(:provider) { create(:cluster_provider_gcp, :errored) }
+
+      it 'serializes only status' do
+        expect(subject.keys).to contain_exactly(:status, :status_reason, :applications)
+      end
+    end
 
-    context 'when represents only status' do
-      let(:resource) { create(:gcp_cluster, :errored) }
+    context 'when provider type is user' do
+      let(:cluster) { create(:cluster, provider_type: :user) }
 
       it 'serializes only status' do
-        expect(subject.keys).to contain_exactly(:status, :status_reason)
+        expect(subject.keys).to contain_exactly(:status, :status_reason, :applications)
       end
     end
   end
diff --git a/spec/serializers/pipeline_details_entity_spec.rb b/spec/serializers/pipeline_details_entity_spec.rb
index f60d1843581..45e18086894 100644
--- a/spec/serializers/pipeline_details_entity_spec.rb
+++ b/spec/serializers/pipeline_details_entity_spec.rb
@@ -107,7 +107,7 @@ describe PipelineDetailsEntity do
       it 'contains stages' do
         expect(subject).to include(:details)
         expect(subject[:details]).to include(:stages)
-        expect(subject[:details][:stages].first).to include(name: 'external')
+        expect(subject[:details][:stages].first).to include(name: 'test')
       end
     end
 
diff --git a/spec/services/base_count_service_spec.rb b/spec/services/base_count_service_spec.rb
new file mode 100644
index 00000000000..5ec8ed0976d
--- /dev/null
+++ b/spec/services/base_count_service_spec.rb
@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe BaseCountService, :use_clean_rails_memory_store_caching do
+  let(:service) { described_class.new }
+
+  describe '#relation_for_count' do
+    it 'raises NotImplementedError' do
+      expect { service.relation_for_count }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#count' do
+    it 'returns the number of values' do
+      expect(service)
+        .to receive(:cache_key)
+        .and_return('foo')
+
+      expect(service)
+        .to receive(:uncached_count)
+        .and_return(5)
+
+      expect(service.count).to eq(5)
+    end
+  end
+
+  describe '#uncached_count' do
+    it 'returns the uncached number of values' do
+      expect(service)
+        .to receive(:relation_for_count)
+        .and_return(double(:relation, count: 5))
+
+      expect(service.uncached_count).to eq(5)
+    end
+  end
+
+  describe '#refresh_cache' do
+    it 'refreshes the cache' do
+      allow(service)
+        .to receive(:cache_key)
+        .and_return('foo')
+
+      allow(service)
+        .to receive(:uncached_count)
+        .and_return(4)
+
+      service.refresh_cache
+
+      expect(Rails.cache.fetch(service.cache_key, raw: service.raw?)).to eq(4)
+    end
+  end
+
+  describe '#delete_cache' do
+    it 'deletes the cache' do
+      allow(service)
+        .to receive(:cache_key)
+        .and_return('foo')
+
+      allow(service)
+        .to receive(:uncached_count)
+        .and_return(4)
+
+      service.refresh_cache
+      service.delete_cache
+
+      expect(Rails.cache.fetch(service.cache_key, raw: service.raw?)).to be_nil
+    end
+  end
+
+  describe '#raw?' do
+    it 'returns false' do
+      expect(service.raw?).to eq(false)
+    end
+  end
+
+  describe '#cache_key' do
+    it 'raises NotImplementedError' do
+      expect { service.cache_key }.to raise_error(NotImplementedError)
+    end
+  end
+end
diff --git a/spec/services/ci/create_cluster_service_spec.rb b/spec/services/ci/create_cluster_service_spec.rb
deleted file mode 100644
index 6e7398fbffa..00000000000
--- a/spec/services/ci/create_cluster_service_spec.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe Ci::CreateClusterService do
-  describe '#execute' do
-    let(:access_token) { 'xxx' }
-    let(:project) { create(:project) }
-    let(:user) { create(:user) }
-    let(:result) { described_class.new(project, user, params).execute(access_token) }
-
-    context 'when correct params' do
-      let(:params) do
-        {
-          gcp_project_id: 'gcp-project',
-          gcp_cluster_name: 'test-cluster',
-          gcp_cluster_zone: 'us-central1-a',
-          gcp_cluster_size: 1
-        }
-      end
-
-      it 'creates a cluster object' do
-        expect(ClusterProvisionWorker).to receive(:perform_async)
-        expect { result }.to change { Gcp::Cluster.count }.by(1)
-        expect(result.gcp_project_id).to eq('gcp-project')
-        expect(result.gcp_cluster_name).to eq('test-cluster')
-        expect(result.gcp_cluster_zone).to eq('us-central1-a')
-        expect(result.gcp_cluster_size).to eq(1)
-        expect(result.gcp_token).to eq(access_token)
-      end
-    end
-
-    context 'when invalid params' do
-      let(:params) do
-        {
-          gcp_project_id: 'gcp-project',
-          gcp_cluster_name: 'test-cluster',
-          gcp_cluster_zone: 'us-central1-a',
-          gcp_cluster_size: 'ABC'
-        }
-      end
-
-      it 'returns an error' do
-        expect(ClusterProvisionWorker).not_to receive(:perform_async)
-        expect { result }.to change { Gcp::Cluster.count }.by(0)
-      end
-    end
-  end
-end
diff --git a/spec/services/ci/fetch_gcp_operation_service_spec.rb b/spec/services/ci/fetch_gcp_operation_service_spec.rb
deleted file mode 100644
index 7792979c5cb..00000000000
--- a/spec/services/ci/fetch_gcp_operation_service_spec.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-require 'spec_helper'
-require 'google/apis'
-
-describe Ci::FetchGcpOperationService do
-  describe '#execute' do
-    let(:cluster) { create(:gcp_cluster) }
-    let(:operation) { double }
-
-    context 'when suceeded' do
-      before do
-        allow_any_instance_of(GoogleApi::CloudPlatform::Client)
-          .to receive(:projects_zones_operations).and_return(operation)
-      end
-
-      it 'fetch the gcp operaion' do
-        expect { |b| described_class.new.execute(cluster, &b) }
-          .to yield_with_args(operation)
-      end
-    end
-
-    context 'when raises an error' do
-      let(:error) { Google::Apis::ServerError.new('a') }
-
-      before do
-        allow_any_instance_of(GoogleApi::CloudPlatform::Client)
-          .to receive(:projects_zones_operations).and_raise(error)
-      end
-
-      it 'sets an error to cluster object' do
-        expect { |b| described_class.new.execute(cluster, &b) }
-          .not_to yield_with_args
-        expect(cluster.reload).to be_errored
-      end
-    end
-  end
-end
diff --git a/spec/services/ci/finalize_cluster_creation_service_spec.rb b/spec/services/ci/finalize_cluster_creation_service_spec.rb
deleted file mode 100644
index def3709fdb4..00000000000
--- a/spec/services/ci/finalize_cluster_creation_service_spec.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe Ci::FinalizeClusterCreationService do
-  describe '#execute' do
-    let(:cluster) { create(:gcp_cluster) }
-    let(:result) { described_class.new.execute(cluster) }
-
-    context 'when suceeded to get cluster from api' do
-      let(:gke_cluster) { double }
-
-      before do
-        allow(gke_cluster).to receive(:endpoint).and_return('111.111.111.111')
-        allow(gke_cluster).to receive(:master_auth).and_return(spy)
-        allow_any_instance_of(GoogleApi::CloudPlatform::Client)
-          .to receive(:projects_zones_clusters_get).and_return(gke_cluster)
-      end
-
-      context 'when suceeded to get kubernetes token' do
-        let(:kubernetes_token) { 'abc' }
-
-        before do
-          allow_any_instance_of(Ci::FetchKubernetesTokenService)
-            .to receive(:execute).and_return(kubernetes_token)
-        end
-
-        it 'executes integration cluster' do
-          expect_any_instance_of(Ci::IntegrateClusterService).to receive(:execute)
-          described_class.new.execute(cluster)
-        end
-      end
-
-      context 'when failed to get kubernetes token' do
-        before do
-          allow_any_instance_of(Ci::FetchKubernetesTokenService)
-            .to receive(:execute).and_return(nil)
-        end
-
-        it 'sets an error to cluster object' do
-          described_class.new.execute(cluster)
-
-          expect(cluster.reload).to be_errored
-        end
-      end
-    end
-
-    context 'when failed to get cluster from api' do
-      let(:error) { Google::Apis::ServerError.new('a') }
-
-      before do
-        allow_any_instance_of(GoogleApi::CloudPlatform::Client)
-          .to receive(:projects_zones_clusters_get).and_raise(error)
-      end
-
-      it 'sets an error to cluster object' do
-        described_class.new.execute(cluster)
-
-        expect(cluster.reload).to be_errored
-      end
-    end
-  end
-end
diff --git a/spec/services/ci/integrate_cluster_service_spec.rb b/spec/services/ci/integrate_cluster_service_spec.rb
deleted file mode 100644
index 3a79c205bd1..00000000000
--- a/spec/services/ci/integrate_cluster_service_spec.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe Ci::IntegrateClusterService do
-  describe '#execute' do
-    let(:cluster) { create(:gcp_cluster, :custom_project_namespace) }
-    let(:endpoint) { '123.123.123.123' }
-    let(:ca_cert) { 'ca_cert_xxx' }
-    let(:token) { 'token_xxx' }
-    let(:username) { 'username_xxx' }
-    let(:password) { 'password_xxx' }
-
-    before do
-      described_class
-        .new.execute(cluster, endpoint, ca_cert, token, username, password)
-
-      cluster.reload
-    end
-
-    context 'when correct params' do
-      it 'creates a cluster object' do
-        expect(cluster.endpoint).to eq(endpoint)
-        expect(cluster.ca_cert).to eq(ca_cert)
-        expect(cluster.kubernetes_token).to eq(token)
-        expect(cluster.username).to eq(username)
-        expect(cluster.password).to eq(password)
-        expect(cluster.service.active).to be_truthy
-        expect(cluster.service.api_url).to eq(cluster.api_url)
-        expect(cluster.service.ca_pem).to eq(ca_cert)
-        expect(cluster.service.namespace).to eq(cluster.project_namespace)
-        expect(cluster.service.token).to eq(token)
-      end
-    end
-
-    context 'when invalid params' do
-      let(:endpoint) { nil }
-
-      it 'sets an error to cluster object' do
-        expect(cluster).to be_errored
-      end
-    end
-  end
-end
diff --git a/spec/services/ci/process_pipeline_service_spec.rb b/spec/services/ci/process_pipeline_service_spec.rb
index 214adc9960f..0ce41e7c7ee 100644
--- a/spec/services/ci/process_pipeline_service_spec.rb
+++ b/spec/services/ci/process_pipeline_service_spec.rb
@@ -292,6 +292,30 @@ describe Ci::ProcessPipelineService, '#execute' do
     end
   end
 
+  context 'when there is only one manual action' do
+    before do
+      create_build('deploy', stage_idx: 0, when: 'manual', allow_failure: true)
+
+      process_pipeline
+    end
+
+    it 'skips the pipeline' do
+      expect(pipeline.reload).to be_skipped
+    end
+
+    context 'when the action was played' do
+      before do
+        play_manual_action('deploy')
+      end
+
+      it 'queues the action and pipeline' do
+        expect(all_builds_statuses).to eq(%w[pending])
+
+        expect(pipeline.reload).to be_pending
+      end
+    end
+  end
+
   context 'when blocking manual actions are defined' do
     before do
       create_build('code:test', stage_idx: 0)
diff --git a/spec/services/ci/provision_cluster_service_spec.rb b/spec/services/ci/provision_cluster_service_spec.rb
deleted file mode 100644
index 5ce5c788314..00000000000
--- a/spec/services/ci/provision_cluster_service_spec.rb
+++ /dev/null
@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-describe Ci::ProvisionClusterService do
-  describe '#execute' do
-    let(:cluster) { create(:gcp_cluster) }
-    let(:operation) { spy }
-
-    shared_examples 'error' do
-      it 'sets an error to cluster object' do
-        described_class.new.execute(cluster)
-
-        expect(cluster.reload).to be_errored
-      end
-    end
-
-    context 'when suceeded to request provision' do
-      before do
-        allow_any_instance_of(GoogleApi::CloudPlatform::Client)
-          .to receive(:projects_zones_clusters_create).and_return(operation)
-      end
-
-      context 'when operation status is RUNNING' do
-        before do
-          allow(operation).to receive(:status).and_return('RUNNING')
-        end
-
-        context 'when suceeded to parse gcp operation id' do
-          before do
-            allow_any_instance_of(GoogleApi::CloudPlatform::Client)
-              .to receive(:parse_operation_id).and_return('operation-123')
-          end
-
-          context 'when cluster status is scheduled' do
-            before do
-              allow_any_instance_of(GoogleApi::CloudPlatform::Client)
-                .to receive(:parse_operation_id).and_return('operation-123')
-            end
-
-            it 'schedules a worker for status minitoring' do
-              expect(WaitForClusterCreationWorker).to receive(:perform_in)
-
-              described_class.new.execute(cluster)
-            end
-          end
-
-          context 'when cluster status is creating' do
-            before do
-              cluster.make_creating!
-            end
-
-            it_behaves_like 'error'
-          end
-        end
-
-        context 'when failed to parse gcp operation id' do
-          before do
-            allow_any_instance_of(GoogleApi::CloudPlatform::Client)
-              .to receive(:parse_operation_id).and_return(nil)
-          end
-
-          it_behaves_like 'error'
-        end
-      end
-
-      context 'when operation status is others' do
-        before do
-          allow(operation).to receive(:status).and_return('others')
-        end
-
-        it_behaves_like 'error'
-      end
-    end
-
-    context 'when failed to request provision' do
-      let(:error) { Google::Apis::ServerError.new('a') }
-
-      before do
-        allow_any_instance_of(GoogleApi::CloudPlatform::Client)
-          .to receive(:projects_zones_clusters_create).and_raise(error)
-      end
-
-      it_behaves_like 'error'
-    end
-  end
-end
diff --git a/spec/services/ci/update_cluster_service_spec.rb b/spec/services/ci/update_cluster_service_spec.rb
deleted file mode 100644
index a289385b88f..00000000000
--- a/spec/services/ci/update_cluster_service_spec.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe Ci::UpdateClusterService do
-  describe '#execute' do
-    let(:cluster) { create(:gcp_cluster, :created_on_gke, :with_kubernetes_service) }
-
-    before do
-      described_class.new(cluster.project, cluster.user, params).execute(cluster)
-
-      cluster.reload
-    end
-
-    context 'when correct params' do
-      context 'when enabled is true' do
-        let(:params) { { 'enabled' => 'true' } }
-
-        it 'enables cluster and overwrite kubernetes service' do
-          expect(cluster.enabled).to be_truthy
-          expect(cluster.service.active).to be_truthy
-          expect(cluster.service.api_url).to eq(cluster.api_url)
-          expect(cluster.service.ca_pem).to eq(cluster.ca_cert)
-          expect(cluster.service.namespace).to eq(cluster.project_namespace)
-          expect(cluster.service.token).to eq(cluster.kubernetes_token)
-        end
-      end
-
-      context 'when enabled is false' do
-        let(:params) { { 'enabled' => 'false' } }
-
-        it 'disables cluster and kubernetes service' do
-          expect(cluster.enabled).to be_falsy
-          expect(cluster.service.active).to be_falsy
-        end
-      end
-    end
-  end
-end
diff --git a/spec/services/clusters/applications/check_installation_progress_service_spec.rb b/spec/services/clusters/applications/check_installation_progress_service_spec.rb
new file mode 100644
index 00000000000..75fc05d36e9
--- /dev/null
+++ b/spec/services/clusters/applications/check_installation_progress_service_spec.rb
@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Clusters::Applications::CheckInstallationProgressService do
+  RESCHEDULE_PHASES = Gitlab::Kubernetes::Pod::PHASES - [Gitlab::Kubernetes::Pod::SUCCEEDED, Gitlab::Kubernetes::Pod::FAILED].freeze
+
+  let(:application) { create(:cluster_applications_helm, :installing) }
+  let(:service) { described_class.new(application) }
+  let(:phase) { Gitlab::Kubernetes::Pod::UNKNOWN }
+  let(:errors) { nil }
+
+  shared_examples 'a terminated installation' do
+    it 'removes the installation POD' do
+      expect(service).to receive(:remove_installation_pod).once
+
+      service.execute
+    end
+  end
+
+  shared_examples 'a not yet terminated installation' do |a_phase|
+    let(:phase) { a_phase }
+
+    context "when phase is #{a_phase}" do
+      context 'when not timeouted' do
+        it 'reschedule a new check' do
+          expect(ClusterWaitForAppInstallationWorker).to receive(:perform_in).once
+          expect(service).not_to receive(:remove_installation_pod)
+
+          service.execute
+
+          expect(application).to be_installing
+          expect(application.status_reason).to be_nil
+        end
+      end
+
+      context 'when timeouted' do
+        let(:application) { create(:cluster_applications_helm, :timeouted) }
+
+        it_behaves_like 'a terminated installation'
+
+        it 'make the application errored' do
+          expect(ClusterWaitForAppInstallationWorker).not_to receive(:perform_in)
+
+          service.execute
+
+          expect(application).to be_errored
+          expect(application.status_reason).to match(/\btimeouted\b/)
+        end
+      end
+    end
+  end
+
+  before do
+    expect(service).to receive(:installation_phase).once.and_return(phase)
+
+    allow(service).to receive(:installation_errors).and_return(errors)
+    allow(service).to receive(:remove_installation_pod).and_return(nil)
+  end
+
+  describe '#execute' do
+    context 'when installation POD succeeded' do
+      let(:phase) { Gitlab::Kubernetes::Pod::SUCCEEDED }
+
+      it_behaves_like 'a terminated installation'
+
+      it 'make the application installed' do
+        expect(ClusterWaitForAppInstallationWorker).not_to receive(:perform_in)
+
+        service.execute
+
+        expect(application).to be_installed
+        expect(application.status_reason).to be_nil
+      end
+    end
+
+    context 'when installation POD failed' do
+      let(:phase) { Gitlab::Kubernetes::Pod::FAILED }
+      let(:errors) { 'test installation failed' }
+
+      it_behaves_like 'a terminated installation'
+
+      it 'make the application errored' do
+        service.execute
+
+        expect(application).to be_errored
+        expect(application.status_reason).to eq(errors)
+      end
+    end
+
+    RESCHEDULE_PHASES.each { |phase| it_behaves_like 'a not yet terminated installation', phase }
+  end
+end
diff --git a/spec/services/clusters/applications/install_service_spec.rb b/spec/services/clusters/applications/install_service_spec.rb
new file mode 100644
index 00000000000..054a49ffedf
--- /dev/null
+++ b/spec/services/clusters/applications/install_service_spec.rb
@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Clusters::Applications::InstallService do
+  describe '#execute' do
+    let(:application) { create(:cluster_applications_helm, :scheduled) }
+    let(:service) { described_class.new(application) }
+    let(:helm_client) { instance_double(Gitlab::Kubernetes::Helm) }
+
+    before do
+      allow(service).to receive(:helm_api).and_return(helm_client)
+    end
+
+    context 'when there are no errors' do
+      before do
+        expect(helm_client).to receive(:install).with(application.install_command)
+        allow(ClusterWaitForAppInstallationWorker).to receive(:perform_in).and_return(nil)
+      end
+
+      it 'make the application installing' do
+        expect(application.cluster).not_to be_nil
+        service.execute
+
+        expect(application).to be_installing
+      end
+
+      it 'schedule async installation status check' do
+        expect(ClusterWaitForAppInstallationWorker).to receive(:perform_in).once
+
+        service.execute
+      end
+    end
+
+    context 'when k8s cluster communication fails' do
+      before do
+        error = KubeException.new(500, 'system failure', nil)
+        expect(helm_client).to receive(:install).with(application.install_command).and_raise(error)
+      end
+
+      it 'make the application errored' do
+        service.execute
+
+        expect(application).to be_errored
+        expect(application.status_reason).to match(/kubernetes error:/i)
+      end
+    end
+
+    context 'when application cannot be persisted' do
+      let(:application) { build(:cluster_applications_helm, :scheduled) }
+
+      it 'make the application errored' do
+        expect(application).to receive(:make_installing!).once.and_raise(ActiveRecord::RecordInvalid)
+        expect(helm_client).not_to receive(:install)
+
+        service.execute
+
+        expect(application).to be_errored
+      end
+    end
+  end
+end
diff --git a/spec/services/clusters/applications/schedule_installation_service_spec.rb b/spec/services/clusters/applications/schedule_installation_service_spec.rb
new file mode 100644
index 00000000000..cf95361c935
--- /dev/null
+++ b/spec/services/clusters/applications/schedule_installation_service_spec.rb
@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Clusters::Applications::ScheduleInstallationService do
+  def count_scheduled
+    application_class&.with_status(:scheduled)&.count || 0
+  end
+
+  shared_examples 'a failing service' do
+    it 'raise an exception' do
+      expect(ClusterInstallAppWorker).not_to receive(:perform_async)
+      count_before = count_scheduled
+
+      expect { service.execute }.to raise_error(StandardError)
+      expect(count_scheduled).to eq(count_before)
+    end
+  end
+
+  describe '#execute' do
+    let(:application_class) { Clusters::Applications::Helm }
+    let(:cluster) { create(:cluster, :project, :provided_by_gcp) }
+    let(:project) { cluster.project }
+    let(:service) { described_class.new(project, nil, cluster: cluster, application_class: application_class) }
+
+    it 'creates a new application' do
+      expect { service.execute }.to change { application_class.count }.by(1)
+    end
+
+    it 'make the application scheduled' do
+      expect(ClusterInstallAppWorker).to receive(:perform_async).with(application_class.application_name, kind_of(Numeric)).once
+
+      expect { service.execute }.to change { application_class.with_status(:scheduled).count }.by(1)
+    end
+
+    context 'when installation is already in progress' do
+      let(:application) { create(:cluster_applications_helm, :installing) }
+      let(:cluster) { application.cluster }
+
+      it_behaves_like 'a failing service'
+    end
+
+    context 'when application_class is nil' do
+      let(:application_class) { nil }
+
+      it_behaves_like 'a failing service'
+    end
+
+    context 'when application cannot be persisted' do
+      before do
+        expect_any_instance_of(application_class).to receive(:make_scheduled!).once.and_raise(ActiveRecord::RecordInvalid)
+      end
+
+      it_behaves_like 'a failing service'
+    end
+  end
+end
diff --git a/spec/services/clusters/create_service_spec.rb b/spec/services/clusters/create_service_spec.rb
new file mode 100644
index 00000000000..5b6edb73beb
--- /dev/null
+++ b/spec/services/clusters/create_service_spec.rb
@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Clusters::CreateService do
+  let(:access_token) { 'xxx' }
+  let(:project) { create(:project) }
+  let(:user) { create(:user) }
+  let(:result) { described_class.new(project, user, params).execute(access_token) }
+
+  context 'when provider is gcp' do
+    context 'when correct params' do
+      let(:params) do
+        {
+          name: 'test-cluster',
+          provider_type: :gcp,
+          provider_gcp_attributes: {
+            gcp_project_id: 'gcp-project',
+            zone: 'us-central1-a',
+            num_nodes: 1,
+            machine_type: 'machine_type-a'
+          }
+        }
+      end
+
+      it 'creates a cluster object and performs a worker' do
+        expect(ClusterProvisionWorker).to receive(:perform_async)
+
+        expect { result }
+          .to change { Clusters::Cluster.count }.by(1)
+          .and change { Clusters::Providers::Gcp.count }.by(1)
+
+        expect(result.name).to eq('test-cluster')
+        expect(result.user).to eq(user)
+        expect(result.project).to eq(project)
+        expect(result.provider.gcp_project_id).to eq('gcp-project')
+        expect(result.provider.zone).to eq('us-central1-a')
+        expect(result.provider.num_nodes).to eq(1)
+        expect(result.provider.machine_type).to eq('machine_type-a')
+        expect(result.provider.access_token).to eq(access_token)
+        expect(result.platform).to be_nil
+      end
+    end
+
+    context 'when invalid params' do
+      let(:params) do
+        {
+          name: 'test-cluster',
+          provider_type: :gcp,
+          provider_gcp_attributes: {
+            gcp_project_id: '!!!!!!!',
+            zone: 'us-central1-a',
+            num_nodes: 1,
+            machine_type: 'machine_type-a'
+          }
+        }
+      end
+
+      it 'returns an error' do
+        expect(ClusterProvisionWorker).not_to receive(:perform_async)
+        expect { result }.to change { Clusters::Cluster.count }.by(0)
+        expect(result.errors[:"provider_gcp.gcp_project_id"]).to be_present
+      end
+    end
+  end
+end
diff --git a/spec/services/clusters/gcp/fetch_operation_service_spec.rb b/spec/services/clusters/gcp/fetch_operation_service_spec.rb
new file mode 100644
index 00000000000..e2fa93904c5
--- /dev/null
+++ b/spec/services/clusters/gcp/fetch_operation_service_spec.rb
@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Clusters::Gcp::FetchOperationService do
+  include GoogleApi::CloudPlatformHelpers
+
+  describe '#execute' do
+    let(:provider) { create(:cluster_provider_gcp, :creating) }
+    let(:gcp_project_id) { provider.gcp_project_id }
+    let(:zone) { provider.zone }
+    let(:operation_id) { provider.operation_id }
+
+    shared_examples 'success' do
+      it 'yields' do
+        expect { |b| described_class.new.execute(provider, &b) }
+          .to yield_with_args
+      end
+    end
+
+    shared_examples 'error' do
+      it 'sets an error to provider object' do
+        expect { |b| described_class.new.execute(provider, &b) }
+          .not_to yield_with_args
+        expect(provider.reload).to be_errored
+      end
+    end
+
+    context 'when suceeded to fetch operation' do
+      before do
+        stub_cloud_platform_get_zone_operation(gcp_project_id, zone, operation_id)
+      end
+
+      it_behaves_like 'success'
+    end
+
+    context 'when Internal Server Error happened' do
+      before do
+        stub_cloud_platform_get_zone_operation_error(gcp_project_id, zone, operation_id)
+      end
+
+      it_behaves_like 'error'
+    end
+  end
+end
diff --git a/spec/services/clusters/gcp/finalize_creation_service_spec.rb b/spec/services/clusters/gcp/finalize_creation_service_spec.rb
new file mode 100644
index 00000000000..0cf91307589
--- /dev/null
+++ b/spec/services/clusters/gcp/finalize_creation_service_spec.rb
@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Clusters::Gcp::FinalizeCreationService do
+  include GoogleApi::CloudPlatformHelpers
+  include KubernetesHelpers
+
+  describe '#execute' do
+    let(:cluster) { create(:cluster, :project, :providing_by_gcp) }
+    let(:provider) { cluster.provider }
+    let(:platform) { cluster.platform }
+    let(:gcp_project_id) { provider.gcp_project_id }
+    let(:zone) { provider.zone }
+    let(:cluster_name) { cluster.name }
+
+    shared_examples 'success' do
+      it 'configures provider and kubernetes' do
+        described_class.new.execute(provider)
+
+        expect(provider).to be_created
+      end
+    end
+
+    shared_examples 'error' do
+      it 'sets an error to provider object' do
+        described_class.new.execute(provider)
+
+        expect(provider.reload).to be_errored
+      end
+    end
+
+    context 'when suceeded to fetch gke cluster info' do
+      let(:endpoint) { '111.111.111.111' }
+      let(:api_url) { 'https://' + endpoint }
+      let(:username) { 'sample-username' }
+      let(:password) { 'sample-password' }
+
+      before do
+        stub_cloud_platform_get_zone_cluster(
+          gcp_project_id, zone, cluster_name,
+          {
+            endpoint: endpoint,
+            username: username,
+            password: password
+          }
+        )
+
+        stub_kubeclient_discover(api_url)
+      end
+
+      context 'when suceeded to fetch kuberenetes token' do
+        let(:token) { 'sample-token' }
+
+        before do
+          stub_kubeclient_get_secrets(
+            api_url,
+            {
+              token: Base64.encode64(token)
+            } )
+        end
+
+        it_behaves_like 'success'
+
+        it 'has corresponded data' do
+          described_class.new.execute(provider)
+          cluster.reload
+          provider.reload
+          platform.reload
+
+          expect(provider.endpoint).to eq(endpoint)
+          expect(platform.api_url).to eq(api_url)
+          expect(platform.ca_cert).to eq(Base64.decode64(load_sample_cert))
+          expect(platform.username).to eq(username)
+          expect(platform.password).to eq(password)
+          expect(platform.token).to eq(token)
+        end
+      end
+
+      context 'when default-token is not found' do
+        before do
+          stub_kubeclient_get_secrets(api_url, metadata_name: 'aaaa')
+        end
+
+        it_behaves_like 'error'
+      end
+
+      context 'when token is empty' do
+        before do
+          stub_kubeclient_get_secrets(api_url, token: '')
+        end
+
+        it_behaves_like 'error'
+      end
+
+      context 'when failed to fetch kuberenetes token' do
+        before do
+          stub_kubeclient_get_secrets_error(api_url)
+        end
+
+        it_behaves_like 'error'
+      end
+    end
+
+    context 'when failed to fetch gke cluster info' do
+      before do
+        stub_cloud_platform_get_zone_cluster_error(gcp_project_id, zone, cluster_name)
+      end
+
+      it_behaves_like 'error'
+    end
+  end
+end
diff --git a/spec/services/clusters/gcp/provision_service_spec.rb b/spec/services/clusters/gcp/provision_service_spec.rb
new file mode 100644
index 00000000000..f48afdc83b2
--- /dev/null
+++ b/spec/services/clusters/gcp/provision_service_spec.rb
@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Clusters::Gcp::ProvisionService do
+  include GoogleApi::CloudPlatformHelpers
+
+  describe '#execute' do
+    let(:provider) { create(:cluster_provider_gcp, :scheduled) }
+    let(:gcp_project_id) { provider.gcp_project_id }
+    let(:zone) { provider.zone }
+
+    shared_examples 'success' do
+      it 'schedules a worker for status minitoring' do
+        expect(WaitForClusterCreationWorker).to receive(:perform_in)
+
+        described_class.new.execute(provider)
+
+        expect(provider.reload).to be_creating
+      end
+    end
+
+    shared_examples 'error' do
+      it 'sets an error to provider object' do
+        described_class.new.execute(provider)
+
+        expect(provider.reload).to be_errored
+      end
+    end
+
+    context 'when suceeded to request provision' do
+      before do
+        stub_cloud_platform_create_cluster(gcp_project_id, zone)
+      end
+
+      it_behaves_like 'success'
+    end
+
+    context 'when operation status is unexpected' do
+      before do
+        stub_cloud_platform_create_cluster(
+          gcp_project_id, zone,
+          {
+            "status": 'unexpected'
+          } )
+      end
+
+      it_behaves_like 'error'
+    end
+
+    context 'when selfLink is unexpected' do
+      before do
+        stub_cloud_platform_create_cluster(
+          gcp_project_id, zone,
+          {
+            "selfLink": 'unexpected'
+          })
+      end
+
+      it_behaves_like 'error'
+    end
+
+    context 'when Internal Server Error happened' do
+      before do
+        stub_cloud_platform_create_cluster_error(gcp_project_id, zone)
+      end
+
+      it_behaves_like 'error'
+    end
+  end
+end
diff --git a/spec/services/clusters/gcp/verify_provision_status_service_spec.rb b/spec/services/clusters/gcp/verify_provision_status_service_spec.rb
new file mode 100644
index 00000000000..2ee2fa51f63
--- /dev/null
+++ b/spec/services/clusters/gcp/verify_provision_status_service_spec.rb
@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Clusters::Gcp::VerifyProvisionStatusService do
+  include GoogleApi::CloudPlatformHelpers
+
+  describe '#execute' do
+    let(:provider) { create(:cluster_provider_gcp, :creating) }
+    let(:gcp_project_id) { provider.gcp_project_id }
+    let(:zone) { provider.zone }
+    let(:operation_id) { provider.operation_id }
+
+    shared_examples 'continue_creation' do
+      it 'schedules a worker for status minitoring' do
+        expect(WaitForClusterCreationWorker).to receive(:perform_in)
+
+        described_class.new.execute(provider)
+      end
+    end
+
+    shared_examples 'finalize_creation' do
+      it 'schedules a worker for status minitoring' do
+        expect_any_instance_of(Clusters::Gcp::FinalizeCreationService).to receive(:execute)
+
+        described_class.new.execute(provider)
+      end
+    end
+
+    shared_examples 'error' do
+      it 'sets an error to provider object' do
+        described_class.new.execute(provider)
+
+        expect(provider.reload).to be_errored
+      end
+    end
+
+    context 'when operation status is RUNNING' do
+      before do
+        stub_cloud_platform_get_zone_operation(
+          gcp_project_id, zone, operation_id,
+          {
+            "status": 'RUNNING',
+            "startTime": 1.minute.ago.strftime("%FT%TZ")
+          } )
+      end
+
+      it_behaves_like 'continue_creation'
+
+      context 'when cluster creation time exceeds timeout' do
+        before do
+          stub_cloud_platform_get_zone_operation(
+            gcp_project_id, zone, operation_id,
+            {
+              "status": 'RUNNING',
+              "startTime": 30.minutes.ago.strftime("%FT%TZ")
+            } )
+        end
+
+        it_behaves_like 'error'
+      end
+    end
+
+    context 'when operation status is PENDING' do
+      before do
+        stub_cloud_platform_get_zone_operation(
+          gcp_project_id, zone, operation_id,
+          {
+            "status": 'PENDING',
+            "startTime": 1.minute.ago.strftime("%FT%TZ")
+          } )
+      end
+
+      it_behaves_like 'continue_creation'
+    end
+
+    context 'when operation status is DONE' do
+      before do
+        stub_cloud_platform_get_zone_operation(
+          gcp_project_id, zone, operation_id,
+          {
+            "status": 'DONE'
+          } )
+      end
+
+      it_behaves_like 'finalize_creation'
+    end
+
+    context 'when operation status is unexpected' do
+      before do
+        stub_cloud_platform_get_zone_operation(
+          gcp_project_id, zone, operation_id,
+          {
+            "status": 'unexpected'
+          } )
+      end
+
+      it_behaves_like 'error'
+    end
+
+    context 'when failed to get operation status' do
+      before do
+        stub_cloud_platform_get_zone_operation_error(gcp_project_id, zone, operation_id)
+      end
+
+      it_behaves_like 'error'
+    end
+  end
+end
diff --git a/spec/services/clusters/update_service_spec.rb b/spec/services/clusters/update_service_spec.rb
new file mode 100644
index 00000000000..2d91a21035d
--- /dev/null
+++ b/spec/services/clusters/update_service_spec.rb
@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Clusters::UpdateService do
+  describe '#execute' do
+    subject { described_class.new(cluster.project, cluster.user, params).execute(cluster) }
+
+    let(:cluster) { create(:cluster, :project, :provided_by_user) }
+
+    context 'when correct params' do
+      context 'when enabled is true' do
+        let(:params) { { enabled: true } }
+
+        it 'enables cluster' do
+          is_expected.to eq(true)
+          expect(cluster.enabled).to be_truthy
+        end
+      end
+
+      context 'when enabled is false' do
+        let(:params) { { enabled: false } }
+
+        it 'disables cluster' do
+          is_expected.to eq(true)
+          expect(cluster.enabled).to be_falsy
+        end
+      end
+
+      context 'when namespace is specified' do
+        let(:params) do
+          {
+            platform_kubernetes_attributes: {
+              namespace: 'custom-namespace'
+            }
+          }
+        end
+
+        it 'updates namespace' do
+          is_expected.to eq(true)
+          expect(cluster.platform.namespace).to eq('custom-namespace')
+        end
+      end
+    end
+
+    context 'when invalid params' do
+      let(:params) do
+        {
+          platform_kubernetes_attributes: {
+            namespace: '!!!'
+          }
+        }
+      end
+
+      it 'returns false' do
+        is_expected.to eq(false)
+        expect(cluster.errors[:"platform_kubernetes.namespace"]).to be_present
+      end
+    end
+  end
+end
diff --git a/spec/services/delete_merged_branches_service_spec.rb b/spec/services/delete_merged_branches_service_spec.rb
index 5a9eb359ee1..0de02576203 100644
--- a/spec/services/delete_merged_branches_service_spec.rb
+++ b/spec/services/delete_merged_branches_service_spec.rb
@@ -42,6 +42,14 @@ describe DeleteMergedBranchesService do
       expect(project.repository.branch_names).to include('improve/awesome')
     end
 
+    it 'ignores protected tags' do
+      create(:protected_tag, project: project, name: 'improve/*')
+
+      service.execute
+
+      expect(project.repository.branch_names).not_to include('improve/awesome')
+    end
+
     context 'user without rights' do
       let(:user) { create(:user) }
 
diff --git a/spec/services/events/render_service_spec.rb b/spec/services/events/render_service_spec.rb
new file mode 100644
index 00000000000..b4a4a44d07b
--- /dev/null
+++ b/spec/services/events/render_service_spec.rb
@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Events::RenderService do
+  describe '#execute' do
+    let!(:note) { build(:note) }
+    let!(:event) { build(:event, target: note, project: note.project) }
+    let!(:user) { build(:user) }
+
+    context 'when the request format is atom' do
+      it 'renders the note inside events' do
+        expect(Banzai::ObjectRenderer).to receive(:new)
+          .with(event.project, user,
+                only_path: false,
+                xhtml: true)
+          .and_call_original
+
+        expect_any_instance_of(Banzai::ObjectRenderer)
+          .to receive(:render).with([note], :note)
+
+        described_class.new(user).execute([event], atom_request: true)
+      end
+    end
+
+    context 'when the request format is not atom' do
+      it 'renders the note inside events' do
+        expect(Banzai::ObjectRenderer).to receive(:new)
+          .with(event.project, user, {})
+          .and_call_original
+
+        expect_any_instance_of(Banzai::ObjectRenderer)
+          .to receive(:render).with([note], :note)
+
+        described_class.new(user).execute([event], atom_request: false)
+      end
+    end
+  end
+end
diff --git a/spec/services/merge_requests/merge_service_spec.rb b/spec/services/merge_requests/merge_service_spec.rb
index ac196e92601..f86f1ac2443 100644
--- a/spec/services/merge_requests/merge_service_spec.rb
+++ b/spec/services/merge_requests/merge_service_spec.rb
@@ -248,6 +248,28 @@ describe MergeRequests::MergeService do
         expect(merge_request.merge_error).to include(error_message)
         expect(Rails.logger).to have_received(:error).with(a_string_matching(error_message))
       end
+
+      context "when fast-forward merge is not allowed" do
+        before do
+          allow_any_instance_of(Repository).to receive(:ancestor?).and_return(nil)
+        end
+
+        %w(semi-linear ff).each do |merge_method|
+          it "logs and saves error if merge is #{merge_method} only" do
+            merge_method = 'rebase_merge' if merge_method == 'semi-linear'
+            merge_request.project.update(merge_method: merge_method)
+            error_message = 'Only fast-forward merge is allowed for your project. Please update your source branch'
+            allow(service).to receive(:execute_hooks)
+
+            service.execute(merge_request)
+
+            expect(merge_request).to be_open
+            expect(merge_request.merge_commit_sha).to be_nil
+            expect(merge_request.merge_error).to include(error_message)
+            expect(Rails.logger).to have_received(:error).with(a_string_matching(error_message))
+          end
+        end
+      end
     end
   end
 end
diff --git a/spec/services/merge_requests/update_service_spec.rb b/spec/services/merge_requests/update_service_spec.rb
index 98409be4236..5ce6ca70c83 100644
--- a/spec/services/merge_requests/update_service_spec.rb
+++ b/spec/services/merge_requests/update_service_spec.rb
@@ -80,7 +80,7 @@ describe MergeRequests::UpdateService, :mailer do
       it 'executes hooks with update action' do
         expect(service)
           .to have_received(:execute_hooks)
-                .with(@merge_request, 'update', old_labels: [], old_assignees: [user3])
+                .with(@merge_request, 'update', old_labels: [], old_assignees: [user3], old_total_time_spent: 0)
       end
 
       it 'sends email to user2 about assign of new merge request and email to user3 about merge request unassignment' do
diff --git a/spec/services/milestones/destroy_service_spec.rb b/spec/services/milestones/destroy_service_spec.rb
index 5739386dd0d..16e288b3148 100644
--- a/spec/services/milestones/destroy_service_spec.rb
+++ b/spec/services/milestones/destroy_service_spec.rb
@@ -4,7 +4,7 @@ describe Milestones::DestroyService do
   let(:user) { create(:user) }
   let(:project) { create(:project) }
   let(:milestone) { create(:milestone, title: 'Milestone v1.0', project: project) }
-  let(:issue) { create(:issue, project: project, milestone: milestone) }
+  let!(:issue) { create(:issue, project: project, milestone: milestone) }
   let(:merge_request) { create(:merge_request, source_project: project, milestone: milestone) }
 
   before do
diff --git a/spec/services/notes/render_service_spec.rb b/spec/services/notes/render_service_spec.rb
new file mode 100644
index 00000000000..faac498037f
--- /dev/null
+++ b/spec/services/notes/render_service_spec.rb
@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Notes::RenderService do
+  describe '#execute' do
+    it 'renders a Note' do
+      note = double(:note)
+      project = double(:project)
+      wiki = double(:wiki)
+      user = double(:user)
+
+      expect(Banzai::ObjectRenderer).to receive(:new)
+        .with(project, user,
+             requested_path: 'foo',
+             project_wiki: wiki,
+             ref: 'bar',
+             only_path: nil,
+             xhtml: false)
+        .and_call_original
+
+      expect_any_instance_of(Banzai::ObjectRenderer)
+        .to receive(:render).with([note], :note)
+
+      described_class.new(user).execute([note], project,
+                                        requested_path: 'foo',
+                                        project_wiki: wiki,
+                                        ref: 'bar',
+                                        only_path: nil,
+                                        xhtml: false)
+    end
+  end
+end
diff --git a/spec/services/projects/import_service_spec.rb b/spec/services/projects/import_service_spec.rb
index 034065aab00..bf7facaec99 100644
--- a/spec/services/projects/import_service_spec.rb
+++ b/spec/services/projects/import_service_spec.rb
@@ -6,6 +6,41 @@ describe Projects::ImportService do
 
   subject { described_class.new(project, user) }
 
+  describe '#async?' do
+    it 'returns true for an asynchronous importer' do
+      importer_class = double(:importer, async?: true)
+
+      allow(subject).to receive(:has_importer?).and_return(true)
+      allow(subject).to receive(:importer_class).and_return(importer_class)
+
+      expect(subject).to be_async
+    end
+
+    it 'returns false for a regular importer' do
+      importer_class = double(:importer, async?: false)
+
+      allow(subject).to receive(:has_importer?).and_return(true)
+      allow(subject).to receive(:importer_class).and_return(importer_class)
+
+      expect(subject).not_to be_async
+    end
+
+    it 'returns false when the importer does not define #async?' do
+      importer_class = double(:importer)
+
+      allow(subject).to receive(:has_importer?).and_return(true)
+      allow(subject).to receive(:importer_class).and_return(importer_class)
+
+      expect(subject).not_to be_async
+    end
+
+    it 'returns false when the importer does not exist' do
+      allow(subject).to receive(:has_importer?).and_return(false)
+
+      expect(subject).not_to be_async
+    end
+  end
+
   describe '#execute' do
     context 'with unknown url' do
       before do
@@ -37,21 +72,24 @@ describe Projects::ImportService do
       end
 
       context 'with a Github repository' do
-        it 'succeeds if repository import is successfully' do
-          expect_any_instance_of(Github::Import).to receive(:execute).and_return(true)
+        it 'succeeds if repository import was scheduled' do
+          expect_any_instance_of(Gitlab::GithubImport::ParallelImporter)
+            .to receive(:execute)
+            .and_return(true)
 
           result = subject.execute
 
           expect(result[:status]).to eq :success
         end
 
-        it 'fails if repository import fails' do
-          expect_any_instance_of(Repository).to receive(:fetch_remote).and_raise(Gitlab::Shell::Error.new('Failed to import the repository'))
+        it 'fails if repository import was not scheduled' do
+          expect_any_instance_of(Gitlab::GithubImport::ParallelImporter)
+            .to receive(:execute)
+            .and_return(false)
 
           result = subject.execute
 
           expect(result[:status]).to eq :error
-          expect(result[:message]).to eq "Error importing repository #{project.import_url} into #{project.path_with_namespace} - The remote data could not be imported."
         end
       end
 
@@ -92,47 +130,22 @@ describe Projects::ImportService do
       end
 
       it 'succeeds if importer succeeds' do
-        allow_any_instance_of(Github::Import).to receive(:execute).and_return(true)
+        allow_any_instance_of(Gitlab::GithubImport::ParallelImporter)
+          .to receive(:execute).and_return(true)
 
         result = subject.execute
 
         expect(result[:status]).to eq :success
       end
 
-      it 'flushes various caches' do
-        allow_any_instance_of(Github::Import).to receive(:execute)
-          .and_return(true)
-
-        expect_any_instance_of(Repository).to receive(:expire_content_cache)
-
-        subject.execute
-      end
-
       it 'fails if importer fails' do
-        allow_any_instance_of(Github::Import).to receive(:execute).and_return(false)
-
-        result = subject.execute
-
-        expect(result[:status]).to eq :error
-        expect(result[:message]).to eq "Error importing repository #{project.import_url} into #{project.full_path} - The remote data could not be imported."
-      end
-
-      it 'fails if importer raise an error' do
-        allow_any_instance_of(Github::Import).to receive(:execute).and_raise(Projects::ImportService::Error.new('Github: failed to connect API'))
+        allow_any_instance_of(Gitlab::GithubImport::ParallelImporter)
+          .to receive(:execute)
+          .and_return(false)
 
         result = subject.execute
 
         expect(result[:status]).to eq :error
-        expect(result[:message]).to eq "Error importing repository #{project.import_url} into #{project.full_path} - Github: failed to connect API"
-      end
-
-      it 'expires content cache after error' do
-        allow_any_instance_of(Project).to receive(:repository_exists?).and_return(false)
-
-        expect_any_instance_of(Repository).to receive(:fetch_remote).and_raise(Gitlab::Shell::Error.new)
-        expect_any_instance_of(Repository).to receive(:expire_content_cache)
-
-        subject.execute
       end
     end
 
diff --git a/spec/services/users/keys_count_service_spec.rb b/spec/services/users/keys_count_service_spec.rb
new file mode 100644
index 00000000000..a188cf86772
--- /dev/null
+++ b/spec/services/users/keys_count_service_spec.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Users::KeysCountService, :use_clean_rails_memory_store_caching do
+  let(:user) { create(:user) }
+  let(:service) { described_class.new(user) }
+
+  describe '#count' do
+    before do
+      create(:personal_key, user: user)
+    end
+
+    it 'returns the number of SSH keys as an Integer' do
+      expect(service.count).to eq(1)
+    end
+
+    it 'caches the number of keys in Redis' do
+      service.delete_cache
+
+      recorder = ActiveRecord::QueryRecorder.new do
+        2.times { service.count }
+      end
+
+      expect(recorder.count).to eq(1)
+    end
+  end
+
+  describe '#refresh_cache' do
+    it 'refreshes the Redis cache' do
+      Rails.cache.write(service.cache_key, 10)
+      service.refresh_cache
+
+      expect(Rails.cache.fetch(service.cache_key, raw: true)).to be_zero
+    end
+  end
+
+  describe '#delete_cache' do
+    it 'removes the cache' do
+      service.count
+      service.delete_cache
+
+      expect(Rails.cache.fetch(service.cache_key, raw: true)).to be_nil
+    end
+  end
+
+  describe '#uncached_count' do
+    it 'returns the number of SSH keys' do
+      expect(service.uncached_count).to be_zero
+    end
+
+    it 'does not cache the number of keys' do
+      recorder = ActiveRecord::QueryRecorder.new do
+        2.times { service.uncached_count }
+      end
+
+      expect(recorder.count).to be > 0
+    end
+  end
+
+  describe '#cache_key' do
+    it 'returns the cache key' do
+      expect(service.cache_key).to eq("users/key-count-service/#{user.id}")
+    end
+  end
+end
diff --git a/spec/support/controllers/githubish_import_controller_shared_examples.rb b/spec/support/controllers/githubish_import_controller_shared_examples.rb
index b23d81a226a..a0839eefe6c 100644
--- a/spec/support/controllers/githubish_import_controller_shared_examples.rb
+++ b/spec/support/controllers/githubish_import_controller_shared_examples.rb
@@ -14,7 +14,7 @@ shared_examples 'a GitHub-ish import controller: POST personal_access_token' do
   it "updates access token" do
     token = 'asdfasdf9876'
 
-    allow_any_instance_of(Gitlab::GithubImport::Client)
+    allow_any_instance_of(Gitlab::LegacyGithubImport::Client)
       .to receive(:user).and_return(true)
 
     post :personal_access_token, personal_access_token: token
@@ -79,7 +79,7 @@ shared_examples 'a GitHub-ish import controller: GET status' do
   end
 
   it "handles an invalid access token" do
-    allow_any_instance_of(Gitlab::GithubImport::Client)
+    allow_any_instance_of(Gitlab::LegacyGithubImport::Client)
       .to receive(:repos).and_raise(Octokit::Unauthorized)
 
     get :status
@@ -110,7 +110,7 @@ shared_examples 'a GitHub-ish import controller: POST create' do
   context "when the repository owner is the provider user" do
     context "when the provider user and GitLab user's usernames match" do
       it "takes the current user's namespace" do
-        expect(Gitlab::GithubImport::ProjectCreator)
+        expect(Gitlab::LegacyGithubImport::ProjectCreator)
           .to receive(:new).with(provider_repo, provider_repo.name, user.namespace, user, access_params, type: provider)
             .and_return(double(execute: true))
 
@@ -122,7 +122,7 @@ shared_examples 'a GitHub-ish import controller: POST create' do
       let(:provider_username) { "someone_else" }
 
       it "takes the current user's namespace" do
-        expect(Gitlab::GithubImport::ProjectCreator)
+        expect(Gitlab::LegacyGithubImport::ProjectCreator)
           .to receive(:new).with(provider_repo, provider_repo.name, user.namespace, user, access_params, type: provider)
             .and_return(double(execute: true))
 
@@ -149,7 +149,7 @@ shared_examples 'a GitHub-ish import controller: POST create' do
         end
 
         it "takes the existing namespace" do
-          expect(Gitlab::GithubImport::ProjectCreator)
+          expect(Gitlab::LegacyGithubImport::ProjectCreator)
             .to receive(:new).with(provider_repo, provider_repo.name, existing_namespace, user, access_params, type: provider)
               .and_return(double(execute: true))
 
@@ -161,7 +161,7 @@ shared_examples 'a GitHub-ish import controller: POST create' do
         it "creates a project using user's namespace" do
           create(:user, username: other_username)
 
-          expect(Gitlab::GithubImport::ProjectCreator)
+          expect(Gitlab::LegacyGithubImport::ProjectCreator)
             .to receive(:new).with(provider_repo, provider_repo.name, user.namespace, user, access_params, type: provider)
               .and_return(double(execute: true))
 
@@ -173,14 +173,14 @@ shared_examples 'a GitHub-ish import controller: POST create' do
     context "when a namespace with the provider user's username doesn't exist" do
       context "when current user can create namespaces" do
         it "creates the namespace" do
-          expect(Gitlab::GithubImport::ProjectCreator)
+          expect(Gitlab::LegacyGithubImport::ProjectCreator)
             .to receive(:new).and_return(double(execute: true))
 
           expect { post :create, target_namespace: provider_repo.name, format: :js }.to change(Namespace, :count).by(1)
         end
 
         it "takes the new namespace" do
-          expect(Gitlab::GithubImport::ProjectCreator)
+          expect(Gitlab::LegacyGithubImport::ProjectCreator)
             .to receive(:new).with(provider_repo, provider_repo.name, an_instance_of(Group), user, access_params, type: provider)
               .and_return(double(execute: true))
 
@@ -194,14 +194,14 @@ shared_examples 'a GitHub-ish import controller: POST create' do
         end
 
         it "doesn't create the namespace" do
-          expect(Gitlab::GithubImport::ProjectCreator)
+          expect(Gitlab::LegacyGithubImport::ProjectCreator)
             .to receive(:new).and_return(double(execute: true))
 
           expect { post :create, format: :js }.not_to change(Namespace, :count)
         end
 
         it "takes the current user's namespace" do
-          expect(Gitlab::GithubImport::ProjectCreator)
+          expect(Gitlab::LegacyGithubImport::ProjectCreator)
             .to receive(:new).with(provider_repo, provider_repo.name, user.namespace, user, access_params, type: provider)
               .and_return(double(execute: true))
 
@@ -219,7 +219,7 @@ shared_examples 'a GitHub-ish import controller: POST create' do
       end
 
       it 'takes the selected namespace and name' do
-        expect(Gitlab::GithubImport::ProjectCreator)
+        expect(Gitlab::LegacyGithubImport::ProjectCreator)
           .to receive(:new).with(provider_repo, test_name, test_namespace, user, access_params, type: provider)
             .and_return(double(execute: true))
 
@@ -227,7 +227,7 @@ shared_examples 'a GitHub-ish import controller: POST create' do
       end
 
       it 'takes the selected name and default namespace' do
-        expect(Gitlab::GithubImport::ProjectCreator)
+        expect(Gitlab::LegacyGithubImport::ProjectCreator)
           .to receive(:new).with(provider_repo, test_name, user.namespace, user, access_params, type: provider)
             .and_return(double(execute: true))
 
@@ -245,7 +245,7 @@ shared_examples 'a GitHub-ish import controller: POST create' do
       end
 
       it 'takes the selected namespace and name' do
-        expect(Gitlab::GithubImport::ProjectCreator)
+        expect(Gitlab::LegacyGithubImport::ProjectCreator)
           .to receive(:new).with(provider_repo, test_name, nested_namespace, user, access_params, type: provider)
             .and_return(double(execute: true))
 
@@ -257,7 +257,7 @@ shared_examples 'a GitHub-ish import controller: POST create' do
       let(:test_name) { 'test_name' }
 
       it 'takes the selected namespace and name' do
-        expect(Gitlab::GithubImport::ProjectCreator)
+        expect(Gitlab::LegacyGithubImport::ProjectCreator)
           .to receive(:new).with(provider_repo, test_name, kind_of(Namespace), user, access_params, type: provider)
             .and_return(double(execute: true))
 
@@ -265,7 +265,7 @@ shared_examples 'a GitHub-ish import controller: POST create' do
       end
 
       it 'creates the namespaces' do
-        allow(Gitlab::GithubImport::ProjectCreator)
+        allow(Gitlab::LegacyGithubImport::ProjectCreator)
           .to receive(:new).with(provider_repo, test_name, kind_of(Namespace), user, access_params, type: provider)
             .and_return(double(execute: true))
 
@@ -274,7 +274,7 @@ shared_examples 'a GitHub-ish import controller: POST create' do
       end
 
       it 'new namespace has the right parent' do
-        allow(Gitlab::GithubImport::ProjectCreator)
+        allow(Gitlab::LegacyGithubImport::ProjectCreator)
           .to receive(:new).with(provider_repo, test_name, kind_of(Namespace), user, access_params, type: provider)
             .and_return(double(execute: true))
 
@@ -289,7 +289,7 @@ shared_examples 'a GitHub-ish import controller: POST create' do
       let!(:parent_namespace) { create(:group, name: 'foo', owner: user) }
 
       it 'takes the selected namespace and name' do
-        expect(Gitlab::GithubImport::ProjectCreator)
+        expect(Gitlab::LegacyGithubImport::ProjectCreator)
           .to receive(:new).with(provider_repo, test_name, kind_of(Namespace), user, access_params, type: provider)
             .and_return(double(execute: true))
 
@@ -297,7 +297,7 @@ shared_examples 'a GitHub-ish import controller: POST create' do
       end
 
       it 'creates the namespaces' do
-        allow(Gitlab::GithubImport::ProjectCreator)
+        allow(Gitlab::LegacyGithubImport::ProjectCreator)
           .to receive(:new).with(provider_repo, test_name, kind_of(Namespace), user, access_params, type: provider)
             .and_return(double(execute: true))
 
diff --git a/spec/support/cycle_analytics_helpers.rb b/spec/support/cycle_analytics_helpers.rb
index 934b4557ba2..26fd271ce31 100644
--- a/spec/support/cycle_analytics_helpers.rb
+++ b/spec/support/cycle_analytics_helpers.rb
@@ -94,6 +94,7 @@ module CycleAnalyticsHelpers
       ref: 'master',
       tag: false,
       name: 'dummy',
+      stage: 'dummy',
       pipeline: dummy_pipeline,
       protected: false)
   end
diff --git a/spec/support/features/discussion_comments_shared_example.rb b/spec/support/features/discussion_comments_shared_example.rb
index aabc64d972b..c24940393f9 100644
--- a/spec/support/features/discussion_comments_shared_example.rb
+++ b/spec/support/features/discussion_comments_shared_example.rb
@@ -71,7 +71,7 @@ shared_examples 'discussion comments' do |resource_name|
       expect(page).not_to have_selector menu_selector
 
       find(toggle_selector).click
-      find('body').click
+      execute_script("document.querySelector('body').click()")
 
       expect(page).not_to have_selector menu_selector
     end
diff --git a/spec/support/gitaly.rb b/spec/support/gitaly.rb
index 89fb362cf14..1512b3e0620 100644
--- a/spec/support/gitaly.rb
+++ b/spec/support/gitaly.rb
@@ -1,6 +1,10 @@
 RSpec.configure do |config|
   config.before(:each) do |example|
-    next if example.metadata[:skip_gitaly_mock]
-    allow(Gitlab::GitalyClient).to receive(:feature_enabled?).and_return(true)
+    if example.metadata[:disable_gitaly]
+      allow(Gitlab::GitalyClient).to receive(:feature_enabled?).and_return(false)
+    else
+      next if example.metadata[:skip_gitaly_mock]
+      allow(Gitlab::GitalyClient).to receive(:feature_enabled?).and_return(true)
+    end
   end
 end
diff --git a/spec/support/google_api/cloud_platform_helpers.rb b/spec/support/google_api/cloud_platform_helpers.rb
new file mode 100644
index 00000000000..dabf0db7666
--- /dev/null
+++ b/spec/support/google_api/cloud_platform_helpers.rb
@@ -0,0 +1,119 @@
+module GoogleApi
+  module CloudPlatformHelpers
+    def stub_google_api_validate_token
+      request.session[GoogleApi::CloudPlatform::Client.session_key_for_token] = 'token'
+      request.session[GoogleApi::CloudPlatform::Client.session_key_for_expires_at] = 1.hour.since.to_i.to_s
+    end
+
+    def stub_google_api_expired_token
+      request.session[GoogleApi::CloudPlatform::Client.session_key_for_token] = 'token'
+      request.session[GoogleApi::CloudPlatform::Client.session_key_for_expires_at] = 1.hour.ago.to_i.to_s
+    end
+
+    def stub_cloud_platform_get_zone_cluster(project_id, zone, cluster_id, **options)
+      WebMock.stub_request(:get, cloud_platform_get_zone_cluster_url(project_id, zone, cluster_id))
+        .to_return(cloud_platform_response(cloud_platform_cluster_body(options)))
+    end
+
+    def stub_cloud_platform_get_zone_cluster_error(project_id, zone, cluster_id)
+      WebMock.stub_request(:get, cloud_platform_get_zone_cluster_url(project_id, zone, cluster_id))
+        .to_return(status: [500, "Internal Server Error"])
+    end
+
+    def stub_cloud_platform_create_cluster(project_id, zone, **options)
+      WebMock.stub_request(:post, cloud_platform_create_cluster_url(project_id, zone))
+        .to_return(cloud_platform_response(cloud_platform_operation_body(options)))
+    end
+
+    def stub_cloud_platform_create_cluster_error(project_id, zone)
+      WebMock.stub_request(:post, cloud_platform_create_cluster_url(project_id, zone))
+        .to_return(status: [500, "Internal Server Error"])
+    end
+
+    def stub_cloud_platform_get_zone_operation(project_id, zone, operation_id, **options)
+      WebMock.stub_request(:get, cloud_platform_get_zone_operation_url(project_id, zone, operation_id))
+        .to_return(cloud_platform_response(cloud_platform_operation_body(options)))
+    end
+
+    def stub_cloud_platform_get_zone_operation_error(project_id, zone, operation_id)
+      WebMock.stub_request(:get, cloud_platform_get_zone_operation_url(project_id, zone, operation_id))
+        .to_return(status: [500, "Internal Server Error"])
+    end
+
+    def cloud_platform_get_zone_cluster_url(project_id, zone, cluster_id)
+      "https://container.googleapis.com/v1/projects/#{project_id}/zones/#{zone}/clusters/#{cluster_id}"
+    end
+
+    def cloud_platform_create_cluster_url(project_id, zone)
+      "https://container.googleapis.com/v1/projects/#{project_id}/zones/#{zone}/clusters"
+    end
+
+    def cloud_platform_get_zone_operation_url(project_id, zone, operation_id)
+      "https://container.googleapis.com/v1/projects/#{project_id}/zones/#{zone}/operations/#{operation_id}"
+    end
+
+    def cloud_platform_response(body)
+      { status: 200, headers: { 'Content-Type' => 'application/json' }, body: body.to_json }
+    end
+
+    def load_sample_cert
+      pem_file = File.expand_path(Rails.root.join('spec/fixtures/clusters/sample_cert.pem'))
+      Base64.encode64(File.read(pem_file))
+    end
+
+    ##
+    # gcloud container clusters create
+    # https://cloud.google.com/container-engine/reference/rest/v1/projects.zones.clusters/create
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def cloud_platform_cluster_body(**options)
+      {
+        "name": options[:name] || 'string',
+        "description": options[:description] || 'string',
+        "initialNodeCount": options[:initialNodeCount] || 'number',
+        "masterAuth": {
+          "username": options[:username] || 'string',
+          "password": options[:password] || 'string',
+          "clusterCaCertificate": options[:clusterCaCertificate] || load_sample_cert,
+          "clientCertificate": options[:clientCertificate] || 'string',
+          "clientKey": options[:clientKey] || 'string'
+        },
+        "loggingService": options[:loggingService] || 'string',
+        "monitoringService": options[:monitoringService] || 'string',
+        "network": options[:network] || 'string',
+        "clusterIpv4Cidr": options[:clusterIpv4Cidr] || 'string',
+        "subnetwork": options[:subnetwork] || 'string',
+        "enableKubernetesAlpha": options[:enableKubernetesAlpha] || 'boolean',
+        "labelFingerprint": options[:labelFingerprint] || 'string',
+        "selfLink": options[:selfLink] || 'string',
+        "zone": options[:zone] || 'string',
+        "endpoint": options[:endpoint] || 'string',
+        "initialClusterVersion": options[:initialClusterVersion] || 'string',
+        "currentMasterVersion": options[:currentMasterVersion] || 'string',
+        "currentNodeVersion": options[:currentNodeVersion] || 'string',
+        "createTime": options[:createTime] || 'string',
+        "status": options[:status] || 'RUNNING',
+        "statusMessage": options[:statusMessage] || 'string',
+        "nodeIpv4CidrSize": options[:nodeIpv4CidrSize] || 'number',
+        "servicesIpv4Cidr": options[:servicesIpv4Cidr] || 'string',
+        "currentNodeCount": options[:currentNodeCount] || 'number',
+        "expireTime": options[:expireTime] || 'string'
+      }
+    end
+
+    def cloud_platform_operation_body(**options)
+      {
+        "name": options[:name] || 'operation-1234567891234-1234567',
+        "zone": options[:zone] || 'us-central1-a',
+        "operationType": options[:operationType] || 'CREATE_CLUSTER',
+        "status": options[:status] || 'PENDING',
+        "detail": options[:detail] || 'detail',
+        "statusMessage": options[:statusMessage] || '',
+        "selfLink": options[:selfLink] || 'https://container.googleapis.com/v1/projects/123456789101/zones/us-central1-a/operations/operation-1234567891234-1234567',
+        "targetLink": options[:targetLink] || 'https://container.googleapis.com/v1/projects/123456789101/zones/us-central1-a/clusters/test-cluster',
+        "startTime": options[:startTime] || '2017-09-13T16:49:13.055601589Z',
+        "endTime": options[:endTime] || ''
+      }
+    end
+  end
+end
diff --git a/spec/support/kubernetes_helpers.rb b/spec/support/kubernetes_helpers.rb
index c92f78b324c..e46b61b6461 100644
--- a/spec/support/kubernetes_helpers.rb
+++ b/spec/support/kubernetes_helpers.rb
@@ -9,22 +9,51 @@ module KubernetesHelpers
     kube_response(kube_pods_body)
   end
 
-  def stub_kubeclient_discover
-    WebMock.stub_request(:get, service.api_url + '/api/v1').to_return(kube_response(kube_v1_discovery_body))
+  def stub_kubeclient_discover(api_url)
+    WebMock.stub_request(:get, api_url + '/api/v1').to_return(kube_response(kube_v1_discovery_body))
   end
 
   def stub_kubeclient_pods(response = nil)
-    stub_kubeclient_discover
+    stub_kubeclient_discover(service.api_url)
     pods_url = service.api_url + "/api/v1/namespaces/#{service.actual_namespace}/pods"
 
     WebMock.stub_request(:get, pods_url).to_return(response || kube_pods_response)
   end
 
+  def stub_kubeclient_get_secrets(api_url, **options)
+    WebMock.stub_request(:get, api_url + '/api/v1/secrets')
+      .to_return(kube_response(kube_v1_secrets_body(options)))
+  end
+
+  def stub_kubeclient_get_secrets_error(api_url)
+    WebMock.stub_request(:get, api_url + '/api/v1/secrets')
+      .to_return(status: [404, "Internal Server Error"])
+  end
+
+  def kube_v1_secrets_body(**options)
+    {
+      "kind" => "SecretList",
+      "apiVersion": "v1",
+      "items" => [
+        {
+          "metadata": {
+            "name": options[:metadata_name] || "default-token-1",
+            "namespace": "kube-system"
+          },
+          "data": {
+            "token": options[:token] || Base64.encode64('token-sample-123')
+          }
+        }
+      ]
+    }
+  end
+
   def kube_v1_discovery_body
     {
       "kind" => "APIResourceList",
       "resources" => [
-        { "name" => "pods", "namespaced" => true, "kind" => "Pod" }
+        { "name" => "pods", "namespaced" => true, "kind" => "Pod" },
+        { "name" => "secrets", "namespaced" => true, "kind" => "Secret" }
       ]
     }
   end
diff --git a/spec/support/legacy_path_redirect_shared_examples.rb b/spec/support/legacy_path_redirect_shared_examples.rb
new file mode 100644
index 00000000000..f300bdd48b1
--- /dev/null
+++ b/spec/support/legacy_path_redirect_shared_examples.rb
@@ -0,0 +1,13 @@
+shared_examples 'redirecting a legacy path' do |source, target|
+  include RSpec::Rails::RequestExampleGroup
+
+  it "redirects #{source} to #{target} when the resource does not exist" do
+    expect(get(source)).to redirect_to(target)
+  end
+
+  it "does not redirect #{source} to #{target} when the resource exists" do
+    resource
+
+    expect(get(source)).not_to redirect_to(target)
+  end
+end
diff --git a/spec/support/matchers/access_matchers_for_controller.rb b/spec/support/matchers/access_matchers_for_controller.rb
index bb6b7c63ee9..cdb62a5deee 100644
--- a/spec/support/matchers/access_matchers_for_controller.rb
+++ b/spec/support/matchers/access_matchers_for_controller.rb
@@ -5,7 +5,7 @@ module AccessMatchersForController
   extend RSpec::Matchers::DSL
   include Warden::Test::Helpers
 
-  EXPECTED_STATUS_CODE_ALLOWED = [200, 201, 302].freeze
+  EXPECTED_STATUS_CODE_ALLOWED = [200, 201, 204, 302].freeze
   EXPECTED_STATUS_CODE_DENIED = [401, 404].freeze
 
   def emulate_user(role, membership = nil)
diff --git a/spec/support/matchers/security_header_matcher.rb b/spec/support/matchers/security_header_matcher.rb
new file mode 100644
index 00000000000..f8518d13ebb
--- /dev/null
+++ b/spec/support/matchers/security_header_matcher.rb
@@ -0,0 +1,5 @@
+RSpec::Matchers.define :include_security_headers do |expected|
+  match do |actual|
+    expect(actual.headers).to include('X-Content-Type-Options')
+  end
+end
diff --git a/spec/support/shared_examples/requests/api/custom_attributes_shared_examples.rb b/spec/support/shared_examples/requests/api/custom_attributes_shared_examples.rb
index 6bc39f2f279..4e18804b937 100644
--- a/spec/support/shared_examples/requests/api/custom_attributes_shared_examples.rb
+++ b/spec/support/shared_examples/requests/api/custom_attributes_shared_examples.rb
@@ -3,7 +3,9 @@ shared_examples 'custom attributes endpoints' do |attributable_name|
   let!(:custom_attribute2) { attributable.custom_attributes.create key: 'bar', value: 'bar' }
 
   describe "GET /#{attributable_name} with custom attributes filter" do
-    let!(:other_attributable) { create attributable.class.name.underscore }
+    before do
+      other_attributable
+    end
 
     context 'with an unauthorized user' do
       it 'does not filter by custom attributes' do
@@ -11,6 +13,7 @@ shared_examples 'custom attributes endpoints' do |attributable_name|
 
         expect(response).to have_gitlab_http_status(200)
         expect(json_response.size).to be 2
+        expect(json_response.map { |r| r['id'] }).to contain_exactly attributable.id, other_attributable.id
       end
     end
 
diff --git a/spec/validators/dynamic_path_validator_spec.rb b/spec/validators/dynamic_path_validator_spec.rb
deleted file mode 100644
index 08e1c5a728a..00000000000
--- a/spec/validators/dynamic_path_validator_spec.rb
+++ /dev/null
@@ -1,97 +0,0 @@
-require 'spec_helper'
-
-describe DynamicPathValidator do
-  let(:validator) { described_class.new(attributes: [:path]) }
-
-  def expect_handles_invalid_utf8
-    expect { yield('\255invalid') }.to be_falsey
-  end
-
-  describe '.valid_user_path' do
-    it 'handles invalid utf8' do
-      expect(described_class.valid_user_path?("a\0weird\255path")).to be_falsey
-    end
-  end
-
-  describe '.valid_group_path' do
-    it 'handles invalid utf8' do
-      expect(described_class.valid_group_path?("a\0weird\255path")).to be_falsey
-    end
-  end
-
-  describe '.valid_project_path' do
-    it 'handles invalid utf8' do
-      expect(described_class.valid_project_path?("a\0weird\255path")).to be_falsey
-    end
-  end
-
-  describe '#path_valid_for_record?' do
-    context 'for project' do
-      it 'calls valid_project_path?' do
-        project = build(:project, path: 'activity')
-
-        expect(described_class).to receive(:valid_project_path?).with(project.full_path).and_call_original
-
-        expect(validator.path_valid_for_record?(project, 'activity')).to be_truthy
-      end
-    end
-
-    context 'for group' do
-      it 'calls valid_group_path?' do
-        group = build(:group, :nested, path: 'activity')
-
-        expect(described_class).to receive(:valid_group_path?).with(group.full_path).and_call_original
-
-        expect(validator.path_valid_for_record?(group, 'activity')).to be_falsey
-      end
-    end
-
-    context 'for user' do
-      it 'calls valid_user_path?' do
-        user = build(:user, username: 'activity')
-
-        expect(described_class).to receive(:valid_user_path?).with(user.full_path).and_call_original
-
-        expect(validator.path_valid_for_record?(user, 'activity')).to be_truthy
-      end
-    end
-
-    context 'for user namespace' do
-      it 'calls valid_user_path?' do
-        user = create(:user, username: 'activity')
-        namespace = user.namespace
-
-        expect(described_class).to receive(:valid_user_path?).with(namespace.full_path).and_call_original
-
-        expect(validator.path_valid_for_record?(namespace, 'activity')).to be_truthy
-      end
-    end
-  end
-
-  describe '#validates_each' do
-    it 'adds a message when the path is not in the correct format' do
-      group = build(:group)
-
-      validator.validate_each(group, :path, "Path with spaces, and comma's!")
-
-      expect(group.errors[:path]).to include(Gitlab::PathRegex.namespace_format_message)
-    end
-
-    it 'adds a message when the path is not in the correct format' do
-      group = build(:group, path: 'users')
-
-      validator.validate_each(group, :path, 'users')
-
-      expect(group.errors[:path]).to include('users is a reserved name')
-    end
-
-    it 'updating to an invalid path is not allowed' do
-      project = create(:project)
-      project.path = 'update'
-
-      validator.validate_each(project, :path, 'update')
-
-      expect(project.errors[:path]).to include('update is a reserved name')
-    end
-  end
-end
diff --git a/spec/validators/namespace_path_validator_spec.rb b/spec/validators/namespace_path_validator_spec.rb
new file mode 100644
index 00000000000..61e2845f35f
--- /dev/null
+++ b/spec/validators/namespace_path_validator_spec.rb
@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe NamespacePathValidator do
+  let(:validator) { described_class.new(attributes: [:path]) }
+
+  describe '.valid_path?' do
+    it 'handles invalid utf8' do
+      expect(described_class.valid_path?("a\0weird\255path")).to be_falsey
+    end
+  end
+
+  describe '#validates_each' do
+    it 'adds a message when the path is not in the correct format' do
+      group = build(:group)
+
+      validator.validate_each(group, :path, "Path with spaces, and comma's!")
+
+      expect(group.errors[:path]).to include(Gitlab::PathRegex.namespace_format_message)
+    end
+
+    it 'adds a message when the path is reserved when creating' do
+      group = build(:group, path: 'help')
+
+      validator.validate_each(group, :path, 'help')
+
+      expect(group.errors[:path]).to include('help is a reserved name')
+    end
+
+    it 'adds a message when the path is reserved when updating' do
+      group = create(:group)
+      group.path = 'help'
+
+      validator.validate_each(group, :path, 'help')
+
+      expect(group.errors[:path]).to include('help is a reserved name')
+    end
+  end
+end
diff --git a/spec/validators/project_path_validator_spec.rb b/spec/validators/project_path_validator_spec.rb
new file mode 100644
index 00000000000..8bb5e72dc22
--- /dev/null
+++ b/spec/validators/project_path_validator_spec.rb
@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe ProjectPathValidator do
+  let(:validator) { described_class.new(attributes: [:path]) }
+
+  describe '.valid_path?' do
+    it 'handles invalid utf8' do
+      expect(described_class.valid_path?("a\0weird\255path")).to be_falsey
+    end
+  end
+
+  describe '#validates_each' do
+    it 'adds a message when the path is not in the correct format' do
+      project = build(:project)
+
+      validator.validate_each(project, :path, "Path with spaces, and comma's!")
+
+      expect(project.errors[:path]).to include(Gitlab::PathRegex.project_path_format_message)
+    end
+
+    it 'adds a message when the path is reserved when creating' do
+      project = build(:project, path: 'blob')
+
+      validator.validate_each(project, :path, 'blob')
+
+      expect(project.errors[:path]).to include('blob is a reserved name')
+    end
+
+    it 'adds a message when the path is reserved when updating' do
+      project = create(:project)
+      project.path = 'blob'
+
+      validator.validate_each(project, :path, 'blob')
+
+      expect(project.errors[:path]).to include('blob is a reserved name')
+    end
+  end
+end
diff --git a/spec/validators/user_path_validator_spec.rb b/spec/validators/user_path_validator_spec.rb
new file mode 100644
index 00000000000..a46089cc24f
--- /dev/null
+++ b/spec/validators/user_path_validator_spec.rb
@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe UserPathValidator do
+  let(:validator) { described_class.new(attributes: [:username]) }
+
+  describe '.valid_path?' do
+    it 'handles invalid utf8' do
+      expect(described_class.valid_path?("a\0weird\255path")).to be_falsey
+    end
+  end
+
+  describe '#validates_each' do
+    it 'adds a message when the path is not in the correct format' do
+      user = build(:user)
+
+      validator.validate_each(user, :username, "Path with spaces, and comma's!")
+
+      expect(user.errors[:username]).to include(Gitlab::PathRegex.namespace_format_message)
+    end
+
+    it 'adds a message when the path is reserved when creating' do
+      user = build(:user, username: 'help')
+
+      validator.validate_each(user, :username, 'help')
+
+      expect(user.errors[:username]).to include('help is a reserved name')
+    end
+
+    it 'adds a message when the path is reserved when updating' do
+      user = create(:user)
+      user.username = 'help'
+
+      validator.validate_each(user, :username, 'help')
+
+      expect(user.errors[:username]).to include('help is a reserved name')
+    end
+  end
+end
diff --git a/spec/views/projects/commit/branches.html.haml_spec.rb b/spec/views/projects/commit/branches.html.haml_spec.rb
new file mode 100644
index 00000000000..b9d4dc80fe0
--- /dev/null
+++ b/spec/views/projects/commit/branches.html.haml_spec.rb
@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe 'projects/commit/branches.html.haml' do
+  let(:project) { create(:project, :repository) }
+
+  before do
+    assign(:project, project)
+  end
+
+  context 'when branches and tags are available' do
+    before do
+      assign(:branches, ['master', 'test-branch'])
+      assign(:branches_limit_exceeded, false)
+      assign(:tags, ['tag1'])
+      assign(:tags_limit_exceeded, false)
+
+      render
+    end
+
+    it 'shows default branch' do
+      expect(rendered).to have_link('master')
+    end
+
+    it 'shows js expand link' do
+      expect(rendered).to have_selector('.js-details-expand')
+    end
+
+    it 'shows branch and tag links' do
+      expect(rendered).to have_link('test-branch')
+      expect(rendered).to have_link('tag1')
+    end
+  end
+
+  context 'when branches are available but no tags' do
+    before do
+      assign(:branches, ['master', 'test-branch'])
+      assign(:branches_limit_exceeded, false)
+      assign(:tags, [])
+      assign(:tags_limit_exceeded, true)
+
+      render
+    end
+
+    it 'shows branches' do
+      expect(rendered).to have_link('master')
+      expect(rendered).to have_link('test-branch')
+    end
+
+    it 'shows js expand link' do
+      expect(rendered).to have_selector('.js-details-expand')
+    end
+
+    it 'shows limit exceeded message for tags' do
+      expect(rendered).to have_text('Tags unavailable')
+    end
+  end
+
+  context 'when tags are available but no branches (just default)' do
+    before do
+      assign(:branches, ['master'])
+      assign(:branches_limit_exceeded, true)
+      assign(:tags, %w(tag1 tag2))
+      assign(:tags_limit_exceeded, false)
+
+      render
+    end
+
+    it 'shows default branch' do
+      expect(rendered).to have_text('master')
+    end
+
+    it 'shows js expand link' do
+      expect(rendered).to have_selector('.js-details-expand')
+    end
+
+    it 'shows tags' do
+      expect(rendered).to have_link('tag1')
+      expect(rendered).to have_link('tag2')
+    end
+
+    it 'shows limit exceeded for branches' do
+      expect(rendered).to have_text('Branches unavailable')
+    end
+  end
+
+  context 'when branches and tags are not available' do
+    before do
+      assign(:branches, ['master'])
+      assign(:branches_limit_exceeded, true)
+      assign(:tags, [])
+      assign(:tags_limit_exceeded, true)
+
+      render
+    end
+
+    it 'shows default branch' do
+      expect(rendered).to have_text('master')
+    end
+
+    it 'shows js expand link' do
+      expect(rendered).to have_selector('.js-details-expand')
+    end
+
+    it 'shows too many to search' do
+      expect(rendered).to have_text('Branches unavailable')
+      expect(rendered).to have_text('Tags unavailable')
+    end
+  end
+end
diff --git a/spec/workers/cluster_provision_worker_spec.rb b/spec/workers/cluster_provision_worker_spec.rb
index 11f208289db..8054ec11a48 100644
--- a/spec/workers/cluster_provision_worker_spec.rb
+++ b/spec/workers/cluster_provision_worker_spec.rb
@@ -2,11 +2,22 @@ require 'spec_helper'
 
 describe ClusterProvisionWorker do
   describe '#perform' do
-    context 'when cluster exists' do
-      let(:cluster) { create(:gcp_cluster) }
+    context 'when provider type is gcp' do
+      let(:cluster) { create(:cluster, provider_type: :gcp, provider_gcp: provider) }
+      let(:provider) { create(:cluster_provider_gcp, :scheduled) }
 
       it 'provision a cluster' do
-        expect_any_instance_of(Ci::ProvisionClusterService).to receive(:execute)
+        expect_any_instance_of(Clusters::Gcp::ProvisionService).to receive(:execute)
+
+        described_class.new.perform(cluster.id)
+      end
+    end
+
+    context 'when provider type is user' do
+      let(:cluster) { create(:cluster, provider_type: :user) }
+
+      it 'does not provision a cluster' do
+        expect_any_instance_of(Clusters::Gcp::ProvisionService).not_to receive(:execute)
 
         described_class.new.perform(cluster.id)
       end
@@ -14,7 +25,7 @@ describe ClusterProvisionWorker do
 
     context 'when cluster does not exist' do
       it 'does not provision a cluster' do
-        expect_any_instance_of(Ci::ProvisionClusterService).not_to receive(:execute)
+        expect_any_instance_of(Clusters::Gcp::ProvisionService).not_to receive(:execute)
 
         described_class.new.perform(123)
       end
diff --git a/spec/workers/concerns/gitlab/github_import/notify_upon_death_spec.rb b/spec/workers/concerns/gitlab/github_import/notify_upon_death_spec.rb
new file mode 100644
index 00000000000..4b9aa9a7ef8
--- /dev/null
+++ b/spec/workers/concerns/gitlab/github_import/notify_upon_death_spec.rb
@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::NotifyUponDeath do
+  let(:worker_class) do
+    Class.new do
+      include Sidekiq::Worker
+      include Gitlab::GithubImport::NotifyUponDeath
+    end
+  end
+
+  describe '.sidekiq_retries_exhausted' do
+    it 'notifies the JobWaiter when 3 arguments are given and the last is a String' do
+      job = { 'args' => [12, {}, '123abc'], 'jid' => '123' }
+
+      expect(Gitlab::JobWaiter)
+        .to receive(:notify)
+        .with('123abc', '123')
+
+      worker_class.sidekiq_retries_exhausted_block.call(job)
+    end
+
+    it 'does not notify the JobWaiter when only 2 arguments are given' do
+      job = { 'args' => [12, {}], 'jid' => '123' }
+
+      expect(Gitlab::JobWaiter)
+        .not_to receive(:notify)
+
+      worker_class.sidekiq_retries_exhausted_block.call(job)
+    end
+
+    it 'does not notify the JobWaiter when only 1 argument is given' do
+      job = { 'args' => [12], 'jid' => '123' }
+
+      expect(Gitlab::JobWaiter)
+        .not_to receive(:notify)
+
+      worker_class.sidekiq_retries_exhausted_block.call(job)
+    end
+
+    it 'does not notify the JobWaiter when the last argument is not a String' do
+      job = { 'args' => [12, {}, 40], 'jid' => '123' }
+
+      expect(Gitlab::JobWaiter)
+        .not_to receive(:notify)
+
+      worker_class.sidekiq_retries_exhausted_block.call(job)
+    end
+  end
+end
diff --git a/spec/workers/concerns/gitlab/github_import/object_importer_spec.rb b/spec/workers/concerns/gitlab/github_import/object_importer_spec.rb
new file mode 100644
index 00000000000..3ccf06f2d7d
--- /dev/null
+++ b/spec/workers/concerns/gitlab/github_import/object_importer_spec.rb
@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::ObjectImporter do
+  let(:worker) do
+    Class.new do
+      include(Gitlab::GithubImport::ObjectImporter)
+
+      def counter_name
+        :dummy_counter
+      end
+
+      def counter_description
+        'This is a counter'
+      end
+    end.new
+  end
+
+  describe '#import' do
+    it 'imports the object' do
+      representation_class = double(:representation_class)
+      importer_class = double(:importer_class)
+      importer_instance = double(:importer_instance)
+      representation = double(:representation)
+      project = double(:project, path_with_namespace: 'foo/bar')
+      client = double(:client)
+
+      expect(worker)
+        .to receive(:representation_class)
+        .and_return(representation_class)
+
+      expect(worker)
+        .to receive(:importer_class)
+        .and_return(importer_class)
+
+      expect(representation_class)
+        .to receive(:from_json_hash)
+        .with(an_instance_of(Hash))
+        .and_return(representation)
+
+      expect(importer_class)
+        .to receive(:new)
+        .with(representation, project, client)
+        .and_return(importer_instance)
+
+      expect(importer_instance)
+        .to receive(:execute)
+
+      expect(worker.counter)
+        .to receive(:increment)
+        .with(project: 'foo/bar')
+        .and_call_original
+
+      worker.import(project, client, { 'number' => 10 })
+    end
+  end
+
+  describe '#counter' do
+    it 'returns a Prometheus counter' do
+      expect(worker)
+        .to receive(:counter_name)
+        .and_call_original
+
+      expect(worker)
+        .to receive(:counter_description)
+        .and_call_original
+
+      worker.counter
+    end
+  end
+end
diff --git a/spec/workers/concerns/gitlab/github_import/queue_spec.rb b/spec/workers/concerns/gitlab/github_import/queue_spec.rb
new file mode 100644
index 00000000000..321ae3fe978
--- /dev/null
+++ b/spec/workers/concerns/gitlab/github_import/queue_spec.rb
@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Queue do
+  it 'sets the Sidekiq options for the worker' do
+    worker = Class.new do
+      include Sidekiq::Worker
+      include Gitlab::GithubImport::Queue
+    end
+
+    expect(worker.sidekiq_options['queue']).to eq('github_importer')
+  end
+end
diff --git a/spec/workers/concerns/gitlab/github_import/rescheduling_methods_spec.rb b/spec/workers/concerns/gitlab/github_import/rescheduling_methods_spec.rb
new file mode 100644
index 00000000000..8de4059c4ae
--- /dev/null
+++ b/spec/workers/concerns/gitlab/github_import/rescheduling_methods_spec.rb
@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::ReschedulingMethods do
+  let(:worker) do
+    Class.new { include(Gitlab::GithubImport::ReschedulingMethods) }.new
+  end
+
+  describe '#perform' do
+    context 'with a non-existing project' do
+      it 'does not perform any work' do
+        expect(worker)
+          .not_to receive(:try_import)
+
+        worker.perform(-1, {})
+      end
+
+      it 'notifies any waiters so they do not wait forever' do
+        expect(worker)
+          .to receive(:notify_waiter)
+          .with('123')
+
+        worker.perform(-1, {}, '123')
+      end
+    end
+
+    context 'with an existing project' do
+      let(:project) { create(:project) }
+
+      it 'notifies any waiters upon successfully importing the data' do
+        expect(worker)
+          .to receive(:try_import)
+          .with(
+            an_instance_of(Project),
+            an_instance_of(Gitlab::GithubImport::Client),
+            { 'number' => 2 }
+          )
+          .and_return(true)
+
+        expect(worker)
+          .to receive(:notify_waiter).with('123')
+
+        worker.perform(project.id, { 'number' => 2 }, '123')
+      end
+
+      it 'reschedules itself if the data could not be imported' do
+        expect(worker)
+          .to receive(:try_import)
+          .with(
+            an_instance_of(Project),
+            an_instance_of(Gitlab::GithubImport::Client),
+            { 'number' => 2 }
+          )
+          .and_return(false)
+
+        expect(worker)
+          .not_to receive(:notify_waiter)
+
+        expect_any_instance_of(Gitlab::GithubImport::Client)
+          .to receive(:rate_limit_resets_in)
+          .and_return(14)
+
+        expect(worker.class)
+          .to receive(:perform_in)
+          .with(14, project.id, { 'number' => 2 }, '123')
+
+        worker.perform(project.id, { 'number' => 2 }, '123')
+      end
+    end
+  end
+
+  describe '#try_import' do
+    it 'returns true when the import succeeds' do
+      expect(worker)
+        .to receive(:import)
+        .with(10, 20)
+
+      expect(worker.try_import(10, 20)).to eq(true)
+    end
+
+    it 'returns false when the import fails due to hitting the GitHub API rate limit' do
+      expect(worker)
+        .to receive(:import)
+        .with(10, 20)
+        .and_raise(Gitlab::GithubImport::RateLimitError)
+
+      expect(worker.try_import(10, 20)).to eq(false)
+    end
+  end
+
+  describe '#notify_waiter' do
+    it 'notifies the waiter if a waiter key is specified' do
+      expect(worker)
+        .to receive(:jid)
+        .and_return('abc123')
+
+      expect(Gitlab::JobWaiter)
+        .to receive(:notify)
+        .with('123', 'abc123')
+
+      worker.notify_waiter('123')
+    end
+
+    it 'does not notify any waiters if no waiter key is specified' do
+      expect(Gitlab::JobWaiter)
+        .not_to receive(:notify)
+
+      worker.notify_waiter(nil)
+    end
+  end
+end
diff --git a/spec/workers/concerns/gitlab/github_import/stage_methods_spec.rb b/spec/workers/concerns/gitlab/github_import/stage_methods_spec.rb
new file mode 100644
index 00000000000..241e8a2b6d3
--- /dev/null
+++ b/spec/workers/concerns/gitlab/github_import/stage_methods_spec.rb
@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::StageMethods do
+  let(:project) { create(:project) }
+  let(:worker) do
+    Class.new { include(Gitlab::GithubImport::StageMethods) }.new
+  end
+
+  describe '#perform' do
+    it 'returns if no project could be found' do
+      expect(worker).not_to receive(:try_import)
+
+      worker.perform(-1)
+    end
+
+    it 'imports the data when the project exists' do
+      allow(worker)
+        .to receive(:find_project)
+        .with(project.id)
+        .and_return(project)
+
+      expect(worker)
+        .to receive(:try_import)
+        .with(
+          an_instance_of(Gitlab::GithubImport::Client),
+          an_instance_of(Project)
+        )
+
+      worker.perform(project.id)
+    end
+  end
+
+  describe '#try_import' do
+    it 'imports the project' do
+      client = double(:client)
+
+      expect(worker)
+        .to receive(:import)
+        .with(client, project)
+
+      worker.try_import(client, project)
+    end
+
+    it 'reschedules the worker if RateLimitError was raised' do
+      client = double(:client, rate_limit_resets_in: 10)
+
+      expect(worker)
+        .to receive(:import)
+        .with(client, project)
+        .and_raise(Gitlab::GithubImport::RateLimitError)
+
+      expect(worker.class)
+        .to receive(:perform_in)
+        .with(10, project.id)
+
+      worker.try_import(client, project)
+    end
+  end
+
+  describe '#find_project' do
+    it 'returns a Project for an existing ID' do
+      project.update_column(:import_status, 'started')
+
+      expect(worker.find_project(project.id)).to eq(project)
+    end
+
+    it 'returns nil for a project that failed importing' do
+      project.update_column(:import_status, 'failed')
+
+      expect(worker.find_project(project.id)).to be_nil
+    end
+
+    it 'returns nil for a non-existing project ID' do
+      expect(worker.find_project(-1)).to be_nil
+    end
+  end
+end
diff --git a/spec/workers/gitlab/github_import/advance_stage_worker_spec.rb b/spec/workers/gitlab/github_import/advance_stage_worker_spec.rb
new file mode 100644
index 00000000000..3be49a0dee8
--- /dev/null
+++ b/spec/workers/gitlab/github_import/advance_stage_worker_spec.rb
@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::AdvanceStageWorker, :clean_gitlab_redis_shared_state do
+  let(:project) { create(:project, import_jid: '123') }
+  let(:worker) { described_class.new }
+
+  describe '#perform' do
+    context 'when the project no longer exists' do
+      it 'does not perform any work' do
+        expect(worker).not_to receive(:wait_for_jobs)
+
+        worker.perform(-1, { '123' => 2 }, :finish)
+      end
+    end
+
+    context 'when there are remaining jobs' do
+      before do
+        allow(worker)
+          .to receive(:find_project)
+          .and_return(project)
+      end
+
+      it 'reschedules itself' do
+        expect(worker)
+          .to receive(:wait_for_jobs)
+          .with({ '123' => 2 })
+          .and_return({ '123' => 1 })
+
+        expect(described_class)
+          .to receive(:perform_in)
+          .with(described_class::INTERVAL, project.id, { '123' => 1 }, :finish)
+
+        worker.perform(project.id, { '123' => 2 }, :finish)
+      end
+    end
+
+    context 'when there are no remaining jobs' do
+      before do
+        allow(worker)
+          .to receive(:find_project)
+          .and_return(project)
+
+        allow(worker)
+          .to receive(:wait_for_jobs)
+          .with({ '123' => 2 })
+          .and_return({})
+      end
+
+      it 'schedules the next stage' do
+        expect(project)
+          .to receive(:refresh_import_jid_expiration)
+
+        expect(Gitlab::GithubImport::Stage::FinishImportWorker)
+          .to receive(:perform_async)
+          .with(project.id)
+
+        worker.perform(project.id, { '123' => 2 }, :finish)
+      end
+
+      it 'raises KeyError when the stage name is invalid' do
+        expect { worker.perform(project.id, { '123' => 2 }, :kittens) }
+          .to raise_error(KeyError)
+      end
+    end
+  end
+
+  describe '#wait_for_jobs' do
+    it 'waits for jobs to complete and returns a new pair of keys to wait for' do
+      waiter1 = double(:waiter1, jobs_remaining: 1, key: '123')
+      waiter2 = double(:waiter2, jobs_remaining: 0, key: '456')
+
+      expect(Gitlab::JobWaiter)
+        .to receive(:new)
+        .ordered
+        .with(2, '123')
+        .and_return(waiter1)
+
+      expect(Gitlab::JobWaiter)
+        .to receive(:new)
+        .ordered
+        .with(1, '456')
+        .and_return(waiter2)
+
+      expect(waiter1)
+        .to receive(:wait)
+        .with(described_class::BLOCKING_WAIT_TIME)
+
+      expect(waiter2)
+        .to receive(:wait)
+        .with(described_class::BLOCKING_WAIT_TIME)
+
+      new_waiters = worker.wait_for_jobs({ '123' => 2, '456' => 1 })
+
+      expect(new_waiters).to eq({ '123' => 1 })
+    end
+  end
+
+  describe '#find_project' do
+    it 'returns a Project' do
+      project.update_column(:import_status, 'started')
+
+      found = worker.find_project(project.id)
+
+      expect(found).to be_an_instance_of(Project)
+
+      # This test is there to make sure we only select the columns we care
+      # about.
+      expect(found.attributes).to eq({ 'id' => nil, 'import_jid' => '123' })
+    end
+
+    it 'returns nil if the project import is not running' do
+      expect(worker.find_project(project.id)).to be_nil
+    end
+  end
+end
diff --git a/spec/workers/gitlab/github_import/import_diff_note_worker_spec.rb b/spec/workers/gitlab/github_import/import_diff_note_worker_spec.rb
new file mode 100644
index 00000000000..7c8c665a9b3
--- /dev/null
+++ b/spec/workers/gitlab/github_import/import_diff_note_worker_spec.rb
@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::ImportDiffNoteWorker do
+  let(:worker) { described_class.new }
+
+  describe '#import' do
+    it 'imports a diff note' do
+      project = double(:project, path_with_namespace: 'foo/bar')
+      client = double(:client)
+      importer = double(:importer)
+      hash = {
+        'noteable_id' => 42,
+        'path' => 'README.md',
+        'commit_id' => '123abc',
+        'diff_hunk' => "@@ -1 +1 @@\n-Hello\n+Hello world",
+        'user' => { 'id' => 4, 'login' => 'alice' },
+        'note' => 'Hello world',
+        'created_at' => Time.zone.now.to_s,
+        'updated_at' => Time.zone.now.to_s
+      }
+
+      expect(Gitlab::GithubImport::Importer::DiffNoteImporter)
+        .to receive(:new)
+        .with(
+          an_instance_of(Gitlab::GithubImport::Representation::DiffNote),
+          project,
+          client
+        )
+        .and_return(importer)
+
+      expect(importer)
+        .to receive(:execute)
+
+      expect(worker.counter)
+        .to receive(:increment)
+        .with(project: 'foo/bar')
+        .and_call_original
+
+      worker.import(project, client, hash)
+    end
+  end
+end
diff --git a/spec/workers/gitlab/github_import/import_issue_worker_spec.rb b/spec/workers/gitlab/github_import/import_issue_worker_spec.rb
new file mode 100644
index 00000000000..4116380ff4d
--- /dev/null
+++ b/spec/workers/gitlab/github_import/import_issue_worker_spec.rb
@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::ImportIssueWorker do
+  let(:worker) { described_class.new }
+
+  describe '#import' do
+    it 'imports an issue' do
+      project = double(:project, path_with_namespace: 'foo/bar')
+      client = double(:client)
+      importer = double(:importer)
+      hash = {
+        'iid' => 42,
+        'title' => 'My Issue',
+        'description' => 'This is my issue',
+        'milestone_number' => 4,
+        'state' => 'opened',
+        'assignees' => [{ 'id' => 4, 'login' => 'alice' }],
+        'label_names' => %w[bug],
+        'user' => { 'id' => 4, 'login' => 'alice' },
+        'created_at' => Time.zone.now.to_s,
+        'updated_at' => Time.zone.now.to_s,
+        'pull_request' => false
+      }
+
+      expect(Gitlab::GithubImport::Importer::IssueAndLabelLinksImporter)
+        .to receive(:new)
+        .with(
+          an_instance_of(Gitlab::GithubImport::Representation::Issue),
+          project,
+          client
+        )
+        .and_return(importer)
+
+      expect(importer)
+        .to receive(:execute)
+
+      expect(worker.counter)
+        .to receive(:increment)
+        .with(project: 'foo/bar')
+        .and_call_original
+
+      worker.import(project, client, hash)
+    end
+  end
+end
diff --git a/spec/workers/gitlab/github_import/import_note_worker_spec.rb b/spec/workers/gitlab/github_import/import_note_worker_spec.rb
new file mode 100644
index 00000000000..0ca825a722b
--- /dev/null
+++ b/spec/workers/gitlab/github_import/import_note_worker_spec.rb
@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::ImportNoteWorker do
+  let(:worker) { described_class.new }
+
+  describe '#import' do
+    it 'imports a note' do
+      project = double(:project, path_with_namespace: 'foo/bar')
+      client = double(:client)
+      importer = double(:importer)
+      hash = {
+        'noteable_id' => 42,
+        'noteable_type' => 'issues',
+        'user' => { 'id' => 4, 'login' => 'alice' },
+        'note' => 'Hello world',
+        'created_at' => Time.zone.now.to_s,
+        'updated_at' => Time.zone.now.to_s
+      }
+
+      expect(Gitlab::GithubImport::Importer::NoteImporter)
+        .to receive(:new)
+        .with(
+          an_instance_of(Gitlab::GithubImport::Representation::Note),
+          project,
+          client
+        )
+        .and_return(importer)
+
+      expect(importer)
+        .to receive(:execute)
+
+      expect(worker.counter)
+        .to receive(:increment)
+        .with(project: 'foo/bar')
+        .and_call_original
+
+      worker.import(project, client, hash)
+    end
+  end
+end
diff --git a/spec/workers/gitlab/github_import/import_pull_request_worker_spec.rb b/spec/workers/gitlab/github_import/import_pull_request_worker_spec.rb
new file mode 100644
index 00000000000..d49f560af42
--- /dev/null
+++ b/spec/workers/gitlab/github_import/import_pull_request_worker_spec.rb
@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::ImportPullRequestWorker do
+  let(:worker) { described_class.new }
+
+  describe '#import' do
+    it 'imports a pull request' do
+      project = double(:project, path_with_namespace: 'foo/bar')
+      client = double(:client)
+      importer = double(:importer)
+      hash = {
+        'iid' => 42,
+        'title' => 'My Pull Request',
+        'description' => 'This is my pull request',
+        'source_branch' => 'my-feature',
+        'source_branch_sha' => '123abc',
+        'target_branch' => 'master',
+        'target_branch_sha' => '456def',
+        'source_repository_id' => 400,
+        'target_repository_id' => 200,
+        'source_repository_owner' => 'alice',
+        'state' => 'closed',
+        'milestone_number' => 4,
+        'user' => { 'id' => 4, 'login' => 'alice' },
+        'assignee' => { 'id' => 4, 'login' => 'alice' },
+        'created_at' => Time.zone.now.to_s,
+        'updated_at' => Time.zone.now.to_s,
+        'merged_at' => Time.zone.now.to_s
+      }
+
+      expect(Gitlab::GithubImport::Importer::PullRequestImporter)
+        .to receive(:new)
+        .with(
+          an_instance_of(Gitlab::GithubImport::Representation::PullRequest),
+          project,
+          client
+        )
+        .and_return(importer)
+
+      expect(importer)
+        .to receive(:execute)
+
+      expect(worker.counter)
+        .to receive(:increment)
+        .with(project: 'foo/bar')
+        .and_call_original
+
+      worker.import(project, client, hash)
+    end
+  end
+end
diff --git a/spec/workers/gitlab/github_import/refresh_import_jid_worker_spec.rb b/spec/workers/gitlab/github_import/refresh_import_jid_worker_spec.rb
new file mode 100644
index 00000000000..073c6d7a2f5
--- /dev/null
+++ b/spec/workers/gitlab/github_import/refresh_import_jid_worker_spec.rb
@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::RefreshImportJidWorker do
+  let(:worker) { described_class.new }
+
+  describe '.perform_in_the_future' do
+    it 'schedules a job in the future' do
+      expect(described_class)
+        .to receive(:perform_in)
+        .with(1.minute.to_i, 10, '123')
+
+      described_class.perform_in_the_future(10, '123')
+    end
+  end
+
+  describe '#perform' do
+    let(:project) { create(:project, import_jid: '123abc') }
+
+    context 'when the project does not exist' do
+      it 'does nothing' do
+        expect(Gitlab::SidekiqStatus)
+          .not_to receive(:running?)
+
+        worker.perform(-1, '123')
+      end
+    end
+
+    context 'when the job is running' do
+      it 'refreshes the import JID and reschedules itself' do
+        allow(worker)
+          .to receive(:find_project)
+          .with(project.id)
+          .and_return(project)
+
+        expect(Gitlab::SidekiqStatus)
+          .to receive(:running?)
+          .with('123')
+          .and_return(true)
+
+        expect(project)
+          .to receive(:refresh_import_jid_expiration)
+
+        expect(worker.class)
+          .to receive(:perform_in_the_future)
+          .with(project.id, '123')
+
+        worker.perform(project.id, '123')
+      end
+    end
+
+    context 'when the job is no longer running' do
+      it 'returns' do
+        allow(worker)
+          .to receive(:find_project)
+          .with(project.id)
+          .and_return(project)
+
+        expect(Gitlab::SidekiqStatus)
+          .to receive(:running?)
+          .with('123')
+          .and_return(false)
+
+        expect(project)
+          .not_to receive(:refresh_import_jid_expiration)
+
+        worker.perform(project.id, '123')
+      end
+    end
+  end
+
+  describe '#find_project' do
+    it 'returns a Project' do
+      project = create(:project, import_status: 'started')
+
+      expect(worker.find_project(project.id)).to be_an_instance_of(Project)
+    end
+
+    it 'only selects the import JID field' do
+      project = create(:project, import_status: 'started', import_jid: '123abc')
+
+      expect(worker.find_project(project.id).attributes)
+        .to eq({ 'id' => nil, 'import_jid' => '123abc' })
+    end
+
+    it 'returns nil for a project for which the import process failed' do
+      project = create(:project, import_status: 'failed')
+
+      expect(worker.find_project(project.id)).to be_nil
+    end
+
+    it 'returns nil for a non-existing project' do
+      expect(worker.find_project(-1)).to be_nil
+    end
+  end
+end
diff --git a/spec/workers/gitlab/github_import/stage/finish_import_worker_spec.rb b/spec/workers/gitlab/github_import/stage/finish_import_worker_spec.rb
new file mode 100644
index 00000000000..91e0cddb5d8
--- /dev/null
+++ b/spec/workers/gitlab/github_import/stage/finish_import_worker_spec.rb
@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Stage::FinishImportWorker do
+  let(:project) { create(:project) }
+  let(:worker) { described_class.new }
+
+  describe '#perform' do
+    it 'marks the import as finished' do
+      expect(project).to receive(:after_import)
+      expect(worker).to receive(:report_import_time).with(project)
+
+      worker.import(double(:client), project)
+    end
+  end
+
+  describe '#report_import_time' do
+    it 'reports the total import time' do
+      expect(worker.histogram)
+        .to receive(:observe)
+        .with({ project: project.path_with_namespace }, a_kind_of(Numeric))
+        .and_call_original
+
+      expect(worker.counter)
+        .to receive(:increment)
+        .and_call_original
+
+      expect(worker.logger).to receive(:info).with(an_instance_of(String))
+
+      worker.report_import_time(project)
+    end
+  end
+end
diff --git a/spec/workers/gitlab/github_import/stage/import_base_data_worker_spec.rb b/spec/workers/gitlab/github_import/stage/import_base_data_worker_spec.rb
new file mode 100644
index 00000000000..8c80d660287
--- /dev/null
+++ b/spec/workers/gitlab/github_import/stage/import_base_data_worker_spec.rb
@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Stage::ImportBaseDataWorker do
+  let(:project) { create(:project) }
+  let(:worker) { described_class.new }
+
+  describe '#import' do
+    it 'imports the base data of a project' do
+      importer = double(:importer)
+      client = double(:client)
+
+      described_class::IMPORTERS.each do |klass|
+        expect(klass)
+          .to receive(:new)
+          .with(project, client)
+          .and_return(importer)
+
+        expect(importer).to receive(:execute)
+      end
+
+      expect(project).to receive(:refresh_import_jid_expiration)
+
+      expect(Gitlab::GithubImport::Stage::ImportPullRequestsWorker)
+        .to receive(:perform_async)
+        .with(project.id)
+
+      worker.import(client, project)
+    end
+  end
+end
diff --git a/spec/workers/gitlab/github_import/stage/import_issues_and_diff_notes_worker_spec.rb b/spec/workers/gitlab/github_import/stage/import_issues_and_diff_notes_worker_spec.rb
new file mode 100644
index 00000000000..ab347f5b75b
--- /dev/null
+++ b/spec/workers/gitlab/github_import/stage/import_issues_and_diff_notes_worker_spec.rb
@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Stage::ImportIssuesAndDiffNotesWorker do
+  let(:project) { create(:project) }
+  let(:worker) { described_class.new }
+
+  describe '#import' do
+    it 'imports the issues and diff notes' do
+      client = double(:client)
+
+      described_class::IMPORTERS.each do |klass|
+        importer = double(:importer)
+        waiter = Gitlab::JobWaiter.new(2, '123')
+
+        expect(klass)
+          .to receive(:new)
+          .with(project, client)
+          .and_return(importer)
+
+        expect(importer)
+          .to receive(:execute)
+          .and_return(waiter)
+      end
+
+      expect(Gitlab::GithubImport::AdvanceStageWorker)
+        .to receive(:perform_async)
+        .with(project.id, { '123' => 2 }, :notes)
+
+      worker.import(client, project)
+    end
+  end
+end
diff --git a/spec/workers/gitlab/github_import/stage/import_notes_worker_spec.rb b/spec/workers/gitlab/github_import/stage/import_notes_worker_spec.rb
new file mode 100644
index 00000000000..098d2d55386
--- /dev/null
+++ b/spec/workers/gitlab/github_import/stage/import_notes_worker_spec.rb
@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Stage::ImportNotesWorker do
+  let(:project) { create(:project) }
+  let(:worker) { described_class.new }
+
+  describe '#import' do
+    it 'imports all the notes' do
+      importer = double(:importer)
+      client = double(:client)
+      waiter = Gitlab::JobWaiter.new(2, '123')
+
+      expect(Gitlab::GithubImport::Importer::NotesImporter)
+        .to receive(:new)
+        .with(project, client)
+        .and_return(importer)
+
+      expect(importer)
+        .to receive(:execute)
+        .and_return(waiter)
+
+      expect(Gitlab::GithubImport::AdvanceStageWorker)
+        .to receive(:perform_async)
+        .with(project.id, { '123' => 2 }, :finish)
+
+      worker.import(client, project)
+    end
+  end
+end
diff --git a/spec/workers/gitlab/github_import/stage/import_pull_requests_worker_spec.rb b/spec/workers/gitlab/github_import/stage/import_pull_requests_worker_spec.rb
new file mode 100644
index 00000000000..2fc91a3e80a
--- /dev/null
+++ b/spec/workers/gitlab/github_import/stage/import_pull_requests_worker_spec.rb
@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Stage::ImportPullRequestsWorker do
+  let(:project) { create(:project) }
+  let(:worker) { described_class.new }
+
+  describe '#import' do
+    it 'imports all the pull requests' do
+      importer = double(:importer)
+      client = double(:client)
+      waiter = Gitlab::JobWaiter.new(2, '123')
+
+      expect(Gitlab::GithubImport::Importer::PullRequestsImporter)
+        .to receive(:new)
+        .with(project, client)
+        .and_return(importer)
+
+      expect(importer)
+        .to receive(:execute)
+        .and_return(waiter)
+
+      expect(project)
+        .to receive(:refresh_import_jid_expiration)
+
+      expect(Gitlab::GithubImport::AdvanceStageWorker)
+        .to receive(:perform_async)
+        .with(project.id, { '123' => 2 }, :issues_and_diff_notes)
+
+      worker.import(client, project)
+    end
+  end
+end
diff --git a/spec/workers/gitlab/github_import/stage/import_repository_worker_spec.rb b/spec/workers/gitlab/github_import/stage/import_repository_worker_spec.rb
new file mode 100644
index 00000000000..adab535ac05
--- /dev/null
+++ b/spec/workers/gitlab/github_import/stage/import_repository_worker_spec.rb
@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Gitlab::GithubImport::Stage::ImportRepositoryWorker do
+  let(:project) { double(:project, id: 4) }
+  let(:worker) { described_class.new }
+
+  describe '#import' do
+    before do
+      expect(Gitlab::GithubImport::RefreshImportJidWorker)
+        .to receive(:perform_in_the_future)
+        .with(project.id, '123')
+
+      expect(worker)
+        .to receive(:jid)
+        .and_return('123')
+    end
+
+    context 'when the import succeeds' do
+      it 'schedules the importing of the base data' do
+        client = double(:client)
+
+        expect_any_instance_of(Gitlab::GithubImport::Importer::RepositoryImporter)
+          .to receive(:execute)
+          .and_return(true)
+
+        expect(Gitlab::GithubImport::Stage::ImportBaseDataWorker)
+          .to receive(:perform_async)
+          .with(project.id)
+
+        worker.import(client, project)
+      end
+    end
+
+    context 'when the import fails' do
+      it 'does not schedule the importing of the base data' do
+        client = double(:client)
+
+        expect_any_instance_of(Gitlab::GithubImport::Importer::RepositoryImporter)
+          .to receive(:execute)
+          .and_return(false)
+
+        expect(Gitlab::GithubImport::Stage::ImportBaseDataWorker)
+          .not_to receive(:perform_async)
+
+        worker.import(client, project)
+      end
+    end
+  end
+end
diff --git a/spec/workers/repository_import_worker_spec.rb b/spec/workers/repository_import_worker_spec.rb
index 5cff5108477..0af537647ad 100644
--- a/spec/workers/repository_import_worker_spec.rb
+++ b/spec/workers/repository_import_worker_spec.rb
@@ -59,5 +59,28 @@ describe RepositoryImportWorker do
         expect(project.reload.import_status).to eq('failed')
       end
     end
+
+    context 'when using an asynchronous importer' do
+      it 'does not mark the import process as finished' do
+        service = double(:service)
+
+        allow(Projects::ImportService)
+          .to receive(:new)
+          .and_return(service)
+
+        allow(service)
+          .to receive(:execute)
+          .and_return(true)
+
+        allow(service)
+          .to receive(:async?)
+          .and_return(true)
+
+        expect_any_instance_of(Project)
+          .not_to receive(:import_finish)
+
+        subject.perform(project.id)
+      end
+    end
   end
 end
diff --git a/spec/workers/update_merge_requests_worker_spec.rb b/spec/workers/update_merge_requests_worker_spec.rb
index 558ff9109ec..0fa19ac84bb 100644
--- a/spec/workers/update_merge_requests_worker_spec.rb
+++ b/spec/workers/update_merge_requests_worker_spec.rb
@@ -23,5 +23,17 @@ describe UpdateMergeRequestsWorker do
 
       perform
     end
+
+    context 'when slow' do
+      before do
+        stub_const("UpdateMergeRequestsWorker::LOG_TIME_THRESHOLD", -1)
+      end
+
+      it 'logs debug info' do
+        expect(Rails.logger).to receive(:info).with(a_string_matching(/\AUpdateMergeRequestsWorker#perform.*project_id=#{project.id},user_id=#{user.id},oldrev=#{oldrev},newrev=#{newrev},ref=#{ref}/))
+
+        perform
+      end
+    end
   end
 end
diff --git a/spec/workers/wait_for_cluster_creation_worker_spec.rb b/spec/workers/wait_for_cluster_creation_worker_spec.rb
index dcd4a3b9aec..0e92b298178 100644
--- a/spec/workers/wait_for_cluster_creation_worker_spec.rb
+++ b/spec/workers/wait_for_cluster_creation_worker_spec.rb
@@ -2,65 +2,32 @@ require 'spec_helper'
 
 describe WaitForClusterCreationWorker do
   describe '#perform' do
-    context 'when cluster exists' do
-      let(:cluster) { create(:gcp_cluster) }
-      let(:operation) { double }
+    context 'when provider type is gcp' do
+      let(:cluster) { create(:cluster, provider_type: :gcp, provider_gcp: provider) }
+      let(:provider) { create(:cluster_provider_gcp, :creating) }
 
-      before do
-        allow(operation).to receive(:status).and_return(status)
-        allow(operation).to receive(:start_time).and_return(1.minute.ago)
-        allow(operation).to receive(:status_message).and_return('error')
-        allow_any_instance_of(Ci::FetchGcpOperationService).to receive(:execute).and_yield(operation)
-      end
-
-      context 'when operation status is RUNNING' do
-        let(:status) { 'RUNNING' }
-
-        it 'reschedules worker' do
-          expect(described_class).to receive(:perform_in)
-
-          described_class.new.perform(cluster.id)
-        end
-
-        context 'when operation timeout' do
-          before do
-            allow(operation).to receive(:start_time).and_return(30.minutes.ago.utc)
-          end
-
-          it 'sets an error message on cluster' do
-            described_class.new.perform(cluster.id)
+      it 'provision a cluster' do
+        expect_any_instance_of(Clusters::Gcp::VerifyProvisionStatusService).to receive(:execute)
 
-            expect(cluster.reload).to be_errored
-          end
-        end
-      end
-
-      context 'when operation status is DONE' do
-        let(:status) { 'DONE' }
-
-        it 'finalizes cluster creation' do
-          expect_any_instance_of(Ci::FinalizeClusterCreationService).to receive(:execute)
-
-          described_class.new.perform(cluster.id)
-        end
+        described_class.new.perform(cluster.id)
       end
+    end
 
-      context 'when operation status is others' do
-        let(:status) { 'others' }
+    context 'when provider type is user' do
+      let(:cluster) { create(:cluster, provider_type: :user) }
 
-        it 'sets an error message on cluster' do
-          described_class.new.perform(cluster.id)
+      it 'does not provision a cluster' do
+        expect_any_instance_of(Clusters::Gcp::VerifyProvisionStatusService).not_to receive(:execute)
 
-          expect(cluster.reload).to be_errored
-        end
+        described_class.new.perform(cluster.id)
       end
     end
 
     context 'when cluster does not exist' do
       it 'does not provision a cluster' do
-        expect_any_instance_of(Ci::FetchGcpOperationService).not_to receive(:execute)
+        expect_any_instance_of(Clusters::Gcp::VerifyProvisionStatusService).not_to receive(:execute)
 
-        described_class.new.perform(1234)
+        described_class.new.perform(123)
       end
     end
   end