Merge branch 'master' into copy-as-md

90 files changed, 2116 insertions, 470 deletions

diff --git a/spec/controllers/projects/services_controller_spec.rb b/spec/controllers/projects/services_controller_spec.rb
index 2e44b5128b4..a6e708c01e4 100644
--- a/spec/controllers/projects/services_controller_spec.rb
+++ b/spec/controllers/projects/services_controller_spec.rb
@@ -54,6 +54,7 @@ describe Projects::ServicesController do
     context 'on successful update' do
       it 'sets the flash' do
         expect(service).to receive(:to_param).and_return('hipchat')
+        expect(service).to receive(:event_names).and_return(HipchatService.event_names)
 
         put :update,
           namespace_id: project.namespace.id,
diff --git a/spec/controllers/projects/settings/integrations_controller_spec.rb b/spec/controllers/projects/settings/integrations_controller_spec.rb
new file mode 100644
index 00000000000..e0f9a5b24a6
--- /dev/null
+++ b/spec/controllers/projects/settings/integrations_controller_spec.rb
@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Projects::Settings::IntegrationsController do
+  let(:project) { create(:project, :public) }
+  let(:user) { create(:user) }
+
+  before do
+    project.team << [user, :master]
+    sign_in(user)
+  end
+
+  describe 'GET show' do
+    it 'renders show with 200 status code' do
+      get :show, namespace_id: project.namespace, project_id: project
+
+      expect(response).to have_http_status(200)
+      expect(response).to render_template(:show)
+    end
+  end
+end
diff --git a/spec/factories/ci/stages.rb b/spec/factories/ci/stages.rb
index ee3b17b8bf1..7f557b25ccb 100644
--- a/spec/factories/ci/stages.rb
+++ b/spec/factories/ci/stages.rb
@@ -3,11 +3,12 @@ FactoryGirl.define do
     transient do
       name 'test'
       status nil
+      warnings nil
       pipeline factory: :ci_empty_pipeline
     end
 
     initialize_with do
-      Ci::Stage.new(pipeline, name: name, status: status)
+      Ci::Stage.new(pipeline, name: name, status: status, warnings: warnings)
     end
   end
 end
diff --git a/spec/features/admin/admin_projects_spec.rb b/spec/features/admin/admin_projects_spec.rb
index a5b88812b75..87a8f62687a 100644
--- a/spec/features/admin/admin_projects_spec.rb
+++ b/spec/features/admin/admin_projects_spec.rb
@@ -10,7 +10,7 @@ describe "Admin::Projects", feature: true  do
   end
 
   describe "GET /admin/projects" do
-    let!(:archived_project) { create :project, :public, archived: true }
+    let!(:archived_project) { create :project, :public, :archived }
 
     before do
       visit admin_projects_path
diff --git a/spec/features/groups/merge_requests_spec.rb b/spec/features/groups/merge_requests_spec.rb
index 30b80aa82b0..78a11ffee99 100644
--- a/spec/features/groups/merge_requests_spec.rb
+++ b/spec/features/groups/merge_requests_spec.rb
@@ -7,7 +7,7 @@ feature 'Group merge requests page', feature: true do
   include_examples 'project features apply to issuables', MergeRequest
 
   context 'archived issuable' do
-    let(:project_archived) { create(:project, group: group, merge_requests_access_level: ProjectFeature::ENABLED, archived: true) }
+    let(:project_archived) { create(:project, :archived, group: group, merge_requests_access_level: ProjectFeature::ENABLED) }
     let(:issuable_archived) { create(:merge_request, source_project: project_archived, target_project: project_archived, title: 'issuable of an archived project') }
     let(:access_level) { ProjectFeature::ENABLED }
     let(:user) { user_in_group }
diff --git a/spec/features/issues/filtered_search/dropdown_assignee_spec.rb b/spec/features/issues/filtered_search/dropdown_assignee_spec.rb
index 3ac9b2e0ae0..8a155c3bfc5 100644
--- a/spec/features/issues/filtered_search/dropdown_assignee_spec.rb
+++ b/spec/features/issues/filtered_search/dropdown_assignee_spec.rb
@@ -43,6 +43,14 @@ describe 'Dropdown assignee', js: true, feature: true do
       expect(page).to have_css(js_dropdown_assignee, visible: true)
     end
 
+    it 'shows assigned to me link' do
+      filtered_search.set('assignee:')
+
+      page.within js_dropdown_assignee do
+        expect(page).to have_content('Assigned to me')
+      end
+    end
+
     it 'closes when the search bar is unfocused' do
       find('body').click()
 
@@ -121,11 +129,19 @@ describe 'Dropdown assignee', js: true, feature: true do
       filtered_search.set('assignee:')
     end
 
+    it 'filters by current user' do
+      page.within js_dropdown_assignee do
+        click_button 'Assigned to me'
+      end
+
+      expect(filtered_search.value).to eq("assignee:#{user.to_reference} ")
+    end
+
     it 'fills in the assignee username when the assignee has not been filtered' do
       click_assignee(user_jacob.name)
 
       expect(page).to have_css(js_dropdown_assignee, visible: false)
-      expect(filtered_search.value).to eq("assignee:@#{user_jacob.username}")
+      expect(filtered_search.value).to eq("assignee:@#{user_jacob.username} ")
     end
 
     it 'fills in the assignee username when the assignee has been filtered' do
@@ -133,14 +149,14 @@ describe 'Dropdown assignee', js: true, feature: true do
       click_assignee(user.name)
 
       expect(page).to have_css(js_dropdown_assignee, visible: false)
-      expect(filtered_search.value).to eq("assignee:@#{user.username}")
+      expect(filtered_search.value).to eq("assignee:@#{user.username} ")
     end
 
     it 'selects `no assignee`' do
       find('#js-dropdown-assignee .filter-dropdown-item', text: 'No Assignee').click
 
       expect(page).to have_css(js_dropdown_assignee, visible: false)
-      expect(filtered_search.value).to eq("assignee:none")
+      expect(filtered_search.value).to eq("assignee:none ")
     end
   end
 
diff --git a/spec/features/issues/filtered_search/dropdown_author_spec.rb b/spec/features/issues/filtered_search/dropdown_author_spec.rb
index 464749d01e3..a5d5d9d4c5e 100644
--- a/spec/features/issues/filtered_search/dropdown_author_spec.rb
+++ b/spec/features/issues/filtered_search/dropdown_author_spec.rb
@@ -121,14 +121,14 @@ describe 'Dropdown author', js: true, feature: true do
       click_author(user_jacob.name)
 
       expect(page).to have_css(js_dropdown_author, visible: false)
-      expect(filtered_search.value).to eq("author:@#{user_jacob.username}")
+      expect(filtered_search.value).to eq("author:@#{user_jacob.username} ")
     end
 
     it 'fills in the author username when the author has been filtered' do
       click_author(user.name)
 
       expect(page).to have_css(js_dropdown_author, visible: false)
-      expect(filtered_search.value).to eq("author:@#{user.username}")
+      expect(filtered_search.value).to eq("author:@#{user.username} ")
     end
   end
 
diff --git a/spec/features/issues/filtered_search/dropdown_label_spec.rb b/spec/features/issues/filtered_search/dropdown_label_spec.rb
index 89c144141c9..bea00160f96 100644
--- a/spec/features/issues/filtered_search/dropdown_label_spec.rb
+++ b/spec/features/issues/filtered_search/dropdown_label_spec.rb
@@ -159,7 +159,7 @@ describe 'Dropdown label', js: true, feature: true do
       click_label(bug_label.title)
 
       expect(page).to have_css(js_dropdown_label, visible: false)
-      expect(filtered_search.value).to eq("label:~#{bug_label.title}")
+      expect(filtered_search.value).to eq("label:~#{bug_label.title} ")
     end
 
     it 'fills in the label name when the label is partially filled' do
@@ -167,49 +167,49 @@ describe 'Dropdown label', js: true, feature: true do
       click_label(bug_label.title)
 
       expect(page).to have_css(js_dropdown_label, visible: false)
-      expect(filtered_search.value).to eq("label:~#{bug_label.title}")
+      expect(filtered_search.value).to eq("label:~#{bug_label.title} ")
     end
 
     it 'fills in the label name that contains multiple words' do
       click_label(two_words_label.title)
 
       expect(page).to have_css(js_dropdown_label, visible: false)
-      expect(filtered_search.value).to eq("label:~\"#{two_words_label.title}\"")
+      expect(filtered_search.value).to eq("label:~\"#{two_words_label.title}\" ")
     end
 
     it 'fills in the label name that contains multiple words and is very long' do
       click_label(long_label.title)
 
       expect(page).to have_css(js_dropdown_label, visible: false)
-      expect(filtered_search.value).to eq("label:~\"#{long_label.title}\"")
+      expect(filtered_search.value).to eq("label:~\"#{long_label.title}\" ")
     end
 
     it 'fills in the label name that contains double quotes' do
       click_label(wont_fix_label.title)
 
       expect(page).to have_css(js_dropdown_label, visible: false)
-      expect(filtered_search.value).to eq("label:~'#{wont_fix_label.title}'")
+      expect(filtered_search.value).to eq("label:~'#{wont_fix_label.title}' ")
     end
 
     it 'fills in the label name with the correct capitalization' do
       click_label(uppercase_label.title)
 
       expect(page).to have_css(js_dropdown_label, visible: false)
-      expect(filtered_search.value).to eq("label:~#{uppercase_label.title}")
+      expect(filtered_search.value).to eq("label:~#{uppercase_label.title} ")
     end
 
     it 'fills in the label name with special characters' do
       click_label(special_label.title)
 
       expect(page).to have_css(js_dropdown_label, visible: false)
-      expect(filtered_search.value).to eq("label:~#{special_label.title}")
+      expect(filtered_search.value).to eq("label:~#{special_label.title} ")
     end
 
     it 'selects `no label`' do
       find('#js-dropdown-label .filter-dropdown-item', text: 'No Label').click
 
       expect(page).to have_css(js_dropdown_label, visible: false)
-      expect(filtered_search.value).to eq("label:none")
+      expect(filtered_search.value).to eq("label:none ")
     end
   end
 
diff --git a/spec/features/issues/filtered_search/dropdown_milestone_spec.rb b/spec/features/issues/filtered_search/dropdown_milestone_spec.rb
index e5a271b663f..134e58ad586 100644
--- a/spec/features/issues/filtered_search/dropdown_milestone_spec.rb
+++ b/spec/features/issues/filtered_search/dropdown_milestone_spec.rb
@@ -127,7 +127,7 @@ describe 'Dropdown milestone', js: true, feature: true do
       click_milestone(milestone.title)
 
       expect(page).to have_css(js_dropdown_milestone, visible: false)
-      expect(filtered_search.value).to eq("milestone:%#{milestone.title}")
+      expect(filtered_search.value).to eq("milestone:%#{milestone.title} ")
     end
 
     it 'fills in the milestone name when the milestone is partially filled' do
@@ -135,56 +135,56 @@ describe 'Dropdown milestone', js: true, feature: true do
       click_milestone(milestone.title)
 
       expect(page).to have_css(js_dropdown_milestone, visible: false)
-      expect(filtered_search.value).to eq("milestone:%#{milestone.title}")
+      expect(filtered_search.value).to eq("milestone:%#{milestone.title} ")
     end
 
     it 'fills in the milestone name that contains multiple words' do
       click_milestone(two_words_milestone.title)
 
       expect(page).to have_css(js_dropdown_milestone, visible: false)
-      expect(filtered_search.value).to eq("milestone:%\"#{two_words_milestone.title}\"")
+      expect(filtered_search.value).to eq("milestone:%\"#{two_words_milestone.title}\" ")
     end
 
     it 'fills in the milestone name that contains multiple words and is very long' do
       click_milestone(long_milestone.title)
 
       expect(page).to have_css(js_dropdown_milestone, visible: false)
-      expect(filtered_search.value).to eq("milestone:%\"#{long_milestone.title}\"")
+      expect(filtered_search.value).to eq("milestone:%\"#{long_milestone.title}\" ")
     end
 
     it 'fills in the milestone name that contains double quotes' do
       click_milestone(wont_fix_milestone.title)
 
       expect(page).to have_css(js_dropdown_milestone, visible: false)
-      expect(filtered_search.value).to eq("milestone:%'#{wont_fix_milestone.title}'")
+      expect(filtered_search.value).to eq("milestone:%'#{wont_fix_milestone.title}' ")
     end
 
     it 'fills in the milestone name with the correct capitalization' do
       click_milestone(uppercase_milestone.title)
 
       expect(page).to have_css(js_dropdown_milestone, visible: false)
-      expect(filtered_search.value).to eq("milestone:%#{uppercase_milestone.title}")
+      expect(filtered_search.value).to eq("milestone:%#{uppercase_milestone.title} ")
     end
 
     it 'fills in the milestone name with special characters' do
       click_milestone(special_milestone.title)
 
       expect(page).to have_css(js_dropdown_milestone, visible: false)
-      expect(filtered_search.value).to eq("milestone:%#{special_milestone.title}")
+      expect(filtered_search.value).to eq("milestone:%#{special_milestone.title} ")
     end
 
     it 'selects `no milestone`' do
       click_static_milestone('No Milestone')
 
       expect(page).to have_css(js_dropdown_milestone, visible: false)
-      expect(filtered_search.value).to eq("milestone:none")
+      expect(filtered_search.value).to eq("milestone:none ")
     end
 
     it 'selects `upcoming milestone`' do
       click_static_milestone('Upcoming')
 
       expect(page).to have_css(js_dropdown_milestone, visible: false)
-      expect(filtered_search.value).to eq("milestone:upcoming")
+      expect(filtered_search.value).to eq("milestone:upcoming ")
     end
   end
 
diff --git a/spec/features/issues/filtered_search/filter_issues_spec.rb b/spec/features/issues/filtered_search/filter_issues_spec.rb
index ead43d6784a..f48a0193545 100644
--- a/spec/features/issues/filtered_search/filter_issues_spec.rb
+++ b/spec/features/issues/filtered_search/filter_issues_spec.rb
@@ -19,9 +19,12 @@ describe 'Filter issues', js: true, feature: true do
   let!(:closed_issue) { create(:issue, title: 'bug that is closed', project: project, state: :closed) }
   let(:filtered_search) { find('.filtered-search') }
 
-  def input_filtered_search(search_term)
+  def input_filtered_search(search_term, submit: true)
     filtered_search.set(search_term)
-    filtered_search.send_keys(:enter)
+
+    if submit
+      filtered_search.send_keys(:enter)
+    end
   end
 
   def expect_filtered_search_input(input)
@@ -43,6 +46,10 @@ describe 'Filter issues', js: true, feature: true do
     end
   end
 
+  def select_search_at_index(pos)
+    evaluate_script("el = document.querySelector('.filtered-search'); el.focus(); el.setSelectionRange(#{pos}, #{pos});")
+  end
+
   before do
     project.team << [user, :master]
     project.team << [user2, :master]
@@ -522,6 +529,44 @@ describe 'Filter issues', js: true, feature: true do
     end
   end
 
+  describe 'overwrites selected filter' do
+    it 'changes author' do
+      input_filtered_search("author:@#{user.username}", submit: false)
+
+      select_search_at_index(3)
+
+      page.within '#js-dropdown-author' do
+        click_button user2.username
+      end
+
+      expect(filtered_search.value).to eq("author:@#{user2.username} ")
+    end
+
+    it 'changes label' do
+      input_filtered_search("author:@#{user.username} label:~#{bug_label.title}", submit: false)
+
+      select_search_at_index(27)
+
+      page.within '#js-dropdown-label' do
+        click_button label.name
+      end
+
+      expect(filtered_search.value).to eq("author:@#{user.username} label:~#{label.name} ")
+    end
+
+    it 'changes label correctly space is in previous label' do
+      input_filtered_search("label:~\"#{multiple_words_label.title}\"", submit: false)
+
+      select_search_at_index(0)
+
+      page.within '#js-dropdown-label' do
+        click_button label.name
+      end
+
+      expect(filtered_search.value).to eq("label:~#{label.name} ")
+    end
+  end
+
   describe 'filter issues by text' do
     context 'only text' do
       it 'filters issues by searched text' do
diff --git a/spec/features/merge_requests/cherry_pick_spec.rb b/spec/features/merge_requests/cherry_pick_spec.rb
index 82bc5226d07..dfe7c910a10 100644
--- a/spec/features/merge_requests/cherry_pick_spec.rb
+++ b/spec/features/merge_requests/cherry_pick_spec.rb
@@ -2,7 +2,8 @@ require 'spec_helper'
 
 describe 'Cherry-pick Merge Requests' do
   let(:user) { create(:user) }
-  let(:project) { create(:project) }
+  let(:group) { create(:group) }
+  let(:project) { create(:project, namespace: group) }
   let(:merge_request) { create(:merge_request_with_diffs, source_project: project, author: user) }
 
   before do
diff --git a/spec/features/merge_requests/edit_mr_spec.rb b/spec/features/merge_requests/edit_mr_spec.rb
index c46bd8d449f..cb3bc392903 100644
--- a/spec/features/merge_requests/edit_mr_spec.rb
+++ b/spec/features/merge_requests/edit_mr_spec.rb
@@ -40,5 +40,32 @@ feature 'Edit Merge Request', feature: true do
 
       expect(page).to have_content 'Remove source branch'
     end
+
+    it 'should preserve description textarea height', js: true do
+      long_description = %q(
+        Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam ac ornare ligula, ut tempus arcu. Etiam ultricies accumsan dolor vitae faucibus. Donec at elit lacus. Mauris orci ante, aliquam quis lorem eget, convallis faucibus arcu. Aenean at pulvinar lacus. Ut viverra quam massa, molestie ornare tortor dignissim a. Suspendisse tristique pellentesque tellus, id lacinia metus elementum id. Nam tristique, arcu rhoncus faucibus viverra, lacus ipsum sagittis ligula, vitae convallis odio lacus a nibh. Ut tincidunt est purus, ac vestibulum augue maximus in. Suspendisse vel erat et mi ultricies semper. Pellentesque volutpat pellentesque consequat.
+
+        Cras congue nec ligula tristique viverra. Curabitur fringilla fringilla fringilla. Donec rhoncus dignissim orci ut accumsan. Ut rutrum urna a rhoncus varius. Maecenas blandit, mauris nec accumsan gravida, augue nibh finibus magna, sed maximus turpis libero nec neque. Suspendisse at semper est. Nunc imperdiet dapibus dui, varius sollicitudin erat luctus non. Sed pellentesque ligula eget posuere facilisis. Donec dictum commodo volutpat. Donec egestas dui ac magna sollicitudin bibendum. Vivamus purus neque, ullamcorper ac feugiat et, tempus sit amet metus. Praesent quis viverra neque. Sed bibendum viverra est, eu aliquam mi ornare vitae. Proin et dapibus ipsum. Nunc tortor diam, malesuada nec interdum vel, placerat quis justo. Ut viverra at erat eu laoreet.
+
+        Pellentesque commodo, diam sit amet dignissim condimentum, tortor justo pretium est, non venenatis metus eros ut nunc. Etiam ut neque eget sem dapibus aliquam. Curabitur vel elit lorem. Nulla nec enim elit. Sed ut ex id justo facilisis convallis at ac augue. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Nullam cursus egestas turpis non tristique. Suspendisse in erat sem. Fusce libero elit, fermentum gravida mauris id, auctor iaculis felis. Nullam vulputate tempor laoreet.
+
+        Nam tempor et magna sed convallis. Fusce sit amet sollicitudin risus, a ullamcorper lacus. Morbi gravida quis sem eget porttitor. Donec eu egestas mauris, in elementum tortor. Sed eget ex mi. Mauris iaculis tortor ut est auctor, nec dignissim quam sagittis. Suspendisse vel metus non quam suscipit tincidunt. Cras molestie lacus non justo finibus sodales quis vitae erat. In a porttitor nisi, id sollicitudin urna. Ut at felis tellus. Suspendisse potenti.
+
+        Maecenas leo ligula, varius at neque vitae, ornare maximus justo. Nullam convallis luctus risus et vulputate. Duis suscipit faucibus iaculis. Etiam quis tortor faucibus, tristique tellus sit amet, sodales neque. Nulla dapibus nisi vel aliquet consequat. Etiam faucibus, metus eget condimentum iaculis, enim urna lobortis sem, id efficitur eros sapien nec nisi. Aenean ut finibus ex.
+      )
+
+      fill_in 'merge_request_description', with: long_description
+
+      height = get_textarea_height
+      find('.js-md-preview-button').click
+      find('.js-md-write-button').click
+      new_height = get_textarea_height
+
+      expect(height).to eq(new_height)
+    end
+
+    def get_textarea_height
+      page.evaluate_script('document.getElementById("merge_request_description").offsetHeight')
+    end
   end
 end
diff --git a/spec/features/merge_requests/merge_immediately_with_pipeline_spec.rb b/spec/features/merge_requests/merge_immediately_with_pipeline_spec.rb
new file mode 100644
index 00000000000..f2f8f11ab28
--- /dev/null
+++ b/spec/features/merge_requests/merge_immediately_with_pipeline_spec.rb
@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+feature 'Merge immediately', :feature, :js do
+  let(:user) { create(:user) }
+  let(:project) { create(:project, :public) }
+
+  let(:merge_request) do
+    create(:merge_request_with_diffs, source_project: project,
+                                      author: user,
+                                      title: 'Bug NS-04')
+  end
+
+  let(:pipeline) do
+    create(:ci_pipeline, project: project,
+                         sha: merge_request.diff_head_sha,
+                         ref: merge_request.source_branch)
+  end
+
+  before { project.team << [user, :master] }
+
+  context 'when there is active pipeline for merge request' do
+    background do
+      create(:ci_build, pipeline: pipeline)
+    end
+
+    before do
+      login_as user
+      visit namespace_project_merge_request_path(merge_request.project.namespace, merge_request.project, merge_request)
+    end
+
+    it 'enables merge immediately' do
+      page.within '.mr-widget-body' do
+        find('.dropdown-toggle').click
+
+        click_link 'Merge Immediately'
+
+        expect(find('.js-merge-button')).to have_content('Merge in progress')
+      end
+    end
+  end
+end
diff --git a/spec/features/merge_requests/merge_when_pipeline_succeeds_spec.rb b/spec/features/merge_requests/merge_when_pipeline_succeeds_spec.rb
index aa24a905001..2ea9c317bd1 100644
--- a/spec/features/merge_requests/merge_when_pipeline_succeeds_spec.rb
+++ b/spec/features/merge_requests/merge_when_pipeline_succeeds_spec.rb
@@ -32,19 +32,61 @@ feature 'Merge When Pipeline Succeeds', :feature, :js do
       expect(page).to have_button "Merge When Pipeline Succeeds"
     end
 
