Merge branch 'master' into feature/gb/manual-actions-protected-branches-permissions

* master: (274 commits)
  Update VERSION to 9.2.0-pre
  Update CHANGELOG.md for 9.1.0
  Update Auto Deploy documentation
  Disable import URL field in New project form since it's hidden by default
  Remove reference to burndown charts since they don't exist for ce.
  Use master_password for Sentinel
  Refactor Discussions docs
  Start versioning cached markdown fields
  Refactor add_users method for project and group
  Improved the spec Now correctly tests against different forms
  Refactor environments components into vue files - part 3
  Adding animation for all dropdown
  fix placeholder visibility
  submodule_links: handle urls that don't end with .git
  Add help regarding vue resource and where to include it
  Append .json to ajax endpoint to prevent browser to display raw json
  Fixed the preview keyboard shortcut focusing wrong tab
  Fix broken link
  Added new discussions docs
  Started on resolvable discussions docs
  ...

16 files changed, 510 insertions, 136 deletions

diff --git a/spec/lib/banzai/filter/issuable_state_filter_spec.rb b/spec/lib/banzai/filter/issuable_state_filter_spec.rb
index 603b79a323c..600f3c123ed 100644
--- a/spec/lib/banzai/filter/issuable_state_filter_spec.rb
+++ b/spec/lib/banzai/filter/issuable_state_filter_spec.rb
@@ -5,9 +5,10 @@ describe Banzai::Filter::IssuableStateFilter, lib: true do
   include FilterSpecHelper
 
   let(:user) { create(:user) }
+  let(:context) { { current_user: user, issuable_state_filter_enabled: true } }
 
-  def create_link(data)
-    link_to('text', '', class: 'gfm has-tooltip', data: data)
+  def create_link(text, data)
+    link_to(text, '', class: 'gfm has-tooltip', data: data)
   end
 
   it 'ignores non-GFM links' do
@@ -19,8 +20,62 @@ describe Banzai::Filter::IssuableStateFilter, lib: true do
 
   it 'ignores non-issuable links' do
     project = create(:empty_project, :public)
-    link = create_link(project: project, reference_type: 'issue')
-    doc = filter(link, current_user: user)
+    link = create_link('text', project: project, reference_type: 'issue')
+    doc = filter(link, context)
+
+    expect(doc.css('a').last.text).to eq('text')
+  end
+
+  it 'ignores issuable links with empty content' do
+    issue = create(:issue, :closed)
+    link = create_link('', issue: issue.id, reference_type: 'issue')
+    doc = filter(link, context)
+
+    expect(doc.css('a').last.text).to eq('')
+  end
+
+  it 'ignores issuable links with custom anchor' do
+    issue = create(:issue, :closed)
+    link = create_link('something', issue: issue.id, reference_type: 'issue')
+    doc = filter(link, context)
+
+    expect(doc.css('a').last.text).to eq('something')
+  end
+
+  it 'ignores issuable links to specific comments' do
+    issue = create(:issue, :closed)
+    link = create_link("#{issue.to_reference} (comment 1)", issue: issue.id, reference_type: 'issue')
+    doc = filter(link, context)
+
+    expect(doc.css('a').last.text).to eq("#{issue.to_reference} (comment 1)")
+  end
+
+  it 'ignores merge request links to diffs tab' do
+    merge_request = create(:merge_request, :closed)
+    link = create_link(
+      "#{merge_request.to_reference} (diffs)",
+      merge_request: merge_request.id,
+      reference_type: 'merge_request'
+    )
+    doc = filter(link, context)
+
+    expect(doc.css('a').last.text).to eq("#{merge_request.to_reference} (diffs)")
+  end
+
+  it 'handles cross project references' do
+    issue = create(:issue, :closed)
+    project = create(:empty_project)
+    link = create_link(issue.to_reference(project), issue: issue.id, reference_type: 'issue')
+    doc = filter(link, context.merge(project: project))
+
+    expect(doc.css('a').last.text).to eq("#{issue.to_reference(project)} (closed)")
+  end
+
+  it 'does not append state when filter is not enabled' do
+    issue = create(:issue, :closed)
+    link = create_link('text', issue: issue.id, reference_type: 'issue')
+    context = { current_user: user }
+    doc = filter(link, context)
 
     expect(doc.css('a').last.text).to eq('text')
   end
@@ -28,68 +83,88 @@ describe Banzai::Filter::IssuableStateFilter, lib: true do
   context 'for issue references' do
     it 'ignores open issue references' do
       issue = create(:issue)
-      link = create_link(issue: issue.id, reference_type: 'issue')
-      doc = filter(link, current_user: user)
+      link = create_link(issue.to_reference, issue: issue.id, reference_type: 'issue')
+      doc = filter(link, context)
 
