Merge branch 'master' into deploy-keys-load-async

50 files changed, 2041 insertions, 386 deletions

diff --git a/spec/controllers/projects/branches_controller_spec.rb b/spec/controllers/projects/branches_controller_spec.rb
index d20e7368086..8f915d9d210 100644
--- a/spec/controllers/projects/branches_controller_spec.rb
+++ b/spec/controllers/projects/branches_controller_spec.rb
@@ -14,7 +14,7 @@ describe Projects::BranchesController do
     controller.instance_variable_set(:@project, project)
   end
 
-  describe "POST create" do
+  describe "POST create with HTML format" do
     render_views
 
     context "on creation of a new branch" do
@@ -152,6 +152,42 @@ describe Projects::BranchesController do
     end
   end
 
+  describe 'POST create with JSON format' do
+    before do
+      sign_in(user)
+    end
+
+    context 'with valid params' do
+      it 'returns a successful 200 response' do
+        create_branch name: 'my-branch', ref: 'master'
+
+        expect(response).to have_http_status(200)
+      end
+
+      it 'returns the created branch' do
+        create_branch name: 'my-branch', ref: 'master'
+
+        expect(response).to match_response_schema('branch')
+      end
+    end
+
+    context 'with invalid params' do
+      it 'returns an unprocessable entity 422 response' do
+        create_branch name: "<script>alert('merge');</script>", ref: "<script>alert('ref');</script>"
+
+        expect(response).to have_http_status(422)
+      end
+    end
+
+    def create_branch(name:, ref:)
+      post :create, namespace_id: project.namespace.to_param,
+                    project_id: project.to_param,
+                    branch_name: name,
+                    ref: ref,
+                    format: :json
+    end
+  end
+
   describe "POST destroy with HTML format" do
     render_views
 
diff --git a/spec/controllers/projects/issues_controller_spec.rb b/spec/controllers/projects/issues_controller_spec.rb
index 79034b8d24d..5f1f892821a 100644
--- a/spec/controllers/projects/issues_controller_spec.rb
+++ b/spec/controllers/projects/issues_controller_spec.rb
@@ -756,4 +756,28 @@ describe Projects::IssuesController do
       expect(response).to have_http_status(200)
     end
   end
+
+  describe 'POST create_merge_request' do
+    before do
+      project.add_developer(user)
+      sign_in(user)
+    end
+
+    it 'creates a new merge request' do
+      expect { create_merge_request }.to change(project.merge_requests, :count).by(1)
+    end
+
+    it 'render merge request as json' do
+      create_merge_request
+
+      expect(response).to match_response_schema('merge_request')
+    end
+
+    def create_merge_request
+      post :create_merge_request, namespace_id: project.namespace.to_param,
+                                  project_id: project.to_param,
+                                  id: issue.to_param,
+                                  format: :json
+    end
+  end
 end
diff --git a/spec/controllers/projects/pages_controller_spec.rb b/spec/controllers/projects/pages_controller_spec.rb
new file mode 100644
index 00000000000..df35d8e86b9
--- /dev/null
+++ b/spec/controllers/projects/pages_controller_spec.rb
@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Projects::PagesController do
+  let(:user) { create(:user) }
+  let(:project) { create(:empty_project, :public, :access_requestable) }
+
+  let(:request_params) do
+    {
+      namespace_id: project.namespace,
+      project_id: project
+    }
+  end
+
+  before do
+    allow(Gitlab.config.pages).to receive(:enabled).and_return(true)
+    sign_in(user)
+    project.add_master(user)
+  end
+
+  describe 'GET show' do
+    it 'returns 200 status' do
+      get :show, request_params
+
+      expect(response).to have_http_status(200)
+    end
+  end
+
+  describe 'DELETE destroy' do
+    it 'returns 302 status' do
+      delete :destroy, request_params
+
+      expect(response).to have_http_status(302)
+    end
+  end
+
+  context 'pages disabled' do
+    before do
+      allow(Gitlab.config.pages).to receive(:enabled).and_return(false)
+    end
+
+    describe 'GET show' do
+      it 'returns 404 status' do
+        get :show, request_params
+
+        expect(response).to have_http_status(404)
+      end
+    end
+
+    describe 'DELETE destroy' do
+      it 'returns 404 status' do
+        delete :destroy, request_params
+
+        expect(response).to have_http_status(404)
+      end
+    end
+  end
+end
diff --git a/spec/controllers/projects/pages_domains_controller_spec.rb b/spec/controllers/projects/pages_domains_controller_spec.rb
index 2362df895a8..33853c4b9d0 100644
--- a/spec/controllers/projects/pages_domains_controller_spec.rb
+++ b/spec/controllers/projects/pages_domains_controller_spec.rb
@@ -1,8 +1,9 @@
 require 'spec_helper'
 
 describe Projects::PagesDomainsController do
-  let(:user)    { create(:user) }
-  let(:project) { create(:project) }
+  let(:user) { create(:user) }
+  let(:project) { create(:empty_project) }
+  let!(:pages_domain) { create(:pages_domain, project: project) }
 
   let(:request_params) do
     {
@@ -11,14 +12,17 @@ describe Projects::PagesDomainsController do
     }
   end
 
+  let(:pages_domain_params) do
+    build(:pages_domain, :with_certificate, :with_key, domain: 'my.otherdomain.com').slice(:key, :certificate, :domain)
+  end
+
   before do
+    allow(Gitlab.config.pages).to receive(:enabled).and_return(true)
     sign_in(user)
-    project.team << [user, :master]
+    project.add_master(user)
   end
 
   describe 'GET show' do
-    let!(:pages_domain)   { create(:pages_domain, project: project) }
-
     it "displays the 'show' page" do
       get(:show, request_params.merge(id: pages_domain.domain))
 
@@ -37,10 +41,6 @@ describe Projects::PagesDomainsController do
   end
 
   describe 'POST create' do
-    let(:pages_domain_params) do
-      build(:pages_domain, :with_certificate, :with_key).slice(:key, :certificate, :domain)
-    end
-
     it "creates a new pages domain" do
       expect do
         post(:create, request_params.merge(pages_domain: pages_domain_params))
@@ -51,8 +51,6 @@ describe Projects::PagesDomainsController do
   end
 
   describe 'DELETE destroy' do
-    let!(:pages_domain)   { create(:pages_domain, project: project) }
-
     it "deletes the pages domain" do
       expect do
         delete(:destroy, request_params.merge(id: pages_domain.domain))
@@ -61,4 +59,42 @@ describe Projects::PagesDomainsController do
       expect(response).to redirect_to(namespace_project_pages_path(project.namespace, project))
     end
   end
+
+  context 'pages disabled' do
+    before do
+      allow(Gitlab.config.pages).to receive(:enabled).and_return(false)
+    end
+
+    describe 'GET show' do
+      it 'returns 404 status' do
+        get(:show, request_params.merge(id: pages_domain.domain))
+
+        expect(response).to have_http_status(404)
+      end
+    end
+
+    describe 'GET new' do
+      it 'returns 404 status' do
+        get :new, request_params
+
+        expect(response).to have_http_status(404)
+      end
+    end
+
+    describe 'POST create' do
+      it "returns 404 status" do
+        post(:create, request_params.merge(pages_domain: pages_domain_params))
+
+        expect(response).to have_http_status(404)
+      end
+    end
+
+    describe 'DELETE destroy' do
+      it "deletes the pages domain" do
+        delete(:destroy, request_params.merge(id: pages_domain.domain))
+
+        expect(response).to have_http_status(404)
+      end
+    end
+  end
 end
diff --git a/spec/controllers/uploads_controller_spec.rb b/spec/controllers/uploads_controller_spec.rb
index f67d26da0ac..7dedfe160a6 100644
--- a/spec/controllers/uploads_controller_spec.rb
+++ b/spec/controllers/uploads_controller_spec.rb
@@ -8,6 +8,93 @@ end
 describe UploadsController do
   let!(:user) { create(:user, avatar: fixture_file_upload(Rails.root + "spec/fixtures/dk.png", "image/png")) }
 
+  describe 'POST create' do
+    let(:model)   { 'personal_snippet' }
+    let(:snippet) { create(:personal_snippet, :public) }
+    let(:jpg)     { fixture_file_upload(Rails.root + 'spec/fixtures/rails_sample.jpg', 'image/jpg') }
+    let(:txt)     { fixture_file_upload(Rails.root + 'spec/fixtures/doc_sample.txt', 'text/plain') }
+
+    context 'when a user does not have permissions to upload a file' do
+      it "returns 401 when the user is not logged in" do
+        post :create, model: model, id: snippet.id, format: :json
+
+        expect(response).to have_http_status(401)
+      end
+
+      it "returns 404 when user can't comment on a snippet" do
+        private_snippet = create(:personal_snippet, :private)
+
+        sign_in(user)
+        post :create, model: model, id: private_snippet.id, format: :json
+
+        expect(response).to have_http_status(404)
+      end
+    end
+
+    context 'when a user is logged in' do
+      before do
+        sign_in(user)
+      end
+
+      it "returns an error without file" do
+        post :create, model: model, id: snippet.id, format: :json
+
+        expect(response).to have_http_status(422)
+      end
+
+      it "returns an error with invalid model" do
+        expect { post :create, model: 'invalid', id: snippet.id, format: :json }
+        .to raise_error(ActionController::UrlGenerationError)
+      end
+
+      it "returns 404 status when object not found" do
+        post :create, model: model, id: 9999, format: :json
+
+        expect(response).to have_http_status(404)
+      end
+
+      context 'with valid image' do
+        before do
+          post :create, model: 'personal_snippet', id: snippet.id, file: jpg, format: :json
+        end
+
+        it 'returns a content with original filename, new link, and correct type.' do
+          expect(response.body).to match '\"alt\":\"rails_sample\"'
+          expect(response.body).to match "\"url\":\"/uploads"
+        end
+
+        it 'creates a corresponding Upload record' do
+          upload = Upload.last
+
+          aggregate_failures do
+            expect(upload).to exist
+            expect(upload.model).to eq snippet
+          end
+        end
+      end
+
+      context 'with valid non-image file' do
+        before do
+          post :create, model: 'personal_snippet', id: snippet.id, file: txt, format: :json
+        end
+
+        it 'returns a content with original filename, new link, and correct type.' do
+          expect(response.body).to match '\"alt\":\"doc_sample.txt\"'
+          expect(response.body).to match "\"url\":\"/uploads"
+        end
+
+        it 'creates a corresponding Upload record' do
+          upload = Upload.last
+
+          aggregate_failures do
+            expect(upload).to exist
+            expect(upload.model).to eq snippet
+          end
+        end
+      end
+    end
+  end
+
   describe "GET show" do
     context 'Content-Disposition security measures' do
       let(:project) { create(:empty_project, :public) }
diff --git a/spec/features/gitlab_flavored_markdown_spec.rb b/spec/features/gitlab_flavored_markdown_spec.rb
index 01b1aee4fd3..f5b54463df8 100644
--- a/spec/features/gitlab_flavored_markdown_spec.rb
+++ b/spec/features/gitlab_flavored_markdown_spec.rb
@@ -62,6 +62,8 @@ describe "GitLab Flavored Markdown", feature: true do
                       project: project,
                       title: "fix #{@other_issue.to_reference}",
                       description: "ask #{fred.to_reference} for details")
+
+      @note = create(:note_on_issue, noteable: @issue, project: @issue.project, note: "Hello world")
     end
 
     it "renders subject in issues#index" do
@@ -81,14 +83,6 @@ describe "GitLab Flavored Markdown", feature: true do
 
       expect(page).to have_link(fred.to_reference)
     end
-
-    it "renders updated subject once edited somewhere else in issues#show" do
-      visit namespace_project_issue_path(project.namespace, project, @issue)
-      @issue.update(title: "fix #{@other_issue.to_reference} and update")
-
-      wait_for_vue_resource
-      expect(page).to have_text("fix #{@other_issue.to_reference} and update")
-    end
   end
 
   describe "for merge requests" do