-    context "Merge When Pipeline Succeeds enabled" do
-      before do
-        click_button "Merge When Pipeline Succeeds"
+    describe 'enabling Merge When Pipeline Succeeds' do
+      shared_examples 'Merge When Pipeline Succeeds activator' do
+        it 'activates the Merge When Pipeline Succeeds feature' do
+          click_button "Merge When Pipeline Succeeds"
+
+          expect(page).to have_content "Set by #{user.name} to be merged automatically when the pipeline succeeds."
+          expect(page).to have_content "The source branch will not be removed."
+          expect(page).to have_link "Cancel Automatic Merge"
+          visit_merge_request(merge_request) # Needed to refresh the page
+          expect(page).to have_content /enabled an automatic merge when the pipeline for \h{8} succeeds/i
+        end
       end
 
-      it 'activates Merge When Pipeline Succeeds feature' do
-        expect(page).to have_link "Cancel Automatic Merge"
+      context "when enabled immediately" do
+        it_behaves_like 'Merge When Pipeline Succeeds activator'
+      end
+
+      context 'when enabled after pipeline status changed' do
+        before do
+          pipeline.run!
 
-        expect(page).to have_content "Set by #{user.name} to be merged automatically when the pipeline succeeds."
-        expect(page).to have_content "The source branch will not be removed."
+          # We depend on merge request widget being reloaded
+          # so we have to wait for asynchronous call to reload it
+          # and have_content expectation handles that.
+          #
+          expect(page).to have_content "Pipeline ##{pipeline.id} running"
+        end
+
+        it_behaves_like 'Merge When Pipeline Succeeds activator'
+      end
+
+      context 'when enabled after it was previously canceled' do
+        before do
+          click_button "Merge When Pipeline Succeeds"
+          click_link "Cancel Automatic Merge"
+        end
+
+        it_behaves_like 'Merge When Pipeline Succeeds activator'
+      end
 
-        visit_merge_request(merge_request) # Needed to refresh the page
-        expect(page).to have_content /enabled an automatic merge when the pipeline for \h{8} succeeds/i
+      context 'when it was enabled and then canceled' do
+        let(:merge_request) do
+          create(:merge_request_with_diffs,
+                 :merge_when_build_succeeds,
+                   source_project: project,
+                   title: 'Bug NS-04',
+                   author: user,
+                   merge_user: user)
+        end
+
+        before do
+          click_link "Cancel Automatic Merge"
+        end
+
+        it_behaves_like 'Merge When Pipeline Succeeds activator'
       end
     end
   end
diff --git a/spec/features/projects/commits/cherry_pick_spec.rb b/spec/features/projects/commits/cherry_pick_spec.rb
index d46d9e9399e..7baf7913424 100644
--- a/spec/features/projects/commits/cherry_pick_spec.rb
+++ b/spec/features/projects/commits/cherry_pick_spec.rb
@@ -2,7 +2,8 @@ require 'spec_helper'
 include WaitForAjax
 
 describe 'Cherry-pick Commits' do
-  let(:project) { create(:project) }
+  let(:group) { create(:group) }
+  let(:project) { create(:project, namespace: group) }
   let(:master_pickable_commit)  { project.commit('7d3b0f7cff5f37573aea97cebfd5692ea1689924') }
   let(:master_pickable_merge)  { project.commit('e56497bb5f03a90a51293fc6d516788730953899') }
 
diff --git a/spec/features/projects/import_export/namespace_export_file_spec.rb b/spec/features/projects/import_export/namespace_export_file_spec.rb
new file mode 100644
index 00000000000..d0bafc6168c
--- /dev/null
+++ b/spec/features/projects/import_export/namespace_export_file_spec.rb
@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+feature 'Import/Export - Namespace export file cleanup', feature: true, js: true do
+  let(:export_path) { "#{Dir::tmpdir}/import_file_spec" }
+  let(:config_hash) { YAML.load_file(Gitlab::ImportExport.config_file).deep_stringify_keys }
+
+  let(:project) { create(:empty_project) }
+
+  background do
+    allow_any_instance_of(Gitlab::ImportExport).to receive(:storage_path).and_return(export_path)
+  end
+
+  after do
+    FileUtils.rm_rf(export_path, secure: true)
+  end
+
+  context 'admin user' do
+    before do
+      login_as(:admin)
+    end
+
+    context 'moving the namespace' do
+      scenario 'removes the export file' do
+        setup_export_project
+
+        old_export_path = project.export_path.dup
+
+        expect(File).to exist(old_export_path)
+
+        project.namespace.update(path: 'new_path')
+
+        expect(File).not_to exist(old_export_path)
+      end
+    end
+
+    context 'deleting the namespace' do
+      scenario 'removes the export file' do
+        setup_export_project
+
+        old_export_path = project.export_path.dup
+
+        expect(File).to exist(old_export_path)
+
+        project.namespace.destroy
+
+        expect(File).not_to exist(old_export_path)
+      end
+    end
+
+    def setup_export_project
+      visit edit_namespace_project_path(project.namespace, project)
+
+      expect(page).to have_content('Export project')
+
+      click_link 'Export project'
+
+      visit edit_namespace_project_path(project.namespace, project)
+
+      expect(page).to have_content('Download export')
+    end
+  end
+end
diff --git a/spec/features/search_spec.rb b/spec/features/search_spec.rb
index a05b83959fb..0fe5a897565 100644
--- a/spec/features/search_spec.rb
+++ b/spec/features/search_spec.rb
@@ -211,4 +211,44 @@ describe "Search", feature: true  do
       end
     end
   end
+
+  describe 'search for commits' do
+    before do
+      visit search_path(project_id: project.id)
+    end
+
+    it 'redirects to commit page when search by sha and only commit found' do
+      fill_in 'search', with: '6d394385cf567f80a8fd85055db1ab4c5295806f'
+
+      click_button 'Search'
+
+      expect(page).to have_current_path(namespace_project_commit_path(project.namespace, project, '6d394385cf567f80a8fd85055db1ab4c5295806f'))
+    end
+
+    it 'redirects to single commit regardless of query case' do
+      fill_in 'search', with: '6D394385cf'
+
+      click_button 'Search'
+
+      expect(page).to have_current_path(namespace_project_commit_path(project.namespace, project, '6d394385cf567f80a8fd85055db1ab4c5295806f'))
+    end
+
+    it 'holds on /search page when the only commit is found by message' do
+      create_commit('Message referencing another sha: "deadbeef" ', project, user, 'master')
+
+      fill_in 'search', with: 'deadbeef'
+      click_button 'Search'
+
+      expect(page).to have_current_path('/search', only_path: true)
+    end
+
+    it 'shows multiple matching commits' do
+      fill_in 'search', with: 'See merge request'
+
+      click_button 'Search'
+      click_link 'Commits'
+
+      expect(page).to have_selector('.commit-row-description', count: 9)
+    end
+  end
 end
diff --git a/spec/features/security/project/internal_access_spec.rb b/spec/features/security/project/internal_access_spec.rb
index ecebabefff8..92d5a2fbc48 100644
--- a/spec/features/security/project/internal_access_spec.rb
+++ b/spec/features/security/project/internal_access_spec.rb
@@ -262,8 +262,8 @@ describe "Internal Project Access", feature: true  do
     it { is_expected.to be_denied_for(:visitor) }
   end
 
-  describe "GET /:project_path/hooks" do
-    subject { namespace_project_hooks_path(project.namespace, project) }
+  describe "GET /:project_path/settings/integrations" do
+    subject { namespace_project_settings_integrations_path(project.namespace, project) }
 
     it { is_expected.to be_allowed_for(:admin) }
     it { is_expected.to be_allowed_for(:owner).of(project) }
diff --git a/spec/features/security/project/private_access_spec.rb b/spec/features/security/project/private_access_spec.rb
index 9bc59a7c4f9..b616e488487 100644
--- a/spec/features/security/project/private_access_spec.rb
+++ b/spec/features/security/project/private_access_spec.rb
@@ -234,8 +234,8 @@ describe "Private Project Access", feature: true  do
     it { is_expected.to be_denied_for(:visitor) }
   end
 
-  describe "GET /:project_path/hooks" do
-    subject { namespace_project_hooks_path(project.namespace, project) }
+  describe "GET /:project_path/namespace/hooks" do
+    subject { namespace_project_settings_integrations_path(project.namespace, project) }
 
     it { is_expected.to be_allowed_for(:admin) }
     it { is_expected.to be_allowed_for(:owner).of(project) }
diff --git a/spec/features/security/project/public_access_spec.rb b/spec/features/security/project/public_access_spec.rb
index a8d43b3d581..ded85e837f4 100644
--- a/spec/features/security/project/public_access_spec.rb
+++ b/spec/features/security/project/public_access_spec.rb
@@ -400,8 +400,8 @@ describe "Public Project Access", feature: true  do
     it { is_expected.to be_allowed_for(:visitor) }
   end
 
-  describe "GET /:project_path/hooks" do
-    subject { namespace_project_hooks_path(project.namespace, project) }
+  describe "GET /:project_path/settings/integrations" do
+    subject { namespace_project_settings_integrations_path(project.namespace, project) }
 
     it { is_expected.to be_allowed_for(:admin) }
     it { is_expected.to be_allowed_for(:owner).of(project) }
diff --git a/spec/features/task_lists_spec.rb b/spec/features/task_lists_spec.rb
index abb27c90e0a..a5d14aa19f1 100644
--- a/spec/features/task_lists_spec.rb
+++ b/spec/features/task_lists_spec.rb
@@ -36,6 +36,19 @@ feature 'Task Lists', feature: true do
     MARKDOWN
   end
 
+  let(:nested_tasks_markdown) do
+    <<-EOT.strip_heredoc
+    - [ ] Task a
+      - [x] Task a.1
+      - [ ] Task a.2
+    - [ ] Task b
+
+    1. [ ] Task 1
+      1. [ ] Task 1.1
+      1. [x] Task 1.2
+    EOT
+  end
+
   before do
     Warden.test_mode!
 
@@ -123,6 +136,35 @@ feature 'Task Lists', feature: true do
         expect(page).to have_content("1 of 1 task completed")
       end
     end
+
+    describe 'nested tasks', js: true do
+      let(:issue) { create(:issue, description: nested_tasks_markdown, author: user, project: project) }
+
+      before { visit_issue(project, issue) }
+
+      it 'renders' do
+        expect(page).to have_selector('ul.task-list',      count: 2)
+        expect(page).to have_selector('li.task-list-item', count: 7)
+        expect(page).to have_selector('ul input[checked]', count: 1)
+        expect(page).to have_selector('ol input[checked]', count: 1)
+      end
+
+      it 'solves tasks' do
+        expect(page).to have_content("2 of 7 tasks completed")
+
+        page.find('li.task-list-item', text: 'Task b').find('input').click
+        page.find('li.task-list-item ul li.task-list-item', text: 'Task a.2').find('input').click
+        page.find('li.task-list-item ol li.task-list-item', text: 'Task 1.1').find('input').click
+
+        expect(page).to have_content("5 of 7 tasks completed")
+
+        visit_issue(project, issue) # reload to see new system notes
+
+        expect(page).to have_content('marked the task Task b as complete')
+        expect(page).to have_content('marked the task Task a.2 as complete')
+        expect(page).to have_content('marked the task Task 1.1 as complete')
+      end
+    end
   end
 
   describe 'for Notes' do
@@ -236,7 +278,7 @@ feature 'Task Lists', feature: true do
         expect(page).to have_content("2 of 6 tasks completed")
       end
     end
-    
+
     describe 'single incomplete task' do
       let!(:merge) { create(:merge_request, :simple, description: singleIncompleteMarkdown, author: user, source_project: project) }
 
diff --git a/spec/features/todos/todos_spec.rb b/spec/features/todos/todos_spec.rb
index 4bda0927692..3850e930b6d 100644
--- a/spec/features/todos/todos_spec.rb
+++ b/spec/features/todos/todos_spec.rb
@@ -165,7 +165,7 @@ describe 'Dashboard Todos', feature: true do
       end
 
       it 'shows the todo' do
-        expect(page).to have_content 'The build failed for your merge request'
+        expect(page).to have_content 'The build failed for merge request'
       end
 
       it 'links to the pipelines for the merge request' do
diff --git a/spec/finders/merge_requests_finder_spec.rb b/spec/finders/merge_requests_finder_spec.rb
index 88361e27102..e4ba1d2f1c2 100644
--- a/spec/finders/merge_requests_finder_spec.rb
+++ b/spec/finders/merge_requests_finder_spec.rb
@@ -6,7 +6,7 @@ describe MergeRequestsFinder do
 
   let(:project1) { create(:project) }
   let(:project2) { create(:project, forked_from_project: project1) }
-  let(:project3) { create(:project, forked_from_project: project1, archived: true) }
+  let(:project3) { create(:project, :archived, forked_from_project: project1) }
 
   let!(:merge_request1) { create(:merge_request, :simple, author: user, source_project: project2, target_project: project1) }
   let!(:merge_request2) { create(:merge_request, :simple, author: user, source_project: project2, target_project: project1, state: 'closed') }
diff --git a/spec/finders/move_to_project_finder_spec.rb b/spec/finders/move_to_project_finder_spec.rb
index fdce4e714ff..dea87980e25 100644
--- a/spec/finders/move_to_project_finder_spec.rb
+++ b/spec/finders/move_to_project_finder_spec.rb
@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe MoveToProjectFinder do
   let(:user) { create(:user) }
-  let(:project) { create(:project) }
+  let(:project) { create(:empty_project) }
 
-  let(:no_access_project) { create(:project) }
-  let(:guest_project) { create(:project) }
-  let(:reporter_project) { create(:project) }
-  let(:developer_project) { create(:project) }
-  let(:master_project) { create(:project) }
+  let(:no_access_project) { create(:empty_project) }
+  let(:guest_project) { create(:empty_project) }
+  let(:reporter_project) { create(:empty_project) }
+  let(:developer_project) { create(:empty_project) }
+  let(:master_project) { create(:empty_project) }
 
   subject { described_class.new(user) }
 
@@ -36,8 +36,8 @@ describe MoveToProjectFinder do
 
       it 'does not return archived projects' do
         reporter_project.team << [user, :reporter]
-        reporter_project.update_attributes(archived: true)
-        other_reporter_project = create(:project)
+        reporter_project.archive!
+        other_reporter_project = create(:empty_project)
         other_reporter_project.team << [user, :reporter]
 
         expect(subject.execute(project).to_a).to eq([other_reporter_project])
@@ -46,7 +46,7 @@ describe MoveToProjectFinder do
       it 'does not return projects for which issues are disabled' do
         reporter_project.team << [user, :reporter]
         reporter_project.update_attributes(issues_enabled: false)
-        other_reporter_project = create(:project)
+        other_reporter_project = create(:empty_project)
         other_reporter_project.team << [user, :reporter]
 
         expect(subject.execute(project).to_a).to eq([other_reporter_project])
@@ -83,10 +83,10 @@ describe MoveToProjectFinder do
       end
 
       it 'returns projects matching a search query' do
-        foo_project = create(:project)
+        foo_project = create(:empty_project)
         foo_project.team << [user, :master]
 
-        wadus_project = create(:project, name: 'wadus')
+        wadus_project = create(:empty_project, name: 'wadus')
         wadus_project.team << [user, :master]
 
         expect(subject.execute(project).to_a).to eq([wadus_project, foo_project])
diff --git a/spec/javascripts/.eslintrc b/spec/javascripts/.eslintrc
index dcbcd014dc3..3cd419b37c9 100644
--- a/spec/javascripts/.eslintrc
+++ b/spec/javascripts/.eslintrc
@@ -23,6 +23,8 @@
   "plugins": ["jasmine"],
   "rules": {
     "prefer-arrow-callback": 0,
-    "func-names": 0
+    "func-names": 0,
+    "jasmine/no-suite-dupes": [1, "branch"],
+    "jasmine/no-spec-dupes": [1, "branch"]
   }
 }
diff --git a/spec/javascripts/environments/environment_spec.js.es6 b/spec/javascripts/environments/environment_spec.js.es6
new file mode 100644
index 00000000000..20e11ca3738
--- /dev/null
+++ b/spec/javascripts/environments/environment_spec.js.es6
@@ -0,0 +1,127 @@
+/* global Vue, environment */
+
+//= require vue
+//= require vue-resource
+//= require flash
+//= require environments/stores/environments_store
+//= require environments/components/environment
+//= require ./mock_data
+
+describe('Environment', () => {
+  preloadFixtures('environments/environments');
+
+  let component;
+
+  beforeEach(() => {
+    loadFixtures('environments/environments');
+  });
+
+  describe('successfull request', () => {
+    describe('without environments', () => {
+      const environmentsEmptyResponseInterceptor = (request, next) => {
+        next(request.respondWith(JSON.stringify([]), {
+          status: 200,
+        }));
+      };
+
+      beforeEach(() => {
+        Vue.http.interceptors.push(environmentsEmptyResponseInterceptor);
+      });
+
+      afterEach(() => {
+        Vue.http.interceptors = _.without(
+          Vue.http.interceptors, environmentsEmptyResponseInterceptor,
+        );
+      });
+
+      it('should render the empty state', (done) => {
+        component = new gl.environmentsList.EnvironmentsComponent({
+          el: document.querySelector('#environments-list-view'),
+          propsData: {
+            store: gl.environmentsList.EnvironmentsStore.create(),
+          },
+        });
+
+        setTimeout(() => {
+          expect(
+            component.$el.querySelector('.js-new-environment-button').textContent,
+          ).toContain('New Environment');
+
+          expect(
+            component.$el.querySelector('.js-blank-state-title').textContent,
+          ).toContain('You don\'t have any environments right now.');
+
+          done();
+        }, 0);
+      });
+    });
+
+    describe('with environments', () => {
+      const environmentsResponseInterceptor = (request, next) => {
+        next(request.respondWith(JSON.stringify([environment]), {
+          status: 200,
+        }));
+      };
+
+      beforeEach(() => {
+        Vue.http.interceptors.push(environmentsResponseInterceptor);
+      });
+
+      afterEach(() => {
+        Vue.http.interceptors = _.without(
+          Vue.http.interceptors, environmentsResponseInterceptor,
+        );
+      });
+
+      it('should render a table with environments', (done) => {
+        component = new gl.environmentsList.EnvironmentsComponent({
+          el: document.querySelector('#environments-list-view'),
+          propsData: {
+            store: gl.environmentsList.EnvironmentsStore.create(),
+          },
+        });
+
+        setTimeout(() => {
+          expect(
+            component.$el.querySelectorAll('table tbody tr').length,
+          ).toEqual(1);
+          done();
+        }, 0);
+      });
+    });
+  });
+
+  describe('unsuccessfull request', () => {
+    const environmentsErrorResponseInterceptor = (request, next) => {
+      next(request.respondWith(JSON.stringify([]), {
+        status: 500,
+      }));
+    };
+
+    beforeEach(() => {
+      Vue.http.interceptors.push(environmentsErrorResponseInterceptor);
+    });
+
+    afterEach(() => {
+      Vue.http.interceptors = _.without(
+        Vue.http.interceptors, environmentsErrorResponseInterceptor,
+      );
+    });
+
+    it('should render empty state', (done) => {
+      component = new gl.environmentsList.EnvironmentsComponent({
+        el: document.querySelector('#environments-list-view'),
+        propsData: {
+          store: gl.environmentsList.EnvironmentsStore.create(),
+        },
+      });
+
+      setTimeout(() => {
+        expect(
+          component.$el.querySelector('.js-blank-state-title').textContent,
+        ).toContain('You don\'t have any environments right now.');
+        done();
+      }, 0);
+    });
+  });
+});
diff --git a/spec/javascripts/environments/mock_data.js.es6 b/spec/javascripts/environments/mock_data.js.es6
index 9e16bc3e6a5..8ecd01f9a83 100644
--- a/spec/javascripts/environments/mock_data.js.es6
+++ b/spec/javascripts/environments/mock_data.js.es6
@@ -133,3 +133,17 @@ const environmentsList = [
     updated_at: '2016-11-07T11:11:16.525Z',
   },
 ];
+
+const environment = {
+  id: 4,
+  name: 'production',
+  state: 'available',
+  external_url: 'http://production.',
+  environment_type: null,
+  last_deployment: {},
+  'stoppable?': false,
+  environment_path: '/root/review-app/environments/4',
+  stop_path: '/root/review-app/environments/4/stop',
+  created_at: '2016-12-16T11:51:04.690Z',
+  updated_at: '2016-12-16T12:04:51.133Z',
+};
diff --git a/spec/javascripts/filtered_search/dropdown_utils_spec.js.es6 b/spec/javascripts/filtered_search/dropdown_utils_spec.js.es6
index ce61b73aa8a..19bd8d53219 100644
--- a/spec/javascripts/filtered_search/dropdown_utils_spec.js.es6
+++ b/spec/javascripts/filtered_search/dropdown_utils_spec.js.es6
@@ -31,41 +31,68 @@
     });
 
     describe('filterWithSymbol', () => {
+      let input;
       const item = {
         title: '@root',
       };
 
+      beforeEach(() => {
+        setFixtures(`
+          <input type="text" id="test" />
+        `);
+
+        input = document.getElementById('test');
+      });
+
       it('should filter without symbol', () => {
-        const updatedItem = gl.DropdownUtils.filterWithSymbol('@', item, ':roo');
+        input.value = ':roo';
+
+        const updatedItem = gl.DropdownUtils.filterWithSymbol('@', input, item);
         expect(updatedItem.droplab_hidden).toBe(false);
       });
 
       it('should filter with symbol', () => {
-        const updatedItem = gl.DropdownUtils.filterWithSymbol('@', item, ':@roo');
+        input.value = '@roo';
+
+        const updatedItem = gl.DropdownUtils.filterWithSymbol('@', input, item);
         expect(updatedItem.droplab_hidden).toBe(false);
       });
 
       it('should filter with colon', () => {
-        const updatedItem = gl.DropdownUtils.filterWithSymbol('@', item, ':');
+        input.value = 'roo';
+
+        const updatedItem = gl.DropdownUtils.filterWithSymbol('@', input, item);
         expect(updatedItem.droplab_hidden).toBe(false);
       });
     });
 
     describe('filterHint', () => {
+      let input;
+
+      beforeEach(() => {
+        setFixtures(`
+          <input type="text" id="test" />
+        `);
+
+        input = document.getElementById('test');
+      });
+
       it('should filter', () => {
-        let updatedItem = gl.DropdownUtils.filterHint({
+        input.value = 'l';
+        let updatedItem = gl.DropdownUtils.filterHint(input, {
           hint: 'label',
-        }, 'l');
+        });
         expect(updatedItem.droplab_hidden).toBe(false);
 
-        updatedItem = gl.DropdownUtils.filterHint({
+        input.value = 'o';
+        updatedItem = gl.DropdownUtils.filterHint(input, {
           hint: 'label',
         }, 'o');
         expect(updatedItem.droplab_hidden).toBe(true);
       });
 
       it('should return droplab_hidden false when item has no hint', () => {
-        const updatedItem = gl.DropdownUtils.filterHint({}, '');
+        const updatedItem = gl.DropdownUtils.filterHint(input, {}, '');
         expect(updatedItem.droplab_hidden).toBe(false);
       });
     });
diff --git a/spec/javascripts/filtered_search/filtered_search_dropdown_manager_spec.js.es6 b/spec/javascripts/filtered_search/filtered_search_dropdown_manager_spec.js.es6
index d0d27ceb4a6..4bd45eb457d 100644
--- a/spec/javascripts/filtered_search/filtered_search_dropdown_manager_spec.js.es6
+++ b/spec/javascripts/filtered_search/filtered_search_dropdown_manager_spec.js.es6
@@ -31,7 +31,7 @@
 
         it('should add tokenName and tokenValue', () => {
           gl.FilteredSearchDropdownManager.addWordToInput('label', 'none');
-          expect(getInputValue()).toBe('label:none');
+          expect(getInputValue()).toBe('label:none ');
         });
       });
 