-      expect(doc.css('a').last.text).to eq('text')
+      expect(doc.css('a').last.text).to eq(issue.to_reference)
     end
 
     it 'ignores reopened issue references' do
-      reopened_issue = create(:issue, :reopened)
-      link = create_link(issue: reopened_issue.id, reference_type: 'issue')
-      doc = filter(link, current_user: user)
+      issue = create(:issue, :reopened)
+      link = create_link(issue.to_reference, issue: issue.id, reference_type: 'issue')
+      doc = filter(link, context)
 
-      expect(doc.css('a').last.text).to eq('text')
+      expect(doc.css('a').last.text).to eq(issue.to_reference)
     end
 
-    it 'appends [closed] to closed issue references' do
-      closed_issue = create(:issue, :closed)
-      link = create_link(issue: closed_issue.id, reference_type: 'issue')
-      doc = filter(link, current_user: user)
+    it 'appends state to closed issue references' do
+      issue = create(:issue, :closed)
+      link = create_link(issue.to_reference, issue: issue.id, reference_type: 'issue')
+      doc = filter(link, context)
 
-      expect(doc.css('a').last.text).to eq('text [closed]')
+      expect(doc.css('a').last.text).to eq("#{issue.to_reference} (closed)")
     end
   end
 
   context 'for merge request references' do
     it 'ignores open merge request references' do
-      mr = create(:merge_request)
-      link = create_link(merge_request: mr.id, reference_type: 'merge_request')
-      doc = filter(link, current_user: user)
-
-      expect(doc.css('a').last.text).to eq('text')
+      merge_request = create(:merge_request)
+      link = create_link(
+        merge_request.to_reference,
+        merge_request: merge_request.id,
+        reference_type: 'merge_request'
+      )
+      doc = filter(link, context)
+
+      expect(doc.css('a').last.text).to eq(merge_request.to_reference)
     end
 
     it 'ignores reopened merge request references' do
-      mr = create(:merge_request, :reopened)
-      link = create_link(merge_request: mr.id, reference_type: 'merge_request')
-      doc = filter(link, current_user: user)
-
-      expect(doc.css('a').last.text).to eq('text')
+      merge_request = create(:merge_request, :reopened)
+      link = create_link(
+        merge_request.to_reference,
+        merge_request: merge_request.id,
+        reference_type: 'merge_request'
+      )
+      doc = filter(link, context)
+
+      expect(doc.css('a').last.text).to eq(merge_request.to_reference)
     end
 
     it 'ignores locked merge request references' do
-      mr = create(:merge_request, :locked)
-      link = create_link(merge_request: mr.id, reference_type: 'merge_request')
-      doc = filter(link, current_user: user)
-
-      expect(doc.css('a').last.text).to eq('text')
+      merge_request = create(:merge_request, :locked)
+      link = create_link(
+        merge_request.to_reference,
+        merge_request: merge_request.id,
+        reference_type: 'merge_request'
+      )
+      doc = filter(link, context)
+
+      expect(doc.css('a').last.text).to eq(merge_request.to_reference)
     end
 
-    it 'appends [closed] to closed merge request references' do
-      mr = create(:merge_request, :closed)
-      link = create_link(merge_request: mr.id, reference_type: 'merge_request')
-      doc = filter(link, current_user: user)
+    it 'appends state to closed merge request references' do
+      merge_request = create(:merge_request, :closed)
+      link = create_link(
+        merge_request.to_reference,
+        merge_request: merge_request.id,
+        reference_type: 'merge_request'
+      )
+      doc = filter(link, context)
 
-      expect(doc.css('a').last.text).to eq('text [closed]')
+      expect(doc.css('a').last.text).to eq("#{merge_request.to_reference} (closed)")
     end
 
-    it 'appends [merged] to merged merge request references' do
-      mr = create(:merge_request, :merged)
-      link = create_link(merge_request: mr.id, reference_type: 'merge_request')
-      doc = filter(link, current_user: user)
+    it 'appends state to merged merge request references' do
+      merge_request = create(:merge_request, :merged)
+      link = create_link(
+        merge_request.to_reference,
+        merge_request: merge_request.id,
+        reference_type: 'merge_request'
+      )
+      doc = filter(link, context)
 
-      expect(doc.css('a').last.text).to eq('text [merged]')
+      expect(doc.css('a').last.text).to eq("#{merge_request.to_reference} (merged)")
     end
   end
 end
