Merge branch 'master' into auto-pipelines-vue

53 files changed, 1246 insertions, 252 deletions

diff --git a/spec/controllers/search_controller_spec.rb b/spec/controllers/search_controller_spec.rb
new file mode 100644
index 00000000000..b7bb9290712
--- /dev/null
+++ b/spec/controllers/search_controller_spec.rb
@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe SearchController do
+  let(:user)    { create(:user) }
+  let(:project) { create(:empty_project, :public) }
+
+  before do
+    sign_in(user)
+  end
+
+  it 'finds issue comments' do
+    project = create(:empty_project, :public)
+    note = create(:note_on_issue, project: project)
+
+    get :show, project_id: project.id, scope: 'notes', search: note.note
+
+    expect(assigns[:search_objects].first).to eq note
+  end
+
+  context 'on restricted projects' do
+    context 'when signed out' do
+      before { sign_out(user) }
+
+      it "doesn't expose comments on issues" do
+        project = create(:empty_project, :public, issues_access_level: ProjectFeature::PRIVATE)
+        note = create(:note_on_issue, project: project)
+
+        get :show, project_id: project.id, scope: 'notes', search: note.note
+
+        expect(assigns[:search_objects].count).to eq(0)
+      end
+    end
+
+    it "doesn't expose comments on issues" do
+      project = create(:empty_project, :public, issues_access_level: ProjectFeature::PRIVATE)
+      note = create(:note_on_issue, project: project)
+
+      get :show, project_id: project.id, scope: 'notes', search: note.note
+
+      expect(assigns[:search_objects].count).to eq(0)
+    end
+
+    it "doesn't expose comments on merge_requests" do
+      project = create(:empty_project, :public, merge_requests_access_level: ProjectFeature::PRIVATE)
+      note = create(:note_on_merge_request, project: project)
+
+      get :show, project_id: project.id, scope: 'notes', search: note.note
+
+      expect(assigns[:search_objects].count).to eq(0)
+    end
+
+    it "doesn't expose comments on snippets" do
+      project = create(:empty_project, :public, snippets_access_level: ProjectFeature::PRIVATE)
+      note = create(:note_on_project_snippet, project: project)
+
+      get :show, project_id: project.id, scope: 'notes', search: note.note
+
+      expect(assigns[:search_objects].count).to eq(0)
+    end
+  end
+end
diff --git a/spec/factories/notes.rb b/spec/factories/notes.rb
index 6919002dedc..a10ba629760 100644
--- a/spec/factories/notes.rb
+++ b/spec/factories/notes.rb
@@ -67,7 +67,7 @@ FactoryGirl.define do
     end
 
     trait :on_project_snippet do
-      noteable { create(:snippet, project: project) }
+      noteable { create(:project_snippet, project: project) }
     end
 
     trait :system do
diff --git a/spec/features/admin/admin_active_tab_spec.rb b/spec/features/admin/admin_active_tab_spec.rb
new file mode 100644
index 00000000000..16064d60ce2
--- /dev/null
+++ b/spec/features/admin/admin_active_tab_spec.rb
@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+RSpec.describe 'admin active tab' do
+  before do
+    login_as :admin
+  end
+
+  shared_examples 'page has active tab' do |title|
+    it "activates #{title} tab" do
+      expect(page).to have_selector('.layout-nav .nav-links > li.active', count: 1)
+      expect(page.find('.layout-nav li.active')).to have_content(title)
+    end
+  end
+
+  shared_examples 'page has active sub tab' do |title|
+    it "activates #{title} sub tab" do
+      expect(page).to have_selector('.sub-nav li.active', count: 1)
+      expect(page.find('.sub-nav li.active')).to have_content(title)
+    end
+  end
+
+  context 'on home page' do
+    before do
+      visit admin_root_path
+    end
+
+    it_behaves_like 'page has active tab', 'Overview'
+  end
+
+  context 'on projects' do
+    before do
+      visit admin_projects_path
+    end
+
+    it_behaves_like 'page has active tab', 'Overview'
+    it_behaves_like 'page has active sub tab', 'Projects'
+  end
+
+  context 'on groups' do
+    before do
+      visit admin_groups_path
+    end
+
+    it_behaves_like 'page has active tab', 'Overview'
+    it_behaves_like 'page has active sub tab', 'Groups'
+  end
+
+  context 'on users' do
+    before do
+      visit admin_users_path
+    end
+
+    it_behaves_like 'page has active tab', 'Overview'
+    it_behaves_like 'page has active sub tab', 'Users'
+  end
+
+  context 'on logs' do
+    before do
+      visit admin_logs_path
+    end
+
+    it_behaves_like 'page has active tab', 'Monitoring'
+    it_behaves_like 'page has active sub tab', 'Logs'
+  end
+
+  context 'on messages' do
+    before do
+      visit admin_broadcast_messages_path
+    end
+
+    it_behaves_like 'page has active tab', 'Messages'
+  end
+
+  context 'on hooks' do
+    before do
+      visit admin_hooks_path
+    end
+
+    it_behaves_like 'page has active tab', 'Hooks'
+  end
+
+  context 'on background jobs' do
+    before do
+      visit admin_background_jobs_path
+    end
+
+    it_behaves_like 'page has active tab', 'Monitoring'
+    it_behaves_like 'page has active sub tab', 'Background Jobs'
+  end
+end
diff --git a/spec/features/issues/bulk_assignment_labels_spec.rb b/spec/features/issues/bulk_assignment_labels_spec.rb
index bc2c087c9b9..832757b24d4 100644
--- a/spec/features/issues/bulk_assignment_labels_spec.rb
+++ b/spec/features/issues/bulk_assignment_labels_spec.rb
@@ -9,6 +9,7 @@ feature 'Issues > Labels bulk assignment', feature: true do
   let!(:issue2)   { create(:issue, project: project, title: "Issue 2") }
   let!(:bug)      { create(:label, project: project, title: 'bug') }
   let!(:feature)  { create(:label, project: project, title: 'feature') }
+  let!(:wontfix)  { create(:label, project: project, title: 'wontfix') }
 
   context 'as an allowed user', js: true do
     before do
@@ -291,6 +292,45 @@ feature 'Issues > Labels bulk assignment', feature: true do
         expect(find("#issue_#{issue1.id}")).not_to have_content 'feature'
       end
     end
+
+    # Special case https://gitlab.com/gitlab-org/gitlab-ce/issues/24877
+    context 'unmarking common label' do
+      before do
+        issue1.labels << bug
+        issue1.labels << feature
+        issue2.labels << bug
+
+        visit namespace_project_issues_path(project.namespace, project)
+      end
+
+      it 'applies label from filtered results' do
+        check 'check_all_issues'
+
+        page.within('.issues_bulk_update') do
+          click_button 'Labels'
+          wait_for_ajax
+
+          expect(find('.dropdown-menu-labels li', text: 'bug')).to have_css('.is-active')
+          expect(find('.dropdown-menu-labels li', text: 'feature')).to have_css('.is-indeterminate')
+
+          click_link 'bug'
+          find('.dropdown-input-field', visible: true).set('wontfix')
+          click_link 'wontfix'
+        end
+
+        update_issues
+
+        page.within '.issues-holder' do
+          expect(find("#issue_#{issue1.id}")).not_to have_content 'bug'
+          expect(find("#issue_#{issue1.id}")).to have_content 'feature'
+          expect(find("#issue_#{issue1.id}")).to have_content 'wontfix'
+
+          expect(find("#issue_#{issue2.id}")).not_to have_content 'bug'
+          expect(find("#issue_#{issue2.id}")).not_to have_content 'feature'
+          expect(find("#issue_#{issue2.id}")).to have_content 'wontfix'
+        end
+      end
+    end
   end
 
   context 'as a guest' do
@@ -320,7 +360,7 @@ feature 'Issues > Labels bulk assignment', feature: true do
 
   def open_labels_dropdown(items = [], unmark = false)
     page.within('.issues_bulk_update') do
-      click_button 'Label'
+      click_button 'Labels'
       wait_for_ajax
       items.map do |item|
         click_link item
diff --git a/spec/features/issues/gfm_autocomplete_spec.rb b/spec/features/issues/gfm_autocomplete_spec.rb
index cd0512a37e6..da64827b377 100644
--- a/spec/features/issues/gfm_autocomplete_spec.rb
+++ b/spec/features/issues/gfm_autocomplete_spec.rb
@@ -89,4 +89,12 @@ feature 'GFM autocomplete', feature: true, js: true do
       end
     end
   end
+
+  it 'doesnt open autocomplete after non-word character' do
+    page.within '.timeline-content-form' do
+      find('#note_note').native.send_keys("@#{user.username[0..2]}!")
+    end
+
+    expect(page).not_to have_selector('.atwho-view')
+  end
 end
diff --git a/spec/features/projects/import_export/test_project_export.tar.gz b/spec/features/projects/import_export/test_project_export.tar.gz
index bfe59bdb90e..d3165d07d7b 100644
--- a/spec/features/projects/import_export/test_project_export.tar.gz
+++ b/spec/features/projects/import_export/test_project_export.tar.gz
diff --git a/spec/features/projects/services/slack_service_spec.rb b/spec/features/projects/services/slack_service_spec.rb
index 16541f51d98..320ed13a01d 100644
--- a/spec/features/projects/services/slack_service_spec.rb
+++ b/spec/features/projects/services/slack_service_spec.rb
@@ -2,8 +2,8 @@ require 'spec_helper'
 
 feature 'Projects > Slack service > Setup events', feature: true do
   let(:user) { create(:user) }
-  let(:service) { SlackService.new }
-  let(:project) { create(:project, slack_service: service) }
+  let(:service) { SlackNotificationService.new }
+  let(:project) { create(:project, slack_notification_service: service) }
 
   background do
     service.fields
diff --git a/spec/finders/issues_finder_spec.rb b/spec/finders/issues_finder_spec.rb
index 7f69e888f32..97737d7ddc7 100644
--- a/spec/finders/issues_finder_spec.rb
+++ b/spec/finders/issues_finder_spec.rb
@@ -10,24 +10,24 @@ describe IssuesFinder do
   let(:issue1) { create(:issue, author: user, assignee: user, project: project1, milestone: milestone, title: 'gitlab') }
   let(:issue2) { create(:issue, author: user, assignee: user, project: project2, description: 'gitlab') }
   let(:issue3) { create(:issue, author: user2, assignee: user2, project: project2) }
-  let(:closed_issue) { create(:issue, author: user2, assignee: user2, project: project2, state: 'closed') }
-  let!(:label_link) { create(:label_link, label: label, target: issue2) }
-
-  before do
-    project1.team << [user, :master]
-    project2.team << [user, :developer]
-    project2.team << [user2, :developer]
-
-    issue1
-    issue2
-    issue3
-  end
 
   describe '#execute' do
+    let(:closed_issue) { create(:issue, author: user2, assignee: user2, project: project2, state: 'closed') }
+    let!(:label_link) { create(:label_link, label: label, target: issue2) }
     let(:search_user) { user }
     let(:params) { {} }
     let(:issues) { IssuesFinder.new(search_user, params.reverse_merge(scope: scope, state: 'opened')).execute }
 