@@ -45,13 +45,13 @@
         it('should replace tokenValue', () => {
           setInputValue('author:roo');
           gl.FilteredSearchDropdownManager.addWordToInput('author', '@root');
-          expect(getInputValue()).toBe('author:@root');
+          expect(getInputValue()).toBe('author:@root ');
         });
 
         it('should add tokenValues containing spaces', () => {
           setInputValue('label:~"test');
           gl.FilteredSearchDropdownManager.addWordToInput('label', '~\'"test me"\'');
-          expect(getInputValue()).toBe('label:~\'"test me"\'');
+          expect(getInputValue()).toBe('label:~\'"test me"\' ');
         });
       });
     });
diff --git a/spec/javascripts/fixtures/environments/environments.html.haml b/spec/javascripts/fixtures/environments/environments.html.haml
index d89bc50c1f0..e6000fbb553 100644
--- a/spec/javascripts/fixtures/environments/environments.html.haml
+++ b/spec/javascripts/fixtures/environments/environments.html.haml
@@ -1,5 +1,5 @@
 %div
-  #environments-list-view{ data: { environments_data: "https://gitlab.com/foo/environments",
+  #environments-list-view{ data: { environments_data: "foo/environments",
     "can-create-deployment" => "true",
     "can-read-environment" => "true",
     "can-create-environment" => "true",
diff --git a/spec/javascripts/fixtures/mini_dropdown_graph.html.haml b/spec/javascripts/fixtures/mini_dropdown_graph.html.haml
index e9bf7568e95..29370b974af 100644
--- a/spec/javascripts/fixtures/mini_dropdown_graph.html.haml
+++ b/spec/javascripts/fixtures/mini_dropdown_graph.html.haml
@@ -1,8 +1,9 @@
-%div.js-builds-dropdown-tests
-  %button.dropdown.js-builds-dropdown-button{'data-stage-endpoint' => 'foobar'}
+%div.js-builds-dropdown-tests.dropdown.dropdown.js-mini-pipeline-graph
+  %button.js-builds-dropdown-button{'data-stage-endpoint' => 'foobar', data: { toggle: 'dropdown'} }
     Dropdown
-  %div.js-builds-dropdown-container
-    %div.js-builds-dropdown-list
 
-    %div.js-builds-dropdown-loading.builds-dropdown-loading.hidden
+  %ul.dropdown-menu.mini-pipeline-graph-dropdown-menu.js-builds-dropdown-container
+    .js-builds-dropdown-list.scrollable-menu
+
+    .js-builds-dropdown-loading.builds-dropdown-loading.hidden
       %span.fa.fa-spinner.fa-spin
diff --git a/spec/javascripts/helpers/class_spec_helper.js.es6 b/spec/javascripts/helpers/class_spec_helper.js.es6
new file mode 100644
index 00000000000..92a20687ec5
--- /dev/null
+++ b/spec/javascripts/helpers/class_spec_helper.js.es6
@@ -0,0 +1,9 @@
+/* eslint-disable no-unused-vars */
+
+class ClassSpecHelper {
+  static itShouldBeAStaticMethod(base, method) {
+    return it('should be a static method', () => {
+      expect(Object.prototype.hasOwnProperty.call(base, method)).toBeTruthy();
+    });
+  }
+}
diff --git a/spec/javascripts/helpers/class_spec_helper_spec.js.es6 b/spec/javascripts/helpers/class_spec_helper_spec.js.es6
new file mode 100644
index 00000000000..d1155f1bd1e
--- /dev/null
+++ b/spec/javascripts/helpers/class_spec_helper_spec.js.es6
@@ -0,0 +1,35 @@
+/* global ClassSpecHelper */
+//= require ./class_spec_helper
+
+describe('ClassSpecHelper', () => {
+  describe('.itShouldBeAStaticMethod', function () {
+    beforeEach(() => {
+      class TestClass {
+        instanceMethod() { this.prop = 'val'; }
+        static staticMethod() {}
+      }
+
+      this.TestClass = TestClass;
+    });
+
+    ClassSpecHelper.itShouldBeAStaticMethod(ClassSpecHelper, 'itShouldBeAStaticMethod');
+
+    it('should have a defined spec', () => {
+      expect(ClassSpecHelper.itShouldBeAStaticMethod(this.TestClass, 'staticMethod').description).toBe('should be a static method');
+    });
+
+    it('should pass for a static method', () => {
+      const spec = ClassSpecHelper.itShouldBeAStaticMethod(this.TestClass, 'staticMethod');
+      expect(spec.status()).toBe('passed');
+    });
+
+    it('should fail for an instance method', (done) => {
+      const spec = ClassSpecHelper.itShouldBeAStaticMethod(this.TestClass, 'instanceMethod');
+      spec.resultCallback = (result) => {
+        expect(result.status).toBe('failed');
+        done();
+      };
+      spec.execute();
+    });
+  });
+});
diff --git a/spec/lib/gitlab/ci/status/build/factory_spec.rb b/spec/lib/gitlab/ci/status/build/factory_spec.rb
index dccb29b5ef6..0c40fca0c1a 100644
--- a/spec/lib/gitlab/ci/status/build/factory_spec.rb
+++ b/spec/lib/gitlab/ci/status/build/factory_spec.rb
@@ -3,15 +3,23 @@ require 'spec_helper'
 describe Gitlab::Ci::Status::Build::Factory do
   let(:user) { create(:user) }
   let(:project) { build.project }
-
-  subject { described_class.new(build, user) }
-  let(:status) { subject.fabricate! }
+  let(:status) { factory.fabricate! }
+  let(:factory) { described_class.new(build, user) }
 
   before { project.team << [user, :developer] }
 
   context 'when build is successful' do
     let(:build) { create(:ci_build, :success) }
 
+    it 'matches correct core status' do
+      expect(factory.core_status).to be_a Gitlab::Ci::Status::Success
+    end
+
+    it 'matches correct extended statuses' do
+      expect(factory.extended_statuses)
+        .to eq [Gitlab::Ci::Status::Build::Retryable]
+    end
+
     it 'fabricates a retryable build status' do
       expect(status).to be_a Gitlab::Ci::Status::Build::Retryable
     end
@@ -26,24 +34,72 @@ describe Gitlab::Ci::Status::Build::Factory do
   end
 
   context 'when build is failed' do
-    let(:build) { create(:ci_build, :failed) }
+    context 'when build is not allowed to fail' do
+      let(:build) { create(:ci_build, :failed) }
 
-    it 'fabricates a retryable build status' do
-      expect(status).to be_a Gitlab::Ci::Status::Build::Retryable
+      it 'matches correct core status' do
+        expect(factory.core_status).to be_a Gitlab::Ci::Status::Failed
+      end
+
+      it 'matches correct extended statuses' do
+        expect(factory.extended_statuses)
+          .to eq [Gitlab::Ci::Status::Build::Retryable]
+      end
+
+      it 'fabricates a retryable build status' do
+        expect(status).to be_a Gitlab::Ci::Status::Build::Retryable
+      end
+
+      it 'fabricates status with correct details' do
+        expect(status.text).to eq 'failed'
+        expect(status.icon).to eq 'icon_status_failed'
+        expect(status.label).to eq 'failed'
+        expect(status).to have_details
+        expect(status).to have_action
+      end
     end
 
-    it 'fabricates status with correct details' do
-      expect(status.text).to eq 'failed'
-      expect(status.icon).to eq 'icon_status_failed'
-      expect(status.label).to eq 'failed'
-      expect(status).to have_details
-      expect(status).to have_action
+    context 'when build is allowed to fail' do
+      let(:build) { create(:ci_build, :failed, :allowed_to_fail) }
+
+      it 'matches correct core status' do
+        expect(factory.core_status).to be_a Gitlab::Ci::Status::Failed
+      end
+
+      it 'matches correct extended statuses' do
+        expect(factory.extended_statuses)
+          .to eq [Gitlab::Ci::Status::Build::Retryable,
+                  Gitlab::Ci::Status::Build::FailedAllowed]
+      end
+
+      it 'fabricates a failed but allowed build status' do
+        expect(status).to be_a Gitlab::Ci::Status::Build::FailedAllowed
+      end
+
+      it 'fabricates status with correct details' do
+        expect(status.text).to eq 'failed'
+        expect(status.icon).to eq 'icon_status_warning'
+        expect(status.label).to eq 'failed (allowed to fail)'
+        expect(status).to have_details
+        expect(status).to have_action
+        expect(status.action_title).to include 'Retry'
+        expect(status.action_path).to include 'retry'
+      end
     end
   end
 
   context 'when build is a canceled' do
     let(:build) { create(:ci_build, :canceled) }
 
+    it 'matches correct core status' do
+      expect(factory.core_status).to be_a Gitlab::Ci::Status::Canceled
+    end
+
+    it 'matches correct extended statuses' do
+      expect(factory.extended_statuses)
+        .to eq [Gitlab::Ci::Status::Build::Retryable]
+    end
+
     it 'fabricates a retryable build status' do
       expect(status).to be_a Gitlab::Ci::Status::Build::Retryable
     end
@@ -60,6 +116,15 @@ describe Gitlab::Ci::Status::Build::Factory do
   context 'when build is running' do
     let(:build) { create(:ci_build, :running) }
 
+    it 'matches correct core status' do
+      expect(factory.core_status).to be_a Gitlab::Ci::Status::Running
+    end
+
+    it 'matches correct extended statuses' do
+      expect(factory.extended_statuses)
+        .to eq [Gitlab::Ci::Status::Build::Cancelable]
+    end
+
     it 'fabricates a canceable build status' do
       expect(status).to be_a Gitlab::Ci::Status::Build::Cancelable
     end
@@ -76,6 +141,15 @@ describe Gitlab::Ci::Status::Build::Factory do
   context 'when build is pending' do
     let(:build) { create(:ci_build, :pending) }
 
+    it 'matches correct core status' do
+      expect(factory.core_status).to be_a Gitlab::Ci::Status::Pending
+    end
+
+    it 'matches correct extended statuses' do
+      expect(factory.extended_statuses)
+        .to eq [Gitlab::Ci::Status::Build::Cancelable]
+    end
+
     it 'fabricates a cancelable build status' do
       expect(status).to be_a Gitlab::Ci::Status::Build::Cancelable
     end
@@ -92,6 +166,14 @@ describe Gitlab::Ci::Status::Build::Factory do
   context 'when build is skipped' do
     let(:build) { create(:ci_build, :skipped) }
 
+    it 'matches correct core status' do
+      expect(factory.core_status).to be_a Gitlab::Ci::Status::Skipped
+    end
+
+    it 'does not match extended statuses' do
+      expect(factory.extended_statuses).to be_empty
+    end
+
     it 'fabricates a core skipped status' do
       expect(status).to be_a Gitlab::Ci::Status::Skipped
     end
@@ -109,6 +191,15 @@ describe Gitlab::Ci::Status::Build::Factory do
     context 'when build is a play action' do
       let(:build) { create(:ci_build, :playable) }
 
+      it 'matches correct core status' do
+        expect(factory.core_status).to be_a Gitlab::Ci::Status::Skipped
+      end
+
+      it 'matches correct extended statuses' do
+        expect(factory.extended_statuses)
+          .to eq [Gitlab::Ci::Status::Build::Play]
+      end
+
       it 'fabricates a core skipped status' do
         expect(status).to be_a Gitlab::Ci::Status::Build::Play
       end
@@ -119,12 +210,22 @@ describe Gitlab::Ci::Status::Build::Factory do
         expect(status.label).to eq 'manual play action'
         expect(status).to have_details
         expect(status).to have_action
+        expect(status.action_path).to include 'play'
       end
     end
 
     context 'when build is an environment stop action' do
       let(:build) { create(:ci_build, :playable, :teardown_environment) }
 
+      it 'matches correct core status' do
+        expect(factory.core_status).to be_a Gitlab::Ci::Status::Skipped
+      end
+
+      it 'matches correct extended statuses' do
+        expect(factory.extended_statuses)
+          .to eq [Gitlab::Ci::Status::Build::Stop]
+      end
+
       it 'fabricates a core skipped status' do
         expect(status).to be_a Gitlab::Ci::Status::Build::Stop
       end
diff --git a/spec/lib/gitlab/ci/status/build/failed_allowed_spec.rb b/spec/lib/gitlab/ci/status/build/failed_allowed_spec.rb
new file mode 100644
index 00000000000..20f71459738
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/build/failed_allowed_spec.rb
@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Build::FailedAllowed do
+  let(:status) { double('core status') }
+  let(:user) { double('user') }
+
+  subject do
+    described_class.new(status)
+  end
+
+  describe '#text' do
+    it 'does not override status text' do
+      expect(status).to receive(:text)
+
+      subject.text
+    end
+  end
+
+  describe '#icon' do
+    it 'returns a warning icon' do
+      expect(subject.icon).to eq 'icon_status_warning'
+    end
+  end
+
+  describe '#label' do
+    it 'returns information about failed but allowed to fail status' do
+      expect(subject.label).to eq 'failed (allowed to fail)'
+    end
+  end
+
+  describe '#group' do
+    it 'returns status failed with warnings status group' do
+      expect(subject.group).to eq 'failed_with_warnings'
+    end
+  end
+
+  describe 'action details' do
+    describe '#has_action?' do
+      it 'does not decorate action details' do
+        expect(status).to receive(:has_action?)
+
+        subject.has_action?
+      end
+    end
+
+    describe '#action_path' do
+      it 'does not decorate action path' do
+        expect(status).to receive(:action_path)
+
+        subject.action_path
+      end
+    end
+
+    describe '#action_icon' do
+      it 'does not decorate action icon' do
+        expect(status).to receive(:action_icon)
+
+        subject.action_icon
+      end
+    end
+
+    describe '#action_title' do
+      it 'does not decorate action title' do
+        expect(status).to receive(:action_title)
+
+        subject.action_title
+      end
+    end
+  end
+
+  describe '.matches?' do
+    subject { described_class.matches?(build, user) }
+
+    context 'when build is failed' do
+      context 'when build is allowed to fail' do
+        let(:build) { create(:ci_build, :failed, :allowed_to_fail) }
+
+        it 'is a correct match' do
+          expect(subject).to be true
+        end
+      end
+
+      context 'when build is not allowed to fail' do
+        let(:build) { create(:ci_build, :failed) }
+
+        it 'is not a correct match' do
+          expect(subject).not_to be true
+        end
+      end
+    end
+
+    context 'when build did not fail' do
+      context 'when build is allowed to fail' do
+        let(:build) { create(:ci_build, :success, :allowed_to_fail) }
+
+        it 'is not a correct match' do
+          expect(subject).not_to be true
+        end
+      end
+
+      context 'when build is not allowed to fail' do
+        let(:build) { create(:ci_build, :success) }
+
+        it 'is not a correct match' do
+          expect(subject).not_to be true
+        end
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/factory_spec.rb b/spec/lib/gitlab/ci/status/factory_spec.rb
index f92a1c149bf..bbf9c7c83a3 100644
--- a/spec/lib/gitlab/ci/status/factory_spec.rb
+++ b/spec/lib/gitlab/ci/status/factory_spec.rb
@@ -1,24 +1,135 @@
 require 'spec_helper'
 
 describe Gitlab::Ci::Status::Factory do
-  subject do
-    described_class.new(resource, user)
+  let(:user) { create(:user) }
+  let(:fabricated_status) { factory.fabricate! }
+  let(:factory) { described_class.new(resource, user) }
+
+  context 'when object has a core status' do
+    HasStatus::AVAILABLE_STATUSES.each do |simple_status|
+      context "when simple core status is #{simple_status}" do
+        let(:resource) { double('resource', status: simple_status) }
+
+        let(:expected_status) do
+          Gitlab::Ci::Status.const_get(simple_status.capitalize)
+        end
+
+        it "fabricates a core status #{simple_status}" do
+          expect(fabricated_status).to be_a expected_status
+        end
+
+        it "matches a valid core status for #{simple_status}" do
+          expect(factory.core_status).to be_a expected_status
+        end
+
+        it "does not match any extended statuses for #{simple_status}" do
+          expect(factory.extended_statuses).to be_empty
+        end
+      end
+    end
   end
 
-  let(:user) { create(:user) }
+  context 'when resource supports multiple extended statuses' do
+    let(:resource) { double('resource', status: :success) }
 
-  let(:status) { subject.fabricate! }
+    let(:first_extended_status) do
+      Class.new(SimpleDelegator) do
+        def first_method
+          'first return value'
+        end
 
-  context 'when object has a core status' do
-    HasStatus::AVAILABLE_STATUSES.each do |core_status|
-      context "when core status is #{core_status}" do
-        let(:resource) { double(status: core_status) }
+        def second_method
+          'second return value'
+        end
+
+        def self.matches?(*)
+          true
+        end
+      end
+    end
 
-        it "fabricates a core status #{core_status}" do
-          expect(status).to be_a(
-            Gitlab::Ci::Status.const_get(core_status.capitalize))
+    let(:second_extended_status) do
+      Class.new(SimpleDelegator) do
+        def first_method
+          'decorated return value'
         end
+
+        def third_method
+          'third return value'
+        end
+
+        def self.matches?(*)
+          true
+        end
+      end
+    end
+
+    shared_examples 'compound decorator factory' do
+      it 'fabricates compound decorator' do
+        expect(fabricated_status.first_method).to eq 'decorated return value'
+        expect(fabricated_status.second_method).to eq 'second return value'
+        expect(fabricated_status.third_method).to eq 'third return value'
       end
+
+      it 'delegates to core status' do
+        expect(fabricated_status.text).to eq 'passed'
+      end
+
+      it 'latest matches status becomes a status name' do
+        expect(fabricated_status.class).to eq second_extended_status
+      end
+
+      it 'matches correct core status' do
+        expect(factory.core_status).to be_a Gitlab::Ci::Status::Success
+      end
+
+      it 'matches correct extended statuses' do
+        expect(factory.extended_statuses)
+          .to eq [first_extended_status, second_extended_status]
+      end
+    end
+
+    context 'when exclusive statuses are matches' do
+      before do
+        allow(described_class).to receive(:extended_statuses)
+          .and_return([[first_extended_status, second_extended_status]])
+      end
+
+      it 'does not fabricate compound decorator' do
+        expect(fabricated_status.first_method).to eq 'first return value'
+        expect(fabricated_status.second_method).to eq 'second return value'
+        expect(fabricated_status).not_to respond_to(:third_method)
+      end
+
+      it 'delegates to core status' do
+        expect(fabricated_status.text).to eq 'passed'
+      end
+
+      it 'matches correct core status' do
+        expect(factory.core_status).to be_a Gitlab::Ci::Status::Success
+      end
+
+      it 'matches correct extended statuses' do
+        expect(factory.extended_statuses).to eq [first_extended_status]
+      end
+    end
+
+    context 'when exclusive statuses are not matched' do
+      before do
+        allow(described_class).to receive(:extended_statuses)
+          .and_return([[first_extended_status], [second_extended_status]])
+      end
+
+      it_behaves_like 'compound decorator factory'
+    end
+
+    context 'when using simplified status grouping' do
+      before do
+        allow(described_class).to receive(:extended_statuses)
+          .and_return([first_extended_status, second_extended_status])
+      end
+
+      it_behaves_like 'compound decorator factory'
     end
   end
 end
diff --git a/spec/lib/gitlab/ci/status/pipeline/factory_spec.rb b/spec/lib/gitlab/ci/status/pipeline/factory_spec.rb
index d4a2dc7fcc1..b10a447c27a 100644
--- a/spec/lib/gitlab/ci/status/pipeline/factory_spec.rb
+++ b/spec/lib/gitlab/ci/status/pipeline/factory_spec.rb
@@ -3,29 +3,32 @@ require 'spec_helper'
 describe Gitlab::Ci::Status::Pipeline::Factory do
   let(:user) { create(:user) }
   let(:project) { pipeline.project }
-
-  subject do
-    described_class.new(pipeline, user)
-  end
-
-  let(:status) do
-    subject.fabricate!
-  end
+  let(:status) { factory.fabricate! }
+  let(:factory) { described_class.new(pipeline, user) }
 
   before do
     project.team << [user, :developer]
   end
 
   context 'when pipeline has a core status' do
-    HasStatus::AVAILABLE_STATUSES.each do |core_status|
-      context "when core status is #{core_status}" do
-        let(:pipeline) do
-          create(:ci_pipeline, status: core_status)
+    HasStatus::AVAILABLE_STATUSES.each do |simple_status|
+      context "when core status is #{simple_status}" do
+        let(:pipeline) { create(:ci_pipeline, status: simple_status) }
+
+        let(:expected_status) do
+          Gitlab::Ci::Status.const_get(simple_status.capitalize)
+        end
+
+        it "matches correct core status for #{simple_status}" do
+          expect(factory.core_status).to be_a expected_status
         end
 
-        it "fabricates a core status #{core_status}" do
-          expect(status).to be_a(
-            Gitlab::Ci::Status.const_get(core_status.capitalize))
+        it 'does not matche extended statuses' do
+          expect(factory.extended_statuses).to be_empty
+        end
+
+        it "fabricates a core status #{simple_status}" do
+          expect(status).to be_a expected_status
         end
 
         it 'extends core status with common pipeline methods' do
@@ -47,13 +50,22 @@ describe Gitlab::Ci::Status::Pipeline::Factory do
       create(:ci_build, :allowed_to_fail, :failed, pipeline: pipeline)
     end
 
+    it 'matches correct core status' do
+      expect(factory.core_status).to be_a Gitlab::Ci::Status::Success
+    end
+
+    it 'matches correct extended statuses' do
+      expect(factory.extended_statuses)
+        .to eq [Gitlab::Ci::Status::SuccessWarning]
+    end
+
     it 'fabricates extended "success with warnings" status' do