diff --git a/spec/lib/banzai/filter/plantuml_filter_spec.rb b/spec/lib/banzai/filter/plantuml_filter_spec.rb
index f85a5dcbd8b..9b8ecb201f3 100644
--- a/spec/lib/banzai/filter/plantuml_filter_spec.rb
+++ b/spec/lib/banzai/filter/plantuml_filter_spec.rb
@@ -5,7 +5,7 @@ describe Banzai::Filter::PlantumlFilter, lib: true do
 
   it 'should replace plantuml pre tag with img tag' do
     stub_application_setting(plantuml_enabled: true, plantuml_url: "http://localhost:8080")
-    input = '<pre class="plantuml"><code>Bob -> Sara : Hello</code><pre>'
+    input = '<pre><code lang="plantuml">Bob -> Sara : Hello</code></pre>'
     output = '<div class="imageblock"><div class="content"><img class="plantuml" src="http://localhost:8080/png/U9npoazIqBLJ24uiIbImKl18pSd91m0rkGMq"></div></div>'
     doc = filter(input)
 
@@ -14,8 +14,8 @@ describe Banzai::Filter::PlantumlFilter, lib: true do
 
   it 'should not replace plantuml pre tag with img tag if disabled' do
     stub_application_setting(plantuml_enabled: false)
-    input = '<pre class="plantuml"><code>Bob -> Sara : Hello</code><pre>'
-    output = '<pre class="plantuml"><code>Bob -&gt; Sara : Hello</code><pre></pre></pre>'
+    input = '<pre><code lang="plantuml">Bob -> Sara : Hello</code></pre>'
+    output = '<pre><code lang="plantuml">Bob -&gt; Sara : Hello</code></pre>'
     doc = filter(input)
 
     expect(doc.to_s).to eq output
@@ -23,7 +23,7 @@ describe Banzai::Filter::PlantumlFilter, lib: true do
 
   it 'should not replace plantuml pre tag with img tag if url is invalid' do
     stub_application_setting(plantuml_enabled: true, plantuml_url: "invalid")
-    input = '<pre class="plantuml"><code>Bob -> Sara : Hello</code><pre>'
+    input = '<pre><code lang="plantuml">Bob -> Sara : Hello</code></pre>'
     output = '<div class="listingblock"><div class="content"><pre class="plantuml plantuml-error"> PlantUML Error: cannot connect to PlantUML server at "invalid"</pre></div></div>'
     doc = filter(input)
 
diff --git a/spec/lib/banzai/object_renderer_spec.rb b/spec/lib/banzai/object_renderer_spec.rb
index 4817fcd031a..dd2674f9f20 100644
--- a/spec/lib/banzai/object_renderer_spec.rb
+++ b/spec/lib/banzai/object_renderer_spec.rb
@@ -4,13 +4,13 @@ describe Banzai::ObjectRenderer do
   let(:project) { create(:empty_project) }
   let(:user) { project.owner }
   let(:renderer) { described_class.new(project, user, custom_value: 'value') }
-  let(:object) { Note.new(note: 'hello', note_html: '<p>hello</p>') }
+  let(:object) { Note.new(note: 'hello', note_html: '<p dir="auto">hello</p>', cached_markdown_version: CacheMarkdownField::CACHE_VERSION) }
 
   describe '#render' do
     it 'renders and redacts an Array of objects' do
       renderer.render([object], :note)
 
-      expect(object.redacted_note_html).to eq '<p>hello</p>'
+      expect(object.redacted_note_html).to eq '<p dir="auto">hello</p>'
       expect(object.user_visible_reference_count).to eq 0
     end
 
diff --git a/spec/lib/banzai/redactor_spec.rb b/spec/lib/banzai/redactor_spec.rb
index 6d2c141e18b..e6f2963193c 100644
--- a/spec/lib/banzai/redactor_spec.rb
+++ b/spec/lib/banzai/redactor_spec.rb
@@ -42,6 +42,31 @@ describe Banzai::Redactor do
       end
     end
 
+    context 'when project is in pending delete' do
+      let!(:issue) { create(:issue, project: project) }
+      let(:redactor) { described_class.new(project, user) }
+
+      before do
+        project.update(pending_delete: true)
+      end
+
+      it 'redacts an issue attached' do
+        doc = Nokogiri::HTML.fragment("<a class='gfm' data-reference-type='issue' data-issue='#{issue.id}'>foo</a>")
+
+        redactor.redact([doc])
+
+        expect(doc.to_html).to eq('foo')
+      end
+
+      it 'redacts an external issue' do
+        doc = Nokogiri::HTML.fragment("<a class='gfm' data-reference-type='issue' data-external-issue='#{issue.id}' data-project='#{project.id}'>foo</a>")
+
+        redactor.redact([doc])
+
+        expect(doc.to_html).to eq('foo')
+      end
+    end
+
     context 'when reference visible to user' do
       it 'does not redact an array of documents' do
         doc1_html = '<a class="gfm" data-reference-type="issue">foo</a>'