diff --git a/spec/features/issues/create_branch_merge_request_spec.rb b/spec/features/issues/create_branch_merge_request_spec.rb
new file mode 100644
index 00000000000..44c19275ae5
--- /dev/null
+++ b/spec/features/issues/create_branch_merge_request_spec.rb
@@ -0,0 +1,91 @@
+require 'rails_helper'
+
+feature 'Create Branch/Merge Request Dropdown on issue page', feature: true, js: true do
+  let(:user) { create(:user) }
+  let!(:project) { create(:project) }
+  let(:issue) { create(:issue, project: project, title: 'Cherry-Coloured Funk') }
+
+  context 'for team members' do
+    before do
+      project.team << [user, :developer]
+      login_as(user)
+    end
+
+    it 'allows creating a merge request from the issue page' do
+      visit namespace_project_issue_path(project.namespace, project, issue)
+
+      select_dropdown_option('create-mr')
+
+      wait_for_ajax
+
+      expect(page).to have_content("created branch 1-cherry-coloured-funk")
+      expect(page).to have_content("mentioned in merge request !1")
+
+      visit namespace_project_merge_request_path(project.namespace, project, MergeRequest.first)
+
+      expect(page).to have_content('WIP: Resolve "Cherry-Coloured Funk"')
+      expect(current_path).to eq(namespace_project_merge_request_path(project.namespace, project, MergeRequest.first))
+    end
+
+    it 'allows creating a branch from the issue page' do
+      visit namespace_project_issue_path(project.namespace, project, issue)
+
+      select_dropdown_option('create-branch')
+
+      wait_for_ajax
+
+      expect(page).to have_selector('.dropdown-toggle-text ', text: '1-cherry-coloured-funk')
+      expect(current_path).to eq namespace_project_tree_path(project.namespace, project, '1-cherry-coloured-funk')
+    end
+
+    context "when there is a referenced merge request" do
+      let!(:note) do
+        create(:note, :on_issue, :system, project: project, noteable: issue,
+                                          note: "mentioned in #{referenced_mr.to_reference}")
+      end
+
+      let(:referenced_mr) do
+        create(:merge_request, :simple, source_project: project, target_project: project,
+                                        description: "Fixes #{issue.to_reference}", author: user)
+      end
+
+      before do
+        referenced_mr.cache_merge_request_closes_issues!(user)
+
+        visit namespace_project_issue_path(project.namespace, project, issue)
+      end
+
+      it 'disables the create branch button' do
+        expect(page).to have_css('.create-mr-dropdown-wrap .unavailable:not(.hide)')
+        expect(page).to have_css('.create-mr-dropdown-wrap .available.hide', visible: false)
+        expect(page).to have_content /1 Related Merge Request/
+      end
+    end
+
+    context 'when issue is confidential' do
+      it 'disables the create branch button' do
+        issue = create(:issue, :confidential, project: project)
+
+        visit namespace_project_issue_path(project.namespace, project, issue)
+
+        expect(page).not_to have_css('.create-mr-dropdown-wrap')
+      end
+    end
+  end
+
+  context 'for visitors' do
+    before do
+      visit namespace_project_issue_path(project.namespace, project, issue)
+    end
+
+    it 'shows no buttons' do
+      expect(page).not_to have_selector('.create-mr-dropdown-wrap')
+    end
+  end
+
+  def select_dropdown_option(option)
+    find('.create-mr-dropdown-wrap .dropdown-toggle').click
+    find("li[data-value='#{option}']").click
+    find('.js-create-merge-request').click
+  end
+end
diff --git a/spec/features/issues/new_branch_button_spec.rb b/spec/features/issues/new_branch_button_spec.rb
deleted file mode 100644
index c0ab42c6822..00000000000
--- a/spec/features/issues/new_branch_button_spec.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-require 'rails_helper'
-
-feature 'Start new branch from an issue', feature: true, js: true do
-  let!(:project)   { create(:project) }
-  let!(:issue)     { create(:issue, project: project) }
-  let!(:user)      { create(:user)}
-
-  context "for team members" do
-    before do
-      project.team << [user, :master]
-      login_as(user)
-    end
-
-    it 'shows the new branch button' do
-      visit namespace_project_issue_path(project.namespace, project, issue)
-
-      expect(page).to have_css('#new-branch .available')
-    end
-
-    context "when there is a referenced merge request" do
-      let!(:note) do
-        create(:note, :on_issue, :system, project: project, noteable: issue,
-                                          note: "mentioned in #{referenced_mr.to_reference}")
-      end
-
-      let(:referenced_mr) do
-        create(:merge_request, :simple, source_project: project, target_project: project,
-                                        description: "Fixes #{issue.to_reference}", author: user)
-      end
-
-      before do
-        referenced_mr.cache_merge_request_closes_issues!(user)
-
-        visit namespace_project_issue_path(project.namespace, project, issue)
-      end
-
-      it "hides the new branch button" do
-        expect(page).to have_css('#new-branch .unavailable')
-        expect(page).not_to have_css('#new-branch .available')
-        expect(page).to have_content /1 Related Merge Request/
-      end
-    end
-
-    context 'when issue is confidential' do
-      it 'hides the new branch button' do
-        issue = create(:issue, :confidential, project: project)
-
-        visit namespace_project_issue_path(project.namespace, project, issue)
-
-        expect(page).not_to have_css('#new-branch')
-      end
-    end
-  end
-
-  context 'for visitors' do
-    it 'shows no buttons' do
-      visit namespace_project_issue_path(project.namespace, project, issue)
-
-      expect(page).not_to have_css('#new-branch')
-    end
-  end
-end
diff --git a/spec/features/issues/note_polling_spec.rb b/spec/features/issues/note_polling_spec.rb
index 378f6de1a78..58b3215f14c 100644
--- a/spec/features/issues/note_polling_spec.rb
+++ b/spec/features/issues/note_polling_spec.rb
@@ -4,14 +4,77 @@ feature 'Issue notes polling', :feature, :js do
   let(:project) { create(:empty_project, :public) }
   let(:issue) { create(:issue, project: project) }
 
-  before do
-    visit namespace_project_issue_path(project.namespace, project, issue)
+  describe 'creates' do
+    before do
+      visit namespace_project_issue_path(project.namespace, project, issue)
+    end
+
+    it 'displays the new comment' do
+      note = create(:note, noteable: issue, project: project, note: 'Looks good!')
+      page.execute_script('notes.refresh();')
+
+      expect(page).to have_selector("#note_#{note.id}", text: 'Looks good!')
+    end
   end
 
-  it 'should display the new comment' do
-    note = create(:note, noteable: issue, project: project, note: 'Looks good!')
-    page.execute_script('notes.refresh();')
+  describe 'updates' do
+    let(:user) { create(:user) }
+    let(:note_text) { "Hello World" }
+    let(:updated_text) { "Bye World" }
+    let!(:existing_note) { create(:note, noteable: issue, project: project, author: user, note: note_text) }
+
+    before do
+      login_as(user)
+      visit namespace_project_issue_path(project.namespace, project, issue)
+    end
+
+    it 'displays the updated content' do
+      expect(page).to have_selector("#note_#{existing_note.id}", text: note_text)
+
+      update_note(existing_note, updated_text)
+
+      expect(page).to have_selector("#note_#{existing_note.id}", text: updated_text)
+    end
+
+    it 'when editing but have not changed anything, and an update comes in, show the updated content in the textarea' do
+      find("#note_#{existing_note.id} .js-note-edit").click
+
+      expect(page).to have_field("note[note]", with: note_text)
+
+      update_note(existing_note, updated_text)
+
+      expect(page).to have_field("note[note]", with: updated_text)
+    end
+
+    it 'when editing but you changed some things, and an update comes in, show a warning' do
+      find("#note_#{existing_note.id} .js-note-edit").click
 
-    expect(page).to have_selector("#note_#{note.id}", text: 'Looks good!')
+      expect(page).to have_field("note[note]", with: note_text)
+
+      find("#note_#{existing_note.id} .js-note-text").set('something random')
+
+      update_note(existing_note, updated_text)
+
+      expect(page).to have_selector(".alert")
+    end
+
+    it 'when editing but you changed some things, an update comes in, and you press cancel, show the updated content' do
+      find("#note_#{existing_note.id} .js-note-edit").click
+
+      expect(page).to have_field("note[note]", with: note_text)
+
+      find("#note_#{existing_note.id} .js-note-text").set('something random')
+
+      update_note(existing_note, updated_text)
+
+      find("#note_#{existing_note.id} .note-edit-cancel").click
+
+      expect(page).to have_selector("#note_#{existing_note.id}", text: updated_text)
+    end
+  end
+
+  def update_note(note, new_text)
+    note.update(note: new_text)
+    page.execute_script('notes.refresh();')
   end
 end
diff --git a/spec/features/merge_requests/versions_spec.rb b/spec/features/merge_requests/versions_spec.rb
index 7a2da623c58..2b5b803946c 100644
--- a/spec/features/merge_requests/versions_spec.rb
+++ b/spec/features/merge_requests/versions_spec.rb
@@ -24,7 +24,12 @@ feature 'Merge Request versions', js: true, feature: true do
     before do
       page.within '.mr-version-dropdown' do
         find('.btn-default').click
-        find(:link, 'version 1').trigger('click')
+        click_link 'version 1'
+      end
+
+      # Wait for the page to load
+      page.within '.mr-version-dropdown' do
+        expect(page).to have_content 'version 1'
       end
     end
 
@@ -36,8 +41,8 @@ feature 'Merge Request versions', js: true, feature: true do
       expect(page).to have_content '5 changed files'
     end
 
-    it 'show the message about disabled comment creation' do
-      expect(page).to have_content 'comment creation is disabled'
+    it 'show the message about comments' do
+      expect(page).to have_content 'Not all comments are displayed'
     end
 
     it 'shows comments that were last relevant at that version' do
@@ -52,15 +57,41 @@ feature 'Merge Request versions', js: true, feature: true do
       outdated_diff_note.position = outdated_diff_note.original_position
       outdated_diff_note.save!
 
+      visit current_url
+
       expect(page).to have_css(".diffs .notes[data-discussion-id='#{outdated_diff_note.discussion_id}']")
     end
+
+    it 'allows commenting' do
+      diff_file_selector = ".diff-file[id='7445606fbf8f3683cd42bdc54b05d7a0bc2dfc44']"
+      line_code = '7445606fbf8f3683cd42bdc54b05d7a0bc2dfc44_2_2'
+
+      page.within(diff_file_selector) do
+        find(".line_holder[id='#{line_code}'] td:nth-of-type(1)").trigger 'mouseover'
+        find(".line_holder[id='#{line_code}'] button").trigger 'click'
+
+        page.within("form[data-line-code='#{line_code}']") do
+          fill_in "note[note]", with: "Typo, please fix"
+          find(".js-comment-button").click
+        end
+
+        wait_for_ajax
+
+        expect(page).to have_content("Typo, please fix")
+      end
+    end
   end
 
   describe 'compare with older version' do
     before do
       page.within '.mr-version-compare-dropdown' do
         find('.btn-default').click
-        find(:link, 'version 1').trigger('click')
+        click_link 'version 1'
+      end
+
+      # Wait for the page to load
+      page.within '.mr-version-compare-dropdown' do
+        expect(page).to have_content 'version 1'
       end
     end
 
@@ -80,8 +111,43 @@ feature 'Merge Request versions', js: true, feature: true do
       end
     end
 
-    it 'show the message about disabled comments' do
-      expect(page).to have_content 'Comments are disabled'
+    it 'show the message about comments' do
+      expect(page).to have_content 'Not all comments are displayed'
+    end
+
+    it 'shows comments that were last relevant at that version' do
+      position = Gitlab::Diff::Position.new(
+        old_path: ".gitmodules",
+        new_path: ".gitmodules",
+        old_line: 4,
+        new_line: 4,
+        diff_refs: merge_request_diff3.compare_with(merge_request_diff1.head_commit_sha).diff_refs
+      )
+      outdated_diff_note = create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: position)
+
+      visit current_url
+      wait_for_ajax
+
+      expect(page).to have_css(".diffs .notes[data-discussion-id='#{outdated_diff_note.discussion_id}']")
+    end
+
+    it 'allows commenting' do
+      diff_file_selector = ".diff-file[id='7445606fbf8f3683cd42bdc54b05d7a0bc2dfc44']"
+      line_code = '7445606fbf8f3683cd42bdc54b05d7a0bc2dfc44_4_4'
+
+      page.within(diff_file_selector) do
+        find(".line_holder[id='#{line_code}'] td:nth-of-type(1)").trigger 'mouseover'
+        find(".line_holder[id='#{line_code}'] button").trigger 'click'
+
+        page.within("form[data-line-code='#{line_code}']") do
+          fill_in "note[note]", with: "Typo, please fix"
+          find(".js-comment-button").click
+        end
+
+        wait_for_ajax
+
+        expect(page).to have_content("Typo, please fix")
+      end
     end
 
     it 'show diff between new and old version' do
diff --git a/spec/features/projects/blobs/blob_show_spec.rb b/spec/features/projects/blobs/blob_show_spec.rb
index 8dba2ccbafa..5955623f565 100644
--- a/spec/features/projects/blobs/blob_show_spec.rb
+++ b/spec/features/projects/blobs/blob_show_spec.rb
@@ -159,7 +159,7 @@ feature 'File blob', :js, feature: true do
           expect(page).to have_selector('.blob-viewer[data-type="rich"]')
 
           # shows an error message
-          expect(page).to have_content('The rendered file could not be displayed because it is stored in LFS. You can view the source or download it instead.')
+          expect(page).to have_content('The rendered file could not be displayed because it is stored in LFS. You can download it instead.')
 
           # shows a viewer switcher
           expect(page).to have_selector('.js-blob-viewer-switcher')
@@ -167,8 +167,8 @@ feature 'File blob', :js, feature: true do
           # does not show a copy button
           expect(page).not_to have_selector('.js-copy-blob-source-btn')
 
-          # shows a raw button
-          expect(page).to have_link('Open raw')
+          # shows a download button
+          expect(page).to have_link('Download')
         end
       end
 
@@ -332,4 +332,41 @@ feature 'File blob', :js, feature: true do
       end
     end
   end
+
+  context 'empty file' do
+    before do
+      project.add_master(project.creator)
+
+      Files::CreateService.new(
+        project,
+        project.creator,
+        start_branch: 'master',
+        branch_name: 'master',
+        commit_message: "Add empty file",
+        file_path: 'files/empty.md',
+        file_content: ''
+      ).execute
+
+      visit_blob('files/empty.md')
+
+      wait_for_ajax
+    end
+
+    it 'displays an error' do
+      aggregate_failures do
+        # shows an error message
+        expect(page).to have_content('Empty file')
+
+        # does not show a viewer switcher
+        expect(page).not_to have_selector('.js-blob-viewer-switcher')
+
+        # does not show a copy button
+        expect(page).not_to have_selector('.js-copy-blob-source-btn')
+
+        # does not show a download or raw button
+        expect(page).not_to have_link('Download')
+        expect(page).not_to have_link('Open raw')
+      end
+    end
+  end
 end
diff --git a/spec/features/protected_tags/access_control_ce_spec.rb b/spec/features/protected_tags/access_control_ce_spec.rb
index 5b24ac0292b..a04fbcdd15f 100644
--- a/spec/features/protected_tags/access_control_ce_spec.rb
+++ b/spec/features/protected_tags/access_control_ce_spec.rb
@@ -10,8 +10,8 @@ RSpec.shared_examples "protected tags > access control > CE" do
 
         unless allowed_to_create_button.text == access_type_name
           allowed_to_create_button.click
-          find('.dropdown.open .dropdown-menu li', match: :first)
-          within(".dropdown.open .dropdown-menu") { click_on access_type_name }
+          find('.create_access_levels-container .dropdown-menu li', match: :first)
+          within('.create_access_levels-container .dropdown-menu') { click_on access_type_name }
         end
       end
 
diff --git a/spec/features/protected_tags_spec.rb b/spec/features/protected_tags_spec.rb
index e3aa87ded28..e68448467b0 100644
--- a/spec/features/protected_tags_spec.rb
+++ b/spec/features/protected_tags_spec.rb
@@ -11,6 +11,7 @@ feature 'Projected Tags', feature: true, js: true do
     find(".js-protected-tag-select").click
     find(".dropdown-input-field").set(tag_name)
     click_on("Create wildcard #{tag_name}")
+    find('.protected-tags-dropdown .dropdown-menu', visible: false)
   end
 
   describe "explicit protected tags" do
diff --git a/spec/finders/pipelines_finder_spec.rb b/spec/finders/pipelines_finder_spec.rb
index 6bada7b3eb9..f2aeda241c1 100644
--- a/spec/finders/pipelines_finder_spec.rb
+++ b/spec/finders/pipelines_finder_spec.rb
@@ -3,50 +3,205 @@ require 'spec_helper'
 describe PipelinesFinder do
   let(:project) { create(:project, :repository) }
 
-  let!(:tag_pipeline)    { create(:ci_pipeline, project: project, ref: 'v1.0.0') }
-  let!(:branch_pipeline) { create(:ci_pipeline, project: project) }
-
-  subject { described_class.new(project).execute(params) }
+  subject { described_class.new(project, params).execute }
 
   describe "#execute" do
-    context 'when a scope is passed' do
-      context 'when scope is nil' do
-        let(:params) { { scope: nil } }
+    context 'when params is empty' do
+      let(:params) { {} }
+      let!(:pipelines) { create_list(:ci_pipeline, 2, project: project) }
+
+      it 'returns all pipelines' do
+        is_expected.to match_array(pipelines)
+      end
+    end
+
+    %w[running pending].each do |target|
+      context "when scope is #{target}" do
+        let(:params) { { scope: target } }
+        let!(:pipeline) { create(:ci_pipeline, project: project, status: target) }
 