-      expect(status)
-        .to be_a Gitlab::Ci::Status::Pipeline::SuccessWithWarnings
+      expect(status).to be_a Gitlab::Ci::Status::SuccessWarning
     end
 
-    it 'extends core status with common pipeline methods' do
+    it 'extends core status with common pipeline method' do
       expect(status).to have_details
+      expect(status.details_path).to include "pipelines/#{pipeline.id}"
     end
   end
 end
diff --git a/spec/lib/gitlab/ci/status/pipeline/success_with_warnings_spec.rb b/spec/lib/gitlab/ci/status/pipeline/success_with_warnings_spec.rb
deleted file mode 100644
index 979160eb9c4..00000000000
--- a/spec/lib/gitlab/ci/status/pipeline/success_with_warnings_spec.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Gitlab::Ci::Status::Pipeline::SuccessWithWarnings do
-  subject do
-    described_class.new(double('status'))
-  end
-
-  describe '#test' do
-    it { expect(subject.text).to eq 'passed' }
-  end
-
-  describe '#label' do
-    it { expect(subject.label).to eq 'passed with warnings' }
-  end
-
-  describe '#icon' do
-    it { expect(subject.icon).to eq 'icon_status_warning' }
-  end
-
-  describe '#group' do
-    it { expect(subject.group).to eq 'success_with_warnings' }
-  end
-
-  describe '.matches?' do
-    context 'when pipeline is successful' do
-      let(:pipeline) do
-        create(:ci_pipeline, status: :success)
-      end
-
-      context 'when pipeline has warnings' do
-        before do
-          allow(pipeline).to receive(:has_warnings?).and_return(true)
-        end
-
-        it 'is a correct match' do
-          expect(described_class.matches?(pipeline, double)).to eq true
-        end
-      end
-
-      context 'when pipeline does not have warnings' do
-        it 'does not match' do
-          expect(described_class.matches?(pipeline, double)).to eq false
-        end
-      end
-    end
-
-    context 'when pipeline is not successful' do
-      let(:pipeline) do
-        create(:ci_pipeline, status: :skipped)
-      end
-
-      context 'when pipeline has warnings' do
-        before do
-          allow(pipeline).to receive(:has_warnings?).and_return(true)
-        end
-
-        it 'does not match' do
-          expect(described_class.matches?(pipeline, double)).to eq false
-        end
-      end
-
-      context 'when pipeline does not have warnings' do
-        it 'does not match' do
-          expect(described_class.matches?(pipeline, double)).to eq false
-        end
-      end
-    end
-  end
-end
diff --git a/spec/lib/gitlab/ci/status/stage/factory_spec.rb b/spec/lib/gitlab/ci/status/stage/factory_spec.rb
index 6f8721d30c2..bbb40e2c1ab 100644
--- a/spec/lib/gitlab/ci/status/stage/factory_spec.rb
+++ b/spec/lib/gitlab/ci/status/stage/factory_spec.rb
@@ -43,4 +43,25 @@ describe Gitlab::Ci::Status::Stage::Factory do
       end
     end
   end
+
+  context 'when stage has warnings' do
+    let(:stage) do
+      build(:ci_stage, name: 'test', status: :success, pipeline: pipeline)
+    end
+
+    before do
+      create(:ci_build, :allowed_to_fail, :failed,
+             stage: 'test', pipeline: stage.pipeline)
+    end
+
+    it 'fabricates extended "success with warnings" status' do
+      expect(status)
+        .to be_a Gitlab::Ci::Status::SuccessWarning
+    end
+
+    it 'extends core status with common stage method' do
+      expect(status).to have_details
+      expect(status.details_path).to include "pipelines/#{pipeline.id}##{stage.name}"
+    end
+  end
 end
diff --git a/spec/lib/gitlab/ci/status/success_warning_spec.rb b/spec/lib/gitlab/ci/status/success_warning_spec.rb
new file mode 100644
index 00000000000..7e2269397c6
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/success_warning_spec.rb
@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::SuccessWarning do
+  subject do
+    described_class.new(double('status'))
+  end
+
+  describe '#test' do
+    it { expect(subject.text).to eq 'passed' }
+  end
+
+  describe '#label' do
+    it { expect(subject.label).to eq 'passed with warnings' }
+  end
+
+  describe '#icon' do
+    it { expect(subject.icon).to eq 'icon_status_warning' }
+  end
+
+  describe '#group' do
+    it { expect(subject.group).to eq 'success_with_warnings' }
+  end
+
+  describe '.matches?' do
+    let(:matchable) { double('matchable') }
+
+    context 'when matchable subject is successful' do
+      before do
+        allow(matchable).to receive(:success?).and_return(true)
+      end
+
+      context 'when matchable subject has warnings' do
+        before do
+          allow(matchable).to receive(:has_warnings?).and_return(true)
+        end
+
+        it 'is a correct match' do
+          expect(described_class.matches?(matchable, double)).to eq true
+        end
+      end
+
+      context 'when matchable subject does not have warnings' do
+        before do
+          allow(matchable).to receive(:has_warnings?).and_return(false)
+        end
+
+        it 'does not match' do
+          expect(described_class.matches?(matchable, double)).to eq false
+        end
+      end
+    end
+
+    context 'when matchable subject is not successful' do
+      before do
+        allow(matchable).to receive(:success?).and_return(false)
+      end
+
+      context 'when matchable subject has warnings' do
+        before do
+          allow(matchable).to receive(:has_warnings?).and_return(true)
+        end
+
+        it 'does not match' do
+          expect(described_class.matches?(matchable, double)).to eq false
+        end
+      end
+
+      context 'when matchable subject does not have warnings' do
+        it 'does not match' do
+          expect(described_class.matches?(matchable, double)).to eq false
+        end
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/email/email_shared_blocks.rb b/spec/lib/gitlab/email/email_shared_blocks.rb
index 19298e261e3..9d806fc524d 100644
--- a/spec/lib/gitlab/email/email_shared_blocks.rb
+++ b/spec/lib/gitlab/email/email_shared_blocks.rb
@@ -18,7 +18,7 @@ shared_context :email_shared_context do
   end
 end
 
-shared_examples :email_shared_examples do
+shared_examples :reply_processing_shared_examples do
   context "when the user could not be found" do
     before do
       user.destroy
diff --git a/spec/lib/gitlab/email/handler/create_issue_handler_spec.rb b/spec/lib/gitlab/email/handler/create_issue_handler_spec.rb
index cb3651e3845..08897a4c310 100644
--- a/spec/lib/gitlab/email/handler/create_issue_handler_spec.rb
+++ b/spec/lib/gitlab/email/handler/create_issue_handler_spec.rb
@@ -3,7 +3,7 @@ require_relative '../email_shared_blocks'
 
 describe Gitlab::Email::Handler::CreateIssueHandler, lib: true do
   include_context :email_shared_context
-  it_behaves_like :email_shared_examples
+  it_behaves_like :reply_processing_shared_examples
 
   before do
     stub_incoming_email_setting(enabled: true, address: "incoming+%{key}@appmail.adventuretime.ooo")
diff --git a/spec/lib/gitlab/email/handler/create_note_handler_spec.rb b/spec/lib/gitlab/email/handler/create_note_handler_spec.rb
index 48660d1dd1b..cebbeff50cf 100644
--- a/spec/lib/gitlab/email/handler/create_note_handler_spec.rb
+++ b/spec/lib/gitlab/email/handler/create_note_handler_spec.rb
@@ -3,7 +3,7 @@ require_relative '../email_shared_blocks'
 
 describe Gitlab::Email::Handler::CreateNoteHandler, lib: true do
   include_context :email_shared_context
-  it_behaves_like :email_shared_examples
+  it_behaves_like :reply_processing_shared_examples
 
   before do
     stub_incoming_email_setting(enabled: true, address: "reply+%{key}@appmail.adventuretime.ooo")
diff --git a/spec/lib/gitlab/email/handler/unsubscribe_handler_spec.rb b/spec/lib/gitlab/email/handler/unsubscribe_handler_spec.rb
new file mode 100644
index 00000000000..a444257754b
--- /dev/null
+++ b/spec/lib/gitlab/email/handler/unsubscribe_handler_spec.rb
@@ -0,0 +1,61 @@
+require 'spec_helper'
+require_relative '../email_shared_blocks'
+
+describe Gitlab::Email::Handler::UnsubscribeHandler, lib: true do
+  include_context :email_shared_context
+
+  before do
+    stub_incoming_email_setting(enabled: true, address: 'reply+%{key}@appmail.adventuretime.ooo')
+    stub_config_setting(host: 'localhost')
+  end
+
+  let(:email_raw) { fixture_file('emails/valid_reply.eml').gsub(mail_key, "#{mail_key}+unsubscribe") }
+  let(:project) { create(:project, :public) }
+  let(:user) { create(:user) }
+  let(:noteable) { create(:issue, project: project) }
+
+  let!(:sent_notification) { SentNotification.record(noteable, user.id, mail_key) }
+
+  context 'when notification concerns a commit' do
+    let(:commit) { create(:commit, project: project) }
+    let!(:sent_notification) { SentNotification.record(commit, user.id, mail_key) }
+
+    it 'handler does not raise an error' do
+      expect { receiver.execute }.not_to raise_error
+    end
+  end
+
+  context 'user is unsubscribed' do
+    it 'leaves user unsubscribed' do
+      expect { receiver.execute }.not_to change { noteable.subscribed?(user) }.from(false)
+    end
+  end
+
+  context 'user is subscribed' do
+    before do
+      noteable.subscribe(user)
+    end
+
+    it 'unsubscribes user from notable' do
+      expect { receiver.execute }.to change { noteable.subscribed?(user) }.from(true).to(false)
+    end
+  end
+
+  context 'when the noteable could not be found' do
+    before do
+      noteable.destroy
+    end
+
+    it 'raises a NoteableNotFoundError' do
+      expect { receiver.execute }.to raise_error(Gitlab::Email::NoteableNotFoundError)
+    end
+  end
+
+  context 'when no sent notification for the mail key could be found' do
+    let(:email_raw) { fixture_file('emails/wrong_mail_key.eml') }
+
+    it 'raises a SentNotificationNotFoundError' do
+      expect { receiver.execute }.to raise_error(Gitlab::Email::SentNotificationNotFoundError)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/import_export/members_mapper_spec.rb b/spec/lib/gitlab/import_export/members_mapper_spec.rb
index 1cb02f8e318..b069696b5c7 100644
--- a/spec/lib/gitlab/import_export/members_mapper_spec.rb
+++ b/spec/lib/gitlab/import_export/members_mapper_spec.rb
@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Gitlab::ImportExport::MembersMapper, services: true do
   describe 'map members' do
-    let(:user) { create(:user, authorized_projects_populated: true) }
+    let(:user) { create(:admin, authorized_projects_populated: true) }
     let(:project) { create(:project, :public, name: 'searchable_project') }
     let(:user2) { create(:user, authorized_projects_populated: true) }
     let(:exported_user_id) { 99 }
@@ -24,7 +24,7 @@ describe Gitlab::ImportExport::MembersMapper, services: true do
            {
              "id" => exported_user_id,
              "email" => user2.email,
-             "username" => user2.username
+             "username" => 'test'
            }
        },
        {
@@ -48,6 +48,10 @@ describe Gitlab::ImportExport::MembersMapper, services: true do
         exported_members: exported_members, user: user, project: project)
     end
 
+    it 'includes the exported user ID in the map' do
+      expect(members_mapper.map.keys).to include(exported_user_id)
+    end
+
     it 'maps a project member' do
       expect(members_mapper.map[exported_user_id]).to eq(user2.id)
     end
@@ -56,12 +60,6 @@ describe Gitlab::ImportExport::MembersMapper, services: true do
       expect(members_mapper.map[-1]).to eq(user.id)
     end
 
-    it 'updates missing author IDs on missing project member' do
-      members_mapper.map[-1]
-
-      expect(members_mapper.missing_author_ids.first).to eq(-1)
-    end
-
     it 'has invited members with no user' do
       members_mapper.map
 
@@ -74,5 +72,25 @@ describe Gitlab::ImportExport::MembersMapper, services: true do
       expect(user.authorized_project?(project)).to be true
       expect(user2.authorized_project?(project)).to be true
     end
+
+    context 'user is not an admin' do
+      let(:user) { create(:user, authorized_projects_populated: true) }
+
+      it 'does not map a project member' do
+        expect(members_mapper.map[exported_user_id]).to eq(user.id)
+      end
+
+      it 'defaults to importer project member if it does not exist' do
+        expect(members_mapper.map[-1]).to eq(user.id)
+      end
+    end
+
+    context 'chooses the one with an email first' do
+      let(:user3) { create(:user, username: 'test') }
+
+      it 'maps the project member that has a matching email first' do
+        expect(members_mapper.map[exported_user_id]).to eq(user2.id)
+      end
+    end
   end
 end
diff --git a/spec/lib/gitlab/import_export/relation_factory_spec.rb b/spec/lib/gitlab/import_export/relation_factory_spec.rb
index 3aa492a8ab1..db0084d6823 100644
--- a/spec/lib/gitlab/import_export/relation_factory_spec.rb
+++ b/spec/lib/gitlab/import_export/relation_factory_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Gitlab::ImportExport::RelationFactory, lib: true do
   let(:project) { create(:empty_project) }
   let(:members_mapper) { double('members_mapper').as_null_object }