diff --git a/spec/lib/banzai/reference_parser/base_parser_spec.rb b/spec/lib/banzai/reference_parser/base_parser_spec.rb
index a3141894c74..d5746107ee1 100644
--- a/spec/lib/banzai/reference_parser/base_parser_spec.rb
+++ b/spec/lib/banzai/reference_parser/base_parser_spec.rb
@@ -114,8 +114,27 @@ describe Banzai::ReferenceParser::BaseParser, lib: true do
       expect(hash).to eq({ link => user })
     end
 
-    it 'returns an empty Hash when the list of nodes is empty' do
-      expect(subject.grouped_objects_for_nodes([], User, 'data-user')).to eq({})
+    it 'returns an empty Hash when entry does not exist in the database' do
+      link = double(:link)
+
+      expect(link).to receive(:has_attribute?).
+          with('data-user').
+          and_return(true)
+
+      expect(link).to receive(:attr).
+          with('data-user').
+          and_return('1')
+
+      nodes = [link]
+      bad_id = user.id + 100
+
+      expect(subject).to receive(:unique_attribute_values).
+          with(nodes, 'data-user').
+          and_return([bad_id.to_s])
+
+      hash = subject.grouped_objects_for_nodes(nodes, User, 'data-user')
+
+      expect(hash).to eq({})
     end
   end
 
diff --git a/spec/lib/banzai/renderer_spec.rb b/spec/lib/banzai/renderer_spec.rb
index aaa6b12e67e..e6f8d2a1fed 100644
--- a/spec/lib/banzai/renderer_spec.rb
+++ b/spec/lib/banzai/renderer_spec.rb
@@ -1,73 +1,36 @@
 require 'spec_helper'
 
 describe Banzai::Renderer do
-  def expect_render(project = :project)
-    expected_context = { project: project }
-    expect(renderer).to receive(:cacheless_render) { :html }.with(:markdown, expected_context)
-  end
-
-  def expect_cache_update
-    expect(object).to receive(:update_column).with("field_html", :html)
-  end
-
-  def fake_object(*features)
-    markdown = :markdown if features.include?(:markdown)
-    html = :html if features.include?(:html)
-
-    object = double(
-      "object",
-      banzai_render_context: { project: :project },
-      field: markdown,
-      field_html: html
-    )
+  def fake_object(fresh:)
+    object = double('object')
 
-    allow(object).to receive(:markdown_cache_field_for).with(:field).and_return("field_html")
-    allow(object).to receive(:new_record?).and_return(features.include?(:new))
-    allow(object).to receive(:destroyed?).and_return(features.include?(:destroyed))
+    allow(object).to receive(:cached_html_up_to_date?).with(:field).and_return(fresh)
+    allow(object).to receive(:cached_html_for).with(:field).and_return('field_html')
 
     object
   end
 
-  describe "#render_field" do
+  describe '#render_field' do
     let(:renderer) { Banzai::Renderer }
-    let(:subject) { renderer.render_field(object, :field) }
+    subject { renderer.render_field(object, :field) }
 
-    context "with an empty cache" do
-      let(:object) { fake_object(:markdown) }
-      it "caches and returns the result" do
-        expect_render
-        expect_cache_update
-        expect(subject).to eq(:html)
-      end
-    end
+    context 'with a stale cache' do
+      let(:object) { fake_object(fresh: false) }
 
-    context "with a filled cache" do
-      let(:object) { fake_object(:markdown, :html) }
+      it 'caches and returns the result' do
+        expect(object).to receive(:refresh_markdown_cache!).with(do_update: true)
 
-      it "uses the cache" do
-        expect_render.never
-        expect_cache_update.never
-        should eq(:html)
+        is_expected.to eq('field_html')
       end
     end
 
-    context "new object" do
-      let(:object) { fake_object(:new, :markdown) }
-
-      it "doesn't cache the result" do
-        expect_render
-        expect_cache_update.never
-        expect(subject).to eq(:html)
-      end
-    end
+    context 'with an up-to-date cache' do
+      let(:object) { fake_object(fresh: true) }
 
-    context "destroyed object" do
-      let(:object) { fake_object(:destroyed, :markdown) }
+      it 'uses the cache' do
+        expect(object).to receive(:refresh_markdown_cache!).never
 
-      it "doesn't cache the result" do
-        expect_render
-        expect_cache_update.never
-        expect(subject).to eq(:html)
+        is_expected.to eq('field_html')
       end
     end
   end
diff --git a/spec/lib/container_registry/path_spec.rb b/spec/lib/container_registry/path_spec.rb
index b9c4572c269..c2bcb54210b 100644
--- a/spec/lib/container_registry/path_spec.rb
+++ b/spec/lib/container_registry/path_spec.rb
@@ -33,10 +33,20 @@ describe ContainerRegistry::Path do
   end
 
   describe '#to_s' do