-        it 'selects all pipelines' do
-          expect(subject.count).to be 2
-          expect(subject).to include tag_pipeline
-          expect(subject).to include branch_pipeline
+        it 'returns matched pipelines' do
+          is_expected.to eq([pipeline])
         end
       end
+    end
+
+    context 'when scope is finished' do
+      let(:params) { { scope: 'finished' } }
+      let!(:pipelines) do
+        [create(:ci_pipeline, project: project, status: 'success'),
+         create(:ci_pipeline, project: project, status: 'failed'),
+         create(:ci_pipeline, project: project, status: 'canceled')]
+      end
 
-      context 'when selecting branches' do
+      it 'returns matched pipelines' do
+        is_expected.to match_array(pipelines)
+      end
+    end
+
+    context 'when scope is branches or tags' do
+      let!(:pipeline_branch) { create(:ci_pipeline, project: project) }
+      let!(:pipeline_tag) { create(:ci_pipeline, project: project, ref: 'v1.0.0', tag: true) }
+
+      context 'when scope is branches' do
         let(:params) { { scope: 'branches' } }
 
-        it 'excludes tags' do
-          expect(subject).not_to include tag_pipeline
-          expect(subject).to     include branch_pipeline
+        it 'returns matched pipelines' do
+          is_expected.to eq([pipeline_branch])
         end
       end
 
-      context 'when selecting tags' do
+      context 'when scope is tags' do
         let(:params) { { scope: 'tags' } }
 
-        it 'excludes branches' do
-          expect(subject).to     include tag_pipeline
-          expect(subject).not_to include branch_pipeline
+        it 'returns matched pipelines' do
+          is_expected.to eq([pipeline_tag])
+        end
+      end
+    end
+
+    HasStatus::AVAILABLE_STATUSES.each do |target|
+      context "when status is #{target}" do
+        let(:params) { { status: target } }
+        let!(:pipeline) { create(:ci_pipeline, project: project, status: target) }
+
+        before do
+          exception_status = HasStatus::AVAILABLE_STATUSES - [target]
+          create(:ci_pipeline, project: project, status: exception_status.first)
+        end
+
+        it 'returns matched pipelines' do
+          is_expected.to eq([pipeline])
         end
       end
     end
 
-    # Scoping to pending will speed up the test as it doesn't hit the FS
-    let(:params) { { scope: 'pending' } }
+    context 'when ref is specified' do
+      let!(:pipeline) { create(:ci_pipeline, project: project) }
+
+      context 'when ref exists' do
+        let(:params) { { ref: 'master' } }
+
+        it 'returns matched pipelines' do
+          is_expected.to eq([pipeline])
+        end
+      end
+
+      context 'when ref does not exist' do
+        let(:params) { { ref: 'invalid-ref' } }
+
+        it 'returns empty' do
+          is_expected.to be_empty
+        end
+      end
+    end
+
+    context 'when name is specified' do
+      let(:user) { create(:user) }
+      let!(:pipeline) { create(:ci_pipeline, project: project, user: user) }
+
+      context 'when name exists' do
+        let(:params) { { name: user.name } }
+
+        it 'returns matched pipelines' do
+          is_expected.to eq([pipeline])
+        end
+      end
+
+      context 'when name does not exist' do
+        let(:params) { { name: 'invalid-name' } }
+
+        it 'returns empty' do
+          is_expected.to be_empty
+        end
+      end
+    end
 
-    it 'orders in descending order on ID' do
-      feature_pipeline = create(:ci_pipeline, project: project, ref: 'feature')
+    context 'when username is specified' do
+      let(:user) { create(:user) }
+      let!(:pipeline) { create(:ci_pipeline, project: project, user: user) }
 
-      expected_ids = [feature_pipeline.id, branch_pipeline.id, tag_pipeline.id].sort.reverse
-      expect(subject.map(&:id)).to eq expected_ids
+      context 'when username exists' do
+        let(:params) { { username: user.username } }
+
+        it 'returns matched pipelines' do
+          is_expected.to eq([pipeline])
+        end
+      end
+
+      context 'when username does not exist' do
+        let(:params) { { username: 'invalid-username' } }
+
+        it 'returns empty' do
+          is_expected.to be_empty
+        end
+      end
+    end
+
+    context 'when yaml_errors is specified' do
+      let!(:pipeline1) { create(:ci_pipeline, project: project, yaml_errors: 'Syntax error') }
+      let!(:pipeline2) { create(:ci_pipeline, project: project) }
+
+      context 'when yaml_errors is true' do
+        let(:params) { { yaml_errors: true } }
+
+        it 'returns matched pipelines' do
+          is_expected.to eq([pipeline1])
+        end
+      end
+
+      context 'when yaml_errors is false' do
+        let(:params) { { yaml_errors: false } }
+
+        it 'returns matched pipelines' do
+          is_expected.to eq([pipeline2])
+        end
+      end
+
+      context 'when yaml_errors is invalid' do
+        let(:params) { { yaml_errors: "invalid-yaml_errors" } }
+
+        it 'returns all pipelines' do
+          is_expected.to match_array([pipeline1, pipeline2])
+        end
+      end
+    end
+
+    context 'when order_by and sort are specified' do
+      context 'when order_by user_id' do
+        let(:params) { { order_by: 'user_id', sort: 'asc' } }
+        let!(:pipelines) { create_list(:ci_pipeline, 2, project: project, user: create(:user)) }
+
+        it 'sorts as user_id: :asc' do
+          is_expected.to match_array(pipelines)
+        end
+
+        context 'when sort is invalid' do
+          let(:params) { { order_by: 'user_id', sort: 'invalid_sort' } }
+
+          it 'sorts as user_id: :desc' do
+            is_expected.to eq(pipelines.sort_by { |p| -p.user.id })
+          end
+        end
+      end
+
+      context 'when order_by is invalid' do
+        let(:params) { { order_by: 'invalid_column', sort: 'asc' } }
+        let!(:pipelines) { create_list(:ci_pipeline, 2, project: project) }
+
+        it 'sorts as id: :asc' do
+          is_expected.to eq(pipelines.sort_by { |p| p.id })
+        end
+      end
+
+      context 'when both are nil' do
+        let(:params) { { order_by: nil, sort: nil } }
+        let!(:pipelines) { create_list(:ci_pipeline, 2, project: project) }
+
+        it 'sorts as id: :desc' do
+          is_expected.to eq(pipelines.sort_by { |p| -p.id })
+        end
+      end
     end
   end
 end
diff --git a/spec/fixtures/api/schemas/branch.json b/spec/fixtures/api/schemas/branch.json
new file mode 100644
index 00000000000..0bb74577010
--- /dev/null
+++ b/spec/fixtures/api/schemas/branch.json
@@ -0,0 +1,12 @@
+{
+  "type": "object",
+  "required" : [
+    "name",
+    "url"
+  ],
+  "properties" : {
+    "name": { "type": "string" },
+    "url": { "type": "uri" }
+  },
+  "additionalProperties": false
+}
diff --git a/spec/fixtures/api/schemas/merge_request.json b/spec/fixtures/api/schemas/merge_request.json
new file mode 100644
index 00000000000..36962660cd9
--- /dev/null
+++ b/spec/fixtures/api/schemas/merge_request.json
@@ -0,0 +1,12 @@
+{
+  "type": "object",
+  "required" : [
+    "iid",
+    "url"
+  ],
+  "properties" : {
+    "iid": { "type": "integer" },
+    "url": { "type": "uri" }
+  },
+  "additionalProperties": false
+}
diff --git a/spec/fixtures/emails/forwarded_new_issue.eml b/spec/fixtures/emails/forwarded_new_issue.eml
new file mode 100644
index 00000000000..258106bb897
--- /dev/null
+++ b/spec/fixtures/emails/forwarded_new_issue.eml
@@ -0,0 +1,25 @@
+Delivered-To: incoming+gitlabhq/gitlabhq+auth_token@appmail.adventuretime.ooo
+Return-Path: <jake@adventuretime.ooo>
+Received: from iceking.adventuretime.ooo ([unix socket]) by iceking (Cyrus v2.2.13-Debian-2.2.13-19+squeeze3) with LMTPA; Thu, 13 Jun 2013 17:03:50 -0400
+Received: from mail-ie0-x234.google.com (mail-ie0-x234.google.com [IPv6:2607:f8b0:4001:c03::234]) by iceking.adventuretime.ooo (8.14.3/8.14.3/Debian-9.4) with ESMTP id r5DL3nFJ016967 (version=TLSv1/SSLv3 cipher=RC4-SHA bits=128 verify=NOT) for <incoming+gitlabhq/gitlabhq@appmail.adventuretime.ooo>; Thu, 13 Jun 2013 17:03:50 -0400
+Received: by mail-ie0-f180.google.com with SMTP id f4so21977375iea.25 for <incoming+gitlabhq/gitlabhq@appmail.adventuretime.ooo>; Thu, 13 Jun 2013 14:03:48 -0700
+Received: by 10.0.0.1 with HTTP; Thu, 13 Jun 2013 14:03:48 -0700
+Date: Thu, 13 Jun 2013 17:03:48 -0400
+From: Jake the Dog <jake@adventuretime.ooo>
+Delivered-To: support@adventuretime.ooo
+To: support@adventuretime.ooo
+Message-ID: <CADkmRc+rNGAGGbV2iE5p918UVy4UyJqVcXRO2=otppgzduJSg@mail.gmail.com>
+Subject: New Issue by email
+Mime-Version: 1.0
+Content-Type: text/plain;
+ charset=ISO-8859-1
+Content-Transfer-Encoding: 7bit
+X-Sieve: CMU Sieve 2.2
+X-Received: by 10.0.0.1 with SMTP id n7mr11234144ipb.85.1371157428600; Thu,
+ 13 Jun 2013 14:03:48 -0700 (PDT)
+X-Scanned-By: MIMEDefang 2.69 on IPv6:2001:470:1d:165::1
+
+The reply by email functionality should be extended to allow creating a new issue by email.
+
+* Allow an admin to specify which project the issue should be created under by checking the sender domain.
+* Possibly allow the use of regular expression matches within the subject/body to specify which project the issue should be created under.
diff --git a/spec/helpers/blob_helper_spec.rb b/spec/helpers/blob_helper_spec.rb
index 075f1887d91..1b4393e6167 100644
--- a/spec/helpers/blob_helper_spec.rb
+++ b/spec/helpers/blob_helper_spec.rb
@@ -145,7 +145,7 @@ describe BlobHelper do
         end
       end
 
-      context 'for error :server_side_but_stored_in_lfs' do
+      context 'for error :server_side_but_stored_externally' do
         let(:blob) { fake_blob(lfs: true) }
 
         it 'returns an error message' do
@@ -183,40 +183,56 @@ describe BlobHelper do
             expect(helper.blob_render_error_options(viewer)).not_to include(/load it anyway/)
           end
         end
-      end
 
-      context 'when the viewer is rich' do
-        context 'the blob is rendered as text' do
-          let(:blob) { fake_blob(path: 'file.md', lfs: true) }
+        context 'when the viewer is rich' do
+          context 'the blob is rendered as text' do
+            let(:blob) { fake_blob(path: 'file.md', size: 2.megabytes) }
+
+            it 'includes a "view the source" link' do
+              expect(helper.blob_render_error_options(viewer)).to include(/view the source/)
+            end
+          end
+
+          context 'the blob is not rendered as text' do
+            let(:blob) { fake_blob(path: 'file.pdf', binary: true, size: 2.megabytes) }
 
-          it 'includes a "view the source" link' do
-            expect(helper.blob_render_error_options(viewer)).to include(/view the source/)
+            it 'does not include a "view the source" link' do
+              expect(helper.blob_render_error_options(viewer)).not_to include(/view the source/)
+            end
           end
         end
 
-        context 'the blob is not rendered as text' do
-          let(:blob) { fake_blob(path: 'file.pdf', binary: true, lfs: true) }
+        context 'when the viewer is not rich' do
+          before do
+            viewer_class.type = :simple
+          end
+
+          let(:blob) { fake_blob(path: 'file.md', size: 2.megabytes) }
 
           it 'does not include a "view the source" link' do
             expect(helper.blob_render_error_options(viewer)).not_to include(/view the source/)
           end
         end
-      end
 
-      context 'when the viewer is not rich' do
-        before do
-          viewer_class.type = :simple
+        it 'includes a "download it" link' do
+          expect(helper.blob_render_error_options(viewer)).to include(/download it/)
         end
+      end
 
+      context 'for error :server_side_but_stored_externally' do
         let(:blob) { fake_blob(path: 'file.md', lfs: true) }
 
+        it 'does not include a "load it anyway" link' do
+          expect(helper.blob_render_error_options(viewer)).not_to include(/load it anyway/)
+        end
+
         it 'does not include a "view the source" link' do
           expect(helper.blob_render_error_options(viewer)).not_to include(/view the source/)
         end
-      end
 
-      it 'includes a "download it" link' do
-        expect(helper.blob_render_error_options(viewer)).to include(/download it/)
+        it 'includes a "download it" link' do
+          expect(helper.blob_render_error_options(viewer)).to include(/download it/)
+        end
       end
     end
   end
diff --git a/spec/helpers/notes_helper_spec.rb b/spec/helpers/notes_helper_spec.rb
index a427de32c4c..6c990f94175 100644
--- a/spec/helpers/notes_helper_spec.rb
+++ b/spec/helpers/notes_helper_spec.rb
@@ -1,6 +1,8 @@
 require "spec_helper"
 
 describe NotesHelper do
+  include RepoHelpers
+
   let(:owner) { create(:owner) }
   let(:group) { create(:group) }
   let(:project) { create(:empty_project, namespace: group) }
@@ -36,4 +38,141 @@ describe NotesHelper do
       expect(helper.note_max_access_for_user(other_note)).to eq('Reporter')
     end
   end
