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

* upstream/master: (116 commits)
  adds impersonator variable and makes sudo usage overall more clear
  Reenables /user API request to return private-token if user is admin and requested with sudo
  Fix Backup::Manager#remove_old
  Allow public access to some Tag API endpoints
  Update outdated visible content spec descriptions
  Grapify the issues API
  new DevOps report, 404s, typos
  Remove dashboard.scss
  Update custom_hooks.md for global custom hooks and chained hook info
  Move admin hooks spinach to rspec
  Move admin logs spinach test to rspec
  Fix 404 error when visit group label edit page
  A simpler implementation of finding a merge request
  Encourage bug reporters to mention if they use GitLab.com [ci skip]
  Bump gitlab-shell version to 4.0.3
  Remove confirmation.scss
  Explain "js: true" in "deleted_source_branch_spec.rb" [ci skip]
  Move award emojis to framwork
  Move image styles to framework
  Remove tags.scss
  ...

25 files changed, 1194 insertions, 123 deletions

diff --git a/spec/lib/banzai/filter/abstract_link_filter_spec.rb b/spec/lib/banzai/filter/abstract_link_filter_spec.rb
index 1ee31a603e4..70a87fbc01e 100644
--- a/spec/lib/banzai/filter/abstract_link_filter_spec.rb
+++ b/spec/lib/banzai/filter/abstract_link_filter_spec.rb
@@ -5,7 +5,7 @@ describe Banzai::Filter::AbstractReferenceFilter do
 
   describe '#references_per_project' do
     it 'returns a Hash containing references grouped per project paths' do
-      doc = Nokogiri::HTML.fragment("#1 #{project.to_reference}#2")
+      doc = Nokogiri::HTML.fragment("#1 #{project.path_with_namespace}#2")
       filter = described_class.new(doc, project: project)
 
       expect(filter).to receive(:object_class).exactly(4).times.and_return(Issue)
@@ -14,7 +14,7 @@ describe Banzai::Filter::AbstractReferenceFilter do
       refs = filter.references_per_project
 
       expect(refs).to be_an_instance_of(Hash)
-      expect(refs[project.to_reference]).to eq(Set.new(%w[1 2]))
+      expect(refs[project.path_with_namespace]).to eq(Set.new(%w[1 2]))
     end
   end
 
diff --git a/spec/lib/banzai/filter/commit_range_reference_filter_spec.rb b/spec/lib/banzai/filter/commit_range_reference_filter_spec.rb
index e6c90ad87ee..9703e2315b8 100644
--- a/spec/lib/banzai/filter/commit_range_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/commit_range_reference_filter_spec.rb
@@ -59,9 +59,7 @@ describe Banzai::Filter::CommitRangeReferenceFilter, lib: true do
     it 'ignores invalid commit IDs' do
       exp = act = "See #{commit1.id.reverse}...#{commit2.id}"
 
-      expect(project).to receive(:valid_repo?).and_return(true)
-      expect(project.repository).to receive(:commit).with(commit1.id.reverse)
-      expect(project.repository).to receive(:commit).with(commit2.id)
+      allow(project.repository).to receive(:commit).with(commit1.id.reverse)
       expect(reference_filter(act).to_html).to eq exp
     end
 
@@ -100,14 +98,44 @@ describe Banzai::Filter::CommitRangeReferenceFilter, lib: true do
     end
   end
 
-  context 'cross-project reference' do
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
-    let(:project2)  { create(:project, :public, namespace: namespace) }
-    let(:reference) { range.to_reference(project) }
+  context 'cross-project / cross-namespace complete reference' do
+    let(:project2)  { create(:project, :public) }
+    let(:reference) { "#{project2.path_with_namespace}@#{commit1.id}...#{commit2.id}" }
 