-  let(:user) { create(:user) }
+  let(:user) { create(:admin) }
   let(:created_object) do
     described_class.create(relation_sym: relation_sym,
                            relation_hash: relation_hash,
@@ -122,4 +122,60 @@ describe Gitlab::ImportExport::RelationFactory, lib: true do
       expect(created_object.values).not_to include(99)
     end
   end
+
+  context 'Notes user references' do
+    let(:relation_sym) { :notes }
+    let(:new_user) { create(:user) }
+    let(:exported_member) do
+      {
+        "id" => 111,
+        "access_level" => 30,
+        "source_id" => 1,
+        "source_type" => "Project",
+        "user_id" => 3,
+        "notification_level" => 3,
+        "created_at" => "2016-11-18T09:29:42.634Z",
+        "updated_at" => "2016-11-18T09:29:42.634Z",
+        "user" => {
+          "id" => 999,
+          "email" => new_user.email,
+          "username" => new_user.username
+        }
+      }
+    end
+
+    let(:relation_hash) do
+      {
+        "id" => 4947,
+        "note" => "merged",
+        "noteable_type" => "MergeRequest",
+        "author_id" => 999,
+        "created_at" => "2016-11-18T09:29:42.634Z",
+        "updated_at" => "2016-11-18T09:29:42.634Z",
+        "project_id" => 1,
+        "attachment" => {
+          "url" => nil
+        },
+        "noteable_id" => 377,
+        "system" => true,
+        "author" => {
+          "name" => "Administrator"
+        },
+        "events" => [
+
+        ]
+      }
+    end
+
+    let(:members_mapper) do
+      Gitlab::ImportExport::MembersMapper.new(
+        exported_members: [exported_member],
+        user: user,
+        project: project)
+    end
+
+    it 'maps the right author to the imported note' do
+      expect(created_object.author).to eq(new_user)
+    end
+  end
 end
diff --git a/spec/lib/gitlab/incoming_email_spec.rb b/spec/lib/gitlab/incoming_email_spec.rb
index 1dcf2c0668b..7e951e3fcdd 100644
--- a/spec/lib/gitlab/incoming_email_spec.rb
+++ b/spec/lib/gitlab/incoming_email_spec.rb
@@ -23,6 +23,48 @@ describe Gitlab::IncomingEmail, lib: true do
     end
   end
 
+  describe 'self.supports_wildcard?' do
+    context 'address contains the wildard placeholder' do
+      before do
+        stub_incoming_email_setting(address: 'replies+%{key}@example.com')
+      end
+
+      it 'confirms that wildcard is supported' do
+        expect(described_class.supports_wildcard?).to be_truthy
+      end
+    end
+
+    context "address doesn't contain the wildcard placeholder" do
+      before do
+        stub_incoming_email_setting(address: 'replies@example.com')
+      end
+
+      it 'returns that wildcard is not supported' do
+        expect(described_class.supports_wildcard?).to be_falsey
+      end
+    end
+
+    context 'address is not set' do
+      before do
+        stub_incoming_email_setting(address: nil)
+      end
+
+      it 'returns that wildard is not supported' do
+        expect(described_class.supports_wildcard?).to be_falsey
+      end
+    end
+  end
+
+  context 'self.unsubscribe_address' do
+    before do
+      stub_incoming_email_setting(address: 'replies+%{key}@example.com')
+    end
+
+    it 'returns the address with interpolated reply key and unsubscribe suffix' do
+      expect(described_class.unsubscribe_address('key')).to eq('replies+key+unsubscribe@example.com')
+    end
+  end
+
   context "self.reply_address" do
     before do
       stub_incoming_email_setting(address: "replies+%{key}@example.com")
diff --git a/spec/lib/gitlab/project_search_results_spec.rb b/spec/lib/gitlab/project_search_results_spec.rb
index 14ee386dba6..d94eb52f838 100644
--- a/spec/lib/gitlab/project_search_results_spec.rb
+++ b/spec/lib/gitlab/project_search_results_spec.rb
@@ -178,4 +178,119 @@ describe Gitlab::ProjectSearchResults, lib: true do
       expect(results.objects('notes')).not_to include note
     end
   end
+
+  # Examples for commit access level test
+  #
+  # params:
+  # * search_phrase
+  # * commit
+  #
+  shared_examples 'access restricted commits' do
+    context 'when project is internal' do
+      let(:project) { create(:project, :internal) }
+
+      it 'does not search if user is not authenticated' do
+        commits = described_class.new(nil, project, search_phrase).objects('commits')
+
+        expect(commits).to be_empty
+      end
+
+      it 'searches if user is authenticated' do
+        commits = described_class.new(user, project, search_phrase).objects('commits')
+
+        expect(commits).to contain_exactly commit
+      end
+    end
+
+    context 'when project is private' do
+      let!(:creator) { create(:user, username: 'private-project-author') }
+      let!(:private_project) { create(:project, :private, creator: creator, namespace: creator.namespace) }
+      let(:team_master) do
+        user = create(:user, username: 'private-project-master')
+        private_project.team << [user, :master]
+        user
+      end
+      let(:team_reporter) do
+        user = create(:user, username: 'private-project-reporter')
+        private_project.team << [user, :reporter]
+        user
+      end
+
+      it 'does not show commit to stranger' do
+        commits = described_class.new(nil, private_project, search_phrase).objects('commits')
+
+        expect(commits).to be_empty
+      end
+
+      context 'team access' do
+        it 'shows commit to creator' do
+          commits = described_class.new(creator, private_project, search_phrase).objects('commits')
+
+          expect(commits).to contain_exactly commit
+        end
+
+        it 'shows commit to master' do
+          commits = described_class.new(team_master, private_project, search_phrase).objects('commits')
+
+          expect(commits).to contain_exactly commit
+        end
+
+        it 'shows commit to reporter' do
+          commits = described_class.new(team_reporter, private_project, search_phrase).objects('commits')
+
+          expect(commits).to contain_exactly commit
+        end
+      end
+    end
+  end
+
+  describe 'commit search' do
+    context 'by commit message' do
+      let(:project) { create(:project, :public) }
+      let(:commit) { project.repository.commit('59e29889be61e6e0e5e223bfa9ac2721d31605b8') }
+      let(:message) { 'Sorry, I did a mistake' }
+
+      it 'finds commit by message' do
+        commits = described_class.new(user, project, message).objects('commits')
+
+        expect(commits).to contain_exactly commit
+      end
+
+      it 'handles when no commit match' do
+        commits = described_class.new(user, project, 'not really an existing description').objects('commits')
+
+        expect(commits).to be_empty
+      end
+
+      it_behaves_like 'access restricted commits' do
+        let(:search_phrase) { message }
+        let(:commit) { project.repository.commit('59e29889be61e6e0e5e223bfa9ac2721d31605b8') }
+      end
+    end
+
+    context 'by commit hash' do
+      let(:project) { create(:project, :public) }
+      let(:commit) { project.repository.commit('0b4bc9a') }
+      commit_hashes = { short: '0b4bc9a', full: '0b4bc9a49b562e85de7cc9e834518ea6828729b9' }
+
+      commit_hashes.each do |type, commit_hash|
+        it "shows commit by #{type} hash id" do
+          commits = described_class.new(user, project, commit_hash).objects('commits')
+
+          expect(commits).to contain_exactly commit
+        end
+      end
+
+      it 'handles not existing commit hash correctly' do
+        commits = described_class.new(user, project, 'deadbeef').objects('commits')
+
+        expect(commits).to be_empty
+      end
+
+      it_behaves_like 'access restricted commits' do
+        let(:search_phrase) { '0b4bc9a49' }
+        let(:commit) { project.repository.commit('0b4bc9a') }
+      end
+    end
+  end
 end
diff --git a/spec/lib/gitlab/user_access_spec.rb b/spec/lib/gitlab/user_access_spec.rb
index d3c3b800b94..369e55f61f1 100644
--- a/spec/lib/gitlab/user_access_spec.rb
+++ b/spec/lib/gitlab/user_access_spec.rb
@@ -66,7 +66,8 @@ describe Gitlab::UserAccess, lib: true do
     end
 
     describe 'push to protected branch' do
-      let(:branch) { create :protected_branch, project: project }
+      let(:branch) { create :protected_branch, project: project, name: "test" }
+      let(:not_existing_branch) { create :protected_branch, :developers_can_merge, project: project }
 
       it 'returns true if user is a master' do
         project.team << [user, :master]
@@ -85,6 +86,12 @@ describe Gitlab::UserAccess, lib: true do
 
         expect(access.can_push_to_branch?(branch.name)).to be_falsey
       end
+
+      it 'returns true if branch does not exist and user has permission to merge' do
+        project.team << [user, :developer]
+
+        expect(access.can_push_to_branch?(not_existing_branch.name)).to be_truthy
+      end
     end
 
     describe 'push to protected branch if allowed for developers' do
diff --git a/spec/lib/gitlab/workhorse_spec.rb b/spec/lib/gitlab/workhorse_spec.rb
index 61da91dcbd3..4b1cd466677 100644
--- a/spec/lib/gitlab/workhorse_spec.rb
+++ b/spec/lib/gitlab/workhorse_spec.rb
@@ -174,4 +174,27 @@ describe Gitlab::Workhorse, lib: true do
       described_class.verify_api_request!(headers)
     end
   end
+
+  describe '.git_http_ok' do
+    let(:user) { create(:user) }
+
+    subject { described_class.git_http_ok(repository, user) }
+
+    it { expect(subject).to eq({ GL_ID: "user-#{user.id}", RepoPath: repository.path_to_repo }) }
+
+    context 'when Gitaly socket path is present' do
+      let(:gitaly_socket_path) { '/tmp/gitaly.sock' }
+
+      before do
+        allow(Gitlab.config.gitaly).to receive(:socket_path).and_return(gitaly_socket_path)
+      end
+
+      it 'includes Gitaly params in the returned value' do
+        expect(subject).to include({
+          GitalyResourcePath: "/projects/#{repository.project.id}/git-http/info-refs",
+          GitalySocketPath: gitaly_socket_path,
+        })
+      end
+    end
+  end
 end
diff --git a/spec/models/ci/build_spec.rb b/spec/models/ci/build_spec.rb
index 3309a7fff9f..f031876e812 100644
--- a/spec/models/ci/build_spec.rb
+++ b/spec/models/ci/build_spec.rb
@@ -1401,4 +1401,14 @@ describe Ci::Build, :models do
       it { is_expected.to eq(%w[predefined project pipeline yaml secret]) }
     end
   end
+
+  describe 'State transition: any => [:pending]' do
+    let(:build) { create(:ci_build, :created) }
+
+    it 'queues BuildQueueWorker' do
+      expect(BuildQueueWorker).to receive(:perform_async).with(build.id)
+
+      build.enqueue
+    end
+  end
 end
diff --git a/spec/models/ci/pipeline_spec.rb b/spec/models/ci/pipeline_spec.rb
index d1aee27057a..2bdd611aeed 100644
--- a/spec/models/ci/pipeline_spec.rb
+++ b/spec/models/ci/pipeline_spec.rb
@@ -122,55 +122,80 @@ describe Ci::Pipeline, models: true do
     end
   end
 
-  describe '#stages' do
+  describe 'pipeline stages' do
     before do
-      create(:commit_status, pipeline: pipeline, stage: 'build', name: 'linux', stage_idx: 0, status: 'success')
-      create(:commit_status, pipeline: pipeline, stage: 'build', name: 'mac', stage_idx: 0, status: 'failed')
-      create(:commit_status, pipeline: pipeline, stage: 'deploy', name: 'staging', stage_idx: 2, status: 'running')
-      create(:commit_status, pipeline: pipeline, stage: 'test', name: 'rspec', stage_idx: 1, status: 'success')
-    end
-
-    subject { pipeline.stages }
-
-    context 'stages list' do
-      it 'returns ordered list of stages' do
-        expect(subject.map(&:name)).to eq(%w[build test deploy])
+      create(:commit_status, pipeline: pipeline,
+                             stage: 'build',
+                             name: 'linux',
+                             stage_idx: 0,
+                             status: 'success')
+
+      create(:commit_status, pipeline: pipeline,
+                             stage: 'build',
+                             name: 'mac',
+                             stage_idx: 0,
+                             status: 'failed')
+
+      create(:commit_status, pipeline: pipeline,
+                             stage: 'deploy',
+                             name: 'staging',
+                             stage_idx: 2,
+                             status: 'running')
+
+      create(:commit_status, pipeline: pipeline,
+                             stage: 'test',
+                             name: 'rspec',
+                             stage_idx: 1,
+                             status: 'success')
+    end
+
+    describe '#stages' do
+      subject { pipeline.stages }
+
+      context 'stages list' do
+        it 'returns ordered list of stages' do
+          expect(subject.map(&:name)).to eq(%w[build test deploy])
+        end
       end
-    end
 
-    it 'returns a valid number of stages' do
-      expect(pipeline.stages_count).to eq(3)
-    end
+      context 'stages with statuses' do
+        let(:statuses) do
+          subject.map { |stage| [stage.name, stage.status] }
+        end
 
-    it 'returns a valid names of stages' do
-      expect(pipeline.stages_name).to eq(['build', 'test', 'deploy'])
-    end
+        it 'returns list of stages with correct statuses' do
+          expect(statuses).to eq([['build', 'failed'],
+                                  ['test', 'success'],
+                                  ['deploy', 'running']])
+        end
 
-    context 'stages with statuses' do
-      let(:statuses) do
-        subject.map do |stage|
-          [stage.name, stage.status]
+        context 'when commit status  is retried' do
+          before do
+            create(:commit_status, pipeline: pipeline,
+                                   stage: 'build',
+                                   name: 'mac',
+                                   stage_idx: 0,
+                                   status: 'success')
+          end
+
+          it 'ignores the previous state' do
+            expect(statuses).to eq([['build', 'success'],
+                                    ['test', 'success'],
+                                    ['deploy', 'running']])
+          end
         end
       end
+    end
 
-      it 'returns list of stages with statuses' do
-        expect(statuses).to eq([['build', 'failed'],
-                                ['test', 'success'],
-                                ['deploy', 'running']
-                               ])
+    describe '#stages_count' do
+      it 'returns a valid number of stages' do
+        expect(pipeline.stages_count).to eq(3)
       end
+    end
 
-      context 'when build is retried' do
-        before do
-          create(:commit_status, pipeline: pipeline, stage: 'build', name: 'mac', stage_idx: 0, status: 'success')
-        end
-
-        it 'ignores the previous state' do
-          expect(statuses).to eq([['build', 'success'],
-                                  ['test', 'success'],
-                                  ['deploy', 'running']
-                                 ])
-        end
+    describe '#stages_name' do
+      it 'returns a valid names of stages' do
+        expect(pipeline.stages_name).to eq(['build', 'test', 'deploy'])
       end
     end
   end
diff --git a/spec/models/ci/runner_spec.rb b/spec/models/ci/runner_spec.rb
index ef65eb99328..2b856ca7af7 100644
--- a/spec/models/ci/runner_spec.rb
+++ b/spec/models/ci/runner_spec.rb
@@ -263,6 +263,62 @@ describe Ci::Runner, models: true do
     end
   end
 
+  describe '#tick_runner_queue' do
+    let(:runner) { create(:ci_runner) }
+
+    it 'returns a new last_update value' do
+      expect(runner.tick_runner_queue).not_to be_empty
+    end
+  end
+
+  describe '#ensure_runner_queue_value' do
+    let(:runner) { create(:ci_runner) }
+
+    it 'sets a new last_update value when it is called the first time' do
+      last_update = runner.ensure_runner_queue_value
+
+      expect_value_in_redis.to eq(last_update)
+    end
+
+    it 'does not change if it is not expired and called again' do
+      last_update = runner.ensure_runner_queue_value
+
+      expect(runner.ensure_runner_queue_value).to eq(last_update)
+      expect_value_in_redis.to eq(last_update)
+    end
+
+    context 'updates runner queue after changing editable value' do
+      let!(:last_update) { runner.ensure_runner_queue_value }
+
+      before do
+        runner.update(description: 'new runner')
+      end
+
+      it 'sets a new last_update value' do
+        expect_value_in_redis.not_to eq(last_update)
+      end
+    end
+
+    context 'does not update runner value after save' do
+      let!(:last_update) { runner.ensure_runner_queue_value }
+
+      before do
+        runner.touch
+      end
+
+      it 'has an old last_update value' do
+        expect_value_in_redis.to eq(last_update)
+      end
+    end
+
+    def expect_value_in_redis
+      Gitlab::Redis.with do |redis|
+        runner_queue_key = runner.send(:runner_queue_key)
+        expect(redis.get(runner_queue_key))
+      end
+    end
+  end
+
   describe '.assignable_for' do
     let(:runner) { create(:ci_runner) }
     let(:project) { create(:project) }
diff --git a/spec/models/ci/stage_spec.rb b/spec/models/ci/stage_spec.rb
index 742bedb37e4..c4a9743a4e2 100644
--- a/spec/models/ci/stage_spec.rb
+++ b/spec/models/ci/stage_spec.rb
@@ -142,6 +142,78 @@ describe Ci::Stage, models: true do
     end
   end
 
+  describe '#success?' do
+    context 'when stage is successful' do
+      before do
+        create_job(:ci_build, status: :success)
+        create_job(:generic_commit_status, status: :success)
+      end
+
+      it 'is successful' do
+        expect(stage).to be_success
+      end
+    end
+
+    context 'when stage is not successful' do
+      before do
+        create_job(:ci_build, status: :failed)
+        create_job(:generic_commit_status, status: :success)
+      end
+
+      it 'is not successful' do
+        expect(stage).not_to be_success
+      end
+    end
+  end
+
+  describe '#has_warnings?' do
+    context 'when stage has warnings' do
+      context 'when using memoized warnings flag' do
+        context 'when there are warnings' do
+          let(:stage) { build(:ci_stage, warnings: true) }
+
+          it 'has memoized warnings' do
+            expect(stage).not_to receive(:statuses)
+            expect(stage).to have_warnings
+          end
+        end
+
+        context 'when there are no warnings' do
+          let(:stage) { build(:ci_stage, warnings: false) }
+
+          it 'has memoized warnings' do
+            expect(stage).not_to receive(:statuses)
+            expect(stage).not_to have_warnings
+          end
+        end
+      end
+
+      context 'when calculating warnings from statuses' do
+        before do
+          create(:ci_build, :failed, :allowed_to_fail,
+                 stage: stage_name, pipeline: pipeline)
+        end
+
+        it 'has warnings calculated from statuses' do
+          expect(stage).to receive(:statuses).and_call_original
+          expect(stage).to have_warnings
+        end
+      end
+    end
+
+    context 'when stage does not have warnings' do
+      before do
+        create(:ci_build, :success, stage: stage_name,
+                                    pipeline: pipeline)
+      end
+
+      it 'does not have warnings calculated from statuses' do
+        expect(stage).to receive(:statuses).and_call_original
+        expect(stage).not_to have_warnings
+      end
+    end
+  end
+
   def create_job(type, status: 'success', stage: stage_name)
     create(type, pipeline: pipeline, stage: stage, status: status)
   end
diff --git a/spec/models/commit_spec.rb b/spec/models/commit_spec.rb
index 0d425ab7fd4..b2202f0fd44 100644
--- a/spec/models/commit_spec.rb
+++ b/spec/models/commit_spec.rb
@@ -351,4 +351,22 @@ eos
       expect(commit).not_to be_work_in_progress
     end
   end
+
+  describe '.valid_hash?' do
+    it 'checks hash contents' do
+      expect(described_class.valid_hash?('abcdef01239ABCDEF')).to be true
+      expect(described_class.valid_hash?("abcdef01239ABCD\nEF")).to be false
+      expect(described_class.valid_hash?(' abcdef01239ABCDEF ')).to be false
+      expect(described_class.valid_hash?('Gabcdef01239ABCDEF')).to be false
+      expect(described_class.valid_hash?('gabcdef01239ABCDEF')).to be false
+      expect(described_class.valid_hash?('-abcdef01239ABCDEF')).to be false
+    end
+
+    it 'checks hash length' do
+      expect(described_class.valid_hash?('a' * 6)).to be false
+      expect(described_class.valid_hash?('a' * 7)).to be true
+      expect(described_class.valid_hash?('a' * 40)).to be true
+      expect(described_class.valid_hash?('a' * 41)).to be false
+    end
+  end
 end
diff --git a/spec/models/concerns/has_status_spec.rb b/spec/models/concerns/has_status_spec.rb
index 4d0f51fe82a..dbfe3cd2d36 100644
--- a/spec/models/concerns/has_status_spec.rb
+++ b/spec/models/concerns/has_status_spec.rb
@@ -219,4 +219,10 @@ describe HasStatus do
       end
     end
   end
+
+  describe '::DEFAULT_STATUS' do
+    it 'is a status created' do
+      expect(described_class::DEFAULT_STATUS).to eq 'created'
+    end
+  end
 end
diff --git a/spec/models/key_spec.rb b/spec/models/key_spec.rb
index 5eaddd822be..7c40cfd8253 100644
--- a/spec/models/key_spec.rb
+++ b/spec/models/key_spec.rb
@@ -30,11 +30,30 @@ describe Key, models: true do
     end
 
     describe "#update_last_used_at" do
-      it "enqueues a UseKeyWorker job" do
-        key = create(:key)
+      let(:key) { create(:key) }
+
+      context 'when key was not updated during the last day' do
+        before do
+          allow_any_instance_of(Gitlab::ExclusiveLease).to receive(:try_obtain).
+            and_return('000000')
+        end
+
+        it 'enqueues a UseKeyWorker job' do
+          expect(UseKeyWorker).to receive(:perform_async).with(key.id)
+          key.update_last_used_at
+        end
+      end
+
+      context 'when key was updated during the last day' do
+        before do
+          allow_any_instance_of(Gitlab::ExclusiveLease).to receive(:try_obtain).
+            and_return(false)
+        end
 
-        expect(UseKeyWorker).to receive(:perform_async).with(key.id)
-        key.update_last_used_at
+        it 'does not enqueue a UseKeyWorker job' do
+          expect(UseKeyWorker).not_to receive(:perform_async)
+          key.update_last_used_at
+        end
       end
     end
   end
diff --git a/spec/models/merge_request_spec.rb b/spec/models/merge_request_spec.rb
index 38c80ba53ad..32ed1e96749 100644
--- a/spec/models/merge_request_spec.rb
+++ b/spec/models/merge_request_spec.rb
@@ -65,7 +65,7 @@ describe MergeRequest, models: true do
   end
 
   describe '#target_branch_sha' do
-    let(:project) { create(:project) }
+    let(:project) { create(:project, :repository) }
 
     subject { create(:merge_request, source_project: project, target_project: project) }
 
@@ -150,7 +150,7 @@ describe MergeRequest, models: true do
     end
 
     it 'supports a cross-project reference' do
-      another_project = build(:project, name: 'another-project', namespace: project.namespace)
+      another_project = build(:empty_project, name: 'another-project', namespace: project.namespace)
       expect(merge_request.to_reference(another_project)).to eq "sample-project!1"
     end
 
@@ -245,8 +245,8 @@ describe MergeRequest, models: true do
 
   describe '#for_fork?' do
     it 'returns true if the merge request is for a fork' do
-      subject.source_project = create(:project, namespace: create(:group))
-      subject.target_project = create(:project, namespace: create(:group))
+      subject.source_project = build_stubbed(:empty_project, namespace: create(:group))
+      subject.target_project = build_stubbed(:empty_project, namespace: create(:group))
 
       expect(subject.for_fork?).to be_truthy
     end
@@ -501,8 +501,8 @@ describe MergeRequest, models: true do
   end
 
   describe '#diverged_commits_count' do
-    let(:project)      { create(:project) }
-    let(:fork_project) { create(:project, forked_from_project: project) }
+    let(:project)      { create(:project, :repository) }
+    let(:fork_project) { create(:project, :repository, forked_from_project: project) }
 
     context 'when the target branch does not exist anymore' do
       subject { create(:merge_request, source_project: project, target_project: project) }
@@ -727,7 +727,7 @@ describe MergeRequest, models: true do
   end
 
   describe '#participants' do
-    let(:project) { create(:project, :public) }
+    let(:project) { create(:empty_project, :public) }
 
     let(:mr) do
       create(:merge_request, source_project: project, target_project: project)
@@ -768,7 +768,7 @@ describe MergeRequest, models: true do
   end
 
   describe '#check_if_can_be_merged' do
-    let(:project) { create(:project, only_allow_merge_if_build_succeeds: true) }
+    let(:project) { create(:empty_project, only_allow_merge_if_build_succeeds: true) }
 
     subject { create(:merge_request, source_project: project, merge_status: :unchecked) }
 
@@ -789,7 +789,7 @@ describe MergeRequest, models: true do
       it 'becomes unmergeable' do
         expect { subject.check_if_can_be_merged }.to change { subject.merge_status }.to('cannot_be_merged')
       end
-      
+
       it 'creates Todo on unmergeability' do
         expect_any_instance_of(TodoService).to receive(:merge_request_became_unmergeable).with(subject)
 
@@ -810,7 +810,7 @@ describe MergeRequest, models: true do
   end
 
   describe '#mergeable?' do
-    let(:project) { create(:project) }
+    let(:project) { create(:empty_project) }
 
     subject { create(:merge_request, source_project: project) }
 
@@ -830,7 +830,7 @@ describe MergeRequest, models: true do
   end
 
   describe '#mergeable_state?' do
-    let(:project) { create(:project) }
+    let(:project) { create(:project, :repository) }
 
     subject { create(:merge_request, source_project: project) }
 
@@ -957,7 +957,7 @@ describe MergeRequest, models: true do
     let(:merge_request) { create(:merge_request_with_diff_notes, source_project: project) }
 
     context 'when project.only_allow_merge_if_all_discussions_are_resolved == true' do
-      let(:project) { create(:project, only_allow_merge_if_all_discussions_are_resolved: true) }
+      let(:project) { create(:project, :repository, only_allow_merge_if_all_discussions_are_resolved: true) }
 
       context 'with all discussions resolved' do
         before do
@@ -991,7 +991,7 @@ describe MergeRequest, models: true do
     end
 
     context 'when project.only_allow_merge_if_all_discussions_are_resolved == false' do
-      let(:project) { create(:project, only_allow_merge_if_all_discussions_are_resolved: false) }
+      let(:project) { create(:project, :repository, only_allow_merge_if_all_discussions_are_resolved: false) }
 
       context 'with unresolved discussions' do
         before do
@@ -1006,7 +1006,7 @@ describe MergeRequest, models: true do
   end
 
   describe "#environments" do
-    let(:project)       { create(:project) }
+    let(:project)       { create(:project, :repository) }
     let(:merge_request) { create(:merge_request, source_project: project) }
 
     context 'with multiple environments' do
@@ -1024,7 +1024,7 @@ describe MergeRequest, models: true do
 
     context 'with environments on source project' do
       let(:source_project) do
-        create(:project) do |fork_project|
+        create(:project, :repository) do |fork_project|
           fork_project.create_forked_project_link(forked_to_project_id: fork_project.id, forked_from_project_id: project.id)
         end
       end
@@ -1401,8 +1401,8 @@ describe MergeRequest, models: true do
   end
 
   describe "#source_project_missing?" do
-    let(:project)      { create(:project) }
-    let(:fork_project) { create(:project, forked_from_project: project) }
+    let(:project)      { create(:empty_project) }
+    let(:fork_project) { create(:empty_project, forked_from_project: project) }
     let(:user)         { create(:user) }
     let(:unlink_project) { Projects::UnlinkForkService.new(fork_project, user) }
 
@@ -1439,8 +1439,8 @@ describe MergeRequest, models: true do
   end
 
   describe "#closed_without_fork?" do
-    let(:project)      { create(:project) }
-    let(:fork_project) { create(:project, forked_from_project: project) }
+    let(:project)      { create(:empty_project) }
+    let(:fork_project) { create(:empty_project, forked_from_project: project) }
     let(:user)         { create(:user) }
     let(:unlink_project) { Projects::UnlinkForkService.new(fork_project, user) }
 
@@ -1485,9 +1485,9 @@ describe MergeRequest, models: true do
       end
 
       context 'forked project' do
-        let(:project)      { create(:project) }
+        let(:project)      { create(:empty_project) }
         let(:user)         { create(:user) }
-        let(:fork_project) { create(:project, forked_from_project: project, namespace: user.namespace) }
+        let(:fork_project) { create(:empty_project, forked_from_project: project, namespace: user.namespace) }
 
         let!(:merge_request) do
           create(:closed_merge_request,
@@ -1531,7 +1531,7 @@ describe MergeRequest, models: true do
         status:  status)
     end
 
-    let(:project)       { create(:project, :public, only_allow_merge_if_build_succeeds: true) }
+    let(:project)       { create(:project, :public, :repository, only_allow_merge_if_build_succeeds: true) }
     let(:developer)     { create(:user) }
     let(:user)          { create(:user) }
     let(:merge_request) { create(:merge_request, source_project: project) }
diff --git a/spec/models/namespace_spec.rb b/spec/models/namespace_spec.rb
index 600538ff5f4..f8e03fa114a 100644
--- a/spec/models/namespace_spec.rb
+++ b/spec/models/namespace_spec.rb
@@ -117,6 +117,7 @@ describe Namespace, models: true do
       new_path = @namespace.path + "_new"
       allow(@namespace).to receive(:path_was).and_return(@namespace.path)
       allow(@namespace).to receive(:path).and_return(new_path)
+      expect(@namespace).to receive(:remove_exports!)
       expect(@namespace.move_dir).to be_truthy
     end
 
@@ -139,11 +140,17 @@ describe Namespace, models: true do
     let!(:project) { create(:project, namespace: namespace) }
     let!(:path) { File.join(Gitlab.config.repositories.storages.default, namespace.path) }
 
-    before { namespace.destroy }
-
     it "removes its dirs when deleted" do
+      namespace.destroy
+
       expect(File.exist?(path)).to be(false)
     end
+
+    it 'removes the exports folder' do
+      expect(namespace).to receive(:remove_exports!)
+
+      namespace.destroy
+    end
   end
 
   describe '.find_by_path_or_name' do
diff --git a/spec/models/project_spec.rb b/spec/models/project_spec.rb
index e93a4e62244..8048e86fc3a 100644
--- a/spec/models/project_spec.rb
+++ b/spec/models/project_spec.rb
@@ -73,9 +73,7 @@ describe Project, models: true do
 
     context 'after initialized' do
       it "has a project_feature" do
-        project = FactoryGirl.build(:project)
-
-        expect(project.project_feature.present?).to be_present
+        expect(Project.new.project_feature).to be_present
       end
     end
 
@@ -129,7 +127,7 @@ describe Project, models: true do
   end
 
   describe 'validation' do
-    let!(:project) { create(:project) }
+    let!(:project) { create(:empty_project) }
 
     it { is_expected.to validate_presence_of(:name) }
     it { is_expected.to validate_uniqueness_of(:name).scoped_to(:namespace_id) }
@@ -148,7 +146,7 @@ describe Project, models: true do
     it { is_expected.to validate_presence_of(:repository_storage) }
 
     it 'does not allow new projects beyond user limits' do
-      project2 = build(:project)
+      project2 = build(:empty_project)
       allow(project2).to receive(:creator).and_return(double(can_create_project?: false, projects_limit: 0).as_null_object)
       expect(project2).not_to be_valid
       expect(project2.errors[:limit_reached].first).to match(/Personal project creation is not allowed/)
@@ -157,7 +155,7 @@ describe Project, models: true do
     describe 'wiki path conflict' do
       context "when the new path has been used by the wiki of other Project" do
         it 'has an error on the name attribute' do
-          new_project = build_stubbed(:project, namespace_id: project.namespace_id, path: "#{project.path}.wiki")
+          new_project = build_stubbed(:empty_project, namespace_id: project.namespace_id, path: "#{project.path}.wiki")
 
           expect(new_project).not_to be_valid
           expect(new_project.errors[:name].first).to eq('has already been taken')
@@ -166,8 +164,8 @@ describe Project, models: true do
 
       context "when the new wiki path has been used by the path of other Project" do
         it 'has an error on the name attribute' do
-          project_with_wiki_suffix = create(:project, path: 'foo.wiki')
-          new_project = build_stubbed(:project, namespace_id: project_with_wiki_suffix.namespace_id, path: 'foo')
+          project_with_wiki_suffix = create(:empty_project, path: 'foo.wiki')
+          new_project = build_stubbed(:empty_project, namespace_id: project_with_wiki_suffix.namespace_id, path: 'foo')
 
           expect(new_project).not_to be_valid
           expect(new_project.errors[:name].first).to eq('has already been taken')
@@ -176,7 +174,7 @@ describe Project, models: true do
     end
 
     context 'repository storages inclussion' do
-      let(:project2) { build(:project, repository_storage: 'missing') }
+      let(:project2) { build(:empty_project, repository_storage: 'missing') }
 
       before do
         storages = { 'custom' => 'tmp/tests/custom_repositories' }
@@ -352,7 +350,7 @@ describe Project, models: true do
   end
 
   describe '#repository_storage_path' do
-    let(:project) { create(:project, repository_storage: 'custom') }
+    let(:project) { create(:empty_project, repository_storage: 'custom') }
 
     before do
       FileUtils.mkdir('tmp/tests/custom_repositories')
@@ -412,7 +410,7 @@ describe Project, models: true do
   describe 'last_activity methods' do
     let(:timestamp) { 2.hours.ago }
     # last_activity_at gets set to created_at upon creation
-    let(:project) { create(:project, created_at: timestamp, updated_at: timestamp) }
+    let(:project) { create(:empty_project, created_at: timestamp, updated_at: timestamp) }
 
     describe 'last_activity' do
       it 'alias last_activity to last_event' do
@@ -496,7 +494,7 @@ describe Project, models: true do
     context 'with namespace' do
       before do
         @group = create :group, name: 'gitlab'
-        @project = create(:project, name: 'gitlabhq', namespace: @group)
+        @project = create(:empty_project, name: 'gitlabhq', namespace: @group)
       end
 
       it { expect(@project.to_param).to eq('gitlabhq') }
@@ -522,7 +520,7 @@ describe Project, models: true do
   end
 
   describe '#repository' do
-    let(:project) { create(:project) }
+    let(:project) { create(:project, :repository) }
 
     it 'returns valid repo' do
       expect(project.repository).to be_kind_of(Repository)
@@ -530,20 +528,22 @@ describe Project, models: true do
   end
 
   describe '#default_issues_tracker?' do
-    let(:project) { create(:project) }
-    let(:ext_project) { create(:redmine_project) }
-
     it "is true if used internal tracker" do
+      project = build(:empty_project)
+
       expect(project.default_issues_tracker?).to be_truthy
     end
 
     it "is false if used other tracker" do
-      expect(ext_project.default_issues_tracker?).to be_falsey
+      # NOTE: The current nature of this factory requires persistence
+      project = create(:redmine_project)
+
+      expect(project.default_issues_tracker?).to be_falsey
     end
   end
 
   describe '#external_issue_tracker' do
-    let(:project) { create(:project) }
+    let(:project) { create(:empty_project) }
     let(:ext_project) { create(:redmine_project) }
 
     context 'on existing projects with no value for has_external_issue_tracker' do
@@ -578,7 +578,7 @@ describe Project, models: true do
   end
 
   describe '#cache_has_external_issue_tracker' do
-    let(:project) { create(:project, has_external_issue_tracker: nil) }
+    let(:project) { create(:empty_project, has_external_issue_tracker: nil) }
 
     it 'stores true if there is any external_issue_tracker' do
       services = double(:service, external_issue_trackers: [RedmineService.new])
@@ -600,9 +600,9 @@ describe Project, models: true do
   end
 
   describe '#has_wiki?' do
-    let(:no_wiki_project)       { create(:project, wiki_access_level: ProjectFeature::DISABLED, has_external_wiki: false) }
-    let(:wiki_enabled_project)  { create(:project) }
-    let(:external_wiki_project) { create(:project, has_external_wiki: true) }
+    let(:no_wiki_project)       { create(:empty_project, wiki_access_level: ProjectFeature::DISABLED, has_external_wiki: false) }
+    let(:wiki_enabled_project)  { create(:empty_project) }
+    let(:external_wiki_project) { create(:empty_project, has_external_wiki: true) }
 
     it 'returns true if project is wiki enabled or has external wiki' do
       expect(wiki_enabled_project).to have_wiki
@@ -612,7 +612,7 @@ describe Project, models: true do
   end
 
   describe '#external_wiki' do
-    let(:project) { create(:project) }
+    let(:project) { create(:empty_project) }
 
     context 'with an active external wiki' do
       before do
@@ -663,7 +663,7 @@ describe Project, models: true do
   end
 
   describe '#open_branches' do
-    let(:project) { create(:project) }
+    let(:project) { create(:project, :repository) }
 
     before do
       project.protected_branches.create(name: 'master')
@@ -685,7 +685,7 @@ describe Project, models: true do
     it 'counts stars from multiple users' do
       user1 = create :user
       user2 = create :user
-      project = create :project, :public
+      project = create(:empty_project, :public)
 
       expect(project.star_count).to eq(0)
 
@@ -707,8 +707,8 @@ describe Project, models: true do
 
     it 'counts stars on the right project' do
       user = create :user
-      project1 = create :project, :public
-      project2 = create :project, :public
+      project1 = create(:empty_project, :public)
+      project2 = create(:empty_project, :public)
 
       expect(project1.star_count).to eq(0)
       expect(project2.star_count).to eq(0)
@@ -740,7 +740,7 @@ describe Project, models: true do
   end
 
   describe '#avatar_type' do
-    let(:project) { create(:project) }
+    let(:project) { create(:empty_project) }
 
     it 'is true if avatar is image' do
       project.update_attribute(:avatar, 'uploads/avatar.png')
@@ -756,7 +756,7 @@ describe Project, models: true do
   describe '#avatar_url' do
     subject { project.avatar_url }
 
-    let(:project) { create(:project) }
+    let(:project) { create(:empty_project) }
 
     context 'When avatar file is uploaded' do
       before do
@@ -791,7 +791,7 @@ describe Project, models: true do
   end
 
   describe '#pipeline_for' do
-    let(:project) { create(:project) }
+    let(:project) { create(:project, :repository) }
     let!(:pipeline) { create_pipeline }
 
     shared_examples 'giving the correct pipeline' do
@@ -825,7 +825,7 @@ describe Project, models: true do
   end
 
   describe '#builds_enabled' do
-    let(:project) { create :project }
+    let(:project) { create(:empty_project) }
 
     subject { project.builds_enabled }
 
@@ -877,7 +877,7 @@ describe Project, models: true do
   end
 
   describe '.visible_to_user' do
-    let!(:project) { create(:project, :private) }
+    let!(:project) { create(:empty_project, :private) }
     let!(:user)    { create(:user) }
 
     subject { described_class.visible_to_user(user) }
@@ -975,7 +975,7 @@ describe Project, models: true do
   end
 
   describe '#visibility_level_allowed?' do
-    let(:project) { create(:project, :internal) }
+    let(:project) { create(:empty_project, :internal) }
 
     context 'when checking on non-forked project' do
       it { expect(project.visibility_level_allowed?(Gitlab::VisibilityLevel::PRIVATE)).to be_truthy }
@@ -984,8 +984,8 @@ describe Project, models: true do
     end
 
     context 'when checking on forked project' do
-      let(:project)        { create(:project, :internal) }
-      let(:forked_project) { create(:project, forked_from_project: project) }
+      let(:project)        { create(:empty_project, :internal) }
+      let(:forked_project) { create(:empty_project, forked_from_project: project) }
 
       it { expect(forked_project.visibility_level_allowed?(Gitlab::VisibilityLevel::PRIVATE)).to be_truthy }
       it { expect(forked_project.visibility_level_allowed?(Gitlab::VisibilityLevel::INTERNAL)).to be_truthy }
@@ -994,7 +994,7 @@ describe Project, models: true do
   end
 
   describe '.search' do
-    let(:project) { create(:project, description: 'kitten mittens') }
+    let(:project) { create(:empty_project, description: 'kitten mittens') }
 
     it 'returns projects with a matching name' do
       expect(described_class.search(project.name)).to eq([project])
@@ -1052,7 +1052,7 @@ describe Project, models: true do
   end
 
   describe '#rename_repo' do
-    let(:project) { create(:project) }
+    let(:project) { create(:project, :repository) }
     let(:gitlab_shell) { Gitlab::Shell.new }
 
     before do
@@ -1102,7 +1102,7 @@ describe Project, models: true do
   end
 
   describe '#expire_caches_before_rename' do
-    let(:project) { create(:project) }
+    let(:project) { create(:project, :repository) }
     let(:repo)    { double(:repo, exists?: true) }
     let(:wiki)    { double(:wiki, exists?: true) }
 
@@ -1123,7 +1123,7 @@ describe Project, models: true do
   end
 
   describe '.search_by_title' do
-    let(:project) { create(:project, name: 'kittens') }
+    let(:project) { create(:empty_project, name: 'kittens') }
 
     it 'returns projects with a matching name' do
       expect(described_class.search_by_title(project.name)).to eq([project])
@@ -1142,8 +1142,8 @@ describe Project, models: true do
     let(:private_group)    { create(:group, visibility_level: 0)  }
     let(:internal_group)   { create(:group, visibility_level: 10) }
 
-    let(:private_project)  { create :project, :private, group: private_group }
-    let(:internal_project) { create :project, :internal, group: internal_group }
+    let(:private_project)  { create :empty_project, :private, group: private_group }
+    let(:internal_project) { create :empty_project, :internal, group: internal_group }
 
     context 'when group is private project can not be internal' do
       it { expect(private_project.visibility_level_allowed?(Gitlab::VisibilityLevel::INTERNAL)).to be_falsey }
@@ -1155,7 +1155,7 @@ describe Project, models: true do
   end
 
   describe '#create_repository' do
-    let(:project) { create(:project) }
+    let(:project) { create(:project, :repository) }
     let(:shell) { Gitlab::Shell.new }
 
     before do
@@ -1197,7 +1197,7 @@ describe Project, models: true do
 
   describe '#protected_branch?' do
     context 'existing project' do
-      let(:project) { create(:project) }
+      let(:project) { create(:project, :repository) }
 
       it 'returns true when the branch matches a protected branch via direct match' do
         create(:protected_branch, project: project, name: "foo")
@@ -1381,7 +1381,7 @@ describe Project, models: true do
              name: name)
     end
 