+
+  describe '#discussion_path' do
+    let(:project) { create(:project) }
+
+    context 'for a merge request discusion' do
+      let(:merge_request) { create(:merge_request, source_project: project, target_project: project, importing: true) }
+      let!(:merge_request_diff1) { merge_request.merge_request_diffs.create(head_commit_sha: '6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9') }
+      let!(:merge_request_diff2) { merge_request.merge_request_diffs.create(head_commit_sha: nil) }
+      let!(:merge_request_diff3) { merge_request.merge_request_diffs.create(head_commit_sha: '5937ac0a7beb003549fc5fd26fc247adbce4a52e') }
+
+      context 'for a diff discussion' do
+        context 'when the discussion is active' do
+          let(:discussion) { create(:diff_note_on_merge_request, noteable: merge_request, project: project).to_discussion }
+
+          it 'returns the diff path with the line code' do
+            expect(helper.discussion_path(discussion)).to eq(diffs_namespace_project_merge_request_path(project.namespace, project, merge_request, anchor: discussion.line_code))
+          end
+        end
+
+        context 'when the discussion is on an older merge request version' do
+          let(:position) do
+            Gitlab::Diff::Position.new(
+              old_path: ".gitmodules",
+              new_path: ".gitmodules",
+              old_line: nil,
+              new_line: 4,
+              diff_refs: merge_request_diff1.diff_refs
+            )
+          end
+
+          let(:diff_note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project, position: position) }
+          let(:discussion) { diff_note.to_discussion }
+
+          before do
+            diff_note.position = diff_note.original_position
+            diff_note.save!
+          end
+
+          it 'returns the diff version path with the line code' do
+            expect(helper.discussion_path(discussion)).to eq(diffs_namespace_project_merge_request_path(project.namespace, project, merge_request, diff_id: merge_request_diff1, anchor: discussion.line_code))
+          end
+        end
+
+        context 'when the discussion is on a comparison between merge request versions' do
+          let(:position) do
+            Gitlab::Diff::Position.new(
+              old_path: ".gitmodules",
+              new_path: ".gitmodules",
+              old_line: 4,
+              new_line: 4,
+              diff_refs: merge_request_diff3.compare_with(merge_request_diff1.head_commit_sha).diff_refs
+            )
+          end
+
+          let(:discussion) { create(:diff_note_on_merge_request, noteable: merge_request, project: project, position: position).to_discussion }
+
+          it 'returns the diff version comparison path with the line code' do
+            expect(helper.discussion_path(discussion)).to eq(diffs_namespace_project_merge_request_path(project.namespace, project, merge_request, diff_id: merge_request_diff3, start_sha: merge_request_diff1.head_commit_sha, anchor: discussion.line_code))
+          end
+        end
+
+        context 'when the discussion does not have a merge request version' do
+          let(:outdated_diff_note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project, diff_refs: project.commit(sample_commit.id).diff_refs) }
+          let(:discussion) { outdated_diff_note.to_discussion }
+
+          before do
+            outdated_diff_note.position = outdated_diff_note.original_position
+            outdated_diff_note.save!
+          end
+
+          it 'returns nil' do
+            expect(helper.discussion_path(discussion)).to be_nil
+          end
+        end
+      end
+
+      context 'for a legacy diff discussion' do
+        let(:discussion) { create(:legacy_diff_note_on_merge_request, noteable: merge_request, project: project).to_discussion }
+
+        context 'when the discussion is active' do
+          before do
+            allow(discussion).to receive(:active?).and_return(true)
+          end
+
+          it 'returns the diff path with the line code' do
+            expect(helper.discussion_path(discussion)).to eq(diffs_namespace_project_merge_request_path(project.namespace, project, merge_request, anchor: discussion.line_code))
+          end
+        end
+
+        context 'when the discussion is outdated' do
+          before do
+            allow(discussion).to receive(:active?).and_return(false)
+          end
+
+          it 'returns nil' do
+            expect(helper.discussion_path(discussion)).to be_nil
+          end
+        end
+      end
+
+      context 'for a non-diff discussion' do
+        let(:discussion) { create(:discussion_note_on_merge_request, noteable: merge_request, project: project).to_discussion }
+
+        it 'returns nil' do
+          expect(helper.discussion_path(discussion)).to be_nil
+        end
+      end
+    end
+
+    context 'for a commit discussion' do
+      let(:commit) { discussion.noteable }
+
+      context 'for a diff discussion' do
+        let(:discussion) { create(:diff_note_on_commit, project: project).to_discussion }
+
+        it 'returns the commit path with the line code' do
+          expect(helper.discussion_path(discussion)).to eq(namespace_project_commit_path(project.namespace, project, commit, anchor: discussion.line_code))
+        end
+      end
+
+      context 'for a legacy diff discussion' do
+        let(:discussion) { create(:legacy_diff_note_on_commit, project: project).to_discussion }
+
+        it 'returns the commit path with the line code' do
+          expect(helper.discussion_path(discussion)).to eq(namespace_project_commit_path(project.namespace, project, commit, anchor: discussion.line_code))
+        end
+      end
+
+      context 'for a non-diff discussion' do
+        let(:discussion) { create(:discussion_note_on_commit, project: project).to_discussion }
+
+        it 'returns the commit path' do
+          expect(helper.discussion_path(discussion)).to eq(namespace_project_commit_path(project.namespace, project, commit))
+        end
+      end
+    end
+  end
 end