-    before do
-      range.project = project2
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq urls.namespace_project_compare_url(project2.namespace, project2, range.to_param)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.css('a').first.text).
+        to eql("#{project2.path_with_namespace}@#{commit1.short_id}...#{commit2.short_id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.text).to eql("Fixed (#{project2.path_with_namespace}@#{commit1.short_id}...#{commit2.short_id}.)")
+    end
+
+    it 'ignores invalid commit IDs on the referenced project' do
+      exp = act = "Fixed #{project2.path_with_namespace}@#{commit1.id.reverse}...#{commit2.id}"
+      expect(reference_filter(act).to_html).to eq exp
+
+      exp = act = "Fixed #{project2.path_with_namespace}@#{commit1.id}...#{commit2.id.reverse}"
+      expect(reference_filter(act).to_html).to eq exp
     end
+  end
+
+  context 'cross-project / same-namespace complete reference' do
+    let(:namespace)         { create(:namespace) }
+    let(:project)           { create(:project, :public, namespace: namespace) }
+    let(:project2)          { create(:project, :public, path: "same-namespace", namespace: namespace) }
+    let(:reference)         { "#{project2.path}@#{commit1.id}...#{commit2.id}" }
 
     it 'links to a valid reference' do
       doc = reference_filter("See #{reference}")
@@ -116,24 +144,65 @@ describe Banzai::Filter::CommitRangeReferenceFilter, lib: true do
         to eq urls.namespace_project_compare_url(project2.namespace, project2, range.to_param)
     end
 
-    it 'links with adjacent text' do
+    it 'link has valid text' do
       doc = reference_filter("Fixed (#{reference}.)")
 
-      exp = Regexp.escape("#{project2.to_reference}@#{range.reference_link_text}")
-      expect(doc.to_html).to match(/\(<a.+>#{exp}<\/a>\.\)/)
+      expect(doc.css('a').first.text).
+        to eql("#{project2.path}@#{commit1.short_id}...#{commit2.short_id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.text).to eql("Fixed (#{project2.path}@#{commit1.short_id}...#{commit2.short_id}.)")
     end
 
     it 'ignores invalid commit IDs on the referenced project' do
-      exp = act = "Fixed #{project2.to_reference}@#{commit1.id.reverse}...#{commit2.id}"
+      exp = act = "Fixed #{project2.path}@#{commit1.id.reverse}...#{commit2.id}"
       expect(reference_filter(act).to_html).to eq exp
 
-      exp = act = "Fixed #{project2.to_reference}@#{commit1.id}...#{commit2.id.reverse}"
+      exp = act = "Fixed #{project2.path}@#{commit1.id}...#{commit2.id.reverse}"
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project shorthand reference' do
+    let(:namespace)         { create(:namespace) }
+    let(:project)           { create(:project, :public, namespace: namespace) }
+    let(:project2)          { create(:project, :public, path: "same-namespace", namespace: namespace) }
+    let(:reference)         { "#{project2.path}@#{commit1.id}...#{commit2.id}" }
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq urls.namespace_project_compare_url(project2.namespace, project2, range.to_param)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.css('a').first.text).
+        to eql("#{project2.path}@#{commit1.short_id}...#{commit2.short_id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.text).to eql("Fixed (#{project2.path}@#{commit1.short_id}...#{commit2.short_id}.)")
+    end
+
+    it 'ignores invalid commit IDs on the referenced project' do
+      exp = act = "Fixed #{project2.path}@#{commit1.id.reverse}...#{commit2.id}"
+      expect(reference_filter(act).to_html).to eq exp
+
+      exp = act = "Fixed #{project2.path}@#{commit1.id}...#{commit2.id.reverse}"
       expect(reference_filter(act).to_html).to eq exp
     end
   end
 
   context 'cross-project URL reference' do
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
+    let(:namespace) { create(:namespace) }
     let(:project2)  { create(:project, :public, namespace: namespace) }
     let(:range)  { CommitRange.new("#{commit1.id}...master", project) }
     let(:reference) { urls.namespace_project_compare_url(project2.namespace, project2, from: commit1.id, to: 'master') }
diff --git a/spec/lib/banzai/filter/commit_reference_filter_spec.rb b/spec/lib/banzai/filter/commit_reference_filter_spec.rb
index e0f08282551..2e6dcc3a434 100644
--- a/spec/lib/banzai/filter/commit_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/commit_reference_filter_spec.rb
@@ -41,6 +41,7 @@ describe Banzai::Filter::CommitReferenceFilter, lib: true do
 
     it 'links with adjacent text' do
       doc = reference_filter("See (#{reference}.)")
+
       expect(doc.to_html).to match(/\(<a.+>#{commit.short_id}<\/a>\.\)/)
     end
 
@@ -48,8 +49,6 @@ describe Banzai::Filter::CommitReferenceFilter, lib: true do
       invalid = invalidate_reference(reference)
       exp = act = "See #{invalid}"
 
-      expect(project).to receive(:valid_repo?).and_return(true)
-      expect(project.repository).to receive(:commit).with(invalid)
       expect(reference_filter(act).to_html).to eq exp
     end
 
@@ -95,34 +94,85 @@ describe Banzai::Filter::CommitReferenceFilter, lib: true do
     end
   end
 
-  context 'cross-project reference' do
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
+  context 'cross-project / cross-namespace complete reference' do
+    let(:namespace) { create(:namespace) }
     let(:project2)  { create(:project, :public, namespace: namespace) }
     let(:commit)    { project2.commit }
-    let(:reference) { commit.to_reference(project) }
+    let(:reference) { "#{project2.path_with_namespace}@#{commit.short_id}" }
 
-    it 'links to a valid reference' do
-      doc = reference_filter("See #{reference}")
+    it 'link has valid text' do
+      doc = reference_filter("See (#{reference}.)")
 
-      expect(doc.css('a').first.attr('href')).
-        to eq urls.namespace_project_commit_url(project2.namespace, project2, commit.id)
+      expect(doc.css('a').first.text).to eql("#{project2.path_with_namespace}@#{commit.short_id}")
     end
 
-    it 'links with adjacent text' do
-      doc = reference_filter("Fixed (#{reference}.)")
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).to eql("See (#{project2.path_with_namespace}@#{commit.short_id}.)")
+    end
+
+    it 'ignores invalid commit IDs on the referenced project' do
+      exp = act = "Committed #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project / same-namespace complete reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, namespace: namespace) }
+    let(:project2)  { create(:project, :public, namespace: namespace) }
+    let(:commit)    { project2.commit }
+    let(:reference) { "#{project2.path_with_namespace}@#{commit.short_id}" }
+
+    it 'link has valid text' do
+      doc = reference_filter("See (#{reference}.)")
 
-      exp = Regexp.escape(project2.to_reference)
-      expect(doc.to_html).to match(/\(<a.+>#{exp}@#{commit.short_id}<\/a>\.\)/)
+      expect(doc.css('a').first.text).to eql("#{project2.path}@#{commit.short_id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).to eql("See (#{project2.path}@#{commit.short_id}.)")
     end
 
     it 'ignores invalid commit IDs on the referenced project' do
       exp = act = "Committed #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project shorthand reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, namespace: namespace) }
+    let(:project2)  { create(:project, :public, namespace: namespace) }
+    let(:commit)    { project2.commit }
+    let(:reference) { "#{project2.path_with_namespace}@#{commit.short_id}" }
+
+    it 'link has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.css('a').first.text).to eql("#{project2.path}@#{commit.short_id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).to eql("See (#{project2.path}@#{commit.short_id}.)")
+    end
+
+    it 'ignores invalid commit IDs on the referenced project' do
+      exp = act = "Committed #{invalidate_reference(reference)}"
+
       expect(reference_filter(act).to_html).to eq exp
     end
   end
 
   context 'cross-project URL reference' do
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
+    let(:namespace) { create(:namespace) }
     let(:project2)  { create(:project, :public, namespace: namespace) }
     let(:commit)    { project2.commit }
     let(:reference) { urls.namespace_project_commit_url(project2.namespace, project2, commit.id) }
diff --git a/spec/lib/banzai/filter/issue_reference_filter_spec.rb b/spec/lib/banzai/filter/issue_reference_filter_spec.rb
index 8f0b2db3e8e..456dbac0698 100644
--- a/spec/lib/banzai/filter/issue_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/issue_reference_filter_spec.rb
@@ -8,7 +8,7 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
   end
 
   let(:project) { create(:empty_project, :public) }
-  let(:issue)   { create(:issue, project: project) }
+  let(:issue)  { create(:issue, project: project) }
 
   it 'requires project context' do
     expect { described_class.call('') }.to raise_error(ArgumentError, /:project/)
@@ -24,7 +24,7 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
   context 'internal reference' do
     it_behaves_like 'a reference containing an element node'
 
-    let(:reference) { issue.to_reference }
+    let(:reference) { "##{issue.iid}" }
 
     it 'ignores valid references when using non-default tracker' do
       allow(project).to receive(:default_issues_tracker?).and_return(false)
@@ -42,7 +42,7 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
 
     it 'links with adjacent text' do
       doc = reference_filter("Fixed (#{reference}.)")
-      expect(doc.to_html).to match(/\(<a.+>#{Regexp.escape(reference)}<\/a>\.\)/)
+      expect(doc.text).to eql("Fixed (#{reference}.)")
     end
 
     it 'ignores invalid issue IDs' do
@@ -116,13 +116,56 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
     end
   end
 
-  context 'cross-project reference' do
+  context 'cross-project / cross-namespace complete reference' do
     it_behaves_like 'a reference containing an element node'
 
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
+    let(:project2)  { create(:empty_project, :public) }
+    let(:issue)     { create(:issue, project: project2) }
+    let(:reference) { "#{project2.path_with_namespace}##{issue.iid}" }
+
+    it 'ignores valid references when cross-reference project uses external tracker' do
+      expect_any_instance_of(described_class).to receive(:find_object).
+        with(project2, issue.iid).
+        and_return(nil)
+
+      exp = act = "Issue #{reference}"
+      expect(reference_filter(act).to_html).to eq exp
+    end
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq helper.url_for_issue(issue.iid, project2)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.css('a').first.text).to eql("#{project2.path_with_namespace}##{issue.iid}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.text).to eq("Fixed (#{project2.path_with_namespace}##{issue.iid}.)")
+    end
+
+    it 'ignores invalid issue IDs on the referenced project' do
+      exp = act = "Fixed #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project / same-namespace complete reference' do
+    it_behaves_like 'a reference containing an element node'
+
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, :public, namespace: namespace) }
     let(:project2)  { create(:empty_project, :public, namespace: namespace) }
     let(:issue)     { create(:issue, project: project2) }
-    let(:reference) { issue.to_reference(project) }
+    let(:reference) { "#{project2.path_with_namespace}##{issue.iid}" }
 
     it 'ignores valid references when cross-reference project uses external tracker' do
       expect_any_instance_of(described_class).to receive(:find_object).
@@ -140,9 +183,16 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
         to eq helper.url_for_issue(issue.iid, project2)
     end
 
-    it 'links with adjacent text' do
+    it 'link has valid text' do
       doc = reference_filter("Fixed (#{reference}.)")
-      expect(doc.to_html).to match(/\(<a.+>#{Regexp.escape(reference)}<\/a>\.\)/)
+
+      expect(doc.css('a').first.text).to eql("#{project2.path}##{issue.iid}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.text).to eq("Fixed (#{project2.path}##{issue.iid}.)")
     end
 
     it 'ignores invalid issue IDs on the referenced project' do
@@ -150,9 +200,47 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
 
       expect(reference_filter(act).to_html).to eq exp
     end
+  end
+
+  context 'cross-project shorthand reference' do
+    it_behaves_like 'a reference containing an element node'
 
-    it 'ignores out-of-bounds issue IDs on the referenced project' do
-      exp = act = "Fixed ##{Gitlab::Database::MAX_INT_VALUE + 1}"
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, :public, namespace: namespace) }
+    let(:project2)  { create(:empty_project, :public, namespace: namespace) }
+    let(:issue)     { create(:issue, project: project2) }
+    let(:reference) { "#{project2.path}##{issue.iid}" }
+
+    it 'ignores valid references when cross-reference project uses external tracker' do
+      expect_any_instance_of(described_class).to receive(:find_object).
+        with(project2, issue.iid).
+        and_return(nil)
+
+      exp = act = "Issue #{reference}"
+      expect(reference_filter(act).to_html).to eq exp
+    end
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq helper.url_for_issue(issue.iid, project2)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.css('a').first.text).to eql("#{project2.path}##{issue.iid}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.text).to eq("Fixed (#{project2.path}##{issue.iid}.)")
+    end
+
+    it 'ignores invalid issue IDs on the referenced project' do
+      exp = act = "Fixed #{invalidate_reference(reference)}"
 
       expect(reference_filter(act).to_html).to eq exp
     end
diff --git a/spec/lib/banzai/filter/label_reference_filter_spec.rb b/spec/lib/banzai/filter/label_reference_filter_spec.rb
index 9c09f00ae8a..284641fb20a 100644
--- a/spec/lib/banzai/filter/label_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/label_reference_filter_spec.rb
@@ -4,7 +4,7 @@ require 'html/pipeline'
 describe Banzai::Filter::LabelReferenceFilter, lib: true do
   include FilterSpecHelper
 
-  let(:project)   { create(:empty_project, :public) }
+  let(:project)   { create(:empty_project, :public, name: 'sample-project') }
   let(:label)     { create(:label, project: project) }
   let(:reference) { label.to_reference }
 
@@ -48,6 +48,14 @@ describe Banzai::Filter::LabelReferenceFilter, lib: true do
     expect(link).to eq urls.namespace_project_issues_path(project.namespace, project, label_name: label.name)
   end
 
+  context 'project that does not exist referenced' do
+    let(:result) { reference_filter('aaa/bbb~ccc') }
+
+    it 'does not link reference' do
+      expect(result.to_html).to eq 'aaa/bbb~ccc'
+    end
+  end
+
   describe 'label span element' do
     it 'includes default classes' do
       doc = reference_filter("Label #{reference}")
@@ -334,14 +342,14 @@ describe Banzai::Filter::LabelReferenceFilter, lib: true do
     end
 
     context 'with project reference' do
-      let(:reference) { project.to_reference + group_label.to_reference(format: :name) }
+      let(:reference) { "#{project.to_reference}#{group_label.to_reference(format: :name)}" }
 
       it 'links to a valid reference' do
         doc = reference_filter("See #{reference}", project: project)
 
         expect(doc.css('a').first.attr('href')).to eq urls.
           namespace_project_issues_url(project.namespace, project, label_name: group_label.name)
-        expect(doc.text).to eq 'See gfm references'
+        expect(doc.text).to eq "See gfm references"
       end
 
       it 'links with adjacent text' do
@@ -357,68 +365,247 @@ describe Banzai::Filter::LabelReferenceFilter, lib: true do
     end
   end
 
-  describe 'cross project label references' do
-    context 'valid project referenced' do
-      let(:another_project)  { create(:empty_project, :public) }
-      let(:project_name) { another_project.name_with_namespace }
-      let(:label) { create(:label, project: another_project, color: '#00ff00') }
-      let(:reference) { label.to_reference(project) }
+  describe 'cross-project / cross-namespace complete reference' do
+    let(:project2)  { create(:empty_project) }
+    let(:label)     { create(:label, project: project2, color: '#00ff00') }
+    let(:reference) { "#{project2.path_with_namespace}~#{label.name}" }
+    let!(:result)   { reference_filter("See #{reference}") }
 
-      let!(:result) { reference_filter("See #{reference}") }
+    it 'links to a valid reference' do
+      expect(result.css('a').first.attr('href'))
+        .to eq urls.namespace_project_issues_url(project2.namespace,
+                                                 project2,
+                                                 label_name: label.name)
+    end
 
-      it 'points to referenced project issues page' do
-        expect(result.css('a').first.attr('href'))
-          .to eq urls.namespace_project_issues_url(another_project.namespace,
-                                                   another_project,
-                                                   label_name: label.name)
-      end
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style')).to match /background-color: #00ff00/
+    end
 
-      it 'has valid color' do
-        expect(result.css('a span').first.attr('style'))
-          .to match /background-color: #00ff00/
-      end
+    it 'has valid link text' do
+      expect(result.css('a').first.text).to eq "#{label.name} in #{project2.name_with_namespace}"
+    end
 
-      it 'contains cross project content' do
-        expect(result.css('a').first.text).to eq "#{label.name} in #{project_name}"
-      end
+    it 'has valid text' do
+      expect(result.text).to eq "See #{label.name} in #{project2.name_with_namespace}"
     end
 
-    context 'project that does not exist referenced' do
-      let(:result) { reference_filter('aaa/bbb~ccc') }
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
 
-      it 'does not link reference' do
-        expect(result.to_html).to eq 'aaa/bbb~ccc'
-      end
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  describe 'cross-project / same-namespace complete reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, namespace: namespace) }
+    let(:project2)  { create(:empty_project, namespace: namespace) }
+    let(:label)     { create(:label, project: project2, color: '#00ff00') }
+    let(:reference) { "#{project2.path_with_namespace}~#{label.name}" }
+    let!(:result)   { reference_filter("See #{reference}") }
+
+    it 'links to a valid reference' do
+      expect(result.css('a').first.attr('href'))
+        .to eq urls.namespace_project_issues_url(project2.namespace,
+                                                 project2,
+                                                 label_name: label.name)
+    end
+
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style')).to match /background-color: #00ff00/
+    end
+
+    it 'has valid link text' do
+      expect(result.css('a').first.text).to eq "#{label.name} in #{project2.name}"
+    end
+
+    it 'has valid text' do
+      expect(result.text).to eq "See #{label.name} in #{project2.name}"
+    end
+
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  describe 'cross-project shorthand reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, namespace: namespace) }
+    let(:project2)  { create(:empty_project, namespace: namespace) }
+    let(:label)     { create(:label, project: project2, color: '#00ff00') }
+    let(:reference) { "#{project2.path}~#{label.name}" }
+    let!(:result)   { reference_filter("See #{reference}") }
+
+    it 'links to a valid reference' do
+      expect(result.css('a').first.attr('href'))
+        .to eq urls.namespace_project_issues_url(project2.namespace,
+                                                 project2,
+                                                 label_name: label.name)
+    end
+
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style')).
+        to match /background-color: #00ff00/
+    end
+
+    it 'has valid link text' do
+      expect(result.css('a').first.text).to eq "#{label.name} in #{project2.name}"
+    end
+
+    it 'has valid text' do
+      expect(result.text).to eq "See #{label.name} in #{project2.name}"
+    end
+
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
     end
   end
 
   describe 'cross group label references' do
-    context 'valid project referenced' do
-      let(:group) { create(:group) }
-      let(:project) { create(:empty_project, :public, namespace: group) }
-      let(:another_group) { create(:group) }
-      let(:another_project)  { create(:empty_project, :public, namespace: another_group) }
-      let(:project_name) { another_project.name_with_namespace }
-      let(:group_label) { create(:group_label, group: another_group, color: '#00ff00') }
-      let(:reference) { another_project.to_reference + group_label.to_reference }
-
-      let!(:result) { reference_filter("See #{reference}", project: project) }
-
-      it 'points to referenced project issues page' do
-        expect(result.css('a').first.attr('href'))
-          .to eq urls.namespace_project_issues_url(another_project.namespace,
-                                                   another_project,
-                                                   label_name: group_label.name)
-      end
+    let(:group)            { create(:group) }
+    let(:project)          { create(:empty_project, :public, namespace: group) }
+    let(:another_group)    { create(:group) }
+    let(:another_project)  { create(:empty_project, :public, namespace: another_group) }
+    let(:group_label)      { create(:group_label, group: another_group, color: '#00ff00') }
+    let(:reference)        { "#{another_project.path_with_namespace}~#{group_label.name}" }
+    let!(:result)          { reference_filter("See #{reference}", project: project) }
 
-      it 'has valid color' do
-        expect(result.css('a span').first.attr('style'))
-          .to match /background-color: #00ff00/
-      end
+    it 'points to referenced project issues page' do
+      expect(result.css('a').first.attr('href'))
+        .to eq urls.namespace_project_issues_url(another_project.namespace,
+                                                 another_project,
+                                                 label_name: group_label.name)
+    end
 
-      it 'contains cross project content' do
-        expect(result.css('a').first.text).to eq "#{group_label.name} in #{project_name}"
-      end
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style')).
+        to match /background-color: #00ff00/
+    end
+
+    it 'has valid link text' do
+      expect(result.css('a').first.text).
+        to eq "#{group_label.name} in #{another_project.name_with_namespace}"
+    end
+
+    it 'has valid text' do
+      expect(result.text).
+        to eq "See #{group_label.name} in #{another_project.name_with_namespace}"
+    end
+
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  describe 'cross-project / same-group_label complete reference' do
+    let(:group)            { create(:group) }
+    let(:project)          { create(:empty_project, :public, namespace: group) }
+    let(:another_project)  { create(:empty_project, :public, namespace: group) }
+    let(:group_label)      { create(:group_label, group: group, color: '#00ff00') }
+    let(:reference)        { "#{another_project.path_with_namespace}~#{group_label.name}" }
+    let!(:result)          { reference_filter("See #{reference}", project: project) }
+
+    it 'points to referenced project issues page' do
+      expect(result.css('a').first.attr('href')).
+        to eq urls.namespace_project_issues_url(another_project.namespace,
+                                                 another_project,
+                                                 label_name: group_label.name)
+    end
+
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style')).
+        to match /background-color: #00ff00/
+    end
+
+    it 'has valid link text' do
+      expect(result.css('a').first.text).
+        to eq "#{group_label.name} in #{another_project.name}"
+    end
+
+    it 'has valid text' do
+      expect(result.text).
+        to eq "See #{group_label.name} in #{another_project.name}"
+    end
+
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  describe 'same project / same group_label complete reference' do
+    let(:group)       { create(:group) }
+    let(:project)     { create(:empty_project, :public, namespace: group) }
+    let(:group_label) { create(:group_label, group: group, color: '#00ff00') }
+    let(:reference)   { "#{project.path_with_namespace}~#{group_label.name}" }
+    let!(:result)     { reference_filter("See #{reference}", project: project) }
+
+    it 'points to referenced project issues page' do
+      expect(result.css('a').first.attr('href'))
+        .to eq urls.namespace_project_issues_url(project.namespace,
+                                                 project,
+                                                 label_name: group_label.name)
+    end
+
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style'))
+        .to match /background-color: #00ff00/
+    end
+
+    it 'has valid link text' do
+      expect(result.css('a').first.text).to eq group_label.name
+    end
+
+    it 'has valid text' do
+      expect(result.text).to eq "See #{group_label.name}"
+    end
+
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  describe 'same project / same group_label shorthand reference' do
+    let(:group)       { create(:group) }
+    let(:project)     { create(:empty_project, :public, namespace: group) }
+    let(:group_label) { create(:group_label, group: group, color: '#00ff00') }
+    let(:reference)   { "#{project.path}~#{group_label.name}" }
+    let!(:result)     { reference_filter("See #{reference}", project: project) }
+
+    it 'points to referenced project issues page' do
+      expect(result.css('a').first.attr('href'))
+        .to eq urls.namespace_project_issues_url(project.namespace,
+                                                 project,
+                                                 label_name: group_label.name)
+    end
+
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style')).
+        to match /background-color: #00ff00/
+    end
+
+    it 'has valid link text' do
+      expect(result.css('a').first.text).to eq group_label.name
+    end
+
+    it 'has valid text' do
+      expect(result.text).to eq "See #{group_label.name}"
+    end
+
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
     end
   end
 end
diff --git a/spec/lib/banzai/filter/merge_request_reference_filter_spec.rb b/spec/lib/banzai/filter/merge_request_reference_filter_spec.rb
index 274258a045c..275010c1a2c 100644
--- a/spec/lib/banzai/filter/merge_request_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/merge_request_reference_filter_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Banzai::Filter::MergeRequestReferenceFilter, lib: true do
   include FilterSpecHelper
 
-  let(:project) { create(:project, :public) }
+  let(:project) { create(:empty_project, :public) }
   let(:merge)   { create(:merge_request, source_project: project) }
 
   it 'requires project context' do
@@ -86,23 +86,97 @@ describe Banzai::Filter::MergeRequestReferenceFilter, lib: true do
     end
   end
 
-  context 'cross-project reference' do
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
-    let(:project2)  { create(:project, :public, namespace: namespace) }
-    let(:merge)     { create(:merge_request, source_project: project2) }
-    let(:reference) { merge.to_reference(project) }
+  context 'cross-project / cross-namespace complete reference' do
+    let(:project2)          { create(:empty_project, :public) }
+    let(:merge)             { create(:merge_request, source_project: project2) }
+    let(:reference)         { "#{project2.path_with_namespace}!#{merge.iid}" }
 
     it 'links to a valid reference' do
       doc = reference_filter("See #{reference}")
 
       expect(doc.css('a').first.attr('href')).
         to eq urls.namespace_project_merge_request_url(project2.namespace,
-                                                      project, merge)
+                                                       project2, merge)
     end
 
-    it 'links with adjacent text' do
+    it 'link has valid text' do
       doc = reference_filter("Merge (#{reference}.)")
-      expect(doc.to_html).to match(/\(<a.+>#{Regexp.escape(reference)}<\/a>\.\)/)
+
+      expect(doc.css('a').first.text).to eq(reference)
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Merge (#{reference}.)")
+
+      expect(doc.text).to eq("Merge (#{reference}.)")
+    end
+
+    it 'ignores invalid merge IDs on the referenced project' do
+      exp = act = "Merge #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project / same-namespace complete reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, :public, namespace: namespace) }
+    let(:project2)  { create(:empty_project, :public, namespace: namespace) }
+    let!(:merge)    { create(:merge_request, source_project: project2) }
+    let(:reference) { "#{project2.path_with_namespace}!#{merge.iid}" }
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq urls.namespace_project_merge_request_url(project2.namespace,
+                                                      project2, merge)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("Merge (#{reference}.)")
+
+      expect(doc.css('a').first.text).to eq("#{project2.path}!#{merge.iid}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Merge (#{reference}.)")
+
+      expect(doc.text).to eq("Merge (#{project2.path}!#{merge.iid}.)")
+    end
+
+    it 'ignores invalid merge IDs on the referenced project' do
+      exp = act = "Merge #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project shorthand reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, :public, namespace: namespace) }
+    let(:project2)  { create(:empty_project, :public, namespace: namespace) }
+    let!(:merge)    { create(:merge_request, source_project: project2) }
+    let(:reference) { "#{project2.path}!#{merge.iid}" }
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq urls.namespace_project_merge_request_url(project2.namespace,
+                                                      project2, merge)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("Merge (#{reference}.)")
+
+      expect(doc.css('a').first.text).to eq("#{project2.path}!#{merge.iid}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Merge (#{reference}.)")
+
+      expect(doc.text).to eq("Merge (#{project2.path}!#{merge.iid}.)")
     end
 
     it 'ignores invalid merge IDs on the referenced project' do
diff --git a/spec/lib/banzai/filter/milestone_reference_filter_spec.rb b/spec/lib/banzai/filter/milestone_reference_filter_spec.rb
index 7419863d848..73b5edb99b3 100644
--- a/spec/lib/banzai/filter/milestone_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/milestone_reference_filter_spec.rb
@@ -148,13 +148,51 @@ describe Banzai::Filter::MilestoneReferenceFilter, lib: true do
     end
   end
 
-  describe 'cross project milestone references' do
-    let(:another_project)  { create(:empty_project, :public) }
-    let(:project_path) { another_project.path_with_namespace }
-    let(:milestone) { create(:milestone, project: another_project) }
-    let(:reference) { milestone.to_reference(project) }
+  describe 'cross-project / cross-namespace complete reference' do
+    let(:namespace)       { create(:namespace) }
+    let(:another_project) { create(:empty_project, :public, namespace: namespace) }
+    let(:milestone)       { create(:milestone, project: another_project) }
+    let(:reference)       { "#{another_project.path_with_namespace}%#{milestone.iid}" }
+    let!(:result)         { reference_filter("See #{reference}") }
 
-    let!(:result) { reference_filter("See #{reference}") }
+    it 'points to referenced project milestone page' do
+      expect(result.css('a').first.attr('href')).to eq urls.
+        namespace_project_milestone_url(another_project.namespace,
+                                        another_project,
+                                        milestone)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.css('a').first.text).
+        to eq("#{milestone.name} in #{another_project.path_with_namespace}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).
+        to eq("See (#{milestone.name} in #{another_project.path_with_namespace}.)")
+    end
+
+    it 'escapes the name attribute' do
+      allow_any_instance_of(Milestone).to receive(:title).and_return(%{"></a>whatever<a title="})
+
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.text).
+        to eq "#{milestone.name} in #{another_project.path_with_namespace}"
+    end
+  end
+
+  describe 'cross-project / same-namespace complete reference' do
+    let(:namespace)       { create(:namespace) }
+    let(:project)         { create(:empty_project, :public, namespace: namespace) }
+    let(:another_project) { create(:empty_project, :public, namespace: namespace) }
+    let(:milestone)       { create(:milestone, project: another_project) }
+    let(:reference)       { "#{another_project.path_with_namespace}%#{milestone.iid}" }
+    let!(:result)         { reference_filter("See #{reference}") }
 
     it 'points to referenced project milestone page' do
       expect(result.css('a').first.attr('href')).to eq urls.
@@ -163,14 +201,66 @@ describe Banzai::Filter::MilestoneReferenceFilter, lib: true do
                                         milestone)
     end
 
-    it 'contains cross project content' do
-      expect(result.css('a').first.text).to eq "#{milestone.name} in #{project_path}"
+    it 'link has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.css('a').first.text).
+        to eq("#{milestone.name} in #{another_project.path}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).
+        to eq("See (#{milestone.name} in #{another_project.path}.)")
     end
 
     it 'escapes the name attribute' do
       allow_any_instance_of(Milestone).to receive(:title).and_return(%{"></a>whatever<a title="})
+
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.text).
+        to eq "#{milestone.name} in #{another_project.path}"
+    end
+  end
+
+  describe 'cross project shorthand reference' do
+    let(:namespace)       { create(:namespace) }
+    let(:project)         { create(:empty_project, :public, namespace: namespace) }
+    let(:another_project) { create(:empty_project, :public, namespace: namespace) }
+    let(:milestone)       { create(:milestone, project: another_project) }
+    let(:reference)       { "#{another_project.path}%#{milestone.iid}" }
+    let!(:result)         { reference_filter("See #{reference}") }
+
+    it 'points to referenced project milestone page' do
+      expect(result.css('a').first.attr('href')).to eq urls.
+        namespace_project_milestone_url(another_project.namespace,
+                                        another_project,
+                                        milestone)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.css('a').first.text).
+        to eq("#{milestone.name} in #{another_project.path}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).
+        to eq("See (#{milestone.name} in #{another_project.path}.)")
+    end
+
+    it 'escapes the name attribute' do
+      allow_any_instance_of(Milestone).to receive(:title).and_return(%{"></a>whatever<a title="})
+
       doc = reference_filter("See #{reference}")
-      expect(doc.css('a').first.text).to eq "#{milestone.name} in #{project_path}"
+
+      expect(doc.css('a').first.text).
+        to eq "#{milestone.name} in #{another_project.path}"
     end
   end
 end
diff --git a/spec/lib/banzai/filter/snippet_reference_filter_spec.rb b/spec/lib/banzai/filter/snippet_reference_filter_spec.rb
index 9b92d1a3926..e036514d283 100644
--- a/spec/lib/banzai/filter/snippet_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/snippet_reference_filter_spec.rb
@@ -79,11 +79,11 @@ describe Banzai::Filter::SnippetReferenceFilter, lib: true do
     end
   end
 
-  context 'cross-project reference' do
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
+  context 'cross-project / cross-namespace complete reference' do
+    let(:namespace) { create(:namespace) }
     let(:project2)  { create(:empty_project, :public, namespace: namespace) }
-    let(:snippet)   { create(:project_snippet, project: project2) }
-    let(:reference) { snippet.to_reference(project) }
+    let!(:snippet)  { create(:project_snippet, project: project2) }
+    let(:reference) { "#{project2.path_with_namespace}$#{snippet.id}" }
 
     it 'links to a valid reference' do
       doc = reference_filter("See #{reference}")
@@ -92,9 +92,82 @@ describe Banzai::Filter::SnippetReferenceFilter, lib: true do
         to eq urls.namespace_project_snippet_url(project2.namespace, project2, snippet)
     end
 
-    it 'links with adjacent text' do
+    it 'link has valid text' do
       doc = reference_filter("See (#{reference}.)")
-      expect(doc.to_html).to match(/\(<a.+>#{Regexp.escape(reference)}<\/a>\.\)/)
+
+      expect(doc.css('a').first.text).to eql(reference)
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).to eql("See (#{reference}.)")
+    end
+
+    it 'ignores invalid snippet IDs on the referenced project' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project / same-namespace complete reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, :public, namespace: namespace) }
+    let(:project2)  { create(:empty_project, :public, namespace: namespace) }
+    let!(:snippet)  { create(:project_snippet, project: project2) }
+    let(:reference) { "#{project2.path_with_namespace}$#{snippet.id}" }
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq urls.namespace_project_snippet_url(project2.namespace, project2, snippet)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("See (#{project2.path}$#{snippet.id}.)")
+
+      expect(doc.css('a').first.text).to eql("#{project2.path}$#{snippet.id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{project2.path}$#{snippet.id}.)")
+
+      expect(doc.text).to eql("See (#{project2.path}$#{snippet.id}.)")
+    end
+
+    it 'ignores invalid snippet IDs on the referenced project' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project shorthand reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, :public, namespace: namespace) }
+    let(:project2)  { create(:empty_project, :public, namespace: namespace) }
+    let!(:snippet)  { create(:project_snippet, project: project2) }
+    let(:reference) { "#{project2.path}$#{snippet.id}" }
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq urls.namespace_project_snippet_url(project2.namespace, project2, snippet)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("See (#{project2.path}$#{snippet.id}.)")
+
+      expect(doc.css('a').first.text).to eql("#{project2.path}$#{snippet.id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{project2.path}$#{snippet.id}.)")
+
+      expect(doc.text).to eql("See (#{project2.path}$#{snippet.id}.)")
     end
 
     it 'ignores invalid snippet IDs on the referenced project' do
diff --git a/spec/lib/gitlab/backup/manager_spec.rb b/spec/lib/gitlab/backup/manager_spec.rb
new file mode 100644
index 00000000000..1b749d1bd39
--- /dev/null
+++ b/spec/lib/gitlab/backup/manager_spec.rb
@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Backup::Manager, lib: true do
+  describe '#remove_old' do
+    let(:progress) { StringIO.new }
+
+    let(:files) do
+      [
+        '1451606400_2016_01_01_gitlab_backup.tar',
+        '1451520000_2015_12_31_gitlab_backup.tar',
+        '1450742400_2015_12_22_gitlab_backup.tar',
+        '1449878400_gitlab_backup.tar',
+        '1449014400_gitlab_backup.tar',
+        'manual_gitlab_backup.tar'
+      ]
+    end
+
+    before do
+      allow(Dir).to receive(:chdir).and_yield
+      allow(Dir).to receive(:glob).and_return(files)
+      allow(FileUtils).to receive(:rm)
+      allow(Time).to receive(:now).and_return(Time.utc(2016))
+
+      allow(progress).to receive(:puts)
+      allow(progress).to receive(:print)
+
+      allow_any_instance_of(String).to receive(:color) do |string, _color|
+        string
+      end
+
+      @old_progress = $progress # rubocop:disable Style/GlobalVars
+      $progress = progress # rubocop:disable Style/GlobalVars
+    end
+
+    after do
+      $progress = @old_progress # rubocop:disable Style/GlobalVars
+    end
+
+    context 'when keep_time is zero' do
+      before do
+        allow(Gitlab.config.backup).to receive(:keep_time).and_return(0)
+
+        subject.remove_old
+      end
+
+      it 'removes no files' do
+        expect(FileUtils).not_to have_received(:rm)
+      end
+
+      it 'prints a skipped message' do
+        expect(progress).to have_received(:puts).with('skipping')
+      end
+    end
+
+    context 'when there are no files older than keep_time' do
+      before do
+        allow(Gitlab.config.backup).to receive(:keep_time).and_return(2592000)
+
+        subject.remove_old
+      end
+
+      it 'removes no files' do
+        expect(FileUtils).not_to have_received(:rm)
+      end
+
+      it 'prints a done message' do
+        expect(progress).to have_received(:puts).with('done. (0 removed)')
+      end
+    end
+
+    context 'when keep_time is set to remove files' do
+      before do
+        allow(Gitlab.config.backup).to receive(:keep_time).and_return(1)
+
+        subject.remove_old
+      end
+
+      it 'removes matching files with a human-readable timestamp' do
+        expect(FileUtils).to have_received(:rm).with(files[1])
+        expect(FileUtils).to have_received(:rm).with(files[2])
+      end
+
+      it 'removes matching files without a human-readable timestamp' do
+        expect(FileUtils).to have_received(:rm).with(files[3])
+        expect(FileUtils).to have_received(:rm).with(files[4])
+      end
+
+      it 'does not remove files that are not old enough' do
+        expect(FileUtils).not_to have_received(:rm).with(files[0])
+      end
+
+      it 'does not remove non-matching files' do
+        expect(FileUtils).not_to have_received(:rm).with(files[5])
+      end
+
+      it 'prints a done message' do
+        expect(progress).to have_received(:puts).with('done. (4 removed)')
+      end
+    end
+
+    context 'when removing a file fails' do
+      let(:file) { files[1] }
+      let(:message) { "Permission denied @ unlink_internal - #{file}" }
+
+      before do
+        allow(Gitlab.config.backup).to receive(:keep_time).and_return(1)
+        allow(FileUtils).to receive(:rm).with(file).and_raise(Errno::EACCES, message)
+
+        subject.remove_old
+      end
+
+      it 'removes the remaining expected files' do
+        expect(FileUtils).to have_received(:rm).with(files[2])
+        expect(FileUtils).to have_received(:rm).with(files[3])
+        expect(FileUtils).to have_received(:rm).with(files[4])
+      end
+
+      it 'sets the correct removed count' do
+        expect(progress).to have_received(:puts).with('done. (3 removed)')
+      end
+
+      it 'prints the error from file that could not be removed' do
+        expect(progress).to have_received(:puts).with(a_string_matching(message))
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/chat_commands/issue_create_spec.rb b/spec/lib/gitlab/chat_commands/issue_create_spec.rb
index dd07cff9243..6c71e79ff6d 100644
--- a/spec/lib/gitlab/chat_commands/issue_create_spec.rb
+++ b/spec/lib/gitlab/chat_commands/issue_create_spec.rb
@@ -57,5 +57,12 @@ describe Gitlab::ChatCommands::IssueCreate, service: true do
       expect(match[:title]).to eq('my title')
       expect(match[:description]).to eq('description')
     end
+
+    it 'matches the alias new' do
+      match = described_class.match("issue new my title")
+
+      expect(match).not_to be_nil
+      expect(match[:title]).to eq('my title')
+    end
   end
 end
diff --git a/spec/lib/gitlab/ci/status/canceled_spec.rb b/spec/lib/gitlab/ci/status/canceled_spec.rb
new file mode 100644
index 00000000000..619ecbcba67
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/canceled_spec.rb
@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Canceled do
+  subject { described_class.new(double('subject')) }
+
+  describe '#text' do
+    it { expect(subject.label).to eq 'canceled' }
+  end
+
+  describe '#label' do
+    it { expect(subject.label).to eq 'canceled' }
+  end
+
+  describe '#icon' do
+    it { expect(subject.icon).to eq 'icon_status_canceled' }
+  end
+
+  describe '#title' do
+    it { expect(subject.title).to eq 'Double: canceled' }
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/created_spec.rb b/spec/lib/gitlab/ci/status/created_spec.rb
new file mode 100644
index 00000000000..157302c65a8
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/created_spec.rb
@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Created do
+  subject { described_class.new(double('subject')) }
+
+  describe '#text' do
+    it { expect(subject.label).to eq 'created' }
+  end
+
+  describe '#label' do
+    it { expect(subject.label).to eq 'created' }
+  end
+
+  describe '#icon' do
+    it { expect(subject.icon).to eq 'icon_status_created' }
+  end
+
+  describe '#title' do
+    it { expect(subject.title).to eq 'Double: created' }
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/extended_spec.rb b/spec/lib/gitlab/ci/status/extended_spec.rb
new file mode 100644
index 00000000000..120e121aae5
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/extended_spec.rb
@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Extended do
+  subject do
+    Class.new.extend(described_class)
+  end
+
+  it 'requires subclass to implement matcher' do
+    expect { subject.matches?(double) }
+      .to raise_error(NotImplementedError)
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/failed_spec.rb b/spec/lib/gitlab/ci/status/failed_spec.rb
new file mode 100644
index 00000000000..0b3cb8168e6
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/failed_spec.rb
@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Failed do
+  subject { described_class.new(double('subject')) }
+
+  describe '#text' do
+    it { expect(subject.label).to eq 'failed' }
+  end
+
+  describe '#label' do
+    it { expect(subject.label).to eq 'failed' }
+  end
+
+  describe '#icon' do
+    it { expect(subject.icon).to eq 'icon_status_failed' }
+  end
+
+  describe '#title' do
+    it { expect(subject.title).to eq 'Double: failed' }
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/pending_spec.rb b/spec/lib/gitlab/ci/status/pending_spec.rb
new file mode 100644
index 00000000000..57c901c1202
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/pending_spec.rb
@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Pending do
+  subject { described_class.new(double('subject')) }
+
+  describe '#text' do
+    it { expect(subject.label).to eq 'pending' }
+  end
+
+  describe '#label' do
+    it { expect(subject.label).to eq 'pending' }
+  end
+
+  describe '#icon' do
+    it { expect(subject.icon).to eq 'icon_status_pending' }
+  end
+
+  describe '#title' do
+    it { expect(subject.title).to eq 'Double: pending' }
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/pipeline/common_spec.rb b/spec/lib/gitlab/ci/status/pipeline/common_spec.rb
new file mode 100644
index 00000000000..21adee3f8e7
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/pipeline/common_spec.rb
@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Pipeline::Common do
+  let(:pipeline) { create(:ci_pipeline) }
+
+  subject do
+    Class.new(Gitlab::Ci::Status::Core)
+      .new(pipeline).extend(described_class)
+  end
+
+  it 'does not have action' do
+    expect(subject).not_to have_action
+  end
+
+  it 'has details' do
+    expect(subject).to have_details
+  end
+
+  it 'links to the pipeline details page' do
+    expect(subject.details_path)
+      .to include "pipelines/#{pipeline.id}"
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/pipeline/factory_spec.rb b/spec/lib/gitlab/ci/status/pipeline/factory_spec.rb
new file mode 100644
index 00000000000..d6243940f2e
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/pipeline/factory_spec.rb
@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Pipeline::Factory do
+  subject do
+    described_class.new(pipeline)
+  end
+
+  let(:status) do
+    subject.fabricate!
+  end
+
+  context 'when pipeline has a core status' do
+    HasStatus::AVAILABLE_STATUSES.each do |core_status|
+      context "when core status is #{core_status}" do
+        let(:pipeline) do
+          create(:ci_pipeline, status: core_status)
+        end
+
+        it "fabricates a core status #{core_status}" do
+          expect(status).to be_a(
+            Gitlab::Ci::Status.const_get(core_status.capitalize))
+        end
+
+        it 'extends core status with common pipeline methods' do
+          expect(status).to have_details
+          expect(status).not_to have_action
+          expect(status.details_path)
+            .to include "pipelines/#{pipeline.id}"
+        end
+      end
+    end
+  end
+
+  context 'when pipeline has warnings' do
+    let(:pipeline) do
+      create(:ci_pipeline, status: :success)
+    end
+
+    before do
+      create(:ci_build, :allowed_to_fail, :failed, pipeline: pipeline)
+    end
+
+    it 'fabricates extended "success with warnings" status' do
+      expect(status)
+        .to be_a Gitlab::Ci::Status::Pipeline::SuccessWithWarnings
+    end
+
+    it 'extends core status with common pipeline methods' do
+      expect(status).to have_details
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/pipeline/success_with_warnings_spec.rb b/spec/lib/gitlab/ci/status/pipeline/success_with_warnings_spec.rb
new file mode 100644
index 00000000000..02e526e3de2
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/pipeline/success_with_warnings_spec.rb
@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Pipeline::SuccessWithWarnings do
+  subject do
+    described_class.new(double('status'))
+  end
+
+  describe '#test' do
+    it { expect(subject.text).to eq 'passed' }
+  end
+
+  describe '#label' do
+    it { expect(subject.label).to eq 'passed with warnings' }
+  end
+
+  describe '#icon' do
+    it { expect(subject.icon).to eq 'icon_status_warning' }
+  end
+
+  describe '.matches?' do
+    context 'when pipeline is successful' do
+      let(:pipeline) do
+        create(:ci_pipeline, status: :success)
+      end
+
+      context 'when pipeline has warnings' do
+        before do
+          allow(pipeline).to receive(:has_warnings?).and_return(true)
+        end
+
+        it 'is a correct match' do
+          expect(described_class.matches?(pipeline)).to eq true
+        end
+      end
+
+      context 'when pipeline does not have warnings' do
+        it 'does not match' do
+          expect(described_class.matches?(pipeline)).to eq false
+        end
+      end
+    end
+
+    context 'when pipeline is not successful' do
+      let(:pipeline) do
+        create(:ci_pipeline, status: :skipped)
+      end
+
+      context 'when pipeline has warnings' do
+        before do
+          allow(pipeline).to receive(:has_warnings?).and_return(true)
+        end
+
+        it 'does not match' do
+          expect(described_class.matches?(pipeline)).to eq false
+        end
+      end
+
+      context 'when pipeline does not have warnings' do
+        it 'does not match' do
+          expect(described_class.matches?(pipeline)).to eq false
+        end
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/running_spec.rb b/spec/lib/gitlab/ci/status/running_spec.rb
new file mode 100644
index 00000000000..c023f1872cc
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/running_spec.rb
@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Running do
+  subject { described_class.new(double('subject')) }
+
+  describe '#text' do
+    it { expect(subject.label).to eq 'running' }
+  end
+
+  describe '#label' do
+    it { expect(subject.label).to eq 'running' }
+  end
+
+  describe '#icon' do
+    it { expect(subject.icon).to eq 'icon_status_running' }
+  end
+
+  describe '#title' do
+    it { expect(subject.title).to eq 'Double: running' }
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/skipped_spec.rb b/spec/lib/gitlab/ci/status/skipped_spec.rb
new file mode 100644
index 00000000000..d4f7f4b3b70
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/skipped_spec.rb
@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Skipped do
+  subject { described_class.new(double('subject')) }
+
+  describe '#text' do
+    it { expect(subject.label).to eq 'skipped' }
+  end
+
+  describe '#label' do
+    it { expect(subject.label).to eq 'skipped' }
+  end
+
+  describe '#icon' do
+    it { expect(subject.icon).to eq 'icon_status_skipped' }
+  end
+
+  describe '#title' do
+    it { expect(subject.title).to eq 'Double: skipped' }
+  end
+end
diff --git a/spec/lib/gitlab/ci/status/success_spec.rb b/spec/lib/gitlab/ci/status/success_spec.rb
new file mode 100644
index 00000000000..9e261a3aa5f
--- /dev/null
+++ b/spec/lib/gitlab/ci/status/success_spec.rb
@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Gitlab::Ci::Status::Success do
+  subject { described_class.new(double('subject')) }
+
+  describe '#text' do
+    it { expect(subject.label).to eq 'passed' }
+  end
+
+  describe '#label' do
+    it { expect(subject.label).to eq 'passed' }
+  end
+
+  describe '#icon' do
+    it { expect(subject.icon).to eq 'icon_status_success' }
+  end
+
+  describe '#title' do
+    it { expect(subject.title).to eq 'Double: passed' }
+  end
+end
diff --git a/spec/lib/gitlab/cycle_analytics/permissions_spec.rb b/spec/lib/gitlab/cycle_analytics/permissions_spec.rb
index dc4f7dc69db..2d85e712db0 100644
--- a/spec/lib/gitlab/cycle_analytics/permissions_spec.rb
+++ b/spec/lib/gitlab/cycle_analytics/permissions_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Gitlab::CycleAnalytics::Permissions do
-  let(:project) { create(:empty_project) }
+  let(:project) { create(:empty_project, public_builds: false) }
   let(:user) { create(:user) }
 
   subject { described_class.get(user: user, project: project) }
diff --git a/spec/lib/gitlab/gfm/reference_rewriter_spec.rb b/spec/lib/gitlab/gfm/reference_rewriter_spec.rb
index 6b3dfebd85d..d619e401897 100644
--- a/spec/lib/gitlab/gfm/reference_rewriter_spec.rb
+++ b/spec/lib/gitlab/gfm/reference_rewriter_spec.rb
@@ -64,7 +64,7 @@ describe Gitlab::Gfm::ReferenceRewriter do
 
         context 'description with project labels' do
           let!(:label) { create(:label, id: 123, name: 'test', project: old_project) }
-          let(:project_ref) { old_project.to_reference }
+          let(:project_ref) { old_project.to_reference(new_project) }
 
           context 'label referenced by id' do
             let(:text) { '#1 and ~123' }
@@ -80,7 +80,7 @@ describe Gitlab::Gfm::ReferenceRewriter do
         context 'description with group labels' do
           let(:old_group) { create(:group) }
           let!(:group_label) { create(:group_label, id: 321, name: 'group label', group: old_group) }
-          let(:project_ref) { old_project.to_reference }
+          let(:project_ref) { old_project.to_reference(new_project) }
 
           before do
             old_project.update(namespace: old_group)
diff --git a/spec/lib/gitlab/github_import/importer_spec.rb b/spec/lib/gitlab/github_import/importer_spec.rb
index 000b9aa6f83..9e027839f59 100644
--- a/spec/lib/gitlab/github_import/importer_spec.rb
+++ b/spec/lib/gitlab/github_import/importer_spec.rb
@@ -155,7 +155,7 @@ describe Gitlab::GithubImport::Importer, lib: true do
           message: 'The remote data could not be fully imported.',
           errors: [
             { type: :label, url: "https://api.github.com/repos/octocat/Hello-World/labels/bug", errors: "Validation failed: Title can't be blank, Title is invalid" },
-            { type: :issue, url: "https://api.github.com/repos/octocat/Hello-World/issues/1348", errors: "Validation failed: Title can't be blank, Title is too short (minimum is 0 characters)" },
+            { type: :issue, url: "https://api.github.com/repos/octocat/Hello-World/issues/1348", errors: "Validation failed: Title can't be blank" },
             { type: :wiki, errors: "Gitlab::Shell::Error" },
             { type: :release, url: 'https://api.github.com/repos/octocat/Hello-World/releases/2', errors: "Validation failed: Description can't be blank" }
           ]
diff --git a/spec/lib/gitlab/import_export/members_mapper_spec.rb b/spec/lib/gitlab/import_export/members_mapper_spec.rb
index 770e8b0c2f4..1cb02f8e318 100644
--- a/spec/lib/gitlab/import_export/members_mapper_spec.rb
+++ b/spec/lib/gitlab/import_export/members_mapper_spec.rb
@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe Gitlab::ImportExport::MembersMapper, services: true do
   describe 'map members' do
-    let(:user) { create(:user) }
+    let(:user) { create(:user, authorized_projects_populated: true) }
     let(:project) { create(:project, :public, name: 'searchable_project') }
-    let(:user2) { create(:user) }
+    let(:user2) { create(:user, authorized_projects_populated: true) }
     let(:exported_user_id) { 99 }
     let(:exported_members) do
       [{
@@ -67,5 +67,12 @@ describe Gitlab::ImportExport::MembersMapper, services: true do
 
       expect(ProjectMember.find_by_invite_email('invite@test.com')).not_to be_nil
     end
+
+    it 'authorizes the users to the project' do
+      members_mapper.map
+
+      expect(user.authorized_project?(project)).to be true
+      expect(user2.authorized_project?(project)).to be true
+    end
   end
 end