+    before do
+      project1.team << [user, :master]
+      project2.team << [user, :developer]
+      project2.team << [user2, :developer]
+
+      issue1
+      issue2
+      issue3
+    end
+
     context 'scope: all' do
       let(:scope) { 'all' }
 
@@ -193,6 +193,15 @@ describe IssuesFinder do
           expect(issues).to contain_exactly(issue2, issue3)
         end
       end
+
+      it 'finds issues user can access due to group' do
+        group = create(:group)
+        project = create(:empty_project, group: group)
+        issue = create(:issue, project: project)
+        group.add_user(user, :owner)
+
+        expect(issues).to include(issue)
+      end
     end
 
     context 'personal scope' do
@@ -210,5 +219,43 @@ describe IssuesFinder do
         end
       end
     end
+
+    context 'when project restricts issues' do
+      let(:scope) { nil }
+
+      it "doesn't return team-only issues to non team members" do
+        project = create(:empty_project, :public, issues_access_level: ProjectFeature::PRIVATE)
+        issue = create(:issue, project: project)
+
+        expect(issues).not_to include(issue)
+      end
+
+      it "doesn't return issues if feature disabled" do
+        [project1, project2].each do |project|
+          project.project_feature.update!(issues_access_level: ProjectFeature::DISABLED)
+        end
+
+        expect(issues.count).to eq 0
+      end
+    end
+  end
+
+  describe '.not_restricted_by_confidentiality' do
+    let(:authorized_user) { create(:user) }
+    let(:project) { create(:empty_project, namespace: authorized_user.namespace) }
+    let!(:public_issue) { create(:issue, project: project) }
+    let!(:confidential_issue) { create(:issue, project: project, confidential: true) }
+
+    it 'returns non confidential issues for nil user' do
+      expect(IssuesFinder.send(:not_restricted_by_confidentiality, nil)).to include(public_issue)
+    end
+
+    it 'returns non confidential issues for user not authorized for the issues projects' do
+      expect(IssuesFinder.send(:not_restricted_by_confidentiality, user)).to include(public_issue)
+    end
+
+    it 'returns all issues for user authorized for the issues projects' do
+      expect(IssuesFinder.send(:not_restricted_by_confidentiality, authorized_user)).to include(public_issue, confidential_issue)
+    end
   end
 end
diff --git a/spec/finders/notes_finder_spec.rb b/spec/finders/notes_finder_spec.rb
index 7c6860372cc..4d21254323c 100644
--- a/spec/finders/notes_finder_spec.rb
+++ b/spec/finders/notes_finder_spec.rb
@@ -2,59 +2,203 @@ require 'spec_helper'
 
 describe NotesFinder do
   let(:user) { create :user }
-  let(:project) { create :project }
-  let(:note1) { create :note_on_commit, project: project }
-  let(:note2) { create :note_on_commit, project: project }
-  let(:commit) { note1.noteable }
+  let(:project) { create(:empty_project) }
 
   before do
     project.team << [user, :master]
   end
 
   describe '#execute' do
-    let(:params)  { { target_id: commit.id, target_type: 'commit', last_fetched_at: 1.hour.ago.to_i } }
+    it 'finds notes on snippets when project is public and user isnt a member'
 
-    before do
-      note1
-      note2
+    it 'finds notes on merge requests' do
+      create(:note_on_merge_request, project: project)
+
+      notes = described_class.new(project, user).execute
+
+      expect(notes.count).to eq(1)
     end
 
-    it 'finds all notes' do
-      notes = NotesFinder.new.execute(project, user, params)
-      expect(notes.size).to eq(2)
+    it 'finds notes on snippets' do
+      create(:note_on_project_snippet, project: project)
+
+      notes = described_class.new(project, user).execute
+
+      expect(notes.count).to eq(1)
     end
 
-    it 'raises an exception for an invalid target_type' do
-      params.merge!(target_type: 'invalid')
-      expect { NotesFinder.new.execute(project, user, params) }.to raise_error('invalid target_type')
+    it "excludes notes on commits the author can't download" do
+      project = create(:project, :private)
+      note = create(:note_on_commit, project: project)
+      params = { target_type: 'commit', target_id: note.noteable.id }
+
+      notes = described_class.new(project, create(:user), params).execute
+
+      expect(notes.count).to eq(0)
     end
 
-    it 'filters out old notes' do
-      note2.update_attribute(:updated_at, 2.hours.ago)
-      notes = NotesFinder.new.execute(project, user, params)
-      expect(notes).to eq([note1])
+    it 'succeeds when no notes found' do
+      notes = described_class.new(project, create(:user)).execute
+
+      expect(notes.count).to eq(0)
     end
 
-    context 'confidential issue notes' do
-      let(:confidential_issue) { create(:issue, :confidential, project: project, author: user) }
-      let!(:confidential_note) { create(:note, noteable: confidential_issue, project: confidential_issue.project) }
+    context 'on restricted projects' do
+      let(:project) do
+        create(:empty_project, :public, issues_access_level: ProjectFeature::PRIVATE,
+                                        snippets_access_level: ProjectFeature::PRIVATE,
+                                        merge_requests_access_level: ProjectFeature::PRIVATE)
+      end
+
+      it 'publicly excludes notes on merge requests' do
+        create(:note_on_merge_request, project: project)
+
+        notes = described_class.new(project, create(:user)).execute
+
+        expect(notes.count).to eq(0)
+      end
+
+      it 'publicly excludes notes on issues' do
+        create(:note_on_issue, project: project)
+
+        notes = described_class.new(project, create(:user)).execute
+
+        expect(notes.count).to eq(0)
+      end
+
+      it 'publicly excludes notes on snippets' do
+        create(:note_on_project_snippet, project: project)
+
+        notes = described_class.new(project, create(:user)).execute
+
+        expect(notes.count).to eq(0)
+      end
+    end
+
+    context 'for target' do
+      let(:project) { create(:project) }
+      let(:note1) { create :note_on_commit, project: project }
+      let(:note2) { create :note_on_commit, project: project }
+      let(:commit) { note1.noteable }
+      let(:params)  { { target_id: commit.id, target_type: 'commit', last_fetched_at: 1.hour.ago.to_i } }
+
+      before do
+        note1
+        note2
+      end
+
+      it 'finds all notes' do
+        notes = described_class.new(project, user, params).execute
+        expect(notes.size).to eq(2)
+      end
+
+      it 'finds notes on merge requests' do
+        note = create(:note_on_merge_request, project: project)
+        params = { target_type: 'merge_request', target_id: note.noteable.id }
+
+        notes = described_class.new(project, user, params).execute
+
+        expect(notes).to include(note)
+      end
+
+      it 'finds notes on snippets' do
+        note = create(:note_on_project_snippet, project: project)
+        params = { target_type: 'snippet', target_id: note.noteable.id }
 
-      let(:params) { { target_id: confidential_issue.id, target_type: 'issue', last_fetched_at: 1.hour.ago.to_i } }
+        notes = described_class.new(project, user, params).execute
 
-      it 'returns notes if user can see the issue' do
-        expect(NotesFinder.new.execute(project, user, params)).to eq([confidential_note])
+        expect(notes.count).to eq(1)
       end
 
-      it 'raises an error if user can not see the issue' do
+      it 'raises an exception for an invalid target_type' do
+        params.merge!(target_type: 'invalid')
+        expect { described_class.new(project, user, params).execute }.to raise_error('invalid target_type')
+      end
+
+      it 'filters out old notes' do
+        note2.update_attribute(:updated_at, 2.hours.ago)
+        notes = described_class.new(project, user, params).execute
+        expect(notes).to eq([note1])
+      end
+
+      context 'confidential issue notes' do
+        let(:confidential_issue) { create(:issue, :confidential, project: project, author: user) }
+        let!(:confidential_note) { create(:note, noteable: confidential_issue, project: confidential_issue.project) }
+
+        let(:params) { { target_id: confidential_issue.id, target_type: 'issue', last_fetched_at: 1.hour.ago.to_i } }
+
+        it 'returns notes if user can see the issue' do
+          expect(described_class.new(project, user, params).execute).to eq([confidential_note])
+        end
+
+        it 'raises an error if user can not see the issue' do
+          user = create(:user)
+          expect { described_class.new(project, user, params).execute }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+
+        it 'raises an error for project members with guest role' do
+          user = create(:user)
+          project.team << [user, :guest]
+
+          expect { described_class.new(project, user, params).execute }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
+    end
+  end
+
+  describe '.search' do
+    let(:project) { create(:empty_project, :public) }
+    let(:note) { create(:note_on_issue, note: 'WoW', project: project) }
+
+    it 'returns notes with matching content' do
+      expect(described_class.new(note.project, nil, search: note.note).execute).to eq([note])
+    end
+
+    it 'returns notes with matching content regardless of the casing' do
+      expect(described_class.new(note.project, nil, search: 'WOW').execute).to eq([note])
+    end
+
+    it 'returns commit notes user can access' do
+      note = create(:note_on_commit, project: project)
+
+      expect(described_class.new(note.project, create(:user), search: note.note).execute).to eq([note])
+    end
+
+    context "confidential issues" do
+      let(:user) { create(:user) }
+      let(:confidential_issue) { create(:issue, :confidential, project: project, author: user) }
+      let(:confidential_note) { create(:note, note: "Random", noteable: confidential_issue, project: confidential_issue.project) }
+
+      it "returns notes with matching content if user can see the issue" do
+        expect(described_class.new(confidential_note.project, user, search: confidential_note.note).execute).to eq([confidential_note])
+      end
+
+      it "does not return notes with matching content if user can not see the issue" do
         user = create(:user)
-        expect { NotesFinder.new.execute(project, user, params) }.to raise_error(ActiveRecord::RecordNotFound)
+        expect(described_class.new(confidential_note.project, user, search: confidential_note.note).execute).to be_empty
       end
 
-      it 'raises an error for project members with guest role' do
+      it "does not return notes with matching content for project members with guest role" do
         user = create(:user)
         project.team << [user, :guest]
+        expect(described_class.new(confidential_note.project, user, search: confidential_note.note).execute).to be_empty
+      end
+
+      it "does not return notes with matching content for unauthenticated users" do
+        expect(described_class.new(confidential_note.project, nil, search: confidential_note.note).execute).to be_empty
+      end
+    end
+
+    context 'inlines SQL filters on subqueries for performance' do
+      let(:sql) { described_class.new(note.project, nil, search: note.note).execute.to_sql }
+      let(:number_of_noteable_types) { 4 }
+
+      specify 'project_id check' do
+        expect(sql.scan(/project_id/).count).to be >= (number_of_noteable_types + 2)
+      end
 
-        expect { NotesFinder.new.execute(project, user, params) }.to raise_error(ActiveRecord::RecordNotFound)
+      specify 'search filter' do
+        expect(sql.scan(/LIKE/).count).to be >= number_of_noteable_types
       end
     end
   end