-    let(:project) { create(:project) }
+    let(:project) { create(:project, :repository) }
     let(:pipeline) { create_pipeline }
 
     context 'with many builds' do
@@ -1461,7 +1461,7 @@ describe Project, models: true do
     end
 
     context 'not forked' do
-      let(:project) { create(:project) }
+      let(:project) { create(:empty_project) }
 
       it 'schedules a RepositoryImportWorker job' do
         expect(RepositoryImportWorker).to receive(:perform_async).with(project.id)
@@ -1472,19 +1472,19 @@ describe Project, models: true do
   end
 
   describe '#gitlab_project_import?' do
-    subject(:project) { build(:project, import_type: 'gitlab_project') }
+    subject(:project) { build(:empty_project, import_type: 'gitlab_project') }
 
     it { expect(project.gitlab_project_import?).to be true }
   end
 
   describe '#gitea_import?' do
-    subject(:project) { build(:project, import_type: 'gitea') }
+    subject(:project) { build(:empty_project, import_type: 'gitea') }
 
     it { expect(project.gitea_import?).to be true }
   end
 
   describe '#lfs_enabled?' do
-    let(:project) { create(:project) }
+    let(:project) { create(:empty_project) }
 
     shared_examples 'project overrides group' do
       it 'returns true when enabled in project' do
@@ -1546,7 +1546,7 @@ describe Project, models: true do
   end
 
   describe '#change_head' do
-    let(:project) { create(:project) }
+    let(:project) { create(:project, :repository) }
 
     it 'calls the before_change_head and after_change_head methods' do
       expect(project.repository).to receive(:before_change_head)
@@ -1574,7 +1574,7 @@ describe Project, models: true do
   end
 
   describe '#pushes_since_gc' do
-    let(:project) { create(:project) }
+    let(:project) { create(:empty_project) }
 
     after do
       project.reset_pushes_since_gc
@@ -1596,7 +1596,7 @@ describe Project, models: true do
   end
 
   describe '#increment_pushes_since_gc' do
-    let(:project) { create(:project) }
+    let(:project) { create(:empty_project) }
 
     after do
       project.reset_pushes_since_gc
@@ -1610,7 +1610,7 @@ describe Project, models: true do
   end
 
   describe '#reset_pushes_since_gc' do
-    let(:project) { create(:project) }
+    let(:project) { create(:empty_project) }
 
     after do
       project.reset_pushes_since_gc
@@ -1626,7 +1626,7 @@ describe Project, models: true do
   end
 
   describe '#environments_for' do
-    let(:project) { create(:project) }
+    let(:project) { create(:project, :repository) }
     let(:environment) { create(:environment, project: project) }
 
     context 'tagged deployment' do
@@ -1678,7 +1678,7 @@ describe Project, models: true do
   end
 
   describe '#environments_recently_updated_on_branch' do
-    let(:project) { create(:project) }
+    let(:project) { create(:project, :repository) }
     let(:environment) { create(:environment, project: project) }
 
     context 'when last deployment to environment is the most recent one' do
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index 8b20ee81614..ca3d4ff0aa9 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -48,7 +48,7 @@ describe User, models: true do
     describe '#project_members' do
       it 'does not include project memberships for which user is a requester' do
         user = create(:user)
-        project = create(:project, :public, :access_requestable)
+        project = create(:empty_project, :public, :access_requestable)
         project.request_access(user)
 
         expect(user.project_members).to be_empty
@@ -386,13 +386,15 @@ describe User, models: true do
 
   describe 'projects' do
     before do
-      @user = create :user
-      @project = create :project, namespace: @user.namespace
-      @project_2 = create :project, group: create(:group) # Grant MASTER access to the user
-      @project_3 = create :project, group: create(:group) # Grant DEVELOPER access to the user
+      @user = create(:user)
 
-      @project_2.team << [@user, :master]
-      @project_3.team << [@user, :developer]
+      @project = create(:empty_project, namespace: @user.namespace)
+      @project_2 = create(:empty_project, group: create(:group)) do |project|
+        project.add_master(@user)
+      end
+      @project_3 = create(:empty_project, group: create(:group)) do |project|
+        project.add_developer(@user)
+      end
     end
 
     it { expect(@user.authorized_projects).to include(@project) }
@@ -435,7 +437,7 @@ describe User, models: true do
   describe 'namespaced' do
     before do
       @user = create :user
-      @project = create :project, namespace: @user.namespace
+      @project = create(:empty_project, namespace: @user.namespace)
     end
 
     it { expect(@user.several_namespaces?).to be_falsey }
@@ -517,7 +519,7 @@ describe User, models: true do
     before do
       User.delete_all
       @user = create :user
-      @project = create :project
+      @project = create(:empty_project)
     end
 
     it { expect(User.not_in_project(@project)).to include(@user, @project.owner) }
@@ -927,8 +929,8 @@ describe User, models: true do
   describe "#starred?" do
     it "determines if user starred a project" do
       user = create :user
-      project1 = create :project, :public
-      project2 = create :project, :public
+      project1 = create(:empty_project, :public)
+      project2 = create(:empty_project, :public)
 
       expect(user.starred?(project1)).to be_falsey
       expect(user.starred?(project2)).to be_falsey
@@ -954,7 +956,7 @@ describe User, models: true do
   describe "#toggle_star" do
     it "toggles stars" do
       user = create :user
-      project = create :project, :public
+      project = create(:empty_project, :public)
 
       expect(user.starred?(project)).to be_falsey
       user.toggle_star(project)
@@ -994,9 +996,9 @@ describe User, models: true do
 
   describe "#contributed_projects" do
     subject { create(:user) }
-    let!(:project1) { create(:project) }
-    let!(:project2) { create(:project, forked_from_project: project3) }
-    let!(:project3) { create(:project) }
+    let!(:project1) { create(:empty_project) }
+    let!(:project2) { create(:empty_project, forked_from_project: project3) }
+    let!(:project3) { create(:empty_project) }
     let!(:merge_request) { create(:merge_request, source_project: project2, target_project: project3, author: subject) }
     let!(:push_event) { create(:event, action: Event::PUSHED, project: project1, target: project1, author: subject) }
     let!(:merge_event) { create(:event, action: Event::CREATED, project: project3, target: merge_request, author: subject) }
@@ -1038,8 +1040,8 @@ describe User, models: true do
 
   describe "#recent_push" do
     subject { create(:user) }
-    let!(:project1) { create(:project) }
-    let!(:project2) { create(:project, forked_from_project: project1) }
+    let!(:project1) { create(:project, :repository) }
+    let!(:project2) { create(:project, :repository, forked_from_project: project1) }
     let!(:push_data) do
       Gitlab::DataBuilder::Push.build_sample(project2, subject)
     end
@@ -1113,7 +1115,7 @@ describe User, models: true do
 
     it "includes user's personal projects" do
       user    = create(:user)
-      project = create(:project, :private, namespace: user.namespace)
+      project = create(:empty_project, :private, namespace: user.namespace)
 
       expect(user.authorized_projects).to include(project)
     end
@@ -1121,7 +1123,7 @@ describe User, models: true do
     it "includes personal projects user has been given access to" do
       user1   = create(:user)
       user2   = create(:user)
-      project = create(:project, :private, namespace: user1.namespace)
+      project = create(:empty_project, :private, namespace: user1.namespace)
 
       project.team << [user2, Gitlab::Access::DEVELOPER]
 
@@ -1130,7 +1132,7 @@ describe User, models: true do
 
     it "includes projects of groups user has been added to" do
       group   = create(:group)
-      project = create(:project, group: group)
+      project = create(:empty_project, group: group)
       user    = create(:user)
 
       group.add_developer(user)
@@ -1140,7 +1142,7 @@ describe User, models: true do
 
     it "does not include projects of groups user has been removed from" do
       group   = create(:group)
-      project = create(:project, group: group)
+      project = create(:empty_project, group: group)
       user    = create(:user)
 
       member = group.add_developer(user)
@@ -1152,7 +1154,7 @@ describe User, models: true do
 
     it "includes projects shared with user's group" do
       user    = create(:user)
-      project = create(:project, :private)
+      project = create(:empty_project, :private)
       group   = create(:group)
 
       group.add_reporter(user)
@@ -1164,7 +1166,7 @@ describe User, models: true do
     it "does not include destroyed projects user had access to" do
       user1   = create(:user)
       user2   = create(:user)
-      project = create(:project, :private, namespace: user1.namespace)
+      project = create(:empty_project, :private, namespace: user1.namespace)
 
       project.team << [user2, Gitlab::Access::DEVELOPER]
       expect(user2.authorized_projects).to include(project)
@@ -1175,7 +1177,7 @@ describe User, models: true do
 
     it "does not include projects of destroyed groups user had access to" do
       group   = create(:group)
-      project = create(:project, namespace: group)
+      project = create(:empty_project, namespace: group)
       user    = create(:user)
 
       group.add_developer(user)
@@ -1190,14 +1192,9 @@ describe User, models: true do
     let(:user) { create(:user) }
 
     it 'includes projects for which the user access level is above or equal to reporter' do
-      create(:project)
-      reporter_project = create(:project)
-      developer_project = create(:project)
-      master_project = create(:project)
-
-      reporter_project.team << [user, :reporter]
-      developer_project.team << [user, :developer]
-      master_project.team << [user, :master]
+      reporter_project  = create(:empty_project) { |p| p.add_reporter(user) }
+      developer_project = create(:empty_project) { |p| p.add_developer(user) }
+      master_project    = create(:empty_project) { |p| p.add_master(user) }
 
       expect(user.projects_where_can_admin_issues.to_a).to eq([master_project, developer_project, reporter_project])
       expect(user.can?(:admin_issue, master_project)).to eq(true)
@@ -1206,10 +1203,8 @@ describe User, models: true do
     end
 
     it 'does not include for which the user access level is below reporter' do
-      project = create(:project)
-      guest_project = create(:project)
-
-      guest_project.team << [user, :guest]
+      project = create(:empty_project)
+      guest_project = create(:empty_project) { |p| p.add_guest(user) }
 
       expect(user.projects_where_can_admin_issues.to_a).to be_empty
       expect(user.can?(:admin_issue, guest_project)).to eq(false)
@@ -1217,15 +1212,14 @@ describe User, models: true do
     end
 
     it 'does not include archived projects' do
-      project = create(:project)
-      project.update_attributes(archived: true)
+      project = create(:empty_project, :archived)
 
       expect(user.projects_where_can_admin_issues.to_a).to be_empty
       expect(user.can?(:admin_issue, project)).to eq(false)
     end
 
     it 'does not include projects for which issues are disabled' do
-      project = create(:project, issues_access_level: ProjectFeature::DISABLED)
+      project = create(:empty_project, issues_access_level: ProjectFeature::DISABLED)
 
       expect(user.projects_where_can_admin_issues.to_a).to be_empty
       expect(user.can?(:admin_issue, project)).to eq(false)
@@ -1241,7 +1235,7 @@ describe User, models: true do
     end
 
     context 'without any projects' do
-      let(:project) { create(:project) }
+      let(:project) { create(:empty_project) }
 
       it 'does not load' do
         expect(user.ci_authorized_runners).to be_empty
@@ -1250,7 +1244,7 @@ describe User, models: true do
 
     context 'with personal projects runners' do
       let(:namespace) { create(:namespace, owner: user) }
-      let(:project) { create(:project, namespace: namespace) }
+      let(:project) { create(:empty_project, namespace: namespace) }
 
       it 'loads' do
         expect(user.ci_authorized_runners).to contain_exactly(runner)
@@ -1281,7 +1275,7 @@ describe User, models: true do
 
     context 'with groups projects runners' do
       let(:group) { create(:group) }
-      let(:project) { create(:project, group: group) }
+      let(:project) { create(:empty_project, group: group) }
 
       def add_user(access)
         group.add_user(user, access)
@@ -1291,7 +1285,7 @@ describe User, models: true do
     end
 
     context 'with other projects runners' do
-      let(:project) { create(:project) }
+      let(:project) { create(:empty_project) }
 
       def add_user(access)
         project.team << [user, access]
@@ -1321,8 +1315,8 @@ describe User, models: true do
   end
 
   describe '#projects_with_reporter_access_limited_to' do
-    let(:project1) { create(:project) }
-    let(:project2) { create(:project) }
+    let(:project1) { create(:empty_project) }
+    let(:project2) { create(:empty_project) }
     let(:user) { create(:user) }
 
     before do
diff --git a/spec/requests/api/access_requests_spec.rb b/spec/requests/api/access_requests_spec.rb
index 1a771b3c87a..e487297748b 100644
--- a/spec/requests/api/access_requests_spec.rb
+++ b/spec/requests/api/access_requests_spec.rb
@@ -9,7 +9,7 @@ describe API::AccessRequests, api: true  do
   let(:stranger) { create(:user) }
 
   let(:project) do