-    let(:path) { 'some/image' }
+    context 'when path does not have uppercase characters' do
+      let(:path) { 'some/image' }
 
-    it 'return a string with a repository path' do
-      expect(subject.to_s).to eq path
+      it 'return a string with a repository path' do
+        expect(subject.to_s).to eq 'some/image'
+      end
+    end
+
+    context 'when path has uppercase characters' do
+      let(:path) { 'SoMe/ImAgE' }
+
+      it 'return a string with a repository path' do
+        expect(subject.to_s).to eq 'some/image'
+      end
     end
   end
 
@@ -70,6 +80,12 @@ describe ContainerRegistry::Path do
 
       it { is_expected.to be_valid }
     end
+
+    context 'when path contains uppercase letters' do
+      let(:path) { 'Some/Registry' }
+
+      it { is_expected.to be_valid }
+    end
   end
 
   describe '#has_repository?' do
@@ -173,15 +189,10 @@ describe ContainerRegistry::Path do
     end
 
     context 'when project exists' do
-      let(:group) { create(:group, path: 'some_group') }
-
-      let(:project) do
-        create(:empty_project, group: group, name: 'some_project')
-      end
+      let(:group) { create(:group, path: 'Some_Group') }
 
       before do
-        allow(path).to receive(:repository_project)
-          .and_return(project)
+        create(:empty_project, group: group, name: 'some_project')
       end
 
       context 'when project path equal repository path' do
@@ -209,4 +220,27 @@ describe ContainerRegistry::Path do
       end
     end
   end
+
+  describe '#project_path' do
+    context 'when project does not exist' do
+      let(:path) { 'some/name' }
+
+      it 'returns nil' do
+        expect(subject.project_path).to be_nil
+      end
+    end
+
+    context 'when project with uppercase characters in path exists' do
+      let(:path) { 'somegroup/myproject/my/image' }
+      let(:group) { create(:group, path: 'SomeGroup') }
+
+      before do
+        create(:empty_project, group: group, name: 'MyProject')
+      end
+
+      it 'returns downcased project path' do
+        expect(subject.project_path).to eq 'somegroup/myproject'
+      end
+    end
+  end
 end
diff --git a/spec/lib/gitlab/ci/trace/stream_spec.rb b/spec/lib/gitlab/ci/trace/stream_spec.rb
index 2e57ccef182..40ac5a3ed37 100644
--- a/spec/lib/gitlab/ci/trace/stream_spec.rb
+++ b/spec/lib/gitlab/ci/trace/stream_spec.rb
@@ -17,12 +17,12 @@ describe Gitlab::Ci::Trace::Stream do
   describe '#limit' do
     let(:stream) do
       described_class.new do
-        StringIO.new("12345678")
+        StringIO.new((1..8).to_a.join("\n"))
       end
     end
 
-    it 'if size is larger we start from beggining' do
-      stream.limit(10)
+    it 'if size is larger we start from beginning' do
+      stream.limit(20)
 
       expect(stream.tell).to eq(0)
     end
@@ -30,17 +30,61 @@ describe Gitlab::Ci::Trace::Stream do
     it 'if size is smaller we start from the end' do
       stream.limit(2)
 
-      expect(stream.tell).to eq(6)
+      expect(stream.raw).to eq("8")
+    end
+
+    context 'when the trace contains ANSI sequence and Unicode' do
+      let(:stream) do
+        described_class.new do
+          File.open(expand_fixture_path('trace/ansi-sequence-and-unicode'))
+        end
+      end
+
+      it 'forwards to the next linefeed, case 1' do
+        stream.limit(7)
+
+        result = stream.raw
+
+        expect(result).to eq('')
+        expect(result.encoding).to eq(Encoding.default_external)
+      end
+
+      it 'forwards to the next linefeed, case 2' do
+        stream.limit(29)
+
+        result = stream.raw
+
+        expect(result).to eq("\e[01;32m許功蓋\e[0m\n")
+        expect(result.encoding).to eq(Encoding.default_external)
+      end
+
+      # See https://gitlab.com/gitlab-org/gitlab-ce/issues/30796
+      it 'reads in binary, output as Encoding.default_external' do
+        stream.limit(52)
+
+        result = stream.html
+
+        expect(result).to eq("ヾ(´༎ຶД༎ຶ`)ﾉ<br><span class=\"term-fg-green\">許功蓋</span><br>")
+        expect(result.encoding).to eq(Encoding.default_external)
+      end
     end
   end
 
   describe '#append' do
+    let(:tempfile) { Tempfile.new }
+
     let(:stream) do
       described_class.new do