diff --git a/spec/javascripts/environments/environment_actions_spec.js b/spec/javascripts/environments/environment_actions_spec.js
index 676bf61cfd9..596d812c724 100644
--- a/spec/javascripts/environments/environment_actions_spec.js
+++ b/spec/javascripts/environments/environment_actions_spec.js
@@ -4,7 +4,6 @@ import actionsComp from '~/environments/components/environment_actions.vue';
 describe('Actions Component', () => {
   let ActionsComponent;
   let actionsMock;
-  let spy;
   let component;
 
   beforeEach(() => {
@@ -26,13 +25,9 @@ describe('Actions Component', () => {
       },
     ];
 
-    spy = jasmine.createSpy('spy').and.returnValue(Promise.resolve());
     component = new ActionsComponent({
       propsData: {
         actions: actionsMock,
-        service: {
-          postAction: spy,
-        },
       },
     }).$mount();
   });
@@ -48,13 +43,6 @@ describe('Actions Component', () => {
     ).toEqual(actionsMock.length);
   });
 
-  it('should call the service when an action is clicked', () => {
-    component.$el.querySelector('.dropdown').click();
-    component.$el.querySelector('.js-manual-action-link').click();
-
-    expect(spy).toHaveBeenCalledWith(actionsMock[0].play_path);
-  });
-
   it('should render a disabled action when it\'s not playable', () => {
     expect(
       component.$el.querySelector('.dropdown-menu li:last-child button').getAttribute('disabled'),
diff --git a/spec/javascripts/environments/environment_rollback_spec.js b/spec/javascripts/environments/environment_rollback_spec.js
index 25397714a76..eb8e49d81fe 100644
--- a/spec/javascripts/environments/environment_rollback_spec.js
+++ b/spec/javascripts/environments/environment_rollback_spec.js
@@ -4,11 +4,9 @@ import rollbackComp from '~/environments/components/environment_rollback.vue';
 describe('Rollback Component', () => {
   const retryURL = 'https://gitlab.com/retry';
   let RollbackComponent;
-  let spy;
 
   beforeEach(() => {
     RollbackComponent = Vue.extend(rollbackComp);
-    spy = jasmine.createSpy('spy').and.returnValue(Promise.resolve());
   });
 
   it('Should render Re-deploy label when isLastDeployment is true', () => {
@@ -17,9 +15,6 @@ describe('Rollback Component', () => {
       propsData: {
         retryUrl: retryURL,
         isLastDeployment: true,
-        service: {
-          postAction: spy,
-        },
       },
     }).$mount();
 
@@ -32,28 +27,9 @@ describe('Rollback Component', () => {
       propsData: {
         retryUrl: retryURL,
         isLastDeployment: false,
-        service: {
-          postAction: spy,
-        },
       },
     }).$mount();
 
     expect(component.$el.querySelector('span').textContent).toContain('Rollback');
   });
-
-  it('should call the service when the button is clicked', () => {
-    const component = new RollbackComponent({
-      propsData: {
-        retryUrl: retryURL,
-        isLastDeployment: false,
-        service: {
-          postAction: spy,
-        },
-      },
-    }).$mount();
-
-    component.$el.click();
-
-    expect(spy).toHaveBeenCalledWith(retryURL);
-  });
 });
diff --git a/spec/javascripts/environments/environment_stop_spec.js b/spec/javascripts/environments/environment_stop_spec.js
index 942e4aaabd4..8131f1e5b11 100644
--- a/spec/javascripts/environments/environment_stop_spec.js
+++ b/spec/javascripts/environments/environment_stop_spec.js
@@ -4,20 +4,15 @@ import stopComp from '~/environments/components/environment_stop.vue';
 describe('Stop Component', () => {
   let StopComponent;
   let component;
-  let spy;
   const stopURL = '/stop';
 
   beforeEach(() => {
     StopComponent = Vue.extend(stopComp);
-    spy = jasmine.createSpy('spy').and.returnValue(Promise.resolve());
     spyOn(window, 'confirm').and.returnValue(true);
 
     component = new StopComponent({
       propsData: {
         stopUrl: stopURL,
-        service: {
-          postAction: spy,
-        },
       },
     }).$mount();
   });
@@ -26,9 +21,4 @@ describe('Stop Component', () => {
     expect(component.$el.tagName).toEqual('BUTTON');
     expect(component.$el.getAttribute('title')).toEqual('Stop');
   });
-
-  it('should call the service when an action is clicked', () => {
-    component.$el.click();
-    expect(spy).toHaveBeenCalled();
-  });
 });
diff --git a/spec/javascripts/fixtures/mini_dropdown_graph.html.haml b/spec/javascripts/fixtures/mini_dropdown_graph.html.haml
index 29370b974af..b532b48a95b 100644
--- a/spec/javascripts/fixtures/mini_dropdown_graph.html.haml
+++ b/spec/javascripts/fixtures/mini_dropdown_graph.html.haml
@@ -3,7 +3,7 @@
     Dropdown
 
   %ul.dropdown-menu.mini-pipeline-graph-dropdown-menu.js-builds-dropdown-container
-    .js-builds-dropdown-list.scrollable-menu
+    %li.js-builds-dropdown-list.scrollable-menu
 
-    .js-builds-dropdown-loading.builds-dropdown-loading.hidden
-      %span.fa.fa-spinner.fa-spin
+    %li.js-builds-dropdown-loading.hidden
+      %span.fa.fa-spinner
diff --git a/spec/javascripts/issue_spec.js b/spec/javascripts/issue_spec.js
index 9a2570ef7e9..0fd573eae3f 100644
--- a/spec/javascripts/issue_spec.js
+++ b/spec/javascripts/issue_spec.js
@@ -108,8 +108,8 @@ describe('Issue', function() {
           expect(this.$triggeredButton).toHaveProp('disabled', true);
           expectNewBranchButtonState(true, false);
           return this.issueStateDeferred;
-        } else if (req.url === Issue.$btnNewBranch.data('path')) {
-          expect(req.type).toBe('get');
+        } else if (req.url === Issue.createMrDropdownWrap.dataset.canCreatePath) {
+          expect(req.type).toBe('GET');
           expectNewBranchButtonState(true, false);
           return this.canCreateBranchDeferred;
         }
diff --git a/spec/javascripts/notes_spec.js b/spec/javascripts/notes_spec.js
index ca8ee04d955..cdc5c4510ff 100644
--- a/spec/javascripts/notes_spec.js
+++ b/spec/javascripts/notes_spec.js
@@ -1,10 +1,12 @@
 /* eslint-disable space-before-function-paren, no-unused-expressions, no-var, object-shorthand, comma-dangle, max-len */
 /* global Notes */
 
-require('~/notes');
-require('vendor/autosize');
-require('~/gl_form');
-require('~/lib/utils/text_utility');
+import 'vendor/autosize';
+import '~/gl_form';
+import '~/lib/utils/text_utility';
+import '~/render_gfm';
+import '~/render_math';
+import '~/notes';
 
 (function() {
   window.gon || (window.gon = {});
@@ -80,35 +82,78 @@ require('~/lib/utils/text_utility');
 
       beforeEach(() => {
         note = {
+          id: 1,
           discussion_html: null,
           valid: true,
-          html: '<div></div>',
+          note: 'heya',
+          html: '<div>heya</div>',
         };
-        $notesList = jasmine.createSpyObj('$notesList', ['find']);
+        $notesList = jasmine.createSpyObj('$notesList', [
+          'find',
+          'append',
+        ]);
 
         notes = jasmine.createSpyObj('notes', [
           'refresh',
           'isNewNote',
+          'isUpdatedNote',
           'collapseLongCommitList',
           'updateNotesCount',
+          'putConflictEditWarningInPlace'
         ]);
         notes.taskList = jasmine.createSpyObj('tasklist', ['init']);
         notes.note_ids = [];
+        notes.updatedNotesTrackingMap = {};
 
-        spyOn(window, '$').and.returnValue($notesList);
         spyOn(gl.utils, 'localTimeAgo');
-        spyOn(Notes, 'animateAppendNote');
-        notes.isNewNote.and.returnValue(true);
-
-        Notes.prototype.renderNote.call(notes, note);
+        spyOn(Notes, 'animateAppendNote').and.callThrough();
+        spyOn(Notes, 'animateUpdateNote').and.callThrough();
       });
 
-      it('should query for the notes list', () => {
-        expect(window.$).toHaveBeenCalledWith('ul.main-notes-list');
+      describe('when adding note', () => {
+        it('should call .animateAppendNote', () => {
+          notes.isNewNote.and.returnValue(true);
+          Notes.prototype.renderNote.call(notes, note, null, $notesList);
+
+          expect(Notes.animateAppendNote).toHaveBeenCalledWith(note.html, $notesList);
+        });
       });
 
-      it('should call .animateAppendNote', () => {
-        expect(Notes.animateAppendNote).toHaveBeenCalledWith(note.html, $notesList);
+      describe('when note was edited', () => {
+        it('should call .animateUpdateNote', () => {
+          notes.isUpdatedNote.and.returnValue(true);
+          const $note = $('<div>');
+          $notesList.find.and.returnValue($note);
+          Notes.prototype.renderNote.call(notes, note, null, $notesList);
+
+          expect(Notes.animateUpdateNote).toHaveBeenCalledWith(note.html, $note);
+        });
+
+        describe('while editing', () => {
+          it('should update textarea if nothing has been touched', () => {
+            notes.isUpdatedNote.and.returnValue(true);
+            const $note = $(`<div class="is-editing">
+              <div class="original-note-content">initial</div>
+              <textarea class="js-note-text">initial</textarea>
+            </div>`);
+            $notesList.find.and.returnValue($note);
+            Notes.prototype.renderNote.call(notes, note, null, $notesList);
+
+            expect($note.find('.js-note-text').val()).toEqual(note.note);
+          });
+
+          it('should call .putConflictEditWarningInPlace', () => {
+            notes.isUpdatedNote.and.returnValue(true);
+            const $note = $(`<div class="is-editing">
+              <div class="original-note-content">initial</div>
+              <textarea class="js-note-text">different</textarea>
+            </div>`);
+            $notesList.find.and.returnValue($note);
+            Notes.prototype.renderNote.call(notes, note, null, $notesList);
+
+            expect(notes.putConflictEditWarningInPlace).toHaveBeenCalledWith(note, $note);
+          });
+        });
       });
     });
 
@@ -147,14 +192,12 @@ require('~/lib/utils/text_utility');
       });
 
       describe('Discussion root note', () => {
-        let $notesList;
         let body;
 
         beforeEach(() => {
           body = jasmine.createSpyObj('body', ['attr']);
           discussionContainer = { length: 0 };
 
-          spyOn(window, '$').and.returnValues(discussionContainer, body, $notesList);
           $form.closest.and.returnValues(row, $form);
           $form.find.and.returnValues(discussionContainer);
           body.attr.and.returnValue('');
@@ -162,12 +205,8 @@ require('~/lib/utils/text_utility');
           Notes.prototype.renderDiscussionNote.call(notes, note, $form);
         });
 
-        it('should query for the notes list', () => {
-          expect(window.$.calls.argsFor(2)).toEqual(['ul.main-notes-list']);
-        });
-
         it('should call Notes.animateAppendNote', () => {
-          expect(Notes.animateAppendNote).toHaveBeenCalledWith(note.discussion_html, $notesList);
+          expect(Notes.animateAppendNote).toHaveBeenCalledWith(note.discussion_html, $('.main-notes-list'));
         });
       });
 
@@ -175,16 +214,12 @@ require('~/lib/utils/text_utility');
         beforeEach(() => {
           discussionContainer = { length: 1 };
 
-          spyOn(window, '$').and.returnValues(discussionContainer);
-          $form.closest.and.returnValues(row);
+          $form.closest.and.returnValues(row, $form);
+          $form.find.and.returnValues(discussionContainer);
 
           Notes.prototype.renderDiscussionNote.call(notes, note, $form);
         });
 
-        it('should query foor the discussion container', () => {
-          expect(window.$).toHaveBeenCalledWith(`.notes[data-discussion-id="${note.discussion_id}"]`);
-        });
-
         it('should call Notes.animateAppendNote', () => {
           expect(Notes.animateAppendNote).toHaveBeenCalledWith(note.html, discussionContainer);
         });
@@ -193,35 +228,45 @@ require('~/lib/utils/text_utility');
 
     describe('animateAppendNote', () => {
       let noteHTML;
-      let $note;
       let $notesList;
+      let $resultantNote;
 
       beforeEach(() => {
         noteHTML = '<div></div>';
-        $note = jasmine.createSpyObj('$note', ['addClass', 'renderGFM', 'removeClass']);
         $notesList = jasmine.createSpyObj('$notesList', ['append']);
 
-        spyOn(window, '$').and.returnValue($note);
-        spyOn(window, 'setTimeout').and.callThrough();
-        $note.addClass.and.returnValue($note);
-        $note.renderGFM.and.returnValue($note);
+        $resultantNote = Notes.animateAppendNote(noteHTML, $notesList);
+      });
 
-        Notes.animateAppendNote(noteHTML, $notesList);
+      it('should have `fade-in` class', () => {
+        expect($resultantNote.hasClass('fade-in')).toEqual(true);
       });
 
-      it('should init the note jquery object', () => {
-        expect(window.$).toHaveBeenCalledWith(noteHTML);
+      it('should append note to the notes list', () => {
+        expect($notesList.append).toHaveBeenCalledWith($resultantNote);
       });
+    });
+
+    describe('animateUpdateNote', () => {
+      let noteHTML;
+      let $note;
+      let $updatedNote;
 
-      it('should call addClass', () => {
-        expect($note.addClass).toHaveBeenCalledWith('fade-in');
+      beforeEach(() => {
+        noteHTML = '<div></div>';
+        $note = jasmine.createSpyObj('$note', [
+          'replaceWith'
+        ]);
+
+        $updatedNote = Notes.animateUpdateNote(noteHTML, $note);
       });
-      it('should call renderGFM', () => {
-        expect($note.renderGFM).toHaveBeenCalledWith();
+
+      it('should have `fade-in` class', () => {
+        expect($updatedNote.hasClass('fade-in')).toEqual(true);
       });
 
-      it('should append note to the notes list', () => {
-        expect($notesList.append).toHaveBeenCalledWith($note);
+      it('should call replaceWith on $note', () => {
+        expect($note.replaceWith).toHaveBeenCalledWith($updatedNote);
       });
     });
   });
diff --git a/spec/javascripts/pipelines/stage_spec.js b/spec/javascripts/pipelines/stage_spec.js
index 2f1154bd999..a4f32a1faed 100644
--- a/spec/javascripts/pipelines/stage_spec.js
+++ b/spec/javascripts/pipelines/stage_spec.js
@@ -1,81 +1,86 @@
 import Vue from 'vue';
-import { SUCCESS_SVG } from '~/ci_status_icons';
-import Stage from '~/pipelines/components/stage';
+import stage from '~/pipelines/components/stage.vue';
+
+describe('Pipelines stage component', () => {
+  let StageComponent;
+  let component;
+
+  beforeEach(() => {
+    StageComponent = Vue.extend(stage);
+
+    component = new StageComponent({
+      propsData: {
+        stage: {
+          status: {
+            group: 'success',
+            icon: 'icon_status_success',
+            title: 'success',
+          },
+          dropdown_path: 'foo',
+        },
+        updateDropdown: false,
+      },
+    }).$mount();
+  });
 
-function minify(string) {
-  return string.replace(/\s/g, '');
-}
+  it('should render a dropdown with the status icon', () => {
+    expect(component.$el.getAttribute('class')).toEqual('dropdown');
+    expect(component.$el.querySelector('svg')).toBeDefined();
+    expect(component.$el.querySelector('button').getAttribute('data-toggle')).toEqual('dropdown');
+  });
 
-describe('Pipelines Stage', () => {
-  describe('data', () => {
-    let stageReturnValue;
+  describe('with successfull request', () => {
+    const interceptor = (request, next) => {
+      next(request.respondWith(JSON.stringify({ html: 'foo' }), {
+        status: 200,
+      }));
+    };
 
     beforeEach(() => {
-      stageReturnValue = Stage.data();
+      Vue.http.interceptors.push(interceptor);
     });
 
-    it('should return object with .builds and .spinner', () => {
-      expect(stageReturnValue).toEqual({
-        builds: '',
-        spinner: '<span class="fa fa-spinner fa-spin"></span>',
-      });
+    afterEach(() => {
+      Vue.http.interceptors = _.without(
+        Vue.http.interceptors, interceptor,
+      );
     });
-  });
 
-  describe('computed', () => {
-    describe('svgHTML', function () {
-      let stage;
-      let svgHTML;
+    it('should render the received data', (done) => {
+      component.$el.querySelector('button').click();
 
-      beforeEach(() => {
-        stage = { stage: { status: { icon: 'icon_status_success' } } };
-
-        svgHTML = Stage.computed.svgHTML.call(stage);
-      });
-
-      it("should return the correct icon for the stage's status", () => {
-        expect(svgHTML).toBe(SUCCESS_SVG);
-      });
+      setTimeout(() => {
+        expect(
+          component.$el.querySelector('.js-builds-dropdown-container ul').textContent.trim(),
+        ).toEqual('foo');
+        done();
+      }, 0);
     });
   });
 
-  describe('when mounted', () => {
-    let StageComponent;
-    let renderedComponent;
-    let stage;
+  describe('when request fails', () => {
+    const interceptor = (request, next) => {
+      next(request.respondWith(JSON.stringify({}), {
+        status: 500,
+      }));
+    };
 
     beforeEach(() => {
-      stage = { status: { icon: 'icon_status_success' } };
-
-      StageComponent = Vue.extend(Stage);
-
-      renderedComponent = new StageComponent({
-        propsData: {
-          stage,
-        },
-      }).$mount();
+      Vue.http.interceptors.push(interceptor);
     });
 
-    it('should render the correct status svg', () => {
-      const minifiedComponent = minify(renderedComponent.$el.outerHTML);
-      const expectedSVG = minify(SUCCESS_SVG);
-
-      expect(minifiedComponent).toContain(expectedSVG);
+    afterEach(() => {
+      Vue.http.interceptors = _.without(
+        Vue.http.interceptors, interceptor,
+      );
     });
-  });
-
-  describe('when request fails', () => {
-    it('closes dropdown', () => {
-      spyOn($, 'ajax').and.callFake(options => options.error());
-      const StageComponent = Vue.extend(Stage);
 
-      const component = new StageComponent({
-        propsData: { stage: { status: { icon: 'foo' } } },
-      }).$mount();
+    it('should close the dropdown', () => {
+      component.$el.click();
 
-      expect(
-        component.$el.classList.contains('open'),
-      ).toEqual(false);
+      setTimeout(() => {
+        expect(component.$el.classList.contains('open')).toEqual(false);
+      }, 0);
     });
   });
 });
diff --git a/spec/lib/gitlab/email/receiver_spec.rb b/spec/lib/gitlab/email/receiver_spec.rb
index f127e45ae6a..c6e3524f743 100644
--- a/spec/lib/gitlab/email/receiver_spec.rb
+++ b/spec/lib/gitlab/email/receiver_spec.rb
@@ -4,6 +4,24 @@ require_relative 'email_shared_blocks'
 describe Gitlab::Email::Receiver, lib: true do
   include_context :email_shared_context
 
+  context "when the email contains a valid email address in a Delivered-To header" do
+    let(:email_raw) { fixture_file('emails/forwarded_new_issue.eml') }
+    let(:handler) { double(:handler) }
+
+    before do
+      stub_incoming_email_setting(enabled: true, address: "incoming+%{key}@appmail.adventuretime.ooo")
+
+      allow(handler).to receive(:execute)
+      allow(handler).to receive(:metrics_params)
+    end
+
+    it "finds the mail key" do
+      expect(Gitlab::Email::Handler).to receive(:for).with(an_instance_of(Mail::Message), 'gitlabhq/gitlabhq+auth_token').and_return(handler)
+
+      receiver.execute
+    end
+  end
+
   context "when we cannot find a capable handler" do
     let(:email_raw) { fixture_file('emails/valid_reply.eml').gsub(mail_key, "!!!") }
 
diff --git a/spec/lib/gitlab/git/repository_spec.rb b/spec/lib/gitlab/git/repository_spec.rb
index ddedb7c3443..fea186fd4f4 100644
--- a/spec/lib/gitlab/git/repository_spec.rb
+++ b/spec/lib/gitlab/git/repository_spec.rb
@@ -1062,7 +1062,7 @@ describe Gitlab::Git::Repository, seed_helper: true do
       end
 
       it "allows ordering by date" do
-        expect_any_instance_of(Rugged::Walker).to receive(:sorting).with(Rugged::SORT_DATE)
+        expect_any_instance_of(Rugged::Walker).to receive(:sorting).with(Rugged::SORT_DATE | Rugged::SORT_TOPO)
 
         repository.find_commits(order: :date)
       end
diff --git a/spec/lib/gitlab/import_export/project_tree_saver_spec.rb b/spec/lib/gitlab/import_export/project_tree_saver_spec.rb
index 6e145947104..1035428b2e7 100644
--- a/spec/lib/gitlab/import_export/project_tree_saver_spec.rb
+++ b/spec/lib/gitlab/import_export/project_tree_saver_spec.rb
@@ -6,7 +6,7 @@ describe Gitlab::ImportExport::ProjectTreeSaver, services: true do
     let(:project_tree_saver) { described_class.new(project: project, current_user: user, shared: shared) }
     let(:export_path) { "#{Dir.tmpdir}/project_tree_saver_spec" }
     let(:user) { create(:user) }
-    let(:project) { setup_project }
+    let!(:project) { setup_project }
 
     before do
       project.team << [user, :master]
@@ -219,7 +219,7 @@ describe Gitlab::ImportExport::ProjectTreeSaver, services: true do
                      releases: [release],
                      group: group
                     )
-    project.update(description_html: 'description')
+    project.update_column(:description_html, 'description')
     project_label = create(:label, project: project)
     group_label = create(:group_label, group: group)
     create(:label_link, label: project_label, target: issue)
diff --git a/spec/models/blob_spec.rb b/spec/models/blob_spec.rb
index 7e8a1c8add7..f84c6b48173 100644
--- a/spec/models/blob_spec.rb
+++ b/spec/models/blob_spec.rb
@@ -35,8 +35,68 @@ describe Blob do
     end
   end
 
+  describe '#external_storage_error?' do
+    context 'if the blob is stored in LFS' do
+      let(:blob) { fake_blob(path: 'file.pdf', lfs: true) }
+
+      context 'when the project has LFS enabled' do
+        it 'returns false' do
+          expect(blob.external_storage_error?).to be_falsey
+        end
+      end
+
+      context 'when the project does not have LFS enabled' do
+        before do
+          project.lfs_enabled = false
+        end
+
+        it 'returns true' do
+          expect(blob.external_storage_error?).to be_truthy
+        end
+      end
+    end
+
+    context 'if the blob is not stored in LFS' do
+      let(:blob) { fake_blob(path: 'file.md') }
+
+      it 'returns false' do
+        expect(blob.external_storage_error?).to be_falsey
+      end
+    end
+  end
+
+  describe '#stored_externally?' do
+    context 'if the blob is stored in LFS' do
+      let(:blob) { fake_blob(path: 'file.pdf', lfs: true) }
+
+      context 'when the project has LFS enabled' do
+        it 'returns true' do
+          expect(blob.stored_externally?).to be_truthy
+        end
+      end
+
+      context 'when the project does not have LFS enabled' do
+        before do
+          project.lfs_enabled = false
+        end
+
+        it 'returns false' do
+          expect(blob.stored_externally?).to be_falsey
+        end
+      end
+    end
+
+    context 'if the blob is not stored in LFS' do
+      let(:blob) { fake_blob(path: 'file.md') }
+
+      it 'returns false' do
+        expect(blob.stored_externally?).to be_falsey
+      end
+    end
+  end
+
   describe '#raw_binary?' do
-    context 'if the blob is a valid LFS pointer' do
+    context 'if the blob is stored externally' do
       context 'if the extension has a rich viewer' do
         context 'if the viewer is binary' do
           it 'returns true' do
@@ -56,15 +116,63 @@ describe Blob do
       end
 
       context "if the extension doesn't have a rich viewer" do
-        it 'returns true' do
-          blob = fake_blob(path: 'file.exe', lfs: true)
+        context 'if the extension has a text mime type' do
+          context 'if the extension is for a programming language' do
+            it 'returns false' do
+              blob = fake_blob(path: 'file.txt', lfs: true)
 
-          expect(blob.raw_binary?).to be_truthy
+              expect(blob.raw_binary?).to be_falsey
+            end
+          end
+
+          context 'if the extension is not for a programming language' do
+            it 'returns false' do
+              blob = fake_blob(path: 'file.ics', lfs: true)
+
+              expect(blob.raw_binary?).to be_falsey
+            end
+          end
+        end
+
+        context 'if the extension has a binary mime type' do
+          context 'if the extension is for a programming language' do
+            it 'returns false' do
+              blob = fake_blob(path: 'file.rb', lfs: true)
+
+              expect(blob.raw_binary?).to be_falsey
+            end
+          end
+
+          context 'if the extension is not for a programming language' do
+            it 'returns true' do
+              blob = fake_blob(path: 'file.exe', lfs: true)
+
+              expect(blob.raw_binary?).to be_truthy
+            end
+          end
+        end
+
+        context 'if the extension has an unknown mime type' do
+          context 'if the extension is for a programming language' do
+            it 'returns false' do
+              blob = fake_blob(path: 'file.ini', lfs: true)
+
+              expect(blob.raw_binary?).to be_falsey
+            end
+          end
+
+          context 'if the extension is not for a programming language' do
+            it 'returns true' do
+              blob = fake_blob(path: 'file.wtf', lfs: true)
+
+              expect(blob.raw_binary?).to be_truthy
+            end
+          end
         end
       end
     end
 
-    context 'if the blob is not an LFS pointer' do
+    context 'if the blob is not stored externally' do
       context 'if the blob is binary' do
         it 'returns true' do
           blob = fake_blob(path: 'file.pdf', binary: true)
@@ -94,7 +202,7 @@ describe Blob do
   describe '#simple_viewer' do
     context 'when the blob is empty' do
       it 'returns an empty viewer' do
-        blob = fake_blob(data: '')
+        blob = fake_blob(data: '', size: 0)
 
         expect(blob.simple_viewer).to be_a(BlobViewer::Empty)
       end
@@ -118,7 +226,7 @@ describe Blob do
   end
 
   describe '#rich_viewer' do
-    context 'when the blob is an invalid LFS pointer' do
+    context 'when the blob has an external storage error' do
       before do
         project.lfs_enabled = false
       end
@@ -138,7 +246,7 @@ describe Blob do
       end
     end
 
-    context 'when the blob is a valid LFS pointer' do
+    context 'when the blob is stored externally' do
       it 'returns a matching viewer' do
         blob = fake_blob(path: 'file.pdf', lfs: true)
 
diff --git a/spec/models/blob_viewer/base_spec.rb b/spec/models/blob_viewer/base_spec.rb
index a3e598de56d..740ad9d275e 100644
--- a/spec/models/blob_viewer/base_spec.rb
+++ b/spec/models/blob_viewer/base_spec.rb
@@ -139,7 +139,7 @@ describe BlobViewer::Base, model: true do
       end
     end
 
-    context 'when the viewer is server side but the blob is stored in LFS' do
+    context 'when the viewer is server side but the blob is stored externally' do
       let(:project) { build(:empty_project, lfs_enabled: true) }
 
       let(:blob) { fake_blob(path: 'file.pdf', lfs: true) }
@@ -148,8 +148,8 @@ describe BlobViewer::Base, model: true do
         allow(Gitlab.config.lfs).to receive(:enabled).and_return(true)
       end
 
-      it 'return :server_side_but_stored_in_lfs' do
-        expect(viewer.render_error).to eq(:server_side_but_stored_in_lfs)
+      it 'return :server_side_but_stored_externally' do
+        expect(viewer.render_error).to eq(:server_side_but_stored_externally)
       end
     end
   end
diff --git a/spec/models/commit_spec.rb b/spec/models/commit_spec.rb
index ce31c8ed94c..08b2169fea7 100644
--- a/spec/models/commit_spec.rb
+++ b/spec/models/commit_spec.rb
@@ -212,7 +212,7 @@ eos
     end
   end
 
-  describe '#latest_pipeline' do
+  describe '#last_pipeline' do
     let!(:first_pipeline) do
       create(:ci_empty_pipeline,
         project: project,
@@ -226,8 +226,8 @@ eos
         status: 'success')
     end
 
-    it 'returns latest pipeline' do
-      expect(commit.latest_pipeline).to eq second_pipeline
+    it 'returns last pipeline' do
+      expect(commit.last_pipeline).to eq second_pipeline
     end
   end
 
diff --git a/spec/models/diff_discussion_spec.rb b/spec/models/diff_discussion_spec.rb
index 48e7c0a822c..81f338745b1 100644
--- a/spec/models/diff_discussion_spec.rb
+++ b/spec/models/diff_discussion_spec.rb
@@ -1,19 +1,86 @@
 require 'spec_helper'
 
 describe DiffDiscussion, model: true do
-  subject { described_class.new([first_note, second_note, third_note]) }
+  include RepoHelpers
 
-  let(:first_note) { create(:diff_note_on_merge_request) }
-  let(:merge_request) { first_note.noteable }
-  let(:project) { first_note.project }
-  let(:second_note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project, in_reply_to: first_note) }
-  let(:third_note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project, in_reply_to: first_note) }
+  subject { described_class.new([diff_note]) }
+
+  let(:project) { create(:project) }
+  let(:merge_request) { create(:merge_request, source_project: project, target_project: project) }
+  let(:diff_note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project) }
 
   describe '#reply_attributes' do
     it 'includes position and original_position' do
       attributes = subject.reply_attributes
-      expect(attributes[:position]).to eq(first_note.position.to_json)
-      expect(attributes[:original_position]).to eq(first_note.original_position.to_json)
+      expect(attributes[:position]).to eq(diff_note.position.to_json)
+      expect(attributes[:original_position]).to eq(diff_note.original_position.to_json)
+    end
+  end
+
+  describe '#merge_request_version_params' do
+    let(:merge_request) { create(:merge_request, source_project: project, target_project: project, importing: true) }
+    let!(:merge_request_diff1) { merge_request.merge_request_diffs.create(head_commit_sha: '6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9') }
+    let!(:merge_request_diff2) { merge_request.merge_request_diffs.create(head_commit_sha: nil) }
+    let!(:merge_request_diff3) { merge_request.merge_request_diffs.create(head_commit_sha: '5937ac0a7beb003549fc5fd26fc247adbce4a52e') }
+
+    context 'when the discussion is active' do
+      it 'returns an empty hash, which will end up showing the latest version' do
+        expect(subject.merge_request_version_params).to eq({})
+      end
+    end
+
+    context 'when the discussion is on an older merge request version' do
+      let(:position) do
+        Gitlab::Diff::Position.new(
+          old_path: ".gitmodules",
+          new_path: ".gitmodules",
+          old_line: nil,
+          new_line: 4,
+          diff_refs: merge_request_diff1.diff_refs
+        )
+      end
+
+      let(:diff_note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project, position: position) }
+
+      before do
+        diff_note.position = diff_note.original_position
+        diff_note.save!
+      end
+
+      it 'returns the diff ID for the version to show' do
+        expect(diff_id: merge_request_diff1.id)
+      end
+    end
+
+    context 'when the discussion is on a comparison between merge request versions' do
+      let(:position) do
+        Gitlab::Diff::Position.new(
+          old_path: ".gitmodules",
+          new_path: ".gitmodules",
+          old_line: 4,
+          new_line: 4,
+          diff_refs: merge_request_diff3.compare_with(merge_request_diff1.head_commit_sha).diff_refs
+        )
+      end
+
+      let(:diff_note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project, position: position) }
+
+      it 'returns the diff ID and start sha of the versions to compare' do
+        expect(subject.merge_request_version_params).to eq(diff_id: merge_request_diff3.id, start_sha: merge_request_diff1.head_commit_sha)
+      end
+    end
+
+    context 'when the discussion does not have a merge request version' do
+      let(:diff_note) { create(:diff_note_on_merge_request, noteable: merge_request, project: project, diff_refs: project.commit(sample_commit.id).diff_refs) }
+
+      before do
+        diff_note.position = diff_note.original_position
+        diff_note.save!
+      end
+
+      it 'returns nil' do
+        expect(subject.merge_request_version_params).to be_nil
+      end
     end
   end
 end
diff --git a/spec/models/diff_note_spec.rb b/spec/models/diff_note_spec.rb
index f32b6b99b3d..ab4c51a87b0 100644
--- a/spec/models/diff_note_spec.rb
+++ b/spec/models/diff_note_spec.rb
@@ -155,23 +155,6 @@ describe DiffNote, models: true do
     end
   end
 
-  describe '#latest_merge_request_diff' do
-    context 'when active' do
-      it 'returns the current merge request diff' do
-        expect(subject.latest_merge_request_diff).to eq(merge_request.merge_request_diff)
-      end
-    end
-
-    context 'when outdated' do
-      let!(:old_merge_request_diff) { merge_request.merge_request_diff }
-      let!(:new_merge_request_diff) { merge_request.merge_request_diffs.create(diff_refs: commit.diff_refs) }
-
-      it 'returns the latest merge request diff that this diff note applied to' do
-        expect(subject.latest_merge_request_diff).to eq(old_merge_request_diff)
-      end
-    end
-  end
-
   describe "creation" do
     describe "updating of position" do
       context "when noteable is a commit" do
@@ -256,4 +239,39 @@ describe DiffNote, models: true do
       end
     end
   end
+
+  describe '#created_at_diff?' do
+    let(:diff_refs) { project.commit(sample_commit.id).diff_refs }
+    let(:position) do
+      Gitlab::Diff::Position.new(
+        old_path: "files/ruby/popen.rb",
+        new_path: "files/ruby/popen.rb",
+        old_line: nil,
+        new_line: 14,
+        diff_refs: diff_refs
+      )
+    end
+
+    context "when noteable is a commit" do
+      subject { build(:diff_note_on_commit, project: project, position: position) }
+
+      it "returns true" do
+        expect(subject.created_at_diff?(diff_refs)).to be true
+      end
+    end
+
+    context "when noteable is a merge request" do
+      context "when the diff refs match the original one of the diff note" do
+        it "returns true" do
+          expect(subject.created_at_diff?(diff_refs)).to be true
+        end
+      end
+
+      context "when the diff refs don't match the original one of the diff note" do
+        it "returns false" do
+          expect(subject.created_at_diff?(merge_request.diff_refs)).to be false
+        end
+      end
+    end
+  end
 end
diff --git a/spec/models/issue_spec.rb b/spec/models/issue_spec.rb
index 11befd4edfe..8748b98a4e3 100644
--- a/spec/models/issue_spec.rb
+++ b/spec/models/issue_spec.rb
@@ -291,6 +291,27 @@ describe Issue, models: true do
     end
   end
 
+  describe '#has_related_branch?' do
+    let(:issue) { create(:issue, title: "Blue Bell Knoll") }
+    subject { issue.has_related_branch? }
+
+    context 'branch found' do
+      before do
+        allow(issue.project.repository).to receive(:branch_names).and_return(["iceblink-luck", issue.to_branch_name])
+      end
+
+      it { is_expected.to eq true }
+    end
+
+    context 'branch not found' do
+      before do
+        allow(issue.project.repository).to receive(:branch_names).and_return(["lazy-calm"])
+      end
+
+      it { is_expected.to eq false }
+    end
+  end
+
   it_behaves_like 'an editable mentionable' do
     subject { create(:issue, project: create(:project, :repository)) }
 
diff --git a/spec/models/legacy_diff_discussion_spec.rb b/spec/models/legacy_diff_discussion_spec.rb
index 153e757a0ef..6eb4a2aaf39 100644
--- a/spec/models/legacy_diff_discussion_spec.rb
+++ b/spec/models/legacy_diff_discussion_spec.rb
@@ -8,4 +8,26 @@ describe LegacyDiffDiscussion, models: true do
       expect(subject.reply_attributes[:line_code]).to eq(subject.line_code)
     end
   end
+
+  describe '#merge_request_version_params' do
+    context 'when the discussion is active' do
+      before do
+        allow(subject).to receive(:active?).and_return(true)
+      end
+
+      it 'returns an empty hash, which will end up showing the latest version' do
+        expect(subject.merge_request_version_params).to eq({})
+      end
+    end
+
+    context 'when the discussion is outdated' do
+      before do
+        allow(subject).to receive(:active?).and_return(false)
+      end
+
+      it 'returns nil' do
+        expect(subject.merge_request_version_params).to be_nil
+      end
+    end
+  end
 end
diff --git a/spec/models/merge_request_spec.rb b/spec/models/merge_request_spec.rb
index be08b96641a..8b72125dd5d 100644
--- a/spec/models/merge_request_spec.rb
+++ b/spec/models/merge_request_spec.rb
@@ -1554,4 +1554,23 @@ describe MergeRequest, models: true do
       expect(subject.has_no_commits?).to be_truthy
     end
   end
+
+  describe '#merge_request_diff_for' do
+    subject { create(:merge_request, importing: true) }
+    let!(:merge_request_diff1) { subject.merge_request_diffs.create(head_commit_sha: '6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9') }
+    let!(:merge_request_diff2) { subject.merge_request_diffs.create(head_commit_sha: nil) }
+    let!(:merge_request_diff3) { subject.merge_request_diffs.create(head_commit_sha: '5937ac0a7beb003549fc5fd26fc247adbce4a52e') }
+
+    context 'with diff refs' do
+      it 'returns the diffs' do
+        expect(subject.merge_request_diff_for(merge_request_diff1.diff_refs)).to eq(merge_request_diff1)
+      end
+    end
+
+    context 'with a commit SHA' do
+      it 'returns the diffs' do
+        expect(subject.merge_request_diff_for(merge_request_diff3.head_commit_sha)).to eq(merge_request_diff3)
+      end
+    end
+  end
 end
diff --git a/spec/models/network/graph_spec.rb b/spec/models/network/graph_spec.rb
index 46b36e11c23..0fe8a591a45 100644
--- a/spec/models/network/graph_spec.rb
+++ b/spec/models/network/graph_spec.rb
@@ -10,17 +10,17 @@ describe Network::Graph, models: true do
     expect(graph.notes).to eq( { note_on_commit.commit_id => 1 } )
   end
 
-  describe "#commits" do
+  describe '#commits' do
     let(:graph) { described_class.new(project, 'refs/heads/master', project.repository.commit, nil) }
 
-    it "returns a list of commits" do
+    it 'returns a list of commits' do
       commits = graph.commits
 
       expect(commits).not_to be_empty
       expect(commits).to all( be_kind_of(Network::Commit) )
     end
 
-    it "sorts the commits by commit date (descending)" do
+    it 'it the commits by commit date (descending)' do
       # Remove duplicate timestamps because they make it harder to
       # assert that the commits are sorted as expected.
       commits = graph.commits.uniq(&:date)
@@ -29,5 +29,20 @@ describe Network::Graph, models: true do
       expect(commits).not_to be_empty
       expect(commits.map(&:id)).to eq(sorted_commits.map(&:id))
     end
+
+    it 'sorts children before parents for commits with the same timestamp' do
+      commits_by_time = graph.commits.group_by(&:date)
+
+      commits_by_time.each do |time, commits|
+        commit_ids = commits.map(&:id)
+
+        commits.each_with_index do |commit, index|
+          parent_indexes = commit.parent_ids.map { |parent_id| commit_ids.find_index(parent_id) }.compact
+
+          # All parents of the current commit should appear after it
+          expect(parent_indexes).to all( be > index )
+        end
+      end
+    end
   end
 end
diff --git a/spec/models/note_spec.rb b/spec/models/note_spec.rb
index 557ea97b008..7a01cef9b4b 100644
--- a/spec/models/note_spec.rb
+++ b/spec/models/note_spec.rb
@@ -272,9 +272,9 @@ describe Note, models: true do
       Gitlab::Diff::Position.new(
         old_path: "files/ruby/popen.rb",
         new_path: "files/ruby/popen.rb",
-        old_line: 16,
-        new_line: 22,
-        diff_refs: merge_request.diff_refs
+        old_line: nil,
+        new_line: 13,
+        diff_refs: project.commit(sample_commit.id).diff_refs
       )
     end
 
@@ -288,26 +288,78 @@ describe Note, models: true do
       )
     end
 
-    subject { merge_request.notes.grouped_diff_discussions }
+    context 'active diff discussions' do
+      subject { merge_request.notes.grouped_diff_discussions }
 
-    it "includes active discussions" do
-      discussions = subject.values.flatten
+      it "includes active discussions" do
+        discussions = subject.values.flatten
 
-      expect(discussions.count).to eq(2)
-      expect(discussions.map(&:id)).to eq([active_diff_note1.discussion_id, active_diff_note3.discussion_id])
-      expect(discussions.all?(&:active?)).to be true
+        expect(discussions.count).to eq(2)
+        expect(discussions.map(&:id)).to eq([active_diff_note1.discussion_id, active_diff_note3.discussion_id])
+        expect(discussions.all?(&:active?)).to be true
 
-      expect(discussions.first.notes).to eq([active_diff_note1, active_diff_note2])
-      expect(discussions.last.notes).to eq([active_diff_note3])
-    end
+        expect(discussions.first.notes).to eq([active_diff_note1, active_diff_note2])
+        expect(discussions.last.notes).to eq([active_diff_note3])
+      end
 
-    it "doesn't include outdated discussions" do
-      expect(subject.values.flatten.map(&:id)).not_to include(outdated_diff_note1.discussion_id)
+      it "doesn't include outdated discussions" do
+        expect(subject.values.flatten.map(&:id)).not_to include(outdated_diff_note1.discussion_id)
+      end
+
+      it "groups the discussions by line code" do
+        expect(subject[active_diff_note1.line_code].first.id).to eq(active_diff_note1.discussion_id)
+        expect(subject[active_diff_note3.line_code].first.id).to eq(active_diff_note3.discussion_id)
+      end
     end
 
-    it "groups the discussions by line code" do
-      expect(subject[active_diff_note1.line_code].first.id).to eq(active_diff_note1.discussion_id)
-      expect(subject[active_diff_note3.line_code].first.id).to eq(active_diff_note3.discussion_id)
+    context 'diff discussions for older diff refs' do
+      subject { merge_request.notes.grouped_diff_discussions(diff_refs) }
+
+      context 'for diff refs a discussion was created at' do
+        let(:diff_refs) { active_position2.diff_refs }
+
+        it "includes discussions that were created then" do
+          discussions = subject.values.flatten
+
+          expect(discussions.count).to eq(1)
+
+          discussion = discussions.first
+
+          expect(discussion.id).to eq(active_diff_note3.discussion_id)
+          expect(discussion.active?).to be true
+          expect(discussion.active?(diff_refs)).to be false
+          expect(discussion.created_at_diff?(diff_refs)).to be true
+
+          expect(discussion.notes).to eq([active_diff_note3])
+        end
+
+        it "groups the discussions by original line code" do
+          expect(subject[active_diff_note3.original_line_code].first.id).to eq(active_diff_note3.discussion_id)
+        end
+      end
+
+      context 'for diff refs a discussion was last active at' do
+        let(:diff_refs) { outdated_position.diff_refs }
+
+        it "includes discussions that were last active" do
+          discussions = subject.values.flatten
+
+          expect(discussions.count).to eq(1)
+
+          discussion = discussions.first
+
+          expect(discussion.id).to eq(outdated_diff_note1.discussion_id)
+          expect(discussion.active?).to be false
+          expect(discussion.active?(diff_refs)).to be true
+          expect(discussion.created_at_diff?(diff_refs)).to be true
+
+          expect(discussion.notes).to eq([outdated_diff_note1, outdated_diff_note2])
+        end
+
+        it "groups the discussions by line code" do
+          expect(subject[outdated_diff_note1.line_code].first.id).to eq(outdated_diff_note1.discussion_id)
+        end
+      end
     end
   end
 
diff --git a/spec/models/project_services/chat_message/pipeline_message_spec.rb b/spec/models/project_services/chat_message/pipeline_message_spec.rb
index ec5c6c5e0ed..e005be42b0d 100644
--- a/spec/models/project_services/chat_message/pipeline_message_spec.rb
+++ b/spec/models/project_services/chat_message/pipeline_message_spec.rb
@@ -4,6 +4,7 @@ describe ChatMessage::PipelineMessage do
   subject { described_class.new(args) }
 
   let(:user) { { name: 'hacker' } }
+  let(:duration) { 7210 }
   let(:args) do
     {
       object_attributes: {
@@ -26,7 +27,6 @@ describe ChatMessage::PipelineMessage do
     context 'pipeline succeeded' do
       let(:status) { 'success' }
       let(:color) { 'good' }
-      let(:duration) { 10 }
       let(:message) { build_message('passed') }
 
       it 'returns a message with information about succeeded build' do
@@ -39,7 +39,6 @@ describe ChatMessage::PipelineMessage do
     context 'pipeline failed' do
       let(:status) { 'failed' }
       let(:color) { 'danger' }
-      let(:duration) { 10 }
       let(:message) { build_message }
 
       it 'returns a message with information about failed build' do
@@ -64,7 +63,7 @@ describe ChatMessage::PipelineMessage do
       "<http://example.gitlab.com|project_name>:" \
         " Pipeline <http://example.gitlab.com/pipelines/123|#123>" \
         " of <http://example.gitlab.com/commits/develop|develop> branch" \
-        " by #{name} #{status_text} in #{duration} #{'second'.pluralize(duration)}"
+        " by #{name} #{status_text} in 02:00:10"
     end
   end
 
@@ -76,7 +75,6 @@ describe ChatMessage::PipelineMessage do
     context 'pipeline succeeded' do
       let(:status) { 'success' }
       let(:color) { 'good' }
-      let(:duration) { 10 }
       let(:message) { build_markdown_message('passed') }
 
       it 'returns a message with information about succeeded build' do
@@ -85,7 +83,7 @@ describe ChatMessage::PipelineMessage do
         expect(subject.activity).to eq({
           title: 'Pipeline [#123](http://example.gitlab.com/pipelines/123) of [develop](http://example.gitlab.com/commits/develop) branch by hacker passed',
           subtitle: 'in [project_name](http://example.gitlab.com)',
-          text: 'in 10 seconds',
+          text: 'in 02:00:10',
           image: ''
         })
       end
@@ -94,7 +92,6 @@ describe ChatMessage::PipelineMessage do
     context 'pipeline failed' do
       let(:status) { 'failed' }
       let(:color) { 'danger' }
-      let(:duration) { 10 }
       let(:message) { build_markdown_message }
 
       it 'returns a message with information about failed build' do
@@ -103,7 +100,7 @@ describe ChatMessage::PipelineMessage do
         expect(subject.activity).to eq({
           title: 'Pipeline [#123](http://example.gitlab.com/pipelines/123) of [develop](http://example.gitlab.com/commits/develop) branch by hacker failed',
           subtitle: 'in [project_name](http://example.gitlab.com)',
-          text: 'in 10 seconds',
+          text: 'in 02:00:10',
           image: ''
         })
       end
@@ -118,7 +115,7 @@ describe ChatMessage::PipelineMessage do
           expect(subject.activity).to eq({
             title: 'Pipeline [#123](http://example.gitlab.com/pipelines/123) of [develop](http://example.gitlab.com/commits/develop) branch by API failed',
             subtitle: 'in [project_name](http://example.gitlab.com)',
-            text: 'in 10 seconds',
+            text: 'in 02:00:10',
             image: ''
           })
         end
@@ -129,7 +126,7 @@ describe ChatMessage::PipelineMessage do
       "[project_name](http://example.gitlab.com):" \
         " Pipeline [#123](http://example.gitlab.com/pipelines/123)" \
         " of [develop](http://example.gitlab.com/commits/develop)" \
-        " branch by #{name} #{status_text} in #{duration} #{'second'.pluralize(duration)}"
+        " branch by #{name} #{status_text} in 02:00:10"
     end
   end
 end
diff --git a/spec/models/repository_spec.rb b/spec/models/repository_spec.rb
index 5216764a82d..dd6514b3b50 100644
--- a/spec/models/repository_spec.rb
+++ b/spec/models/repository_spec.rb
@@ -1098,21 +1098,33 @@ describe Repository, models: true do
   end
 
   describe '#merge' do
-    it 'merges the code and return the commit id' do
+    let(:merge_request) { create(:merge_request, source_branch: 'feature', target_branch: 'master', source_project: project) }
+
+    let(:commit_options) do
+      author = repository.user_to_committer(user)
+      { message: 'Test \r\n\r\n message', committer: author, author: author }
+    end
+
+    it 'merges the code and returns the commit id' do
       expect(merge_commit).to be_present
       expect(repository.blob_at(merge_commit.id, 'files/ruby/feature.rb')).to be_present
     end
 
     it 'sets the `in_progress_merge_commit_sha` flag for the given merge request' do
-      merge_request = create(:merge_request, source_branch: 'feature', target_branch: 'master', source_project: project)
-
-      merge_commit_id = repository.merge(user,
-                                         merge_request.diff_head_sha,
-                                         merge_request,
-                                         commit_options)
+      merge_commit_id = merge(repository, user, merge_request, commit_options)
 
       expect(merge_request.in_progress_merge_commit_sha).to eq(merge_commit_id)
     end
+
+    it 'removes carriage returns from commit message' do
+      merge_commit_id = merge(repository, user, merge_request, commit_options)
+
+      expect(repository.commit(merge_commit_id).message).to eq(commit_options[:message].delete("\r"))
+    end
+
+    def merge(repository, user, merge_request, options = {})
+      repository.merge(user, merge_request.diff_head_sha, merge_request, options)
+    end
   end
 
   describe '#revert' do
diff --git a/spec/policies/personal_snippet_policy_spec.rb b/spec/policies/personal_snippet_policy_spec.rb
new file mode 100644
index 00000000000..58aa1145c9e
--- /dev/null
+++ b/spec/policies/personal_snippet_policy_spec.rb
@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe PersonalSnippetPolicy, models: true do
+  let(:regular_user) { create(:user) }
+  let(:external_user) { create(:user, :external) }
+  let(:admin_user) { create(:user, :admin) }
+
+  let(:author_permissions) do
+    [
+      :update_personal_snippet,
+      :admin_personal_snippet,
+      :destroy_personal_snippet
+    ]
+  end
+
+  def permissions(user)
+    described_class.abilities(user, snippet).to_set
+  end
+
+  context 'public snippet' do
+    let(:snippet) { create(:personal_snippet, :public) }
+
+    context 'no user' do
+      subject { permissions(nil) }
+
+      it do
+        is_expected.to include(:read_personal_snippet)
+        is_expected.not_to include(:comment_personal_snippet)
+        is_expected.not_to include(*author_permissions)
+      end
+    end
+
+    context 'regular user' do
+      subject { permissions(regular_user) }
+
+      it do
+        is_expected.to include(:read_personal_snippet)
+        is_expected.to include(:comment_personal_snippet)
+        is_expected.not_to include(*author_permissions)
+      end
+    end
+
+    context 'author' do
+      subject { permissions(snippet.author) }
+
+      it do
+        is_expected.to include(:read_personal_snippet)
+        is_expected.to include(:comment_personal_snippet)
+        is_expected.to include(*author_permissions)
+      end
+    end
+  end
+
+  context 'internal snippet' do
+    let(:snippet) { create(:personal_snippet, :internal) }
+
+    context 'no user' do
+      subject { permissions(nil) }
+
+      it do
+        is_expected.not_to include(:read_personal_snippet)
+        is_expected.not_to include(:comment_personal_snippet)
+        is_expected.not_to include(*author_permissions)
+      end
+    end
+
+    context 'regular user' do
+      subject { permissions(regular_user) }
+
+      it do
+        is_expected.to include(:read_personal_snippet)
+        is_expected.to include(:comment_personal_snippet)
+        is_expected.not_to include(*author_permissions)
+      end
+    end
+
+    context 'external user' do
+      subject { permissions(external_user) }
+
+      it do
+        is_expected.not_to include(:read_personal_snippet)
+        is_expected.not_to include(:comment_personal_snippet)
+        is_expected.not_to include(*author_permissions)
+      end
+    end
+
+    context 'snippet author' do
+      subject { permissions(snippet.author) }
+
+      it do
+        is_expected.to include(:read_personal_snippet)
+        is_expected.to include(:comment_personal_snippet)
+        is_expected.to include(*author_permissions)
+      end
+    end
+  end
+
+  context 'private snippet' do
+    let(:snippet) { create(:project_snippet, :private) }
+
+    context 'no user' do
+      subject { permissions(nil) }
+
+      it do
+        is_expected.not_to include(:read_personal_snippet)
+        is_expected.not_to include(:comment_personal_snippet)
+        is_expected.not_to include(*author_permissions)
+      end
+    end
+
+    context 'regular user' do
+      subject { permissions(regular_user) }
+
+      it do
+        is_expected.not_to include(:read_personal_snippet)
+        is_expected.not_to include(:comment_personal_snippet)
+        is_expected.not_to include(*author_permissions)
+      end
+    end
+
+    context 'external user' do
+      subject { permissions(external_user) }
+
+      it do
+        is_expected.not_to include(:read_personal_snippet)
+        is_expected.not_to include(:comment_personal_snippet)
+        is_expected.not_to include(*author_permissions)
+      end
+    end
+
+    context 'snippet author' do
+      subject { permissions(snippet.author) }
+
+      it do
+        is_expected.to include(:read_personal_snippet)
+        is_expected.to include(:comment_personal_snippet)
+        is_expected.to include(*author_permissions)
+      end
+    end
+  end
+end
diff --git a/spec/requests/api/pipelines_spec.rb b/spec/requests/api/pipelines_spec.rb
index 762345cd41c..f9e5316b3de 100644
--- a/spec/requests/api/pipelines_spec.rb
+++ b/spec/requests/api/pipelines_spec.rb
@@ -24,6 +24,245 @@ describe API::Pipelines do
         expect(json_response.first['id']).to eq pipeline.id
         expect(json_response.first.keys).to contain_exactly(*%w[id sha ref status])
       end
+
+      context 'when parameter is passed' do
+        %w[running pending].each do |target|
+          context "when scope is #{target}" do
+            before do
+              create(:ci_pipeline, project: project, status: target)
+            end
+
+            it 'returns matched pipelines' do
+              get api("/projects/#{project.id}/pipelines", user), scope: target
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response).not_to be_empty
+              json_response.each { |r| expect(r['status']).to eq(target) }
+            end
+          end
+        end
+
+        context 'when scope is finished' do
+          before do
+            create(:ci_pipeline, project: project, status: 'success')
+            create(:ci_pipeline, project: project, status: 'failed')
+            create(:ci_pipeline, project: project, status: 'canceled')
+          end
+
+          it 'returns matched pipelines' do
+            get api("/projects/#{project.id}/pipelines", user), scope: 'finished'
+
+            expect(response).to have_http_status(:ok)
+            expect(response).to include_pagination_headers
+            expect(json_response).not_to be_empty
+            json_response.each { |r| expect(r['status']).to be_in(%w[success failed canceled]) }
+          end
+        end
+
+        context 'when scope is branches or tags' do
+          let!(:pipeline_branch) { create(:ci_pipeline, project: project) }
+          let!(:pipeline_tag) { create(:ci_pipeline, project: project, ref: 'v1.0.0', tag: true) }
+
+          context 'when scope is branches' do
+            it 'returns matched pipelines' do
+              get api("/projects/#{project.id}/pipelines", user), scope: 'branches'
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response).not_to be_empty
+              expect(json_response.last['id']).to eq(pipeline_branch.id)
+            end
+          end
+
+          context 'when scope is tags' do
+            it 'returns matched pipelines' do
+              get api("/projects/#{project.id}/pipelines", user), scope: 'tags'
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response).not_to be_empty
+              expect(json_response.last['id']).to eq(pipeline_tag.id)
+            end
+          end
+        end
+
+        context 'when scope is invalid' do
+          it 'returns bad_request' do
+            get api("/projects/#{project.id}/pipelines", user), scope: 'invalid-scope'
+
+            expect(response).to have_http_status(:bad_request)
+          end
+        end
+
+        HasStatus::AVAILABLE_STATUSES.each do |target|
+          context "when status is #{target}" do
+            before do
+              create(:ci_pipeline, project: project, status: target)
+              exception_status = HasStatus::AVAILABLE_STATUSES - [target]
+              create(:ci_pipeline, project: project, status: exception_status.sample)
+            end
+
+            it 'returns matched pipelines' do
+              get api("/projects/#{project.id}/pipelines", user), status: target
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response).not_to be_empty
+              json_response.each { |r| expect(r['status']).to eq(target) }
+            end
+          end
+        end
+
+        context 'when status is invalid' do
+          it 'returns bad_request' do
+            get api("/projects/#{project.id}/pipelines", user), status: 'invalid-status'
+
+            expect(response).to have_http_status(:bad_request)
+          end
+        end
+
+        context 'when ref is specified' do
+          before do
+            create(:ci_pipeline, project: project)
+          end
+
+          context 'when ref exists' do
+            it 'returns matched pipelines' do
+              get api("/projects/#{project.id}/pipelines", user), ref: 'master'
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response).not_to be_empty
+              json_response.each { |r| expect(r['ref']).to eq('master') }
+            end
+          end
+
+          context 'when ref does not exist' do
+            it 'returns empty' do
+              get api("/projects/#{project.id}/pipelines", user), ref: 'invalid-ref'
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response).to be_empty
+            end
+          end
+        end
+
+        context 'when name is specified' do
+          let!(:pipeline) { create(:ci_pipeline, project: project, user: user) }
+
+          context 'when name exists' do
+            it 'returns matched pipelines' do
+              get api("/projects/#{project.id}/pipelines", user), name: user.name
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response.first['id']).to eq(pipeline.id)
+            end
+          end
+
+          context 'when name does not exist' do
+            it 'returns empty' do
+              get api("/projects/#{project.id}/pipelines", user), name: 'invalid-name'
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response).to be_empty
+            end
+          end
+        end
+
+        context 'when username is specified' do
+          let!(:pipeline) { create(:ci_pipeline, project: project, user: user) }
+
+          context 'when username exists' do
+            it 'returns matched pipelines' do
+              get api("/projects/#{project.id}/pipelines", user), username: user.username
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response.first['id']).to eq(pipeline.id)
+            end
+          end
+
+          context 'when username does not exist' do
+            it 'returns empty' do
+              get api("/projects/#{project.id}/pipelines", user), username: 'invalid-username'
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response).to be_empty
+            end
+          end
+        end
+
+        context 'when yaml_errors is specified' do
+          let!(:pipeline1) { create(:ci_pipeline, project: project, yaml_errors: 'Syntax error') }
+          let!(:pipeline2) { create(:ci_pipeline, project: project) }
+
+          context 'when yaml_errors is true' do
+            it 'returns matched pipelines' do
+              get api("/projects/#{project.id}/pipelines", user), yaml_errors: true
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response.first['id']).to eq(pipeline1.id)
+            end
+          end
+
+          context 'when yaml_errors is false' do
+            it 'returns matched pipelines' do
+              get api("/projects/#{project.id}/pipelines", user), yaml_errors: false
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response.first['id']).to eq(pipeline2.id)
+            end
+          end
+
+          context 'when yaml_errors is invalid' do
+            it 'returns bad_request' do
+              get api("/projects/#{project.id}/pipelines", user), yaml_errors: 'invalid-yaml_errors'
+
+              expect(response).to have_http_status(:bad_request)
+            end
+          end
+        end
+
+        context 'when order_by and sort are specified' do
+          context 'when order_by user_id' do
+            let!(:pipeline) { create_list(:ci_pipeline, 2, project: project, user: create(:user)) }
+
+            it 'sorts as user_id: :asc' do
+              get api("/projects/#{project.id}/pipelines", user), order_by: 'user_id', sort: 'asc'
+
+              expect(response).to have_http_status(:ok)
+              expect(response).to include_pagination_headers
+              expect(json_response).not_to be_empty
+              pipeline.sort_by { |p| p.user.id }.tap do |sorted_pipeline|
+                json_response.each_with_index { |r, i| expect(r['id']).to eq(sorted_pipeline[i].id) }
+              end
+            end
+
+            context 'when sort is invalid' do
+              it 'returns bad_request' do
+                get api("/projects/#{project.id}/pipelines", user), order_by: 'user_id', sort: 'invalid_sort'
+
+                expect(response).to have_http_status(:bad_request)
+              end
+            end
+          end
+
+          context 'when order_by is invalid' do
+            it 'returns bad_request' do
+              get api("/projects/#{project.id}/pipelines", user), order_by: 'lock_version', sort: 'asc'
+
+              expect(response).to have_http_status(:bad_request)
+            end
+          end
+        end
+      end
     end
 
     context 'unauthorized user' do
diff --git a/spec/requests/api/projects_spec.rb b/spec/requests/api/projects_spec.rb
index cc03d7a933b..ab70ce5cd2f 100644
--- a/spec/requests/api/projects_spec.rb
+++ b/spec/requests/api/projects_spec.rb
@@ -665,6 +665,20 @@ describe API::Projects do
         })
       end
 
+      it "does not include statistics by default" do
+        get api("/projects/#{project.id}", user)
+
+        expect(response).to have_http_status(200)
+        expect(json_response).not_to include 'statistics'
+      end
+
+      it "includes statistics if requested" do
+        get api("/projects/#{project.id}", user), statistics: true
+
+        expect(response).to have_http_status(200)
+        expect(json_response).to include 'statistics'
+      end
+
       describe 'permissions' do
         context 'all projects' do
           before { project.team << [user, :master] }
diff --git a/spec/services/merge_requests/create_from_issue_service_spec.rb b/spec/services/merge_requests/create_from_issue_service_spec.rb
new file mode 100644
index 00000000000..1588d30c394
--- /dev/null
+++ b/spec/services/merge_requests/create_from_issue_service_spec.rb
@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe MergeRequests::CreateFromIssueService, services: true do
+  let(:project) { create(:project, :repository) }
+  let(:user)    { create(:user) }
+  let(:issue)   { create(:issue, project: project) }
+
+  subject(:service) { described_class.new(project, user, issue_iid: issue.iid) }
+
+  before do
+    project.add_developer(user)
+  end
+
+  describe '#execute' do
+    it 'returns an error with invalid issue iid' do
+      result = described_class.new(project, user, issue_iid: -1).execute
+
+      expect(result[:status]).to eq :error
+      expect(result[:message]).to eq 'Invalid issue iid'
+    end
+
+    it 'delegates issue search to IssuesFinder' do
+      expect_any_instance_of(IssuesFinder).to receive(:execute).once.and_call_original
+
+      described_class.new(project, user, issue_iid: -1).execute
+    end
+
+    it 'delegates the branch creation to CreateBranchService' do
+      expect_any_instance_of(CreateBranchService).to receive(:execute).once.and_call_original
+
+      service.execute
+    end
+
+    it 'creates a branch based on issue title' do
+      service.execute
+
+      expect(project.repository.branch_exists?(issue.to_branch_name)).to be_truthy
+    end
+
+    it 'creates a system note' do
+      expect(SystemNoteService).to receive(:new_issue_branch).with(issue, project, user, issue.to_branch_name)
+
+      service.execute
+    end
+
+    it 'creates a merge request' do
+      expect { service.execute }.to change(project.merge_requests, :count).by(1)
+    end
+
+    it 'sets the merge request title to: "WIP: Resolves "$issue-title"' do
+      result = service.execute
+
+      expect(result[:merge_request].title).to eq("WIP: Resolve \"#{issue.title}\"")
+    end
+
+    it 'sets the merge request author to current user' do
+      result = service.execute
+
+      expect(result[:merge_request].author).to eq user
+    end
+
+    it 'sets the merge request source branch to the new issue branch' do
+      result = service.execute
+
+      expect(result[:merge_request].source_branch).to eq issue.to_branch_name
+    end
+
+    it 'sets the merge request target branch to the project default branch' do
+      result = service.execute
+
+      expect(result[:merge_request].target_branch).to eq project.default_branch
+    end
+  end
+end
diff --git a/spec/services/projects/upload_service_spec.rb b/spec/services/upload_service_spec.rb
index d2cefa46bfa..95ba28dbecd 100644
--- a/spec/services/projects/upload_service_spec.rb
+++ b/spec/services/upload_service_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Projects::UploadService, services: true do
+describe UploadService, services: true do
   describe 'File service' do
     before do
       @user = create(:user)
@@ -68,6 +68,6 @@ describe Projects::UploadService, services: true do
   end
 
   def upload_file(project, file)
-    Projects::UploadService.new(project, file).execute
+    described_class.new(project, file, FileUploader).execute
   end
 end
diff --git a/spec/support/helpers/fake_blob_helpers.rb b/spec/support/helpers/fake_blob_helpers.rb
index b29af732ad3..bc9686ed9cf 100644
--- a/spec/support/helpers/fake_blob_helpers.rb
+++ b/spec/support/helpers/fake_blob_helpers.rb
@@ -1,6 +1,6 @@
 module FakeBlobHelpers
   class FakeBlob
-    include Linguist::BlobHelper
+    include BlobLike
 
     attr_reader :path, :size, :data, :lfs_oid, :lfs_size
 
@@ -19,10 +19,6 @@ module FakeBlobHelpers
 
     alias_method :name, :path
 
-    def mode
-      nil
-    end
-
     def id
       0
     end
@@ -31,17 +27,11 @@ module FakeBlobHelpers
       @binary
     end
 
-    def load_all_data!(repository)
-      # No-op
+    def external_storage
+      :lfs if @lfs_pointer
     end
 
-    def lfs_pointer?
-      @lfs_pointer
-    end
-
-    def truncated?
-      false
-    end
+    alias_method :external_size, :lfs_size
   end
 
   def fake_blob(**kwargs)
diff --git a/spec/tasks/gitlab/shell_rake_spec.rb b/spec/tasks/gitlab/shell_rake_spec.rb
index 226d34fe2c9..ee3614c50f6 100644
--- a/spec/tasks/gitlab/shell_rake_spec.rb
+++ b/spec/tasks/gitlab/shell_rake_spec.rb
@@ -11,6 +11,10 @@ describe 'gitlab:shell rake tasks' do
     it 'invokes create_hooks task' do
       expect(Rake::Task['gitlab:shell:create_hooks']).to receive(:invoke)
 
+      storages = Gitlab.config.repositories.storages.values.map { |rs| rs['path'] }
+      expect(Kernel).to receive(:system).with('bin/install', *storages).and_call_original
+      expect(Kernel).to receive(:system).with('bin/compile').and_call_original
+
       run_rake_task('gitlab:shell:install')
     end
   end
diff --git a/spec/uploaders/personal_file_uploader_spec.rb b/spec/uploaders/personal_file_uploader_spec.rb
new file mode 100644
index 00000000000..fb92f2ae3ab
--- /dev/null
+++ b/spec/uploaders/personal_file_uploader_spec.rb
@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe PersonalFileUploader do
+  let(:uploader) { described_class.new(build_stubbed(:empty_project)) }
+  let(:snippet) { create(:personal_snippet) }
+
+  describe '.absolute_path' do
+    it 'returns the correct absolute path by building it dynamically' do
+      upload = double(model: snippet, path: 'secret/foo.jpg')
+
+      dynamic_segment = "personal_snippet/#{snippet.id}"
+
+      expect(described_class.absolute_path(upload)).to end_with("#{dynamic_segment}/secret/foo.jpg")
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns the hass' do
+      uploader = described_class.new(snippet, 'secret')
+
+      allow(uploader).to receive(:file).and_return(double(extension: 'txt', filename: 'file_name'))
+      expected_url = "/uploads/personal_snippet/#{snippet.id}/secret/file_name"
+
+      expect(uploader.to_h).to eq(
+        alt: 'file_name',
+        url: expected_url,
+        markdown: "[file_name](#{expected_url})"
+      )
+    end
+  end
+end
diff --git a/spec/views/projects/tags/index.html.haml_spec.rb b/spec/views/projects/tags/index.html.haml_spec.rb
new file mode 100644
index 00000000000..33122365e9a
--- /dev/null
+++ b/spec/views/projects/tags/index.html.haml_spec.rb
@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'projects/tags/index', :view do
+  let(:project) { create(:project) }
+
+  before do
+    assign(:project, project)
+    assign(:repository, project.repository)
+    assign(:tags, [])
+
+    allow(view).to receive(:current_ref).and_return('master')
+    allow(view).to receive(:can?).and_return(false)
+  end
+
+  it 'defaults sort dropdown toggle to last updated' do
+    render
+
+    expect(rendered).to have_button('Last updated')
+  end
+end