-    create(:project, :public, :access_requestable, creator_id: master.id, namespace: master.namespace) do |project|
+    create(:empty_project, :public, :access_requestable, creator_id: master.id, namespace: master.namespace) do |project|
       project.team << [developer, :developer]
       project.team << [master, :master]
       project.request_access(access_requester)
diff --git a/spec/requests/api/boards_spec.rb b/spec/requests/api/boards_spec.rb
index 3019724f52e..c14c3cb1ce7 100644
--- a/spec/requests/api/boards_spec.rb
+++ b/spec/requests/api/boards_spec.rb
@@ -8,7 +8,7 @@ describe API::Boards, api: true  do
   let(:non_member)  { create(:user) }
   let(:guest)       { create(:user) }
   let(:admin)       { create(:user, :admin) }
-  let!(:project)    { create(:project, :public, creator_id: user.id, namespace: user.namespace ) }
+  let!(:project)    { create(:empty_project, :public, creator_id: user.id, namespace: user.namespace ) }
 
   let!(:dev_label) do
     create(:label, title: 'Development', color: '#FFAABB', project: project)
@@ -188,7 +188,7 @@ describe API::Boards, api: true  do
 
     context "when the user is project owner" do
       let(:owner)     { create(:user) }
-      let(:project)   { create(:project, namespace: owner.namespace) }
+      let(:project)   { create(:empty_project, namespace: owner.namespace) }
 
       it "deletes the list if an admin requests it" do
         delete api("#{base_url}/#{dev_list.id}", owner)
diff --git a/spec/requests/api/deploy_keys_spec.rb b/spec/requests/api/deploy_keys_spec.rb
index aabab8e6ae6..766234d7104 100644
--- a/spec/requests/api/deploy_keys_spec.rb
+++ b/spec/requests/api/deploy_keys_spec.rb
@@ -5,8 +5,8 @@ describe API::DeployKeys, api: true  do
 
   let(:user)        { create(:user) }
   let(:admin)       { create(:admin) }
-  let(:project)     { create(:project, creator_id: user.id) }
-  let(:project2)    { create(:project, creator_id: user.id) }
+  let(:project)     { create(:empty_project, creator_id: user.id) }
+  let(:project2)    { create(:empty_project, creator_id: user.id) }
   let(:deploy_key)  { create(:deploy_key, public: true) }
 
   let!(:deploy_keys_project) do
@@ -73,19 +73,14 @@ describe API::DeployKeys, api: true  do
       post api("/projects/#{project.id}/deploy_keys", admin), { title: 'invalid key' }
 
       expect(response).to have_http_status(400)
-      expect(json_response['message']['key']).to eq([
-        'can\'t be blank',
-        'is invalid'
-      ])
+      expect(json_response['error']).to eq('key is missing')
     end
 
     it 'should not create a key without title' do
       post api("/projects/#{project.id}/deploy_keys", admin), key: 'some key'
 
       expect(response).to have_http_status(400)
-      expect(json_response['message']['title']).to eq([
-        'can\'t be blank'
-      ])
+      expect(json_response['error']).to eq('title is missing')
     end
 
     it 'should create new ssh key' do
diff --git a/spec/requests/api/environments_spec.rb b/spec/requests/api/environments_spec.rb
index b9d535bc314..8168b613766 100644
--- a/spec/requests/api/environments_spec.rb
+++ b/spec/requests/api/environments_spec.rb
@@ -5,7 +5,7 @@ describe API::Environments, api: true  do
 
   let(:user)          { create(:user) }
   let(:non_member)    { create(:user) }
-  let(:project)       { create(:project, :private, namespace: user.namespace) }
+  let(:project)       { create(:empty_project, :private, namespace: user.namespace) }
   let!(:environment)  { create(:environment, project: project) }
 
   before do
diff --git a/spec/requests/api/fork_spec.rb b/spec/requests/api/fork_spec.rb
index e38d5745d44..df29099bc2f 100644
--- a/spec/requests/api/fork_spec.rb
+++ b/spec/requests/api/fork_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe API::API, api: true  do
+describe API::Projects, api: true  do
   include ApiHelpers
   let(:user)  { create(:user) }
   let(:user2) { create(:user) }
diff --git a/spec/requests/api/groups_spec.rb b/spec/requests/api/groups_spec.rb
index e355d5e28bc..edbf0140583 100644
--- a/spec/requests/api/groups_spec.rb
+++ b/spec/requests/api/groups_spec.rb
@@ -10,9 +10,9 @@ describe API::Groups, api: true  do
   let(:admin) { create(:admin) }
   let!(:group1) { create(:group, avatar: File.open(uploaded_image_temp_path)) }
   let!(:group2) { create(:group, :private) }
-  let!(:project1) { create(:project, namespace: group1) }
-  let!(:project2) { create(:project, namespace: group2) }
-  let!(:project3) { create(:project, namespace: group1, path: 'test', visibility_level: Gitlab::VisibilityLevel::PRIVATE) }
+  let!(:project1) { create(:empty_project, namespace: group1) }
+  let!(:project2) { create(:empty_project, namespace: group2) }
+  let!(:project3) { create(:empty_project, namespace: group1, path: 'test', visibility_level: Gitlab::VisibilityLevel::PRIVATE) }
 
   before do
     group1.add_owner(user1)
@@ -163,7 +163,7 @@ describe API::Groups, api: true  do
   describe "GET /groups/:id" do
     context "when authenticated as user" do
       it "returns one of user1's groups" do
-        project = create(:project, namespace: group2, path: 'Foo')
+        project = create(:empty_project, namespace: group2, path: 'Foo')
         create(:project_group_link, project: project, group: group1)
 
         get api("/groups/#{group1.id}", user1)
@@ -287,7 +287,7 @@ describe API::Groups, api: true  do
         expect(json_response.length).to eq(2)
         project_names = json_response.map { |proj| proj['name' ] }
         expect(project_names).to match_array([project1.name, project3.name])
-        expect(json_response.first['default_branch']).to be_present
+        expect(json_response.first['visibility_level']).to be_present
       end
 
       it "returns the group's projects with simple representation" do
@@ -297,11 +297,11 @@ describe API::Groups, api: true  do
         expect(json_response.length).to eq(2)
         project_names = json_response.map { |proj| proj['name' ] }
         expect(project_names).to match_array([project1.name, project3.name])
-        expect(json_response.first['default_branch']).not_to be_present
+        expect(json_response.first['visibility_level']).not_to be_present
       end
 
       it 'filters the groups projects' do
-        public_project = create(:project, :public, path: 'test1', group: group1)
+        public_project = create(:empty_project, :public, path: 'test1', group: group1)
 
         get api("/groups/#{group1.id}/projects", user1), visibility: 'public'
 
@@ -462,7 +462,7 @@ describe API::Groups, api: true  do
   end
 
   describe "POST /groups/:id/projects/:project_id" do
-    let(:project) { create(:project) }
+    let(:project) { create(:empty_project) }
     let(:project_path) { "#{project.namespace.path}%2F#{project.path}" }
 
     before(:each) do
diff --git a/spec/requests/api/helpers_spec.rb b/spec/requests/api/helpers_spec.rb
index b8ee2293a33..a89676fec93 100644
--- a/spec/requests/api/helpers_spec.rb
+++ b/spec/requests/api/helpers_spec.rb
@@ -12,6 +12,7 @@ describe API::Helpers, api: true do
   let(:params) { {} }
   let(:env) { { 'REQUEST_METHOD' => 'GET' } }
   let(:request) { Rack::Request.new(env) }
+  let(:header) { }
 
   def set_env(user_or_token, identifier)
     clear_env
@@ -46,7 +47,7 @@ describe API::Helpers, api: true do
     allow_any_instance_of(self.class).to receive(:doorkeeper_guard){ value }
   end
 
-  def error!(message, status)
+  def error!(message, status, header)
     raise Exception.new("#{status} - #{message}")
   end
 
diff --git a/spec/requests/api/internal_spec.rb b/spec/requests/api/internal_spec.rb
index 35644bd8cc9..a3798c8cd6c 100644
--- a/spec/requests/api/internal_spec.rb
+++ b/spec/requests/api/internal_spec.rb
@@ -239,7 +239,7 @@ describe API::Internal, api: true  do
     end
 
     context "blocked user" do
-      let(:personal_project) { create(:project, namespace: user.namespace) }
+      let(:personal_project) { create(:empty_project, namespace: user.namespace) }
 
       before do
         user.block
@@ -265,7 +265,7 @@ describe API::Internal, api: true  do
     end
 
     context "archived project" do
-      let(:personal_project) { create(:project, namespace: user.namespace) }
+      let(:personal_project) { create(:empty_project, namespace: user.namespace) }
 
       before do
         project.team << [user, :developer]
diff --git a/spec/requests/api/issues_spec.rb b/spec/requests/api/issues_spec.rb
index 807c999b84a..62f1b8d7ca2 100644
--- a/spec/requests/api/issues_spec.rb
+++ b/spec/requests/api/issues_spec.rb
@@ -11,7 +11,7 @@ describe API::Issues, api: true  do
   let(:author)      { create(:author) }
   let(:assignee)    { create(:assignee) }
   let(:admin)       { create(:user, :admin) }
-  let!(:project)    { create(:project, :public, creator_id: user.id, namespace: user.namespace ) }
+  let!(:project)    { create(:empty_project, :public, creator_id: user.id, namespace: user.namespace ) }
   let!(:closed_issue) do
     create :closed_issue,
            author: user,
@@ -224,7 +224,7 @@ describe API::Issues, api: true  do
 
   describe "GET /groups/:id/issues" do
     let!(:group)            { create(:group) }
-    let!(:group_project)    { create(:project, :public, creator_id: user.id, namespace: group) }
+    let!(:group_project)    { create(:empty_project, :public, creator_id: user.id, namespace: group) }
     let!(:group_closed_issue) do
       create :closed_issue,
              author: user,
@@ -1052,7 +1052,7 @@ describe API::Issues, api: true  do
 
     context "when the user is project owner" do
       let(:owner)     { create(:user) }
-      let(:project)   { create(:project, namespace: owner.namespace) }
+      let(:project)   { create(:empty_project, namespace: owner.namespace) }
 
       it "deletes the issue if an admin requests it" do
         delete api("/projects/#{project.id}/issues/#{issue.id}", owner)
@@ -1071,8 +1071,8 @@ describe API::Issues, api: true  do
   end
 
   describe '/projects/:id/issues/:issue_id/move' do
-    let!(:target_project) { create(:project, path: 'project2', creator_id: user.id, namespace: user.namespace ) }
-    let!(:target_project2) { create(:project, creator_id: non_member.id, namespace: non_member.namespace ) }
+    let!(:target_project) { create(:empty_project, path: 'project2', creator_id: user.id, namespace: user.namespace ) }
+    let!(:target_project2) { create(:empty_project, creator_id: non_member.id, namespace: non_member.namespace ) }
 
     it 'moves an issue' do
       post api("/projects/#{project.id}/issues/#{issue.id}/move", user),
diff --git a/spec/requests/api/labels_spec.rb b/spec/requests/api/labels_spec.rb
index b29ce1ea25e..a8cd787f398 100644
--- a/spec/requests/api/labels_spec.rb
+++ b/spec/requests/api/labels_spec.rb
@@ -4,7 +4,7 @@ describe API::Labels, api: true  do
   include ApiHelpers
 
   let(:user) { create(:user) }
-  let(:project) { create(:project, creator_id: user.id, namespace: user.namespace) }
+  let(:project) { create(:empty_project, creator_id: user.id, namespace: user.namespace) }
   let!(:label1) { create(:label, title: 'label1', project: project) }
   let!(:priority_label) { create(:label, title: 'bug', project: project, priority: 3) }
 
diff --git a/spec/requests/api/members_spec.rb b/spec/requests/api/members_spec.rb
index 2c94c86ccfa..9892e014cb9 100644
--- a/spec/requests/api/members_spec.rb
+++ b/spec/requests/api/members_spec.rb
@@ -9,7 +9,7 @@ describe API::Members, api: true  do
   let(:stranger) { create(:user) }
 
   let(:project) do
-    create(:project, :public, :access_requestable, creator_id: master.id, namespace: master.namespace) do |project|
+    create(:empty_project, :public, :access_requestable, creator_id: master.id, namespace: master.namespace) do |project|
       project.team << [developer, :developer]
       project.team << [master, :master]
       project.request_access(access_requester)
diff --git a/spec/requests/api/merge_requests_spec.rb b/spec/requests/api/merge_requests_spec.rb
index 4e4fea1dad8..71a7994e544 100644
--- a/spec/requests/api/merge_requests_spec.rb
+++ b/spec/requests/api/merge_requests_spec.rb
@@ -308,8 +308,8 @@ describe API::MergeRequests, api: true  do
 
     context 'forked projects' do
       let!(:user2) { create(:user) }
-      let!(:fork_project) { create(:project, forked_from_project: project,  namespace: user2.namespace, creator_id: user2.id) }
-      let!(:unrelated_project) { create(:project,  namespace: create(:user).namespace, creator_id: user2.id) }
+      let!(:fork_project) { create(:empty_project, forked_from_project: project,  namespace: user2.namespace, creator_id: user2.id) }
+      let!(:unrelated_project) { create(:empty_project,  namespace: create(:user).namespace, creator_id: user2.id) }
 
       before :each do |each|
         fork_project.team << [user2, :reporter]
@@ -627,6 +627,17 @@ describe API::MergeRequests, api: true  do
       expect(json_response.first['title']).to eq(issue.title)
       expect(json_response.first['id']).to eq(issue.id)
     end
+
+    it 'returns 403 if the user has no access to the merge request' do
+      project = create(:empty_project, :private)
+      merge_request = create(:merge_request, :simple, source_project: project)
+      guest = create(:user)
+      project.team << [guest, :guest]
+
+      get api("/projects/#{project.id}/merge_requests/#{merge_request.id}/closes_issues", guest)
+
+      expect(response).to have_http_status(403)
+    end
   end
 
   describe 'POST :id/merge_requests/:merge_request_id/subscription' do
@@ -648,6 +659,15 @@ describe API::MergeRequests, api: true  do
 
       expect(response).to have_http_status(404)
     end
+
+    it 'returns 403 if user has no access to read code' do
+      guest = create(:user)
+      project.team << [guest, :guest]
+
+      post api("/projects/#{project.id}/merge_requests/#{merge_request.id}/subscription", guest)
+
+      expect(response).to have_http_status(403)
+    end
   end
 
   describe 'DELETE :id/merge_requests/:merge_request_id/subscription' do
@@ -669,6 +689,15 @@ describe API::MergeRequests, api: true  do
 
       expect(response).to have_http_status(404)
     end
+
+    it 'returns 403 if user has no access to read code' do
+      guest = create(:user)
+      project.team << [guest, :guest]
+
+      delete api("/projects/#{project.id}/merge_requests/#{merge_request.id}/subscription", guest)
+
+      expect(response).to have_http_status(403)
+    end
   end
 
   describe 'Time tracking' do
diff --git a/spec/requests/api/notes_spec.rb b/spec/requests/api/notes_spec.rb
index 028f93c8561..0353ebea9e5 100644
--- a/spec/requests/api/notes_spec.rb
+++ b/spec/requests/api/notes_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe API::Notes, api: true  do
   include ApiHelpers
   let(:user) { create(:user) }
-  let!(:project) { create(:project, :public, namespace: user.namespace) }
+  let!(:project) { create(:empty_project, :public, namespace: user.namespace) }
   let!(:issue) { create(:issue, project: project, author: user) }
   let!(:merge_request) { create(:merge_request, source_project: project, target_project: project, author: user) }
   let!(:snippet) { create(:project_snippet, project: project, author: user) }
@@ -14,12 +14,12 @@ describe API::Notes, api: true  do
   # For testing the cross-reference of a private issue in a public issue
   let(:private_user)    { create(:user) }
   let(:private_project) do
-    create(:project, namespace: private_user.namespace).
+    create(:empty_project, namespace: private_user.namespace).
     tap { |p| p.team << [private_user, :master] }
   end
   let(:private_issue)    { create(:issue, project: private_project) }
 
-  let(:ext_proj)  { create(:project, :public) }
+  let(:ext_proj)  { create(:empty_project, :public) }
   let(:ext_issue) { create(:issue, project: ext_proj) }
 
   let!(:cross_reference_note) do
@@ -264,8 +264,20 @@ describe API::Notes, api: true  do
       end
     end
 
+    context 'when user does not have access to read the noteable' do
+      it 'responds with 404' do
+        project = create(:empty_project, :private) { |p| p.add_guest(user) }
+        issue = create(:issue, :confidential, project: project)
+
+        post api("/projects/#{project.id}/issues/#{issue.id}/notes", user),
+          body: 'Foo'
+
+        expect(response).to have_http_status(404)
+      end
+    end
+
     context 'when user does not have access to create noteable' do
-      let(:private_issue) { create(:issue, project: create(:project, :private)) }
+      let(:private_issue) { create(:issue, project: create(:empty_project, :private)) }
 
       ##
       # We are posting to project user has access to, but we use issue id
diff --git a/spec/requests/api/notification_settings_spec.rb b/spec/requests/api/notification_settings_spec.rb
index 8691a81420f..39d3afcb78f 100644
--- a/spec/requests/api/notification_settings_spec.rb
+++ b/spec/requests/api/notification_settings_spec.rb
@@ -5,7 +5,7 @@ describe API::NotificationSettings, api: true do
 
   let(:user) { create(:user) }
   let!(:group) { create(:group) }
-  let!(:project) { create(:project, :public, creator_id: user.id, namespace: group) }
+  let!(:project) { create(:empty_project, :public, creator_id: user.id, namespace: group) }
 
   describe "GET /notification_settings" do
     it "returns global notification settings for the current user" do
diff --git a/spec/requests/api/project_hooks_spec.rb b/spec/requests/api/project_hooks_spec.rb
index 36fbcf088e7..f4973d71088 100644
--- a/spec/requests/api/project_hooks_spec.rb
+++ b/spec/requests/api/project_hooks_spec.rb
@@ -4,7 +4,7 @@ describe API::ProjectHooks, 'ProjectHooks', api: true do
   include ApiHelpers
   let(:user) { create(:user) }
   let(:user3) { create(:user) }
-  let!(:project) { create(:project, creator_id: user.id, namespace: user.namespace) }
+  let!(:project) { create(:empty_project, creator_id: user.id, namespace: user.namespace) }
   let!(:hook) do
     create(:project_hook,
            :all_events_enabled,
@@ -204,7 +204,7 @@ describe API::ProjectHooks, 'ProjectHooks', api: true do
 
     it "returns a 404 if a user attempts to delete project hooks he/she does not own" do
       test_user = create(:user)
-      other_project = create(:project)
+      other_project = create(:empty_project)
       other_project.team << [test_user, :master]
 
       delete api("/projects/#{other_project.id}/hooks/#{hook.id}", test_user)
diff --git a/spec/requests/api/projects_spec.rb b/spec/requests/api/projects_spec.rb
index cdb16b4c46b..cc5c532de83 100644
--- a/spec/requests/api/projects_spec.rb
+++ b/spec/requests/api/projects_spec.rb
@@ -8,8 +8,8 @@ describe API::Projects, api: true  do
   let(:user2) { create(:user) }
   let(:user3) { create(:user) }
   let(:admin) { create(:admin) }
-  let(:project) { create(:project, creator_id: user.id, namespace: user.namespace) }
-  let(:project2) { create(:project, path: 'project2', creator_id: user.id, namespace: user.namespace) }
+  let(:project) { create(:empty_project, creator_id: user.id, namespace: user.namespace) }
+  let(:project2) { create(:empty_project, path: 'project2', creator_id: user.id, namespace: user.namespace) }
   let(:snippet) { create(:project_snippet, :public, author: user, project: project, title: 'example') }
   let(:project_member) { create(:project_member, :master, user: user, project: project) }
   let(:project_member2) { create(:project_member, :developer, user: user3, project: project) }
@@ -32,7 +32,7 @@ describe API::Projects, api: true  do
     access_level: ProjectMember::MASTER)
   end
   let(:project4) do