diff --git a/spec/helpers/application_helper_spec.rb b/spec/helpers/application_helper_spec.rb
index 15863d444f8..92053e5a7c6 100644
--- a/spec/helpers/application_helper_spec.rb
+++ b/spec/helpers/application_helper_spec.rb
@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe ApplicationHelper do
+  include UploadHelpers
+
   describe 'current_controller?' do
     it 'returns true when controller matches argument' do
       stub_controller_name('foo')
@@ -52,10 +54,8 @@ describe ApplicationHelper do
   end
 
   describe 'project_icon' do
-    let(:avatar_file_path) { File.join(Rails.root, 'spec', 'fixtures', 'banana_sample.gif') }
-
     it 'returns an url for the avatar' do
-      project = create(:project, avatar: File.open(avatar_file_path))
+      project = create(:project, avatar: File.open(uploaded_image_temp_path))
 
       avatar_url = "http://#{Gitlab.config.gitlab.host}/uploads/project/avatar/#{project.id}/banana_sample.gif"
       expect(helper.project_icon("#{project.namespace.to_param}/#{project.to_param}").to_s).
@@ -74,10 +74,8 @@ describe ApplicationHelper do
   end
 
   describe 'avatar_icon' do
-    let(:avatar_file_path) { File.join(Rails.root, 'spec', 'fixtures', 'banana_sample.gif') }
-
     it 'returns an url for the avatar' do
-      user = create(:user, avatar: File.open(avatar_file_path))
+      user = create(:user, avatar: File.open(uploaded_image_temp_path))
 
       expect(helper.avatar_icon(user.email).to_s).
         to match("/uploads/user/avatar/#{user.id}/banana_sample.gif")
@@ -88,7 +86,7 @@ describe ApplicationHelper do
       # Must be stubbed after the stub above, and separately
       stub_config_setting(url: Settings.send(:build_gitlab_url))
 
-      user = create(:user, avatar: File.open(avatar_file_path))
+      user = create(:user, avatar: File.open(uploaded_image_temp_path))
 
       expect(helper.avatar_icon(user.email).to_s).
         to match("/gitlab/uploads/user/avatar/#{user.id}/banana_sample.gif")
@@ -102,7 +100,7 @@ describe ApplicationHelper do
 
     describe 'using a User' do
       it 'returns an URL for the avatar' do
-        user = create(:user, avatar: File.open(avatar_file_path))
+        user = create(:user, avatar: File.open(uploaded_image_temp_path))
 
         expect(helper.avatar_icon(user).to_s).
           to match("/uploads/user/avatar/#{user.id}/banana_sample.gif")
diff --git a/spec/javascripts/abuse_reports_spec.js.es6 b/spec/javascripts/abuse_reports_spec.js.es6
index 9e94c9d1d74..49e56249565 100644
--- a/spec/javascripts/abuse_reports_spec.js.es6
+++ b/spec/javascripts/abuse_reports_spec.js.es6
@@ -1,42 +1,44 @@
-/* eslint-disable space-before-function-paren, no-new, padded-blocks */
-
+/*= require lib/utils/text_utility */
 /*= require abuse_reports */