-        StringIO.new("12345678")
+        tempfile.write("12345678")
+        tempfile.rewind
+        tempfile
       end
     end
 
+    after do
+      tempfile.unlink
+    end
+
     it "truncates and append content" do
       stream.append("89", 4)
       stream.seek(0)
@@ -48,6 +92,17 @@ describe Gitlab::Ci::Trace::Stream do
       expect(stream.size).to eq(6)
       expect(stream.raw).to eq("123489")
     end
+
+    it 'appends in binary mode' do
+      '😺'.force_encoding('ASCII-8BIT').each_char.with_index do |byte, offset|
+        stream.append(byte, offset)
+      end
+
+      stream.seek(0)
+
+      expect(stream.size).to eq(4)
+      expect(stream.raw).to eq('😺')
+    end
   end
 
   describe '#set' do
diff --git a/spec/lib/gitlab/diff/position_tracer_spec.rb b/spec/lib/gitlab/diff/position_tracer_spec.rb
index 994995b57b8..c166f83664a 100644
--- a/spec/lib/gitlab/diff/position_tracer_spec.rb
+++ b/spec/lib/gitlab/diff/position_tracer_spec.rb
@@ -100,7 +100,7 @@ describe Gitlab::Diff::PositionTracer, lib: true do
       project,
       current_user,
       start_branch: branch_name,
-      target_branch: branch_name,
+      branch_name: branch_name,
       commit_message: "Create file",
       file_path: file_name,
       file_content: content
@@ -113,7 +113,7 @@ describe Gitlab::Diff::PositionTracer, lib: true do
       project,
       current_user,
       start_branch: branch_name,
-      target_branch: branch_name,
+      branch_name: branch_name,
       commit_message: "Update file",
       file_path: file_name,
       file_content: content
@@ -122,11 +122,11 @@ describe Gitlab::Diff::PositionTracer, lib: true do
   end
 
   def delete_file(branch_name, file_name)