-    create(:project,
+    create(:empty_project,
     name: 'third_project',
     path: 'third_project',
     creator_id: user4.id,
@@ -252,7 +252,7 @@ describe API::Projects, api: true  do
       end
     end
 
-    let!(:public_project) { create(:project, :public) }
+    let!(:public_project) { create(:empty_project, :public) }
     before do
       project
       project2
@@ -283,7 +283,7 @@ describe API::Projects, api: true  do
   end
 
   describe 'GET /projects/starred' do
-    let(:public_project) { create(:project, :public) }
+    let(:public_project) { create(:empty_project, :public) }
 
     before do
       project_member2
@@ -583,7 +583,7 @@ describe API::Projects, api: true  do
   describe 'GET /projects/:id' do
     context 'when unauthenticated' do
       it 'returns the public projects' do
-        public_project = create(:project, :public)
+        public_project = create(:empty_project, :public)
 
         get api("/projects/#{public_project.id}")
 
@@ -665,7 +665,7 @@ describe API::Projects, api: true  do
 
       it 'handles users with dots' do
         dot_user = create(:user, username: 'dot.user')
-        project = create(:project, creator_id: dot_user.id, namespace: dot_user.namespace)
+        project = create(:empty_project, creator_id: dot_user.id, namespace: dot_user.namespace)
 
         get api("/projects/#{dot_user.namespace.name}%2F#{project.path}", dot_user)
         expect(response).to have_http_status(200)
@@ -711,7 +711,7 @@ describe API::Projects, api: true  do
         end
 
         context 'group project' do
-          let(:project2) { create(:project, group: create(:group)) }
+          let(:project2) { create(:empty_project, group: create(:group)) }
 
           before { project2.group.add_owner(user) }
 
@@ -756,7 +756,7 @@ describe API::Projects, api: true  do
 
     context 'when unauthenticated' do
       it_behaves_like 'project events response' do
-        let(:project) { create(:project, :public) }
+        let(:project) { create(:empty_project, :public) }
         let(:current_user) { nil }
       end
     end
@@ -807,7 +807,7 @@ describe API::Projects, api: true  do
 
     context 'when unauthenticated' do
       it_behaves_like 'project users response' do
-        let(:project) { create(:project, :public) }
+        let(:project) { create(:empty_project, :public) }
         let(:current_user) { nil }
       end
     end
@@ -921,11 +921,11 @@ describe API::Projects, api: true  do
   end
 
   describe :fork_admin do
-    let(:project_fork_target) { create(:project) }
-    let(:project_fork_source) { create(:project, :public) }
+    let(:project_fork_target) { create(:empty_project) }
+    let(:project_fork_source) { create(:empty_project, :public) }
 
     describe 'POST /projects/:id/fork/:forked_from_id' do
-      let(:new_project_fork_source) { create(:project, :public) }
+      let(:new_project_fork_source) { create(:empty_project, :public) }
 
       it "is not available for non admin users" do
         post api("/projects/#{project_fork_target.id}/fork/#{project_fork_source.id}", user)
@@ -966,7 +966,7 @@ describe API::Projects, api: true  do
       end
 
       context 'when users belong to project group' do
-        let(:project_fork_target) { create(:project, group: create(:group)) }
+        let(:project_fork_target) { create(:empty_project, group: create(:group)) }
 
         before do
           project_fork_target.group.add_owner user
@@ -1121,7 +1121,6 @@ describe API::Projects, api: true  do
       it_behaves_like 'project search response', query: 'one.dot.two', results: 1 do
         let(:current_user) { user }
       end
-      
     end
 
     context 'when authenticated as a different user' do
diff --git a/spec/requests/api/runners_spec.rb b/spec/requests/api/runners_spec.rb
index 99414270be6..f2d81a28cb8 100644
--- a/spec/requests/api/runners_spec.rb
+++ b/spec/requests/api/runners_spec.rb
@@ -7,8 +7,8 @@ describe API::Runners, api: true  do
   let(:user) { create(:user) }
   let(:user2) { create(:user) }
 
-  let(:project) { create(:project, creator_id: user.id) }
-  let(:project2) { create(:project, creator_id: user.id) }
+  let(:project) { create(:empty_project, creator_id: user.id) }
+  let(:project2) { create(:empty_project, creator_id: user.id) }
 
   let!(:shared_runner) { create(:ci_runner, :shared) }
   let!(:unused_specific_runner) { create(:ci_runner) }
diff --git a/spec/requests/api/services_spec.rb b/spec/requests/api/services_spec.rb
index 39c9e0505d1..776dc655650 100644
--- a/spec/requests/api/services_spec.rb
+++ b/spec/requests/api/services_spec.rb
@@ -6,7 +6,7 @@ describe API::Services, api: true  do
   let(:user) { create(:user) }
   let(:admin) { create(:admin) }
   let(:user2) { create(:user) }
-  let(:project) {create(:empty_project, creator_id: user.id, namespace: user.namespace) }
+  let(:project) { create(:empty_project, creator_id: user.id, namespace: user.namespace) }
 
   Service.available_services_names.each do |service|
     describe "PUT /projects/:id/services/#{service.dasherize}" do
@@ -16,6 +16,15 @@ describe API::Services, api: true  do
         put api("/projects/#{project.id}/services/#{dashed_service}", user), service_attrs
 
         expect(response).to have_http_status(200)
+
+        current_service = project.services.first
+        event = current_service.event_names.empty? ? "foo" : current_service.event_names.first
+        state = current_service[event] || false
+
+        put api("/projects/#{project.id}/services/#{dashed_service}?#{event}=#{!state}", user), service_attrs
+
+        expect(response).to have_http_status(200)
+        expect(project.services.first[event]).not_to eq(state) unless event == "foo"
       end
 
       it "returns if required fields missing" do
diff --git a/spec/requests/api/todos_spec.rb b/spec/requests/api/todos_spec.rb
index 887a2ba5b84..56dc017ce54 100644
--- a/spec/requests/api/todos_spec.rb
+++ b/spec/requests/api/todos_spec.rb
@@ -3,8 +3,8 @@ require 'spec_helper'
 describe API::Todos, api: true do
   include ApiHelpers
 
-  let(:project_1) { create(:project) }
-  let(:project_2) { create(:project) }
+  let(:project_1) { create(:empty_project) }
+  let(:project_2) { create(:empty_project) }
   let(:author_1) { create(:user) }
   let(:author_2) { create(:user) }
   let(:john_doe) { create(:user, username: 'john_doe') }
@@ -183,12 +183,25 @@ describe API::Todos, api: true do
 
       expect(response.status).to eq(404)
     end
+
+    it 'returns an error if the issuable is not accessible' do
+      guest = create(:user)
+      project_1.team << [guest, :guest]
+
+      post api("/projects/#{project_1.id}/#{issuable_type}/#{issuable.id}/todo", guest)
+
+      if issuable_type == 'merge_requests'
+        expect(response).to have_http_status(403)
+      else
+        expect(response).to have_http_status(404)
+      end
+    end
   end
 
   describe 'POST :id/issuable_type/:issueable_id/todo' do
     context 'for an issue' do
       it_behaves_like 'an issuable', 'issues' do
-        let(:issuable) { create(:issue, author: author_1, project: project_1) }
+        let(:issuable) { create(:issue, :confidential, author: author_1, project: project_1) }
       end
     end
 
diff --git a/spec/requests/api/triggers_spec.rb b/spec/requests/api/triggers_spec.rb
index 67ec3168679..cd01283b655 100644
--- a/spec/requests/api/triggers_spec.rb
+++ b/spec/requests/api/triggers_spec.rb
@@ -15,7 +15,7 @@ describe API::Triggers do
   let!(:trigger_request) { create(:ci_trigger_request, trigger: trigger, created_at: '2015-01-01 12:13:14') }
 
   describe 'POST /projects/:project_id/trigger' do
-    let!(:project2) { create(:empty_project) }
+    let!(:project2) { create(:project) }
     let(:options) do
       {
         token: trigger_token
diff --git a/spec/requests/api/variables_spec.rb b/spec/requests/api/variables_spec.rb
index 7435f320607..769f04c5057 100644
--- a/spec/requests/api/variables_spec.rb
+++ b/spec/requests/api/variables_spec.rb
@@ -5,7 +5,7 @@ describe API::Variables, api: true do
 
   let(:user) { create(:user) }
   let(:user2) { create(:user) }
-  let!(:project) { create(:project, creator_id: user.id) }
+  let!(:project) { create(:empty_project, creator_id: user.id) }
   let!(:master) { create(:project_member, :master, user: user, project: project) }
   let!(:developer) { create(:project_member, :developer, user: user2, project: project) }
   let!(:variable) { create(:ci_variable, project: project) }
diff --git a/spec/requests/ci/api/builds_spec.rb b/spec/requests/ci/api/builds_spec.rb
index 3b5dc98e4d5..270c23e3f19 100644
--- a/spec/requests/ci/api/builds_spec.rb
+++ b/spec/requests/ci/api/builds_spec.rb
@@ -4,7 +4,8 @@ describe Ci::API::Builds do
   include ApiHelpers
 
   let(:runner) { FactoryGirl.create(:ci_runner, tag_list: ["mysql", "ruby"]) }
-  let(:project) { FactoryGirl.create(:empty_project) }
+  let(:project) { FactoryGirl.create(:empty_project, shared_runners_enabled: false) }
+  let(:last_update) { nil }
 
   describe "Builds API for runners" do
     let(:pipeline) { create(:ci_pipeline_without_jobs, project: project, ref: 'master') }
@@ -16,6 +17,8 @@ describe Ci::API::Builds do
     describe "POST /builds/register" do
       let!(:build) { create(:ci_build, pipeline: pipeline, name: 'spinach', stage: 'test', stage_idx: 0) }
       let(:user_agent) { 'gitlab-ci-multi-runner 1.5.2 (1-5-stable; go1.6.3; linux/amd64)' }
+      let!(:last_update) { }
+      let!(:new_update) { }
 
       before do
         stub_container_registry_config(enabled: false)
@@ -24,7 +27,31 @@ describe Ci::API::Builds do
       shared_examples 'no builds available' do
         context 'when runner sends version in User-Agent' do
           context 'for stable version' do
-            it { expect(response).to have_http_status(204) }
+            it 'gives 204 and set X-GitLab-Last-Update' do
+              expect(response).to have_http_status(204)
+              expect(response.header).to have_key('X-GitLab-Last-Update')
+            end
+          end
+
+          context 'when last_update is up-to-date' do
+            let(:last_update) { runner.ensure_runner_queue_value }
+
+            it 'gives 204 and set the same X-GitLab-Last-Update' do
+              expect(response).to have_http_status(204)
+              expect(response.header['X-GitLab-Last-Update'])
+                .to eq(last_update)
+            end
+          end
+
+          context 'when last_update is outdated' do
+            let(:last_update) { runner.ensure_runner_queue_value }
+            let(:new_update) { runner.tick_runner_queue }
+
+            it 'gives 204 and set a new X-GitLab-Last-Update' do
+              expect(response).to have_http_status(204)
+              expect(response.header['X-GitLab-Last-Update'])
+                .to eq(new_update)
+            end
           end
 
           context 'for beta version' do
@@ -49,6 +76,7 @@ describe Ci::API::Builds do
           register_builds info: { platform: :darwin }
 
           expect(response).to have_http_status(201)
+          expect(response.headers).not_to have_key('X-GitLab-Last-Update')
           expect(json_response['sha']).to eq(build.sha)
           expect(runner.reload.platform).to eq("darwin")
           expect(json_response["options"]).to eq({ "image" => "ruby:2.1", "services" => ["postgres"] })
@@ -119,10 +147,10 @@ describe Ci::API::Builds do
       end
 
       context 'for shared runner' do
-        let(:shared_runner) { create(:ci_runner, token: "SharedRunner") }
+        let!(:runner) { create(:ci_runner, :shared, token: "SharedRunner") }
 
         before do
-          register_builds shared_runner.token
+          register_builds(runner.token)
         end
 
         it_behaves_like 'no builds available'
@@ -224,7 +252,9 @@ describe Ci::API::Builds do
       end
 
       def register_builds(token = runner.token, **params)
-        post ci_api("/builds/register"), params.merge(token: token), { 'User-Agent' => user_agent }
+        new_params = params.merge(token: token, last_update: last_update)
+
+        post ci_api("/builds/register"), new_params, { 'User-Agent' => user_agent }
       end
     end
 
diff --git a/spec/requests/projects/cycle_analytics_events_spec.rb b/spec/requests/projects/cycle_analytics_events_spec.rb
index e0368e6001f..72978846e93 100644
--- a/spec/requests/projects/cycle_analytics_events_spec.rb
+++ b/spec/requests/projects/cycle_analytics_events_spec.rb
@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe 'cycle analytics events' do
+  include ApiHelpers
+
   let(:user) { create(:user) }
   let(:project) { create(:project, public_builds: false) }
   let(:issue) {  create(:issue, project: project, created_at: 2.days.ago) }
@@ -20,19 +22,19 @@ describe 'cycle analytics events' do
     it 'lists the issue events' do
       get namespace_project_cycle_analytics_issue_path(project.namespace, project, format: :json)
 
-      expect(json_response['events']).not_to be_empty
-
-      first_issue_iid = Issue.order(created_at: :desc).pluck(:iid).first.to_s
+      first_issue_iid = project.issues.sort(:created_desc).pluck(:iid).first.to_s
 
+      expect(json_response['events']).not_to be_empty
       expect(json_response['events'].first['iid']).to eq(first_issue_iid)
     end
 
     it 'lists the plan events' do
       get namespace_project_cycle_analytics_plan_path(project.namespace, project, format: :json)
 
-      expect(json_response['events']).not_to be_empty
+      first_mr_short_sha = project.merge_requests.sort(:created_asc).first.commits.first.short_id
 
-      expect(json_response['events'].first['short_sha']).to eq(MergeRequest.last.commits.first.short_id)
+      expect(json_response['events']).not_to be_empty
+      expect(json_response['events'].first['short_sha']).to eq(first_mr_short_sha)
     end
 
     it 'lists the code events' do
@@ -40,7 +42,7 @@ describe 'cycle analytics events' do
 
       expect(json_response['events']).not_to be_empty
 
-      first_mr_iid = project.merge_requests.order(id: :desc).pluck(:iid).first.to_s
+      first_mr_iid = project.merge_requests.sort(:created_desc).pluck(:iid).first.to_s
 
       expect(json_response['events'].first['iid']).to eq(first_mr_iid)
     end
@@ -49,17 +51,15 @@ describe 'cycle analytics events' do
       get namespace_project_cycle_analytics_test_path(project.namespace, project, format: :json)
 
       expect(json_response['events']).not_to be_empty
-
       expect(json_response['events'].first['date']).not_to be_empty
     end
 
     it 'lists the review events' do
       get namespace_project_cycle_analytics_review_path(project.namespace, project, format: :json)
 
-      expect(json_response['events']).not_to be_empty
-
-      first_mr_iid = MergeRequest.order(created_at: :desc).pluck(:iid).first.to_s
+      first_mr_iid = project.merge_requests.sort(:created_desc).pluck(:iid).first.to_s
 
+      expect(json_response['events']).not_to be_empty
       expect(json_response['events'].first['iid']).to eq(first_mr_iid)
     end
 
@@ -67,35 +67,32 @@ describe 'cycle analytics events' do
       get namespace_project_cycle_analytics_staging_path(project.namespace, project, format: :json)
 
       expect(json_response['events']).not_to be_empty
-
       expect(json_response['events'].first['date']).not_to be_empty
     end
 
     it 'lists the production events' do
       get namespace_project_cycle_analytics_production_path(project.namespace, project, format: :json)
 
-      expect(json_response['events']).not_to be_empty
-
-      first_issue_iid = Issue.order(created_at: :desc).pluck(:iid).first.to_s
+      first_issue_iid = project.issues.sort(:created_desc).pluck(:iid).first.to_s
 
+      expect(json_response['events']).not_to be_empty
       expect(json_response['events'].first['iid']).to eq(first_issue_iid)
     end
 
     context 'specific branch' do
       it 'lists the test events' do
-        branch = MergeRequest.first.source_branch
+        branch = project.merge_requests.first.source_branch
 
         get namespace_project_cycle_analytics_test_path(project.namespace, project, format: :json, branch: branch)
 
         expect(json_response['events']).not_to be_empty
-
         expect(json_response['events'].first['date']).not_to be_empty
       end
     end
 
     context 'with private project and builds' do
       before do
-        ProjectMember.first.update(access_level: Gitlab::Access::GUEST)
+        project.members.first.update(access_level: Gitlab::Access::GUEST)
       end
 
       it 'does not list the test events' do
@@ -118,10 +115,6 @@ describe 'cycle analytics events' do
     end
   end
 
-  def json_response
-    JSON.parse(response.body)
-  end
-
   def create_cycle
     milestone = create(:milestone, project: project)
     issue.update(milestone: milestone)
diff --git a/spec/serializers/pipeline_entity_spec.rb b/spec/serializers/pipeline_entity_spec.rb
index b19464c7117..ccb72973f9c 100644
--- a/spec/serializers/pipeline_entity_spec.rb
+++ b/spec/serializers/pipeline_entity_spec.rb
@@ -134,5 +134,17 @@ describe PipelineEntity do
         expect(subject).not_to have_key(:yaml_errors)
       end
     end
+
+    context 'when pipeline ref is empty' do
+      let(:pipeline) { create(:ci_empty_pipeline) }
+
+      before do
+        allow(pipeline).to receive(:ref).and_return(nil)
+      end
+
+      it 'does not generate branch path' do
+        expect(subject[:ref][:path]).to be_nil
+      end
+    end
   end
 end
diff --git a/spec/services/ci/update_build_queue_service_spec.rb b/spec/services/ci/update_build_queue_service_spec.rb
new file mode 100644
index 00000000000..f01a388b895
--- /dev/null
+++ b/spec/services/ci/update_build_queue_service_spec.rb
@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Ci::UpdateBuildQueueService, :services do
+  let(:project) { create(:project) }
+  let(:build) { create(:ci_build, pipeline: pipeline) }
+  let(:pipeline) { create(:ci_pipeline, project: project) }
+
+  context 'when updating specific runners' do
+    let(:runner) { create(:ci_runner) }
+
+    context 'when there are runner that can pick build' do
+      before { build.project.runners << runner }
+
+      it 'ticks runner queue value' do
+        expect { subject.execute(build) }
+          .to change { runner.ensure_runner_queue_value }
+      end
+    end
+
+    context 'when there are no runners that can pick build' do
+      it 'does not tick runner queue value' do
+        expect { subject.execute(build) }
+          .not_to change { runner.ensure_runner_queue_value }
+      end
+    end
+  end
+
+  context 'when updating shared runners' do
+    let(:runner) { create(:ci_runner, :shared) }
+
+    context 'when there are runner that can pick build' do
+      it 'ticks runner queue value' do
+        expect { subject.execute(build) }
+          .to change { runner.ensure_runner_queue_value }
+      end
+    end
+
+    context 'when there are no runners that can pick build' do
+      before { build.tag_list = [:docker] }
+
+      it 'does not tick runner queue value' do
+        expect { subject.execute(build) }
+          .not_to change { runner.ensure_runner_queue_value }
+      end
+    end
+  end
+end
diff --git a/spec/services/merge_requests/refresh_service_spec.rb b/spec/services/merge_requests/refresh_service_spec.rb
index 00d0e20f47c..314ea670a71 100644
--- a/spec/services/merge_requests/refresh_service_spec.rb
+++ b/spec/services/merge_requests/refresh_service_spec.rb
@@ -106,23 +106,46 @@ describe MergeRequests::RefreshService, services: true do
 
     context 'push to fork repo source branch' do
       let(:refresh_service) { service.new(@fork_project, @user) }
-      before do
-        allow(refresh_service).to receive(:execute_hooks)
-        refresh_service.execute(@oldrev, @newrev, 'refs/heads/master')
-        reload_mrs
-      end
 
-      it 'executes hooks with update action' do
-        expect(refresh_service).to have_received(:execute_hooks).
-          with(@fork_merge_request, 'update', @oldrev)
+      context 'open fork merge request' do
+        before do
+          allow(refresh_service).to receive(:execute_hooks)
+          refresh_service.execute(@oldrev, @newrev, 'refs/heads/master')
+          reload_mrs
+        end
+
+        it 'executes hooks with update action' do
+          expect(refresh_service).to have_received(:execute_hooks).
+            with(@fork_merge_request, 'update', @oldrev)
+        end
+
+        it { expect(@merge_request.notes).to be_empty }
+        it { expect(@merge_request).to be_open }
+        it { expect(@fork_merge_request.notes.last.note).to include('added 28 commits') }
+        it { expect(@fork_merge_request).to be_open }
+        it { expect(@build_failed_todo).to be_pending }
+        it { expect(@fork_build_failed_todo).to be_pending }
       end
 
-      it { expect(@merge_request.notes).to be_empty }
-      it { expect(@merge_request).to be_open }
-      it { expect(@fork_merge_request.notes.last.note).to include('added 28 commits') }
-      it { expect(@fork_merge_request).to be_open }
-      it { expect(@build_failed_todo).to be_pending }
-      it { expect(@fork_build_failed_todo).to be_pending }
+      context 'closed fork merge request' do
+        before do
+          @fork_merge_request.close!
+          allow(refresh_service).to receive(:execute_hooks)
+          refresh_service.execute(@oldrev, @newrev, 'refs/heads/master')
+          reload_mrs
+        end
+
+        it 'do not execute hooks with update action' do
+          expect(refresh_service).not_to have_received(:execute_hooks)
+        end
+
+        it { expect(@merge_request.notes).to be_empty }
+        it { expect(@merge_request).to be_open }
+        it { expect(@fork_merge_request.notes).to be_empty }
+        it { expect(@fork_merge_request).to be_closed }
+        it { expect(@build_failed_todo).to be_pending }
+        it { expect(@fork_build_failed_todo).to be_pending }
+      end
     end
 
     context 'push to fork repo target branch' do
diff --git a/spec/support/notify_shared_examples.rb b/spec/support/notify_shared_examples.rb
index 49867aa5cc4..a3724b801b3 100644
--- a/spec/support/notify_shared_examples.rb
+++ b/spec/support/notify_shared_examples.rb
@@ -179,9 +179,24 @@ shared_examples 'it should show Gmail Actions View Commit link' do
 end
 
 shared_examples 'an unsubscribeable thread' do
+  it_behaves_like 'an unsubscribeable thread with incoming address without %{key}'
+
+  it 'has a List-Unsubscribe header in the correct format' do
+    is_expected.to have_header 'List-Unsubscribe', /unsubscribe/
+    is_expected.to have_header 'List-Unsubscribe', /mailto/
+    is_expected.to have_header 'List-Unsubscribe', /^<.+,.+>$/
+  end
+
+  it { is_expected.to have_body_text /unsubscribe/ }
+end
+
+shared_examples 'an unsubscribeable thread with incoming address without %{key}' do
+  include_context 'reply-by-email is enabled with incoming address without %{key}'
+
   it 'has a List-Unsubscribe header in the correct format' do
     is_expected.to have_header 'List-Unsubscribe', /unsubscribe/
-    is_expected.to have_header 'List-Unsubscribe', /^<.+>$/
+    is_expected.not_to have_header 'List-Unsubscribe', /mailto/
+    is_expected.to have_header 'List-Unsubscribe', /^<[^,]+>$/
   end
 
   it { is_expected.to have_body_text /unsubscribe/ }
diff --git a/spec/support/taskable_shared_examples.rb b/spec/support/taskable_shared_examples.rb
index ad1c783df4d..1b6c33248c9 100644
--- a/spec/support/taskable_shared_examples.rb
+++ b/spec/support/taskable_shared_examples.rb
@@ -33,6 +33,30 @@ shared_examples 'a Taskable' do
     end
   end
 
+  describe 'with nested tasks' do
+    before do
+      subject.description = <<-EOT.strip_heredoc
+        - [ ] Task a
+          - [x] Task a.1
+          - [ ] Task a.2
+        - [ ] Task b
+
+        1. [ ] Task 1
+          1. [ ] Task 1.1
+          1. [ ] Task 1.2
+        1. [x] Task 2
+          1. [x] Task 2.1
+      EOT
+    end
+
+    it 'returns the correct task status' do
+      expect(subject.task_status).to match('3 of')
+      expect(subject.task_status).to match('9 tasks completed')
+      expect(subject.task_status_short).to match('3/')
+      expect(subject.task_status_short).to match('9 tasks')
+    end
+  end
+
   describe 'with an incomplete task' do
     before do
       subject.description = <<-EOT.strip_heredoc
diff --git a/spec/teaspoon_env.rb b/spec/teaspoon_env.rb
index 5ea020f313c..643b161cdf4 100644
--- a/spec/teaspoon_env.rb
+++ b/spec/teaspoon_env.rb
@@ -166,7 +166,7 @@ Teaspoon.configure do |config|
 
     # Assets to be ignored when generating coverage reports. Accepts an array of filenames or regular expressions. The
     # default excludes assets from vendor, gems and support libraries.
-    coverage.ignore = [%r{vendor/}, %r{spec/}]
+    coverage.ignore = [%r{vendor/}, %r{spec/javascripts/(?!helpers/)}]
 
     # Various thresholds requirements can be defined, and those thresholds will be checked at the end of a run. If any
     # aren't met the run will fail with a message. Thresholds can be defined as a percentage (0-100), or nil.