-/*= require jquery */
 
 ((global) => {
-  const FIXTURE = 'abuse_reports.html';
-  const MAX_MESSAGE_LENGTH = 500;
+  describe('Abuse Reports', () => {
+    const FIXTURE = 'abuse_reports/abuse_reports_list.html.raw';
+    const MAX_MESSAGE_LENGTH = 500;
+
+    let messages;
 
-  function assertMaxLength($message) {
-    expect($message.text().length).toEqual(MAX_MESSAGE_LENGTH);
-  }
+    const assertMaxLength = $message => expect($message.text().length).toEqual(MAX_MESSAGE_LENGTH);
+    const findMessage = searchText => messages.filter(
+      (index, element) => element.innerText.indexOf(searchText) > -1,
+    ).first();
 
-  describe('Abuse Reports', function() {
     fixture.preload(FIXTURE);
 
-    beforeEach(function() {
+    beforeEach(function () {
       fixture.load(FIXTURE);
-      new global.AbuseReports();
+      this.abuseReports = new global.AbuseReports();
+      messages = $('.abuse-reports .message');
     });
 
-    it('should truncate long messages', function() {
-      const $longMessage = $('#long');
+
+    it('should truncate long messages', () => {
+      const $longMessage = findMessage('LONG MESSAGE');
       expect($longMessage.data('original-message')).toEqual(jasmine.anything());
       assertMaxLength($longMessage);
     });
 
-    it('should not truncate short messages', function() {
-      const $shortMessage = $('#short');
+    it('should not truncate short messages', () => {
+      const $shortMessage = findMessage('SHORT MESSAGE');
       expect($shortMessage.data('original-message')).not.toEqual(jasmine.anything());
     });
 
-    it('should allow clicking a truncated message to expand and collapse the full message', function() {
-      const $longMessage = $('#long');
+    it('should allow clicking a truncated message to expand and collapse the full message', () => {
+      const $longMessage = findMessage('LONG MESSAGE');
       $longMessage.click();
       expect($longMessage.data('original-message').length).toEqual($longMessage.text().length);
       $longMessage.click();
       assertMaxLength($longMessage);
     });
   });
-
 })(window.gl);
diff --git a/spec/javascripts/extensions/object_spec.js.es6 b/spec/javascripts/extensions/object_spec.js.es6
new file mode 100644
index 00000000000..3b71c255b30
--- /dev/null
+++ b/spec/javascripts/extensions/object_spec.js.es6
@@ -0,0 +1,25 @@
+/*= require extensions/object */
+
+describe('Object extensions', () => {
+  describe('assign', () => {
+    it('merges source object into target object', () => {
+      const targetObj = {};
+      const sourceObj = {
+        foo: 'bar',
+      };
+      Object.assign(targetObj, sourceObj);
+      expect(targetObj.foo).toBe('bar');
+    });
+
+    it('merges object with the same properties', () => {
+      const targetObj = {
+        foo: 'bar',
+      };
+      const sourceObj = {
+        foo: 'baz',
+      };
+      Object.assign(targetObj, sourceObj);
+      expect(targetObj.foo).toBe('baz');
+    });
+  });
+});
diff --git a/spec/javascripts/fixtures/abuse_reports.html.haml b/spec/javascripts/fixtures/abuse_reports.html.haml
deleted file mode 100644
index 2ec302abcb7..00000000000
--- a/spec/javascripts/fixtures/abuse_reports.html.haml
+++ /dev/null
@@ -1,16 +0,0 @@
-.abuse-reports
-  .message#long
-    Cat ipsum dolor sit amet, hide head under blanket so no one can see.
-    Gate keepers of hell eat and than sleep on your face but hunt by meowing
-    loudly at 5am next to human slave food dispenser cats go for world
-    domination or chase laser, yet poop on grasses chirp at birds. Cat is love,
-    cat is life chase after silly colored fish toys around the house climb a
-    tree, wait for a fireman jump to fireman then scratch his face fall asleep
-    on the washing machine lies down always hungry so caticus cuteicus. Sit on
-    human. Spot something, big eyes, big eyes, crouch, shake butt, prepare to
-    pounce sleep in the bathroom sink hiss at vacuum cleaner hide head under
-    blanket so no one can see throwup on your pillow.
-  .message#short
-    Cat ipsum dolor sit amet, groom yourself 4 hours - checked, have your
-    beauty sleep 18 hours - checked, be fabulous for the rest of the day -
-    checked! for shake treat bag.
diff --git a/spec/javascripts/fixtures/abuse_reports.rb b/spec/javascripts/fixtures/abuse_reports.rb
new file mode 100644
index 00000000000..de673f94d72
--- /dev/null
+++ b/spec/javascripts/fixtures/abuse_reports.rb
@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Admin::AbuseReportsController, '(JavaScript fixtures)', type: :controller do
+  include JavaScriptFixturesHelpers
+
+  let(:admin) { create(:admin) }
+  let!(:abuse_report) { create(:abuse_report) }
+  let!(:abuse_report_with_short_message) { create(:abuse_report, message: 'SHORT MESSAGE') }
+  let!(:abuse_report_with_long_message) { create(:abuse_report, message: "LONG MESSAGE\n" * 50) }
+
+  render_views
+
+  before(:all) do
+    clean_frontend_fixtures('abuse_reports/')
+  end
+
+  before(:each) do
+    sign_in(admin)
+  end
+
+  it 'abuse_reports/abuse_reports_list.html.raw' do |example|
+    get :index
+
+    expect(response).to be_success
+    store_frontend_fixture(response, example.description)
+  end
+end
diff --git a/spec/lib/banzai/filter/math_filter_spec.rb b/spec/lib/banzai/filter/math_filter_spec.rb
new file mode 100644
index 00000000000..3fe2c7f5d5d
--- /dev/null
+++ b/spec/lib/banzai/filter/math_filter_spec.rb
@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe Banzai::Filter::MathFilter, lib: true do
+  include FilterSpecHelper
+
+  it 'leaves regular inline code unchanged' do
+    input = "<code>2+2</code>"
+    doc = filter(input)
+
+    expect(doc.to_s).to eq input
+  end
+
+  it 'removes surrounding dollar signs and adds class code, math and js-render-math' do
+    doc = filter("$<code>2+2</code>$")
+
+    expect(doc.to_s).to eq '<code class="code math js-render-math" data-math-style="inline">2+2</code>'
+  end
+
+  it 'only removes surrounding dollar signs' do
+    doc = filter("test $<code>2+2</code>$ test")
+    before = doc.xpath('descendant-or-self::text()[1]').first
+    after = doc.xpath('descendant-or-self::text()[3]').first
+
+    expect(before.to_s).to eq 'test '
+    expect(after.to_s).to eq ' test'
+  end
+
+  it 'only removes surrounding single dollar sign' do
+    doc = filter("test $$<code>2+2</code>$$ test")
+    before = doc.xpath('descendant-or-self::text()[1]').first
+    after = doc.xpath('descendant-or-self::text()[3]').first
+
+    expect(before.to_s).to eq 'test $'
+    expect(after.to_s).to eq '$ test'
+  end
+
+  it 'adds data-math-style inline attribute to inline math' do
+    doc = filter('$<code>2+2</code>$')
+    code = doc.xpath('descendant-or-self::code').first
+
+    expect(code['data-math-style']).to eq 'inline'
+  end
+
+  it 'adds class code and math to inline math' do
+    doc = filter('$<code>2+2</code>$')
+    code = doc.xpath('descendant-or-self::code').first
+
+    expect(code[:class]).to include("code")
+    expect(code[:class]).to include("math")
+  end
+
+  it 'adds js-render-math class to inline math' do
+    doc = filter('$<code>2+2</code>$')
+    code = doc.xpath('descendant-or-self::code').first
+
+    expect(code[:class]).to include("js-render-math")
+  end
+
+  # Cases with faulty syntax. Should be a no-op
+
+  it 'ignores cases with missing dolar sign at the end' do
+    input = "test $<code>2+2</code> test"
+    doc = filter(input)
+
+    expect(doc.to_s).to eq input
+  end
+
+  it 'ignores cases with missing dolar sign at the beginning' do
+    input = "test <code>2+2</code>$ test"
+    doc = filter(input)
+
+    expect(doc.to_s).to eq input
+  end
+
+  it 'ignores dollar signs if it is not adjacent' do
+    input = '<p>We check strictly $<code>2+2</code> and  <code>2+2</code>$ </p>'
+    doc = filter(input)
+
+    expect(doc.to_s).to eq input
+  end
+
+  # Display math
+
+  it 'adds data-math-style display attribute to display math' do
+    doc = filter('<pre class="code highlight js-syntax-highlight math" v-pre="true"><code>2+2</code></pre>')
+    pre = doc.xpath('descendant-or-self::pre').first
+
+    expect(pre['data-math-style']).to eq 'display'
+  end
+
+  it 'adds js-render-math class to display math' do
+    doc = filter('<pre class="code highlight js-syntax-highlight math" v-pre="true"><code>2+2</code></pre>')
+    pre = doc.xpath('descendant-or-self::pre').first
+
+    expect(pre[:class]).to include("js-render-math")
+  end
+
+  it 'ignores code blocks that are not math' do
+    input = '<pre class="code highlight js-syntax-highlight plaintext" v-pre="true"><code>2+2</code></pre>'
+    doc = filter(input)
+
+    expect(doc.to_s).to eq input
+  end
+
+  it 'requires the pre to contain both code and math' do
+    input = '<pre class="highlight js-syntax-highlight plaintext math" v-pre="true"><code>2+2</code></pre>'
+    doc = filter(input)
+
+    expect(doc.to_s).to eq input
+  end
+
+  it 'dollar signs around to display math' do
+    doc = filter('$<pre class="code highlight js-syntax-highlight math" v-pre="true"><code>2+2</code></pre>$')
+    before = doc.xpath('descendant-or-self::text()[1]').first
+    after = doc.xpath('descendant-or-self::text()[3]').first
+
+    expect(before.to_s).to eq '$'
+    expect(after.to_s).to eq '$'
+  end
+end
diff --git a/spec/lib/gitlab/asciidoc_spec.rb b/spec/lib/gitlab/asciidoc_spec.rb
index 4aba783dc33..f3843ca64ff 100644
--- a/spec/lib/gitlab/asciidoc_spec.rb
+++ b/spec/lib/gitlab/asciidoc_spec.rb
@@ -11,7 +11,7 @@ module Gitlab
       it "converts the input using Asciidoctor and default options" do
         expected_asciidoc_opts = {
             safe: :secure,
-            backend: :html5,
+            backend: :gitlab_html5,
             attributes: described_class::DEFAULT_ADOC_ATTRS
         }
 
@@ -27,7 +27,7 @@ module Gitlab
         it "merges the options with default ones" do
           expected_asciidoc_opts = {
               safe: :safe,
-              backend: :html5,
+              backend: :gitlab_html5,
               attributes: described_class::DEFAULT_ADOC_ATTRS + ['foo']
           }
 
diff --git a/spec/lib/gitlab/badge/build/status_spec.rb b/spec/lib/gitlab/badge/build/status_spec.rb
index 38eebb2a176..70f03021d36 100644
--- a/spec/lib/gitlab/badge/build/status_spec.rb
+++ b/spec/lib/gitlab/badge/build/status_spec.rb
@@ -69,8 +69,8 @@ describe Gitlab::Badge::Build::Status do
         new_build.success!
       end
 
-      it 'reports the compound status' do
-        expect(badge.status).to eq 'failed'
+      it 'does not take outdated pipeline into account' do
+        expect(badge.status).to eq 'success'
       end
     end
   end
diff --git a/spec/lib/gitlab/import_export/all_models.yml b/spec/lib/gitlab/import_export/all_models.yml
index c4ee838b7c9..9b49d6837c3 100644
--- a/spec/lib/gitlab/import_export/all_models.yml
+++ b/spec/lib/gitlab/import_export/all_models.yml
@@ -136,7 +136,8 @@ project:
 - assembla_service
 - asana_service
 - gemnasium_service
-- slack_service
+- slack_notification_service
+- mattermost_notification_service
 - buildkite_service
 - bamboo_service
 - teamcity_service
diff --git a/spec/lib/gitlab/import_export/avatar_restorer_spec.rb b/spec/lib/gitlab/import_export/avatar_restorer_spec.rb
index 5ae178414cc..08a42fd27a2 100644
--- a/spec/lib/gitlab/import_export/avatar_restorer_spec.rb
+++ b/spec/lib/gitlab/import_export/avatar_restorer_spec.rb
@@ -1,12 +1,14 @@
 require 'spec_helper'
 
 describe Gitlab::ImportExport::AvatarRestorer, lib: true do
+  include UploadHelpers
+
   let(:shared) { Gitlab::ImportExport::Shared.new(relative_path: 'test') }
   let(:project) { create(:empty_project) }
 
   before do
     allow_any_instance_of(described_class).to receive(:avatar_export_file)
-                                                .and_return(Rails.root + "spec/fixtures/dk.png")
+                                                .and_return(uploaded_image_temp_path)
   end
 
   after do
diff --git a/spec/lib/gitlab/middleware/multipart_spec.rb b/spec/lib/gitlab/middleware/multipart_spec.rb
new file mode 100644
index 00000000000..ab1ab22795c
--- /dev/null
+++ b/spec/lib/gitlab/middleware/multipart_spec.rb
@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+require 'tempfile'
+
+describe Gitlab::Middleware::Multipart do
+  let(:app) { double(:app) }
+  let(:middleware) { described_class.new(app) }
+
+  it 'opens top-level files' do
+    Tempfile.open('top-level') do |tempfile|
+      env = post_env({ 'file' => tempfile.path }, { 'file.name' => 'filename' }, Gitlab::Workhorse.secret, 'gitlab-workhorse')
+
+      expect(app).to receive(:call) do |env|
+        file = Rack::Request.new(env).params['file']
+        expect(file).to be_a(File)
+        expect(file.path).to eq(tempfile.path)
+      end
+
+      middleware.call(env)
+    end
+  end
+
+  it 'rejects headers signed with the wrong secret' do
+    env = post_env({ 'file' => '/var/empty/nonesuch' }, {}, 'x' * 32, 'gitlab-workhorse')
+
+    expect { middleware.call(env) }.to raise_error(JWT::VerificationError)
+  end
+
+  it 'rejects headers signed with the wrong issuer' do
+    env = post_env({ 'file' => '/var/empty/nonesuch' }, {}, Gitlab::Workhorse.secret, 'acme-inc')
+
+    expect { middleware.call(env) }.to raise_error(JWT::InvalidIssuerError)
+  end
+
+  it 'opens files one level deep' do
+    Tempfile.open('one-level') do |tempfile|
+      in_params = { 'user' => { 'avatar' => { '.name' => 'filename' } } }
+      env = post_env({ 'user[avatar]' => tempfile.path }, in_params, Gitlab::Workhorse.secret, 'gitlab-workhorse')
+
+      expect(app).to receive(:call) do |env|
+        file = Rack::Request.new(env).params['user']['avatar']
+        expect(file).to be_a(File)
+        expect(file.path).to eq(tempfile.path)
+      end
+
+      middleware.call(env)
+    end
+  end
+
+  it 'opens files two levels deep' do
+    Tempfile.open('two-levels') do |tempfile|
+      in_params = { 'project' => { 'milestone' => { 'themesong' => { '.name' => 'filename' } } } }
+      env = post_env({ 'project[milestone][themesong]' => tempfile.path }, in_params, Gitlab::Workhorse.secret, 'gitlab-workhorse')
+
+      expect(app).to receive(:call) do |env|
+        file = Rack::Request.new(env).params['project']['milestone']['themesong']
+        expect(file).to be_a(File)
+        expect(file.path).to eq(tempfile.path)
+      end
+
+      middleware.call(env)
+    end
+  end
+
+  def post_env(rewritten_fields, params, secret, issuer)
+    token = JWT.encode({ 'iss' => issuer, 'rewritten_fields' => rewritten_fields }, secret, 'HS256')
+    Rack::MockRequest.env_for(
+      '/',
+      method: 'post',
+      params: params,
+      described_class::RACK_ENV_KEY => token
+    )
+  end
+end
diff --git a/spec/lib/gitlab/project_search_results_spec.rb b/spec/lib/gitlab/project_search_results_spec.rb
index 3cd9863ec6a..14ee386dba6 100644
--- a/spec/lib/gitlab/project_search_results_spec.rb
+++ b/spec/lib/gitlab/project_search_results_spec.rb
@@ -149,4 +149,33 @@ describe Gitlab::ProjectSearchResults, lib: true do
       expect(results.issues_count).to eq 3
     end
   end
+
+  describe 'notes search' do
+    it 'lists notes' do
+      project = create(:empty_project, :public)
+      note = create(:note, project: project)
+
+      results = described_class.new(user, project, note.note)
+
+      expect(results.objects('notes')).to include note
+    end
+
+    it "doesn't list issue notes when access is restricted" do
+      project = create(:empty_project, :public, issues_access_level: ProjectFeature::PRIVATE)
+      note = create(:note_on_issue, project: project)
+
+      results = described_class.new(user, project, note.note)
+
+      expect(results.objects('notes')).not_to include note
+    end
+
+    it "doesn't list merge_request notes when access is restricted" do
+      project = create(:empty_project, :public, merge_requests_access_level: ProjectFeature::PRIVATE)
+      note = create(:note_on_merge_request, project: project)
+
+      results = described_class.new(user, project, note.note)
+
+      expect(results.objects('notes')).not_to include note
+    end
+  end
 end
diff --git a/spec/lib/gitlab/regex_spec.rb b/spec/lib/gitlab/regex_spec.rb
index c51b10bdc69..c78cd30157e 100644
--- a/spec/lib/gitlab/regex_spec.rb
+++ b/spec/lib/gitlab/regex_spec.rb
@@ -29,4 +29,20 @@ describe Gitlab::Regex, lib: true do
   describe 'file path regex' do
     it { expect('foo@/bar').to match(Gitlab::Regex.file_path_regex) }
   end
+
+  describe 'environment slug regex' do
+    def be_matched
+      match(Gitlab::Regex.environment_slug_regex)
+    end
+
+    it { expect('foo').to be_matched }
+    it { expect('foo-1').to be_matched }
+
+    it { expect('FOO').not_to be_matched }
+    it { expect('foo/1').not_to be_matched }
+    it { expect('foo.1').not_to be_matched }
+    it { expect('foo*1').not_to be_matched }
+    it { expect('9foo').not_to be_matched }
+    it { expect('foo-').not_to be_matched }
+  end
 end
diff --git a/spec/lib/gitlab/sql/union_spec.rb b/spec/lib/gitlab/sql/union_spec.rb
index 0cdbab87544..849edb09476 100644
--- a/spec/lib/gitlab/sql/union_spec.rb
+++ b/spec/lib/gitlab/sql/union_spec.rb
@@ -1,16 +1,26 @@
 require 'spec_helper'
 
 describe Gitlab::SQL::Union, lib: true do
+  let(:relation_1) { User.where(email: 'alice@example.com').select(:id) }
+  let(:relation_2) { User.where(email: 'bob@example.com').select(:id) }
+
+  def to_sql(relation)
+    relation.reorder(nil).to_sql
+  end
+
   describe '#to_sql' do
     it 'returns a String joining relations together using a UNION' do
-      rel1  = User.where(email: 'alice@example.com')
-      rel2  = User.where(email: 'bob@example.com')
-      union = described_class.new([rel1, rel2])
+      union = described_class.new([relation_1, relation_2])
+
+      expect(union.to_sql).to eq("#{to_sql(relation_1)}\nUNION\n#{to_sql(relation_2)}")
+    end
 
-      sql1 = rel1.reorder(nil).to_sql
-      sql2 = rel2.reorder(nil).to_sql
+    it 'skips Model.none segements' do
+      empty_relation = User.none
+      union = described_class.new([empty_relation, relation_1, relation_2])
 
-      expect(union.to_sql).to eq("#{sql1}\nUNION\n#{sql2}")
+      expect{User.where("users.id IN (#{union.to_sql})").to_a}.not_to raise_error
+      expect(union.to_sql).to eq("#{to_sql(relation_1)}\nUNION\n#{to_sql(relation_2)}")
     end
   end
 end
diff --git a/spec/models/build_spec.rb b/spec/models/build_spec.rb
index ea60c17a58a..d5f2ffcff59 100644
--- a/spec/models/build_spec.rb
+++ b/spec/models/build_spec.rb
@@ -87,6 +87,26 @@ describe Ci::Build, models: true do
     end
   end
 
+  describe '#persisted_environment' do
+    before do
+      @environment = create(:environment, project: project, name: "foo-#{project.default_branch}")
+    end
+
+    subject { build.persisted_environment }
+
+    context 'referenced literally' do
+      let(:build) { create(:ci_build, pipeline: pipeline, environment: "foo-#{project.default_branch}") }
+
+      it { is_expected.to eq(@environment) }
+    end
+
+    context 'referenced with a variable' do
+      let(:build) { create(:ci_build, pipeline: pipeline, environment: "foo-$CI_BUILD_REF_NAME") }
+
+      it { is_expected.to eq(@environment) }
+    end
+  end
+
   describe '#trace' do
     it { expect(build.trace).to be_nil }
 
@@ -328,6 +348,22 @@ describe Ci::Build, models: true do
       it { user_variables.each { |v| is_expected.to include(v) } }
     end
 
+    context 'when build has an environment' do
+      before do
+        build.update(environment: 'production')
+        create(:environment, project: build.project, name: 'production', slug: 'prod-slug')
+      end
+
+      let(:environment_variables) do
+        [
+          { key: 'CI_ENVIRONMENT_NAME', value: 'production', public: true },
+          { key: 'CI_ENVIRONMENT_SLUG', value: 'prod-slug',  public: true }
+        ]
+      end
+
+      it { environment_variables.each { |v| is_expected.to include(v) } }
+    end
+
     context 'when build started manually' do
       before do
         build.update_attributes(when: :manual)
diff --git a/spec/models/ci/pipeline_spec.rb b/spec/models/ci/pipeline_spec.rb
index e78ae14b737..52dd41065e9 100644
--- a/spec/models/ci/pipeline_spec.rb
+++ b/spec/models/ci/pipeline_spec.rb
@@ -381,6 +381,65 @@ describe Ci::Pipeline, models: true do
     end
   end
 
+  shared_context 'with some outdated pipelines' do
+    before do
+      create_pipeline(:canceled, 'ref', 'A')
+      create_pipeline(:success, 'ref', 'A')
+      create_pipeline(:failed, 'ref', 'B')
+      create_pipeline(:skipped, 'feature', 'C')
+    end
+
+    def create_pipeline(status, ref, sha)
+      create(:ci_empty_pipeline, status: status, ref: ref, sha: sha)
+    end
+  end
+
+  describe '.latest' do
+    include_context 'with some outdated pipelines'
+
+    context 'when no ref is specified' do
+      let(:pipelines) { described_class.latest.all }
+
+      it 'returns the latest pipeline for the same ref and different sha' do
+        expect(pipelines.map(&:sha)).to contain_exactly('A', 'B', 'C')
+        expect(pipelines.map(&:status)).
+          to contain_exactly('success', 'failed', 'skipped')
+      end
+    end
+
+    context 'when ref is specified' do
+      let(:pipelines) { described_class.latest('ref').all }
+
+      it 'returns the latest pipeline for ref and different sha' do
+        expect(pipelines.map(&:sha)).to contain_exactly('A', 'B')
+        expect(pipelines.map(&:status)).
+          to contain_exactly('success', 'failed')
+      end
+    end
+  end
+
+  describe '.latest_status' do
+    include_context 'with some outdated pipelines'
+
+    context 'when no ref is specified' do
+      let(:latest_status) { described_class.latest_status }
+
+      it 'returns the latest status for the same ref and different sha' do
+        expect(latest_status).to eq(described_class.latest.status)
+        expect(latest_status).to eq('failed')
+      end
+    end
+
+    context 'when ref is specified' do
+      let(:latest_status) { described_class.latest_status('ref') }
+
+      it 'returns the latest status for ref and different sha' do
+        expect(latest_status).to eq(described_class.latest_status('ref'))
+        expect(latest_status).to eq('failed')
+      end
+    end
+  end
+
   describe '#status' do
     let!(:build) { create(:ci_build, :created, pipeline: pipeline, name: 'test') }
 
diff --git a/spec/models/commit_spec.rb b/spec/models/commit_spec.rb
index 0935fc0561c..74b50d2908d 100644
--- a/spec/models/commit_spec.rb
+++ b/spec/models/commit_spec.rb
@@ -213,23 +213,19 @@ eos
   end
 
   describe '#status' do
-    context 'without arguments for compound status' do
-      shared_examples 'giving the status from pipeline' do
-        it do
-          expect(commit.status).to eq(Ci::Pipeline.status)
-        end
-      end
-
-      context 'with pipelines' do
-        let!(:pipeline) do
-          create(:ci_empty_pipeline, project: project, sha: commit.sha)
+    context 'without ref argument' do
+      before do
+        %w[success failed created pending].each do |status|
+          create(:ci_empty_pipeline,
+                 project: project,
+                 sha: commit.sha,
+                 status: status)
         end
-
-        it_behaves_like 'giving the status from pipeline'
       end
 
-      context 'without pipelines' do
-        it_behaves_like 'giving the status from pipeline'
+      it 'gives compound status from latest pipelines' do
+        expect(commit.status).to eq(Ci::Pipeline.latest_status)
+        expect(commit.status).to eq('pending')
       end
     end
 
@@ -255,8 +251,9 @@ eos
         expect(commit.status('fix')).to eq(pipeline_from_fix.status)
       end
 
-      it 'gives compound status if ref is nil' do
-        expect(commit.status(nil)).to eq(commit.status)
+      it 'gives compound status from latest pipelines if ref is nil' do
+        expect(commit.status(nil)).to eq(Ci::Pipeline.latest_status)
+        expect(commit.status(nil)).to eq('failed')
       end
     end
   end
diff --git a/spec/models/environment_spec.rb b/spec/models/environment_spec.rb
index c8170164898..97cbb093ed2 100644
--- a/spec/models/environment_spec.rb
+++ b/spec/models/environment_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Environment, models: true do
-  let(:environment) { create(:environment) }
+  subject(:environment) { create(:environment) }
 
   it { is_expected.to belong_to(:project) }
   it { is_expected.to have_many(:deployments) }
@@ -15,15 +15,11 @@ describe Environment, models: true do
   it { is_expected.to validate_uniqueness_of(:name).scoped_to(:project_id) }
   it { is_expected.to validate_length_of(:name).is_at_most(255) }
 
-  it { is_expected.to validate_length_of(:external_url).is_at_most(255) }
-
-  # To circumvent a not null violation of the name column:
-  # https://github.com/thoughtbot/shoulda-matchers/issues/336
-  it 'validates uniqueness of :external_url' do
-    create(:environment)
+  it { is_expected.to validate_uniqueness_of(:slug).scoped_to(:project_id) }
+  it { is_expected.to validate_length_of(:slug).is_at_most(24) }
 
-    is_expected.to validate_uniqueness_of(:external_url).scoped_to(:project_id)
-  end
+  it { is_expected.to validate_length_of(:external_url).is_at_most(255) }
+  it { is_expected.to validate_uniqueness_of(:external_url).scoped_to(:project_id) }
 
   describe '#nullify_external_url' do
     it 'replaces a blank url with nil' do
@@ -199,4 +195,38 @@ describe Environment, models: true do
       expect(environment.actions_for('review/master')).to contain_exactly(review_action)
     end
   end
+
+  describe '#slug' do
+    it "is automatically generated" do
+      expect(environment.slug).not_to be_nil
+    end
+
+    it "is not regenerated if name changes" do
+      original_slug = environment.slug
+      environment.update_attributes!(name: environment.name.reverse)
+
+      expect(environment.slug).to eq(original_slug)
+    end
+  end
+
+  describe '#generate_slug' do
+    SUFFIX = "-[a-z0-9]{6}"
+    {
+      "staging-12345678901234567" => "staging-123456789" + SUFFIX,
+      "9-staging-123456789012345" => "env-9-staging-123" + SUFFIX,
+      "staging-1234567890123456"  => "staging-1234567890123456",
+      "production"                => "production",
+      "PRODUCTION"                => "production" + SUFFIX,
+      "review/1-foo"              => "review-1-foo" + SUFFIX,
+      "1-foo"                     => "env-1-foo" + SUFFIX,
+      "1/foo"                     => "env-1-foo" + SUFFIX,
+      "foo-"                      => "foo" + SUFFIX,
+    }.each do |name, matcher|
+      it "returns a slug matching #{matcher}, given #{name}" do
+        slug = described_class.new(name: name).generate_slug
+
+        expect(slug).to match(/\A#{matcher}\z/)
+      end
+    end
+  end
 end
diff --git a/spec/models/group_spec.rb b/spec/models/group_spec.rb
index 893c6827a91..7d5ecfbaa64 100644
--- a/spec/models/group_spec.rb
+++ b/spec/models/group_spec.rb
@@ -272,7 +272,7 @@ describe Group, models: true do
   end
 
   describe 'nested group' do
-    subject { create(:group, :nested) }
+    subject { build(:group, :nested) }
 
     it { is_expected.to be_valid }
     it { expect(subject.parent).to be_kind_of(Group) }
diff --git a/spec/models/issue_spec.rb b/spec/models/issue_spec.rb
index 24e216329a9..bb56e44db29 100644
--- a/spec/models/issue_spec.rb
+++ b/spec/models/issue_spec.rb
@@ -22,26 +22,6 @@ describe Issue, models: true do
     it { is_expected.to have_db_index(:deleted_at) }
   end
 
-  describe '.visible_to_user' do
-    let(:user) { create(:user) }
-    let(:authorized_user) { create(:user) }
-    let(:project) { create(:project, namespace: authorized_user.namespace) }
-    let!(:public_issue) { create(:issue, project: project) }
-    let!(:confidential_issue) { create(:issue, project: project, confidential: true) }
-
-    it 'returns non confidential issues for nil user' do
-      expect(Issue.visible_to_user(nil).count).to be(1)
-    end
-
-    it 'returns non confidential issues for user not authorized for the issues projects' do
-      expect(Issue.visible_to_user(user).count).to be(1)
-    end
-
-    it 'returns all issues for user authorized for the issues projects' do
-      expect(Issue.visible_to_user(authorized_user).count).to be(2)
-    end
-  end
-
   describe '#to_reference' do
     let(:project) { build(:empty_project, name: 'sample-project') }
     let(:issue) { build(:issue, iid: 1, project: project) }
diff --git a/spec/models/merge_request_spec.rb b/spec/models/merge_request_spec.rb
index 8b730be91fd..1b71d00eb8f 100644
--- a/spec/models/merge_request_spec.rb
+++ b/spec/models/merge_request_spec.rb
@@ -205,7 +205,7 @@ describe MergeRequest, models: true do
     end
   end
 
-  describe "#mr_and_commit_notes" do
+  describe "#related_notes" do
     let!(:merge_request) { create(:merge_request) }
 
     before do
@@ -217,7 +217,7 @@ describe MergeRequest, models: true do
 
     it "includes notes for commits" do
       expect(merge_request.commits).not_to be_empty
-      expect(merge_request.mr_and_commit_notes.count).to eq(2)
+      expect(merge_request.related_notes.count).to eq(2)
     end
 
     it "includes notes for commits from target project as well" do
@@ -225,7 +225,7 @@ describe MergeRequest, models: true do
                               project: merge_request.target_project)
 
       expect(merge_request.commits).not_to be_empty
-      expect(merge_request.mr_and_commit_notes.count).to eq(3)
+      expect(merge_request.related_notes.count).to eq(3)
     end
   end
 
diff --git a/spec/models/milestone_spec.rb b/spec/models/milestone_spec.rb
index 0cc2efae5f9..064f29d2d66 100644
--- a/spec/models/milestone_spec.rb
+++ b/spec/models/milestone_spec.rb
@@ -24,8 +24,9 @@ describe Milestone, models: true do
     it { is_expected.to have_many(:issues) }
   end
 
-  let(:milestone) { create(:milestone) }
-  let(:issue) { create(:issue) }
+  let(:project) { create(:project, :public) }
+  let(:milestone) { create(:milestone, project: project) }
+  let(:issue) { create(:issue, project: project) }
   let(:user) { create(:user) }
 
   describe "#title" do
@@ -110,8 +111,8 @@ describe Milestone, models: true do
 
   describe :items_count do
     before do
-      milestone.issues << create(:issue)
-      milestone.issues << create(:closed_issue)
+      milestone.issues << create(:issue, project: project)
+      milestone.issues << create(:closed_issue, project: project)
       milestone.merge_requests << create(:merge_request)
     end
 
@@ -126,7 +127,7 @@ describe Milestone, models: true do
 
   describe '#total_items_count' do
     before do
-      create :closed_issue, milestone: milestone
+      create :closed_issue, milestone: milestone, project: project
       create :merge_request, milestone: milestone
     end
 
diff --git a/spec/models/namespace_spec.rb b/spec/models/namespace_spec.rb
index 069c59fb5ca..9fd06bb6b23 100644
--- a/spec/models/namespace_spec.rb
+++ b/spec/models/namespace_spec.rb
@@ -128,4 +128,26 @@ describe Namespace, models: true do
     it { expect(group.full_path).to eq(group.path) }
     it { expect(nested_group.full_path).to eq("#{group.path}/#{nested_group.path}") }
   end
+
+  describe '#full_name' do
+    let(:group) { create(:group) }
+    let(:nested_group) { create(:group, parent: group) }
+
+    it { expect(group.full_name).to eq(group.name) }
+    it { expect(nested_group.full_name).to eq("#{group.name} / #{nested_group.name}") }
+  end
+
+  describe '#parents' do
+    let(:group) { create(:group) }
+    let(:nested_group) { create(:group, parent: group) }
+    let(:deep_nested_group) { create(:group, parent: nested_group) }
+    let(:very_deep_nested_group) { create(:group, parent: deep_nested_group) }
+
+    it 'returns the correct parents' do
+      expect(very_deep_nested_group.parents).to eq([group, nested_group, deep_nested_group])
+      expect(deep_nested_group.parents).to eq([group, nested_group])
+      expect(nested_group.parents).to eq([group])
+      expect(group.parents).to eq([])
+    end
+  end
 end
diff --git a/spec/models/note_spec.rb b/spec/models/note_spec.rb
index 17a15b12dcb..310fecd8a5c 100644
--- a/spec/models/note_spec.rb
+++ b/spec/models/note_spec.rb
@@ -162,44 +162,6 @@ describe Note, models: true do
     end
   end
 
-  describe '.search' do
-    let(:note) { create(:note_on_issue, note: 'WoW') }
-
-    it 'returns notes with matching content' do
-      expect(described_class.search(note.note)).to eq([note])
-    end
-
-    it 'returns notes with matching content regardless of the casing' do
-      expect(described_class.search('WOW')).to eq([note])
-    end
-
-    context "confidential issues" do
-      let(:user) { create(:user) }
-      let(:project) { create(:project) }
-      let(:confidential_issue) { create(:issue, :confidential, project: project, author: user) }
-      let(:confidential_note) { create(:note, note: "Random", noteable: confidential_issue, project: confidential_issue.project) }
-
-      it "returns notes with matching content if user can see the issue" do
-        expect(described_class.search(confidential_note.note, as_user: user)).to eq([confidential_note])
-      end
-
-      it "does not return notes with matching content if user can not see the issue" do
-        user = create(:user)
-        expect(described_class.search(confidential_note.note, as_user: user)).to be_empty
-      end
-
-      it "does not return notes with matching content for project members with guest role" do
-        user = create(:user)
-        project.team << [user, :guest]
-        expect(described_class.search(confidential_note.note, as_user: user)).to be_empty
-      end
-
-      it "does not return notes with matching content for unauthenticated users" do
-        expect(described_class.search(confidential_note.note)).to be_empty
-      end
-    end
-  end
-
   describe "editable?" do
     it "returns true" do
       note = build(:note)
diff --git a/spec/models/project_services/slack_service/build_message_spec.rb b/spec/models/project_services/chat_message/build_message_spec.rb
index 452f4e2782c..b71d153f814 100644
--- a/spec/models/project_services/slack_service/build_message_spec.rb
+++ b/spec/models/project_services/chat_message/build_message_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe SlackService::BuildMessage do
-  subject { SlackService::BuildMessage.new(args) }
+describe ChatMessage::BuildMessage do
+  subject { described_class.new(args) }
 
   let(:args) do
     {
diff --git a/spec/models/project_services/slack_service/issue_message_spec.rb b/spec/models/project_services/chat_message/issue_message_spec.rb
index 98c36ec088d..ebe0ead4408 100644
--- a/spec/models/project_services/slack_service/issue_message_spec.rb
+++ b/spec/models/project_services/chat_message/issue_message_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe SlackService::IssueMessage, models: true do
-  subject { SlackService::IssueMessage.new(args) }
+describe ChatMessage::IssueMessage, models: true do
+  subject { described_class.new(args) }
 
   let(:args) do
     {
diff --git a/spec/models/project_services/slack_service/merge_message_spec.rb b/spec/models/project_services/chat_message/merge_message_spec.rb
index c5c052d9af1..07c414c6ca4 100644
--- a/spec/models/project_services/slack_service/merge_message_spec.rb
+++ b/spec/models/project_services/chat_message/merge_message_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe SlackService::MergeMessage, models: true do
-  subject { SlackService::MergeMessage.new(args) }
+describe ChatMessage::MergeMessage, models: true do
+  subject { described_class.new(args) }
 
   let(:args) do
     {
diff --git a/spec/models/project_services/slack_service/note_message_spec.rb b/spec/models/project_services/chat_message/note_message_spec.rb
index 97f818125d3..31936da40a2 100644
--- a/spec/models/project_services/slack_service/note_message_spec.rb
+++ b/spec/models/project_services/chat_message/note_message_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe SlackService::NoteMessage, models: true do
+describe ChatMessage::NoteMessage, models: true do
   let(:color) { '#345' }
 
   before do
@@ -36,7 +36,7 @@ describe SlackService::NoteMessage, models: true do
     end
 
     it 'returns a message regarding notes on commits' do
-      message = SlackService::NoteMessage.new(@args)
+      message = described_class.new(@args)
       expect(message.pretext).to eq("test.user <url|commented on " \
       "commit 5f163b2b> in <somewhere.com|project_name>: " \
       "*Added a commit message*")
@@ -62,7 +62,7 @@ describe SlackService::NoteMessage, models: true do
     end
 
     it 'returns a message regarding notes on a merge request' do
-      message = SlackService::NoteMessage.new(@args)
+      message = described_class.new(@args)
       expect(message.pretext).to eq("test.user <url|commented on " \
       "merge request !30> in <somewhere.com|project_name>: " \
       "*merge request title*")
@@ -88,7 +88,7 @@ describe SlackService::NoteMessage, models: true do
     end
 
     it 'returns a message regarding notes on an issue' do
-      message = SlackService::NoteMessage.new(@args)
+      message = described_class.new(@args)
       expect(message.pretext).to eq(
         "test.user <url|commented on " \
         "issue #20> in <somewhere.com|project_name>: " \
@@ -114,7 +114,7 @@ describe SlackService::NoteMessage, models: true do
     end
 
     it 'returns a message regarding notes on a project snippet' do
-      message = SlackService::NoteMessage.new(@args)
+      message = described_class.new(@args)
       expect(message.pretext).to eq("test.user <url|commented on " \
       "snippet #5> in <somewhere.com|project_name>: " \
       "*snippet title*")
diff --git a/spec/models/project_services/slack_service/pipeline_message_spec.rb b/spec/models/project_services/chat_message/pipeline_message_spec.rb
index 4098500122f..eca71db07b6 100644
--- a/spec/models/project_services/slack_service/pipeline_message_spec.rb
+++ b/spec/models/project_services/chat_message/pipeline_message_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe SlackService::PipelineMessage do
-  subject { SlackService::PipelineMessage.new(args) }
+describe ChatMessage::PipelineMessage do
+  subject { described_class.new(args) }
   let(:user) { { name: 'hacker' } }
 
   let(:args) do
diff --git a/spec/models/project_services/slack_service/push_message_spec.rb b/spec/models/project_services/chat_message/push_message_spec.rb
index 17cd05e24f1..b781c4505db 100644
--- a/spec/models/project_services/slack_service/push_message_spec.rb
+++ b/spec/models/project_services/chat_message/push_message_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe SlackService::PushMessage, models: true do
-  subject { SlackService::PushMessage.new(args) }
+describe ChatMessage::PushMessage, models: true do
+  subject { described_class.new(args) }
 
   let(:args) do
     {
diff --git a/spec/models/project_services/slack_service/wiki_page_message_spec.rb b/spec/models/project_services/chat_message/wiki_page_message_spec.rb
index 093911598b0..94c04dc0865 100644
--- a/spec/models/project_services/slack_service/wiki_page_message_spec.rb
+++ b/spec/models/project_services/chat_message/wiki_page_message_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe SlackService::WikiPageMessage, models: true do
+describe ChatMessage::WikiPageMessage, models: true do
   subject { described_class.new(args) }
 
   let(:args) do
diff --git a/spec/models/project_services/chat_notification_service_spec.rb b/spec/models/project_services/chat_notification_service_spec.rb
new file mode 100644
index 00000000000..c98e7ee14fd
--- /dev/null
+++ b/spec/models/project_services/chat_notification_service_spec.rb
@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe ChatNotificationService, models: true do
+  describe "Associations" do
+    before do
+      allow(subject).to receive(:activated?).and_return(true)
+    end
+
+    it { is_expected.to validate_presence_of :webhook }
+  end
+end
diff --git a/spec/models/project_services/mattermost_notification_service_spec.rb b/spec/models/project_services/mattermost_notification_service_spec.rb
new file mode 100644
index 00000000000..c01e64b4c8e
--- /dev/null
+++ b/spec/models/project_services/mattermost_notification_service_spec.rb
@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe MattermostNotificationService, models: true do
+  it_behaves_like "slack or mattermost"
+end
diff --git a/spec/models/project_services/slack_notification_service_spec.rb b/spec/models/project_services/slack_notification_service_spec.rb
new file mode 100644
index 00000000000..59ddddf7454
--- /dev/null
+++ b/spec/models/project_services/slack_notification_service_spec.rb
@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe SlackNotificationService, models: true do
+  it_behaves_like "slack or mattermost"
+end
diff --git a/spec/models/project_spec.rb b/spec/models/project_spec.rb
index 21ff238841e..bab3c3dbb02 100644
--- a/spec/models/project_spec.rb
+++ b/spec/models/project_spec.rb
@@ -22,7 +22,8 @@ describe Project, models: true do
     it { is_expected.to have_many(:protected_branches).dependent(:destroy) }
     it { is_expected.to have_many(:chat_services) }
     it { is_expected.to have_one(:forked_project_link).dependent(:destroy) }
-    it { is_expected.to have_one(:slack_service).dependent(:destroy) }
+    it { is_expected.to have_one(:slack_notification_service).dependent(:destroy) }
+    it { is_expected.to have_one(:mattermost_notification_service).dependent(:destroy) }
     it { is_expected.to have_one(:pushover_service).dependent(:destroy) }
     it { is_expected.to have_one(:asana_service).dependent(:destroy) }
     it { is_expected.to have_many(:boards).dependent(:destroy) }
diff --git a/spec/policies/group_policy_spec.rb b/spec/policies/group_policy_spec.rb
new file mode 100644
index 00000000000..a20ac303a53
--- /dev/null
+++ b/spec/policies/group_policy_spec.rb
@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe GroupPolicy, models: true do
+  let(:guest) { create(:user) }
+  let(:reporter) { create(:user) }
+  let(:developer) { create(:user) }
+  let(:master) { create(:user) }
+  let(:owner) { create(:user) }
+  let(:admin) { create(:admin) }
+  let(:group) { create(:group) }
+
+  let(:master_permissions) do
+    [
+      :create_projects,
+      :admin_milestones,
+      :admin_label
+    ]
+  end
+
+  let(:owner_permissions) do
+    [
+      :admin_group,
+      :admin_namespace,
+      :admin_group_member,
+      :change_visibility_level
+    ]
+  end
+
+  before do
+    group.add_guest(guest)
+    group.add_reporter(reporter)
+    group.add_developer(developer)
+    group.add_master(master)
+    group.add_owner(owner)
+  end
+
+  subject { described_class.abilities(current_user, group).to_set }
+
+  context 'with no user' do
+    let(:current_user) { nil }
+
+    it do
+      is_expected.to include(:read_group)
+      is_expected.not_to include(*master_permissions)
+      is_expected.not_to include(*owner_permissions)
+    end
+  end
+
+  context 'guests' do
+    let(:current_user) { guest }
+
+    it do
+      is_expected.to include(:read_group)
+      is_expected.not_to include(*master_permissions)
+      is_expected.not_to include(*owner_permissions)
+    end
+  end
+
+  context 'reporter' do
+    let(:current_user) { reporter }
+
+    it do
+      is_expected.to include(:read_group)
+      is_expected.not_to include(*master_permissions)
+      is_expected.not_to include(*owner_permissions)
+    end
+  end
+
+  context 'developer' do
+    let(:current_user) { developer }
+
+    it do
+      is_expected.to include(:read_group)
+      is_expected.not_to include(*master_permissions)
+      is_expected.not_to include(*owner_permissions)
+    end
+  end
+
+  context 'master' do
+    let(:current_user) { master }
+
+    it do
+      is_expected.to include(:read_group)
+      is_expected.to include(*master_permissions)
+      is_expected.not_to include(*owner_permissions)
+    end
+  end
+
+  context 'owner' do
+    let(:current_user) { owner }
+
+    it do
+      is_expected.to include(:read_group)
+      is_expected.to include(*master_permissions)
+      is_expected.to include(*owner_permissions)
+    end
+  end
+
+  context 'admin' do
+    let(:current_user) { admin }
+
+    it do
+      is_expected.to include(:read_group)
+      is_expected.to include(*master_permissions)
+      is_expected.to include(*owner_permissions)
+    end
+  end
+end
diff --git a/spec/requests/api/environments_spec.rb b/spec/requests/api/environments_spec.rb
index 126496c43a5..b9d535bc314 100644
--- a/spec/requests/api/environments_spec.rb
+++ b/spec/requests/api/environments_spec.rb
@@ -46,6 +46,7 @@ describe API::Environments, api: true  do
 
         expect(response).to have_http_status(201)
         expect(json_response['name']).to eq('mepmep')
+        expect(json_response['slug']).to eq('mepmep')
         expect(json_response['external']).to be nil
       end
 
@@ -60,6 +61,13 @@ describe API::Environments, api: true  do
 
         expect(response).to have_http_status(400)
       end
+
+      it 'returns a 400 if slug is specified' do
+        post api("/projects/#{project.id}/environments", user), name: "foo", slug: "foo"
+
+        expect(response).to have_http_status(400)
+        expect(json_response["error"]).to eq("slug is automatically generated and cannot be changed")
+      end
     end
 
     context 'a non member' do
@@ -86,6 +94,15 @@ describe API::Environments, api: true  do
       expect(json_response['external_url']).to eq(url)
     end
 
+    it "won't allow slug to be changed" do
+      slug = environment.slug
+      api_url = api("/projects/#{project.id}/environments/#{environment.id}", user)
+      put api_url, slug: slug + "-foo"
+
+      expect(response).to have_http_status(400)
+      expect(json_response["error"]).to eq("slug is automatically generated and cannot be changed")
+    end
+
     it "won't update the external_url if only the name is passed" do
       url = environment.external_url
       put api("/projects/#{project.id}/environments/#{environment.id}", user),
diff --git a/spec/requests/api/groups_spec.rb b/spec/requests/api/groups_spec.rb
index a75ba824e85..cdeb965b413 100644
--- a/spec/requests/api/groups_spec.rb
+++ b/spec/requests/api/groups_spec.rb
@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe API::Groups, api: true  do
   include ApiHelpers
+  include UploadHelpers
 
   let(:user1) { create(:user, can_create_group: false) }
   let(:user2) { create(:user) }
   let(:user3) { create(:user) }
   let(:admin) { create(:admin) }
-  let(:avatar_file_path) { File.join(Rails.root, 'spec', 'fixtures', 'banana_sample.gif') }
-  let!(:group1) { create(:group, avatar: File.open(avatar_file_path)) }
+  let!(:group1) { create(:group, avatar: File.open(uploaded_image_temp_path)) }
   let!(:group2) { create(:group, :private) }
   let!(:project1) { create(:project, namespace: group1) }
   let!(:project2) { create(:project, namespace: group2) }
diff --git a/spec/services/ci/create_pipeline_service_spec.rb b/spec/services/ci/create_pipeline_service_spec.rb
index 4aadd009f3e..ceaca96e25b 100644
--- a/spec/services/ci/create_pipeline_service_spec.rb
+++ b/spec/services/ci/create_pipeline_service_spec.rb
@@ -210,5 +210,22 @@ describe Ci::CreatePipelineService, services: true do
         expect(result.manual_actions).not_to be_empty
       end
     end
+
+    context 'with environment' do
+      before do
+        config = YAML.dump(deploy: { environment: { name: "review/$CI_BUILD_REF_NAME" }, script: 'ls' })
+        stub_ci_pipeline_yaml_file(config)
+      end
+
+      it 'creates the environment' do
+        result = execute(ref: 'refs/heads/master',
+                         before: '00000000',
+                         after: project.commit.id,
+                         commits: [{ message: 'some msg' }])
+
+        expect(result).to be_persisted
+        expect(Environment.find_by(name: "review/master")).not_to be_nil
+      end
+    end
   end
 end
diff --git a/spec/models/project_services/slack_service_spec.rb b/spec/support/slack_mattermost_shared_examples.rb
index c07a70a8069..56d4965f74d 100644
--- a/spec/models/project_services/slack_service_spec.rb
+++ b/spec/support/slack_mattermost_shared_examples.rb
@@ -1,7 +1,7 @@
-require 'spec_helper'
+Dir[Rails.root.join("app/models/project_services/chat_message/*.rb")].each { |f| require f }
 
-describe SlackService, models: true do
-  let(:slack) { SlackService.new }
+RSpec.shared_examples 'slack or mattermost' do
+  let(:chat_service) { described_class.new }
   let(:webhook_url) { 'https://example.gitlab.com/' }
 
   describe "Associations" do
@@ -24,7 +24,7 @@ describe SlackService, models: true do
     end
   end
 
-  describe "Execute" do
+  describe "#execute" do
     let(:user)    { create(:user) }
     let(:project) { create(:project) }
     let(:username) { 'slack_username' }
@@ -35,7 +35,7 @@ describe SlackService, models: true do
     end
 
     before do
-      allow(slack).to receive_messages(
+      allow(chat_service).to receive_messages(
         project: project,
         project_id: project.id,
         service_hook: true,
@@ -77,54 +77,55 @@ describe SlackService, models: true do
       @wiki_page_sample_data = wiki_page_service.hook_data(@wiki_page, 'create')
     end
 
-    it "calls Slack API for push events" do
-      slack.execute(push_sample_data)
+    it "calls Slack/Mattermost API for push events" do
+      chat_service.execute(push_sample_data)
 
       expect(WebMock).to have_requested(:post, webhook_url).once
     end
 
-    it "calls Slack API for issue events" do
-      slack.execute(@issues_sample_data)
+    it "calls Slack/Mattermost API for issue events" do
+      chat_service.execute(@issues_sample_data)
 
       expect(WebMock).to have_requested(:post, webhook_url).once
     end
 
-    it "calls Slack API for merge requests events" do
-      slack.execute(@merge_sample_data)
+    it "calls Slack/Mattermost API for merge requests events" do
+      chat_service.execute(@merge_sample_data)
 
       expect(WebMock).to have_requested(:post, webhook_url).once
     end
 
-    it "calls Slack API for wiki page events" do
-      slack.execute(@wiki_page_sample_data)
+    it "calls Slack/Mattermost API for wiki page events" do
+      chat_service.execute(@wiki_page_sample_data)
 
       expect(WebMock).to have_requested(:post, webhook_url).once
     end
 
     it 'uses the username as an option for slack when configured' do
-      allow(slack).to receive(:username).and_return(username)
+      allow(chat_service).to receive(:username).and_return(username)
+
       expect(Slack::Notifier).to receive(:new).
-       with(webhook_url, username: username).
+       with(webhook_url, username: username, channel: chat_service.default_channel).
        and_return(
          double(:slack_service).as_null_object
        )
 
-      slack.execute(push_sample_data)
+      chat_service.execute(push_sample_data)
     end
 
     it 'uses the channel as an option when it is configured' do
-      allow(slack).to receive(:channel).and_return(channel)
+      allow(chat_service).to receive(:channel).and_return(channel)
       expect(Slack::Notifier).to receive(:new).
         with(webhook_url, channel: channel).
         and_return(
           double(:slack_service).as_null_object
         )
-      slack.execute(push_sample_data)
+      chat_service.execute(push_sample_data)
     end
 
     context "event channels" do
       it "uses the right channel for push event" do
-        slack.update_attributes(push_channel: "random")
+        chat_service.update_attributes(push_channel: "random")
 
         expect(Slack::Notifier).to receive(:new).
          with(webhook_url, channel: "random").
@@ -132,11 +133,11 @@ describe SlackService, models: true do
            double(:slack_service).as_null_object
          )
 
-        slack.execute(push_sample_data)
+        chat_service.execute(push_sample_data)
       end
 
       it "uses the right channel for merge request event" do
-        slack.update_attributes(merge_request_channel: "random")
+        chat_service.update_attributes(merge_request_channel: "random")
 
         expect(Slack::Notifier).to receive(:new).
          with(webhook_url, channel: "random").
@@ -144,11 +145,11 @@ describe SlackService, models: true do
            double(:slack_service).as_null_object
          )
 
-        slack.execute(@merge_sample_data)
+        chat_service.execute(@merge_sample_data)
       end
 
       it "uses the right channel for issue event" do
-        slack.update_attributes(issue_channel: "random")
+        chat_service.update_attributes(issue_channel: "random")
 
         expect(Slack::Notifier).to receive(:new).
          with(webhook_url, channel: "random").
@@ -156,11 +157,11 @@ describe SlackService, models: true do
            double(:slack_service).as_null_object
          )
 
-        slack.execute(@issues_sample_data)
+        chat_service.execute(@issues_sample_data)
       end
 
       it "uses the right channel for wiki event" do
-        slack.update_attributes(wiki_page_channel: "random")
+        chat_service.update_attributes(wiki_page_channel: "random")
 
         expect(Slack::Notifier).to receive(:new).
          with(webhook_url, channel: "random").
@@ -168,7 +169,7 @@ describe SlackService, models: true do
            double(:slack_service).as_null_object
          )
 
-        slack.execute(@wiki_page_sample_data)
+        chat_service.execute(@wiki_page_sample_data)
       end
 
       context "note event" do
@@ -177,7 +178,7 @@ describe SlackService, models: true do
         end
 
         it "uses the right channel" do
-          slack.update_attributes(note_channel: "random")
+          chat_service.update_attributes(note_channel: "random")
 
           note_data = Gitlab::DataBuilder::Note.build(issue_note, user)
 
@@ -187,7 +188,7 @@ describe SlackService, models: true do
              double(:slack_service).as_null_object
            )
 
-          slack.execute(note_data)
+          chat_service.execute(note_data)
         end
       end
     end
@@ -198,7 +199,7 @@ describe SlackService, models: true do
     let(:project) { create(:project, creator_id: user.id) }
 
     before do
-      allow(slack).to receive_messages(
+      allow(chat_service).to receive_messages(
         project: project,
         project_id: project.id,
         service_hook: true,
@@ -216,9 +217,9 @@ describe SlackService, models: true do
                                 note: 'a comment on a commit')
       end
 
-      it "calls Slack API for commit comment events" do
+      it "calls Slack/Mattermost API for commit comment events" do
         data = Gitlab::DataBuilder::Note.build(commit_note, user)
-        slack.execute(data)
+        chat_service.execute(data)
 
         expect(WebMock).to have_requested(:post, webhook_url).once
       end
@@ -232,7 +233,7 @@ describe SlackService, models: true do
 
       it "calls Slack API for merge request comment events" do
         data = Gitlab::DataBuilder::Note.build(merge_request_note, user)
-        slack.execute(data)
+        chat_service.execute(data)
 
         expect(WebMock).to have_requested(:post, webhook_url).once
       end
@@ -245,7 +246,7 @@ describe SlackService, models: true do
 
       it "calls Slack API for issue comment events" do
         data = Gitlab::DataBuilder::Note.build(issue_note, user)
-        slack.execute(data)
+        chat_service.execute(data)
 
         expect(WebMock).to have_requested(:post, webhook_url).once
       end
@@ -259,7 +260,7 @@ describe SlackService, models: true do
 
       it "calls Slack API for snippet comment events" do
         data = Gitlab::DataBuilder::Note.build(snippet_note, user)
-        slack.execute(data)
+        chat_service.execute(data)
 
         expect(WebMock).to have_requested(:post, webhook_url).once
       end
@@ -277,21 +278,21 @@ describe SlackService, models: true do
     end
 
     before do
-      allow(slack).to receive_messages(
+      allow(chat_service).to receive_messages(
         project: project,
         service_hook: true,
         webhook: webhook_url
       )
     end
 
-    shared_examples 'call Slack API' do
+    shared_examples 'call Slack/Mattermost API' do
       before do
         WebMock.stub_request(:post, webhook_url)
       end
 
-      it 'calls Slack API for pipeline events' do
+      it 'calls Slack/Mattermost API for pipeline events' do
         data = Gitlab::DataBuilder::Pipeline.build(pipeline)
-        slack.execute(data)
+        chat_service.execute(data)
 
         expect(WebMock).to have_requested(:post, webhook_url).once
       end
@@ -300,16 +301,16 @@ describe SlackService, models: true do
     context 'with failed pipeline' do
       let(:status) { 'failed' }
 
-      it_behaves_like 'call Slack API'
+      it_behaves_like 'call Slack/Mattermost API'
     end
 
     context 'with succeeded pipeline' do
       let(:status) { 'success' }
 
       context 'with default to notify_only_broken_pipelines' do
-        it 'does not call Slack API for pipeline events' do
+        it 'does not call Slack/Mattermost API for pipeline events' do
           data = Gitlab::DataBuilder::Pipeline.build(pipeline)
-          result = slack.execute(data)
+          result = chat_service.execute(data)
 
           expect(result).to be_falsy
         end
@@ -317,10 +318,10 @@ describe SlackService, models: true do
 
       context 'with setting notify_only_broken_pipelines to false' do
         before do
-          slack.notify_only_broken_pipelines = false
+          chat_service.notify_only_broken_pipelines = false
         end
 
-        it_behaves_like 'call Slack API'
+        it_behaves_like 'call Slack/Mattermost API'
       end
     end
   end
diff --git a/spec/support/upload_helpers.rb b/spec/support/upload_helpers.rb
new file mode 100644
index 00000000000..5eead80c935
--- /dev/null
+++ b/spec/support/upload_helpers.rb
@@ -0,0 +1,16 @@
+require 'fileutils'
+
+module UploadHelpers
+  extend self
+
+  def uploaded_image_temp_path
+    basename = 'banana_sample.gif'
+    orig_path = File.join(Rails.root, 'spec', 'fixtures', basename)
+    tmp_path = File.join(Rails.root, 'tmp', 'tests', basename)
+    # Because we use 'move_to_store' on all uploaders, we create a new
+    # tempfile on each call: the file we return here will be renamed in most
+    # cases.
+    FileUtils.copy(orig_path, tmp_path)
+    tmp_path
+  end
+end
diff --git a/spec/uploaders/attachment_uploader_spec.rb b/spec/uploaders/attachment_uploader_spec.rb
new file mode 100644
index 00000000000..6098be5cd45
--- /dev/null
+++ b/spec/uploaders/attachment_uploader_spec.rb
@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe AttachmentUploader do
+  let(:issue) { build(:issue) }
+  subject { described_class.new(issue) }
+
+  describe '#move_to_cache' do
+    it 'is true' do
+      expect(subject.move_to_cache).to eq(true)
+    end
+  end
+
+  describe '#move_to_store' do
+    it 'is true' do
+      expect(subject.move_to_store).to eq(true)
+    end
+  end
+end
diff --git a/spec/uploaders/avatar_uploader_spec.rb b/spec/uploaders/avatar_uploader_spec.rb
new file mode 100644
index 00000000000..1f0e8732587
--- /dev/null
+++ b/spec/uploaders/avatar_uploader_spec.rb
@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe AvatarUploader do
+  let(:user) { build(:user) }
+  subject { described_class.new(user) }
+
+  describe '#move_to_cache' do
+    it 'is true' do
+      expect(subject.move_to_cache).to eq(true)
+    end
+  end
+
+  describe '#move_to_store' do
+    it 'is true' do
+      expect(subject.move_to_store).to eq(true)
+    end
+  end
+end
diff --git a/spec/uploaders/file_uploader_spec.rb b/spec/uploaders/file_uploader_spec.rb
index e8300abed5d..bc86adfef68 100644
--- a/spec/uploaders/file_uploader_spec.rb
+++ b/spec/uploaders/file_uploader_spec.rb
@@ -42,4 +42,16 @@ describe FileUploader do
       expect(@uploader.image_or_video?).to be false
     end
   end
+
+  describe '#move_to_cache' do
+    it 'is true' do
+      expect(@uploader.move_to_cache).to eq(true)
+    end
+  end
+
+  describe '#move_to_store' do
+    it 'is true' do
+      expect(@uploader.move_to_store).to eq(true)
+    end
+  end
 end