-    Files::DestroyService.new(
+    Files::DeleteService.new(
       project,
       current_user,
       start_branch: branch_name,
-      target_branch: branch_name,
+      branch_name: branch_name,
       commit_message: "Delete file",
       file_path: file_name
     ).execute
diff --git a/spec/lib/gitlab/git/blob_spec.rb b/spec/lib/gitlab/git/blob_spec.rb
index 3f494257545..e6a07a58d73 100644
--- a/spec/lib/gitlab/git/blob_spec.rb
+++ b/spec/lib/gitlab/git/blob_spec.rb
@@ -234,7 +234,7 @@ describe Gitlab::Git::Blob, seed_helper: true do
 
       it { expect(blob.lfs_pointer?).to eq(true) }
       it { expect(blob.lfs_oid).to eq("4206f951d2691c78aac4c0ce9f2b23580b2c92cdcc4336e1028742c0274938e0") }
-      it { expect(blob.lfs_size).to eq("19548") }
+      it { expect(blob.lfs_size).to eq(19548) }
       it { expect(blob.id).to eq("f4d76af13003d1106be7ac8c5a2a3d37ddf32c2a") }
       it { expect(blob.name).to eq("image.jpg") }
       it { expect(blob.path).to eq("files/lfs/image.jpg") }
@@ -273,7 +273,7 @@ describe Gitlab::Git::Blob, seed_helper: true do
 
         it { expect(blob.lfs_pointer?).to eq(false) }
         it { expect(blob.lfs_oid).to eq(nil) }
-        it { expect(blob.lfs_size).to eq("1575078") }
+        it { expect(blob.lfs_size).to eq(1575078) }
         it { expect(blob.id).to eq("5ae35296e1f95c1ef9feda1241477ed29a448572") }
         it { expect(blob.name).to eq("picture-invalid.png") }
         it { expect(blob.path).to eq("files/lfs/picture-invalid.png") }
diff --git a/spec/lib/gitlab/git/encoding_helper_spec.rb b/spec/lib/gitlab/git/encoding_helper_spec.rb
index 27bcc241b82..f6ac7b23d1d 100644
--- a/spec/lib/gitlab/git/encoding_helper_spec.rb
+++ b/spec/lib/gitlab/git/encoding_helper_spec.rb
@@ -56,6 +56,10 @@ describe Gitlab::Git::EncodingHelper do
         expect(r.encoding.name).to eq('UTF-8')
       end
     end
+
+    it 'returns empty string on conversion errors' do
+      expect { ext_class.encode_utf8('') }.not_to raise_error(ArgumentError)
+    end
   end
 
   describe '#clean' do
diff --git a/spec/lib/gitlab/git/index_spec.rb b/spec/lib/gitlab/git/index_spec.rb
index 07d71f6777d..21b71654251 100644
--- a/spec/lib/gitlab/git/index_spec.rb
+++ b/spec/lib/gitlab/git/index_spec.rb
@@ -33,7 +33,7 @@ describe Gitlab::Git::Index, seed_helper: true do
       end
 
       it 'raises an error' do
-        expect { index.create(options) }.to raise_error('Filename already exists')
+        expect { index.create(options) }.to raise_error('A file with this name already exists')
       end
     end
 
@@ -89,7 +89,7 @@ describe Gitlab::Git::Index, seed_helper: true do
       end
 
       it 'raises an error' do
-        expect { index.create_dir(options) }.to raise_error('Directory already exists as a file')
+        expect { index.create_dir(options) }.to raise_error('A file with this name already exists')
       end
     end
 
@@ -99,7 +99,7 @@ describe Gitlab::Git::Index, seed_helper: true do
       end
 
       it 'raises an error' do
-        expect { index.create_dir(options) }.to raise_error('Directory already exists')
+        expect { index.create_dir(options) }.to raise_error('A directory with this name already exists')
       end
     end
   end
@@ -118,7 +118,7 @@ describe Gitlab::Git::Index, seed_helper: true do
       end
 
       it 'raises an error' do
-        expect { index.update(options) }.to raise_error("File doesn't exist")
+        expect { index.update(options) }.to raise_error("A file with this name doesn't exist")
       end
     end
 
@@ -156,7 +156,15 @@ describe Gitlab::Git::Index, seed_helper: true do
       it 'raises an error' do
         options[:previous_path] = 'documents/story.txt'
 
-        expect { index.move(options) }.to raise_error("File doesn't exist")
+        expect { index.move(options) }.to raise_error("A file with this name doesn't exist")
+      end
+    end
+
+    context 'when a file at the new path already exists' do
+      it 'raises an error' do
+        options[:file_path] = 'CHANGELOG'
+
+        expect { index.move(options) }.to raise_error("A file with this name already exists")
       end
     end
 
@@ -203,7 +211,7 @@ describe Gitlab::Git::Index, seed_helper: true do
       end
 
       it 'raises an error' do
-        expect { index.delete(options) }.to raise_error("File doesn't exist")
+        expect { index.delete(options) }.to raise_error("A file with this name doesn't exist")
       end
     end
 
diff --git a/spec/lib/gitlab/git_access_spec.rb b/spec/lib/gitlab/git_access_spec.rb
index 703b41f95ac..d8b72615fab 100644
--- a/spec/lib/gitlab/git_access_spec.rb
+++ b/spec/lib/gitlab/git_access_spec.rb
@@ -211,7 +211,7 @@ describe Gitlab::GitAccess, lib: true do
         target_branch = project.repository.lookup('feature')
         source_branch = project.repository.create_file(
           user,
-          'John Doe',
+          'filename',
           'This is the file content',
           message: 'This is a good commit message',
           branch_name: unprotected_branch)
diff --git a/spec/lib/gitlab/regex_spec.rb b/spec/lib/gitlab/regex_spec.rb
index ba45e2d758c..127cd8c78d8 100644
--- a/spec/lib/gitlab/regex_spec.rb
+++ b/spec/lib/gitlab/regex_spec.rb
@@ -32,12 +32,6 @@ describe Gitlab::Regex, lib: true do
     it { is_expected.to match('foo@bar') }
   end
 
-  describe '.file_path_regex' do
-    subject { described_class.file_path_regex }
-
-    it { is_expected.to match('foo@/bar') }
-  end
-
   describe '.environment_slug_regex' do
     subject { described_class.environment_slug_regex }
 
diff --git a/spec/lib/gitlab/usage_data_spec.rb b/spec/lib/gitlab/usage_data_spec.rb
new file mode 100644
index 00000000000..7f21288cf88
--- /dev/null
+++ b/spec/lib/gitlab/usage_data_spec.rb
@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Gitlab::UsageData do
+  let!(:project) { create(:empty_project) }
+  let!(:project2) { create(:empty_project) }
+  let!(:board) { create(:board, project: project) }
+
+  describe '#data' do
+    subject { Gitlab::UsageData.data }
+
+    it "gathers usage data" do
+      expect(subject.keys).to match_array(%i(
+        active_user_count
+        counts
+        recorded_at
+        mattermost_enabled
+        edition
+        version
+        uuid
+      ))
+    end
+
+    it "gathers usage counts" do
+      count_data = subject[:counts]
+
+      expect(count_data[:boards]).to eq(1)
+      expect(count_data[:projects]).to eq(2)
+
+      expect(count_data.keys).to match_array(%i(
+        boards
+        ci_builds
+        ci_pipelines
+        ci_runners
+        ci_triggers
+        deploy_keys
+        deployments
+        environments
+        groups
+        issues
+        keys
+        labels
+        lfs_objects
+        merge_requests
+        milestones
+        notes
+        projects
+        projects_prometheus_active
+        pages_domains
+        protected_branches
+        releases
+        services
+        snippets
+        todos
+        uploads
+        web_hooks
+      ))
+    end
+  end
+
+  describe '#license_usage_data' do
+    subject { Gitlab::UsageData.license_usage_data }
+
+    it "gathers license data" do
+      expect(subject[:uuid]).to eq(current_application_settings.uuid)
+      expect(subject[:version]).to eq(Gitlab::VERSION)
+      expect(subject[:active_user_count]).to eq(User.active.count)
+      expect(subject[:recorded_at]).to be_a(Time)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/user_activities_spec.rb b/spec/lib/gitlab/user_activities_spec.rb
new file mode 100644
index 00000000000..187d88c8c58
--- /dev/null
+++ b/spec/lib/gitlab/user_activities_spec.rb
@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Gitlab::UserActivities, :redis, lib: true do
+  let(:now) { Time.now }
+
+  describe '.record' do
+    context 'with no time given' do
+      it 'uses Time.now and records an activity in Redis' do
+        Timecop.freeze do
+          now # eager-load now
+          described_class.record(42)
+        end
+
+        Gitlab::Redis.with do |redis|
+          expect(redis.hscan(described_class::KEY, 0)).to eq(['0', [['42', now.to_i.to_s]]])
+        end
+      end
+    end
+
+    context 'with a time given' do
+      it 'uses the given time and records an activity in Redis' do
+        described_class.record(42, now)
+
+        Gitlab::Redis.with do |redis|
+          expect(redis.hscan(described_class::KEY, 0)).to eq(['0', [['42', now.to_i.to_s]]])
+        end
+      end
+    end
+  end
+
+  describe '.delete' do
+    context 'with a single key' do
+      context 'and key exists' do
+        it 'removes the pair from Redis' do
+          described_class.record(42, now)
+
+          Gitlab::Redis.with do |redis|
+            expect(redis.hscan(described_class::KEY, 0)).to eq(['0', [['42', now.to_i.to_s]]])
+          end
+
+          subject.delete(42)
+
+          Gitlab::Redis.with do |redis|
+            expect(redis.hscan(described_class::KEY, 0)).to eq(['0', []])
+          end
+        end
+      end
+
+      context 'and key does not exist' do
+        it 'removes the pair from Redis' do
+          Gitlab::Redis.with do |redis|
+            expect(redis.hscan(described_class::KEY, 0)).to eq(['0', []])
+          end
+
+          subject.delete(42)
+
+          Gitlab::Redis.with do |redis|
+            expect(redis.hscan(described_class::KEY, 0)).to eq(['0', []])
+          end
+        end
+      end
+    end
+
+    context 'with multiple keys' do
+      context 'and all keys exist' do
+        it 'removes the pair from Redis' do
+          described_class.record(41, now)
+          described_class.record(42, now)
+
+          Gitlab::Redis.with do |redis|
+            expect(redis.hscan(described_class::KEY, 0)).to eq(['0', [['41', now.to_i.to_s], ['42', now.to_i.to_s]]])
+          end
+
+          subject.delete(41, 42)
+
+          Gitlab::Redis.with do |redis|
+            expect(redis.hscan(described_class::KEY, 0)).to eq(['0', []])
+          end
+        end
+      end
+
+      context 'and some keys does not exist' do
+        it 'removes the existing pair from Redis' do
+          described_class.record(42, now)
+
+          Gitlab::Redis.with do |redis|
+            expect(redis.hscan(described_class::KEY, 0)).to eq(['0', [['42', now.to_i.to_s]]])
+          end
+
+          subject.delete(41, 42)
+
+          Gitlab::Redis.with do |redis|
+            expect(redis.hscan(described_class::KEY, 0)).to eq(['0', []])
+          end
+        end
+      end
+    end
+  end
+
+  describe 'Enumerable' do
+    before do
+      described_class.record(40, now)
+      described_class.record(41, now)
+      described_class.record(42, now)
+    end
+
+    it 'allows to read the activities sequentially' do
+      expected = { '40' => now.to_i.to_s, '41' => now.to_i.to_s, '42' => now.to_i.to_s }
+
+      actual = described_class.new.each_with_object({}) do |(key, time), actual|
+        actual[key] = time
+      end
+
+      expect(actual).to eq(expected)
+    end
+
+    context 'with many records' do
+      before do
+        1_000.times { |i| described_class.record(i, now) }
+      end
+
+      it 'is possible to loop through all the records' do
+        expect(described_class.new.count).to eq(1_000)
+      end
+    end
+  end
+end