10 files changed, 377 insertions, 168 deletions

diff --git a/spec/models/application_setting_spec.rb b/spec/models/application_setting_spec.rb
index 01ca1584ed2..c2c19c62048 100644
--- a/spec/models/application_setting_spec.rb
+++ b/spec/models/application_setting_spec.rb
@@ -4,6 +4,7 @@ describe ApplicationSetting, models: true do
   let(:setting) { ApplicationSetting.create_from_defaults }
 
   it { expect(setting).to be_valid }
+  it { expect(setting.uuid).to be_present }
 
   describe 'validations' do
     let(:http)  { 'http://example.com' }
diff --git a/spec/models/blob_spec.rb b/spec/models/blob_spec.rb
index e5dd57fc4bb..7e8a1c8add7 100644
--- a/spec/models/blob_spec.rb
+++ b/spec/models/blob_spec.rb
@@ -2,6 +2,14 @@
 require 'rails_helper'
 
 describe Blob do
+  include FakeBlobHelpers
+
+  let(:project) { build(:empty_project, lfs_enabled: true) }
+
+  before do
+    allow(Gitlab.config.lfs).to receive(:enabled).and_return(true)
+  end
+
   describe '.decorate' do
     it 'returns NilClass when given nil' do
       expect(described_class.decorate(nil)).to be_nil
@@ -12,7 +20,7 @@ describe Blob do
     context 'using a binary blob' do
       it 'returns the data as-is' do
         data = "\n\xFF\xB9\xC3"
-        blob = described_class.new(double(binary?: true, data: data))
+        blob = fake_blob(binary: true, data: data)
 
         expect(blob.data).to eq(data)
       end
@@ -20,202 +28,176 @@ describe Blob do
 
     context 'using a text blob' do
       it 'converts the data to UTF-8' do
-        blob = described_class.new(double(binary?: false, data: "\n\xFF\xB9\xC3"))
+        blob = fake_blob(binary: false, data: "\n\xFF\xB9\xC3")
 
         expect(blob.data).to eq("\n���")
       end
     end
   end
 
-  describe '#svg?' do
-    it 'is falsey when not text' do
-      git_blob = double(text?: false)
+  describe '#raw_binary?' do
+    context 'if the blob is a valid LFS pointer' do
+      context 'if the extension has a rich viewer' do
+        context 'if the viewer is binary' do
+          it 'returns true' do
+            blob = fake_blob(path: 'file.pdf', lfs: true)
 
-      expect(described_class.decorate(git_blob)).not_to be_svg
-    end
-
-    it 'is falsey when no language is detected' do
-      git_blob = double(text?: true, language: nil)
+            expect(blob.raw_binary?).to be_truthy
+          end
+        end
 
-      expect(described_class.decorate(git_blob)).not_to be_svg
-    end
+        context 'if the viewer is text-based' do
+          it 'return false' do
+            blob = fake_blob(path: 'file.md', lfs: true)
 
-    it' is falsey when language is not SVG' do
-      git_blob = double(text?: true, language: double(name: 'XML'))
-
-      expect(described_class.decorate(git_blob)).not_to be_svg
-    end
-
-    it 'is truthy when language is SVG' do
-      git_blob = double(text?: true, language: double(name: 'SVG'))
-
-      expect(described_class.decorate(git_blob)).to be_svg
-    end
-  end
-
-  describe '#pdf?' do
-    it 'is falsey when file extension is not .pdf' do
-      git_blob = Gitlab::Git::Blob.new(name: 'git_blob.txt')
-
-      expect(described_class.decorate(git_blob)).not_to be_pdf
-    end
+            expect(blob.raw_binary?).to be_falsey
+          end
+        end
+      end
 
-    it 'is truthy when file extension is .pdf' do
-      git_blob = Gitlab::Git::Blob.new(name: 'git_blob.pdf')
+      context "if the extension doesn't have a rich viewer" do
+        it 'returns true' do
+          blob = fake_blob(path: 'file.exe', lfs: true)
 
-      expect(described_class.decorate(git_blob)).to be_pdf
+          expect(blob.raw_binary?).to be_truthy
+        end
+      end
     end
-  end
 
-  describe '#ipython_notebook?' do
-    it 'is falsey when language is not Jupyter Notebook' do
-      git_blob = double(text?: true, language: double(name: 'JSON'))
+    context 'if the blob is not an LFS pointer' do
+      context 'if the blob is binary' do
+        it 'returns true' do
+          blob = fake_blob(path: 'file.pdf', binary: true)
 
-      expect(described_class.decorate(git_blob)).not_to be_ipython_notebook
-    end
+          expect(blob.raw_binary?).to be_truthy
+        end
+      end
 
-    it 'is truthy when language is Jupyter Notebook' do
-      git_blob = double(text?: true, language: double(name: 'Jupyter Notebook'))
+      context 'if the blob is text-based' do
+        it 'return false' do
+          blob = fake_blob(path: 'file.md')
 
-      expect(described_class.decorate(git_blob)).to be_ipython_notebook
+          expect(blob.raw_binary?).to be_falsey
+        end
+      end
     end
   end
 
-  describe '#sketch?' do
-    it 'is falsey with image extension' do
-      git_blob = Gitlab::Git::Blob.new(name: "design.png")
-
-      expect(described_class.decorate(git_blob)).not_to be_sketch
-    end
-
-    it 'is truthy with sketch extension' do
-      git_blob = Gitlab::Git::Blob.new(name: "design.sketch")
+  describe '#extension' do
+    it 'returns the extension' do
+      blob = fake_blob(path: 'file.md')
 
-      expect(described_class.decorate(git_blob)).to be_sketch
+      expect(blob.extension).to eq('md')
     end
   end
 
-  describe '#video?' do
-    it 'is falsey with image extension' do
-      git_blob = Gitlab::Git::Blob.new(name: 'image.png')
+  describe '#simple_viewer' do
+    context 'when the blob is empty' do
+      it 'returns an empty viewer' do
+        blob = fake_blob(data: '')
 
-      expect(described_class.decorate(git_blob)).not_to be_video
-    end
-
-    UploaderHelper::VIDEO_EXT.each do |ext|
-      it "is truthy when extension is .#{ext}" do
-        git_blob = Gitlab::Git::Blob.new(name: "video.#{ext}")
-
-        expect(described_class.decorate(git_blob)).to be_video
+        expect(blob.simple_viewer).to be_a(BlobViewer::Empty)
       end
     end
-  end
 
-  describe '#stl?' do
-    it 'is falsey with image extension' do
-      git_blob = Gitlab::Git::Blob.new(name: 'file.png')
+    context 'when the file represented by the blob is binary' do
+      it 'returns a download viewer' do
+        blob = fake_blob(binary: true)
 
-      expect(described_class.decorate(git_blob)).not_to be_stl
+        expect(blob.simple_viewer).to be_a(BlobViewer::Download)
+      end
     end
 
-    it 'is truthy with STL extension' do
-      git_blob = Gitlab::Git::Blob.new(name: 'file.stl')
+    context 'when the file represented by the blob is text-based' do
+      it 'returns a text viewer' do
+        blob = fake_blob
 
-      expect(described_class.decorate(git_blob)).to be_stl
+        expect(blob.simple_viewer).to be_a(BlobViewer::Text)
+      end
     end
   end
 
-  describe '#to_partial_path' do
-    let(:project) { double(lfs_enabled?: true) }
+  describe '#rich_viewer' do
+    context 'when the blob is an invalid LFS pointer' do
+      before do
+        project.lfs_enabled = false
+      end
 
-    def stubbed_blob(overrides = {})
-      overrides.reverse_merge!(
-        name: nil,
-        image?: false,
-        language: nil,
-        lfs_pointer?: false,
-        svg?: false,
-        text?: false,
-        binary?: false,
-        stl?: false
-      )
+      it 'returns nil' do
+        blob = fake_blob(path: 'file.pdf', lfs: true)
 
-      described_class.decorate(Gitlab::Git::Blob.new({})).tap do |blob|
-        allow(blob).to receive_messages(overrides)
+        expect(blob.rich_viewer).to be_nil
       end
     end
 
-    it 'handles LFS pointers with LFS enabled' do
-      blob = stubbed_blob(lfs_pointer?: true, text?: true)
-      expect(blob.to_partial_path(project)).to eq 'download'
-    end
-
-    it 'handles LFS pointers with LFS disabled' do
-      blob = stubbed_blob(lfs_pointer?: true, text?: true)
-      project = double(lfs_enabled?: false)
-      expect(blob.to_partial_path(project)).to eq 'text'
-    end
+    context 'when the blob is empty' do
+      it 'returns nil' do
+        blob = fake_blob(data: '')
 
-    it 'handles SVGs' do
-      blob = stubbed_blob(text?: true, svg?: true)
-      expect(blob.to_partial_path(project)).to eq 'svg'
+        expect(blob.rich_viewer).to be_nil
+      end
     end
 
-    it 'handles images' do
-      blob = stubbed_blob(image?: true)
-      expect(blob.to_partial_path(project)).to eq 'image'
-    end
+    context 'when the blob is a valid LFS pointer' do
+      it 'returns a matching viewer' do
+        blob = fake_blob(path: 'file.pdf', lfs: true)
 
-    it 'handles text' do
-      blob = stubbed_blob(text?: true, name: 'test.txt')
-      expect(blob.to_partial_path(project)).to eq 'text'
-    end
-
-    it 'defaults to download' do
-      blob = stubbed_blob
-      expect(blob.to_partial_path(project)).to eq 'download'
+        expect(blob.rich_viewer).to be_a(BlobViewer::PDF)
+      end
     end
 
-    it 'handles PDFs' do
-      blob = stubbed_blob(name: 'blob.pdf', pdf?: true)
-      expect(blob.to_partial_path(project)).to eq 'pdf'
-    end
+    context 'when the blob is binary' do
+      it 'returns a matching binary viewer' do
+        blob = fake_blob(path: 'file.pdf', binary: true)
 
-    it 'handles iPython notebooks' do
-      blob = stubbed_blob(text?: true, ipython_notebook?: true)
-      expect(blob.to_partial_path(project)).to eq 'notebook'
+        expect(blob.rich_viewer).to be_a(BlobViewer::PDF)
+      end
     end
 
-    it 'handles Sketch files' do
-      blob = stubbed_blob(text?: true, sketch?: true, binary?: true)
-      expect(blob.to_partial_path(project)).to eq 'sketch'
-    end
+    context 'when the blob is text-based' do
+      it 'returns a matching text-based viewer' do
+        blob = fake_blob(path: 'file.md')
 
-    it 'handles STLs' do
-      blob = stubbed_blob(text?: true, stl?: true)
-      expect(blob.to_partial_path(project)).to eq 'stl'
+        expect(blob.rich_viewer).to be_a(BlobViewer::Markup)
+      end
     end
   end
 
-  describe '#size_within_svg_limits?' do
-    let(:blob) { described_class.decorate(double(:blob)) }
+  describe '#rendered_as_text?' do
+    context 'when ignoring errors' do
+      context 'when the simple viewer is text-based' do
+        it 'returns true' do
+          blob = fake_blob(path: 'file.md', size: 100.megabytes)
 
-    it 'returns true when the blob size is smaller than the SVG limit' do
-      expect(blob).to receive(:size).and_return(42)
+          expect(blob.rendered_as_text?).to be_truthy
+        end
+      end
+
+      context 'when the simple viewer is binary' do
+        it 'returns false' do
+          blob = fake_blob(path: 'file.pdf', binary: true, size: 100.megabytes)
 
-      expect(blob.size_within_svg_limits?).to eq(true)
+          expect(blob.rendered_as_text?).to be_falsey
+        end
+      end
     end
 
-    it 'returns true when the blob size is equal to the SVG limit' do
-      expect(blob).to receive(:size).and_return(Blob::MAXIMUM_SVG_SIZE)
+    context 'when not ignoring errors' do
+      context 'when the viewer has render errors' do
+        it 'returns false' do
+          blob = fake_blob(path: 'file.md', size: 100.megabytes)
 
-      expect(blob.size_within_svg_limits?).to eq(true)
-    end
+          expect(blob.rendered_as_text?(ignore_errors: false)).to be_falsey
+        end
+      end
 
-    it 'returns false when the blob size is larger than the SVG limit' do
-      expect(blob).to receive(:size).and_return(1.terabyte)
+      context "when the viewer doesn't have render errors" do
+        it 'returns true' do
+          blob = fake_blob(path: 'file.md')
 
-      expect(blob.size_within_svg_limits?).to eq(false)
+          expect(blob.rendered_as_text?(ignore_errors: false)).to be_truthy
+        end
+      end
     end
   end
 end
diff --git a/spec/models/blob_viewer/base_spec.rb b/spec/models/blob_viewer/base_spec.rb
new file mode 100644
index 00000000000..a3e598de56d
--- /dev/null
+++ b/spec/models/blob_viewer/base_spec.rb
@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe BlobViewer::Base, model: true do
+  include FakeBlobHelpers
+
+  let(:project) { build(:empty_project) }
+
+  let(:viewer_class) do
+    Class.new(described_class) do
+      self.extensions = %w(pdf)
+      self.max_size = 1.megabyte
+      self.absolute_max_size = 5.megabytes
+      self.client_side = false
+    end
+  end
+
+  let(:viewer) { viewer_class.new(blob) }
+
+  describe '.can_render?' do
+    context 'when the extension is supported' do
+      let(:blob) { fake_blob(path: 'file.pdf') }
+
+      it 'returns true' do
+        expect(viewer_class.can_render?(blob)).to be_truthy
+      end
+    end
+
+    context 'when the extension is not supported' do
+      let(:blob) { fake_blob(path: 'file.txt') }
+
+      it 'returns false' do
+        expect(viewer_class.can_render?(blob)).to be_falsey
+      end
+    end
+  end
+
+  describe '#too_large?' do
+    context 'when the blob size is larger than the max size' do
+      let(:blob) { fake_blob(path: 'file.pdf', size: 2.megabytes) }
+
+      it 'returns true' do
+        expect(viewer.too_large?).to be_truthy
+      end
+    end
+
+    context 'when the blob size is smaller than the max size' do
+      let(:blob) { fake_blob(path: 'file.pdf', size: 10.kilobytes) }
+
+      it 'returns false' do
+        expect(viewer.too_large?).to be_falsey
+      end
+    end
+  end
+
+  describe '#absolutely_too_large?' do
+    context 'when the blob size is larger than the absolute max size' do
+      let(:blob) { fake_blob(path: 'file.pdf', size: 10.megabytes) }
+
+      it 'returns true' do
+        expect(viewer.absolutely_too_large?).to be_truthy
+      end
+    end
+
+    context 'when the blob size is smaller than the absolute max size' do
+      let(:blob) { fake_blob(path: 'file.pdf', size: 2.megabytes) }
+
+      it 'returns false' do
+        expect(viewer.absolutely_too_large?).to be_falsey
+      end
+    end
+  end
+
+  describe '#can_override_max_size?' do
+    context 'when the blob size is larger than the max size' do
+      context 'when the blob size is larger than the absolute max size' do
+        let(:blob) { fake_blob(path: 'file.pdf', size: 10.megabytes) }
+
+        it 'returns false' do
+          expect(viewer.can_override_max_size?).to be_falsey
+        end
+      end
+
+      context 'when the blob size is smaller than the absolute max size' do
+        let(:blob) { fake_blob(path: 'file.pdf', size: 2.megabytes) }
+
+        it 'returns true' do
+          expect(viewer.can_override_max_size?).to be_truthy
+        end
+      end
+    end
+
+    context 'when the blob size is smaller than the max size' do
+      let(:blob) { fake_blob(path: 'file.pdf', size: 10.kilobytes) }
+
+      it 'returns false' do
+        expect(viewer.can_override_max_size?).to be_falsey
+      end
+    end
+  end
+
+  describe '#render_error' do
+    context 'when the max size is overridden' do
+      before do
+        viewer.override_max_size = true
+      end
+
+      context 'when the blob size is larger than the absolute max size' do
+        let(:blob) { fake_blob(path: 'file.pdf', size: 10.megabytes) }
+
+        it 'returns :too_large' do
+          expect(viewer.render_error).to eq(:too_large)
+        end
+      end
+
+      context 'when the blob size is smaller than the absolute max size' do
+        let(:blob) { fake_blob(path: 'file.pdf', size: 2.megabytes) }
+
+        it 'returns nil' do
+          expect(viewer.render_error).to be_nil
+        end
+      end
+    end
+
+    context 'when the max size is not overridden' do
+      context 'when the blob size is larger than the max size' do
+        let(:blob) { fake_blob(path: 'file.pdf', size: 2.megabytes) }
+
+        it 'returns :too_large' do
+          expect(viewer.render_error).to eq(:too_large)
+        end
+      end
+
+      context 'when the blob size is smaller than the max size' do
+        let(:blob) { fake_blob(path: 'file.pdf', size: 10.kilobytes) }
+
+        it 'returns nil' do
+          expect(viewer.render_error).to be_nil
+        end
+      end
+    end
+
+    context 'when the viewer is server side but the blob is stored in LFS' do
+      let(:project) { build(:empty_project, lfs_enabled: true) }
+
+      let(:blob) { fake_blob(path: 'file.pdf', lfs: true) }
+
+      before do
+        allow(Gitlab.config.lfs).to receive(:enabled).and_return(true)
+      end
+
+      it 'return :server_side_but_stored_in_lfs' do
+        expect(viewer.render_error).to eq(:server_side_but_stored_in_lfs)
+      end
+    end
+  end
+
+  describe '#prepare!' do
+    context 'when the viewer is server side' do
+      let(:blob) { fake_blob(path: 'file.md') }
+
+      before do
+        viewer_class.client_side = false
+      end
+
+      it 'loads all blob data' do
+        expect(blob).to receive(:load_all_data!)
+
+        viewer.prepare!
+      end
+    end
+
+    context 'when the viewer is client side' do
+      let(:blob) { fake_blob(path: 'file.md') }
+
+      before do
+        viewer_class.client_side = true
+      end
+
+      it "doesn't load all blob data" do
+        expect(blob).not_to receive(:load_all_data!)
+
+        viewer.prepare!
+      end
+    end
+  end
+end
diff --git a/spec/models/concerns/cache_markdown_field_spec.rb b/spec/models/concerns/cache_markdown_field_spec.rb
index de0069bdcac..4edafbc4e32 100644
--- a/spec/models/concerns/cache_markdown_field_spec.rb
+++ b/spec/models/concerns/cache_markdown_field_spec.rb
@@ -18,7 +18,7 @@ describe CacheMarkdownField do
     end
 
     extend ActiveModel::Callbacks
-    define_model_callbacks :save
+    define_model_callbacks :create, :update
 
     include CacheMarkdownField
     cache_markdown_field :foo
@@ -56,7 +56,7 @@ describe CacheMarkdownField do
     end
 
     def save
-      run_callbacks :save do
+      run_callbacks :update do
         changes_applied
       end
     end
diff --git a/spec/models/network/graph_spec.rb b/spec/models/network/graph_spec.rb
index 492c4e01bd8..46b36e11c23 100644
--- a/spec/models/network/graph_spec.rb
+++ b/spec/models/network/graph_spec.rb
@@ -9,4 +9,25 @@ describe Network::Graph, models: true do
 
     expect(graph.notes).to eq( { note_on_commit.commit_id => 1 } )
   end
+
+  describe "#commits" do
+    let(:graph) { described_class.new(project, 'refs/heads/master', project.repository.commit, nil) }
+
+    it "returns a list of commits" do
+      commits = graph.commits
+
+      expect(commits).not_to be_empty
+      expect(commits).to all( be_kind_of(Network::Commit) )
+    end
+
+    it "sorts the commits by commit date (descending)" do
+      # Remove duplicate timestamps because they make it harder to
+      # assert that the commits are sorted as expected.
+      commits = graph.commits.uniq(&:date)
+      sorted_commits = commits.sort_by(&:date).reverse
+
+      expect(commits).not_to be_empty
+      expect(commits.map(&:id)).to eq(sorted_commits.map(&:id))
+    end
+  end
 end
diff --git a/spec/models/project_services/chat_notification_service_spec.rb b/spec/models/project_services/chat_notification_service_spec.rb
index 592c90cda36..8fbe42248ae 100644
--- a/spec/models/project_services/chat_notification_service_spec.rb
+++ b/spec/models/project_services/chat_notification_service_spec.rb
@@ -11,10 +11,10 @@ describe ChatNotificationService, models: true do
 
   describe '#can_test?' do
     context 'with empty repository' do
-      it 'returns false' do
+      it 'returns true' do
         subject.project = create(:empty_project, :empty_repo)
 
-        expect(subject.can_test?).to be false
+        expect(subject.can_test?).to be true
       end
     end
 
diff --git a/spec/models/project_services/issue_tracker_service_spec.rb b/spec/models/project_services/issue_tracker_service_spec.rb
index fbe6f344a98..869b25b933b 100644
--- a/spec/models/project_services/issue_tracker_service_spec.rb
+++ b/spec/models/project_services/issue_tracker_service_spec.rb
@@ -8,7 +8,7 @@ describe IssueTrackerService, models: true do
       let(:service) { RedmineService.new(project: project, active: true) }
 
       before do
-        create(:service, project: project, active: true, category: 'issue_tracker')  
+        create(:custom_issue_tracker_service, project: project)
       end
 
       context 'when service is changed manually by user' do
diff --git a/spec/models/repository_spec.rb b/spec/models/repository_spec.rb
index 74d5ebc6db0..98d0641443e 100644
--- a/spec/models/repository_spec.rb
+++ b/spec/models/repository_spec.rb
@@ -1803,9 +1803,9 @@ describe Repository, models: true do
   describe '#refresh_method_caches' do
     it 'refreshes the caches of the given types' do
       expect(repository).to receive(:expire_method_caches).
-        with(%i(readme license_blob license_key))
+        with(%i(rendered_readme license_blob license_key))
 
-      expect(repository).to receive(:readme)
+      expect(repository).to receive(:rendered_readme)
       expect(repository).to receive(:license_blob)
       expect(repository).to receive(:license_key)
 
diff --git a/spec/models/service_spec.rb b/spec/models/service_spec.rb
index 0e2f07e945f..134882648b9 100644
--- a/spec/models/service_spec.rb
+++ b/spec/models/service_spec.rb
@@ -6,44 +6,53 @@ describe Service, models: true do
     it { is_expected.to have_one :service_hook }
   end
 
+  describe 'Validations' do
+    it { is_expected.to validate_presence_of(:type) }
+  end
+
   describe "Test Button" do
-    before do
-      @service = Service.new
-    end
+    describe '#can_test?' do
+      let(:service) { create(:service, project: project) }
 
-    describe "Testable" do
-      let(:project) { create(:project, :repository) }
+      context 'when repository is not empty' do
+        let(:project) { create(:project, :repository) }
 
-      before do
-        allow(@service).to receive(:project).and_return(project)
-        @testable = @service.can_test?
+        it 'returns true' do
+          expect(service.can_test?).to be true
+        end
       end
 
-      describe '#can_test?' do
-        it { expect(@testable).to eq(true) }
+      context 'when repository is empty' do
+        let(:project) { create(:empty_project) }
+
+        it 'returns true' do
+          expect(service.can_test?).to be true
+        end
       end
+    end
+
+    describe '#test' do
+      let(:data) { 'test' }
+      let(:service) { create(:service, project: project) }
 
-      describe '#test' do
-        let(:data) { 'test' }
+      context 'when repository is not empty' do
+        let(:project) { create(:project, :repository) }
 
         it 'test runs execute' do
-          expect(@service).to receive(:execute).with(data)
+          expect(service).to receive(:execute).with(data)
 
-          @service.test(data)
+          service.test(data)
         end
       end
-    end
 
-    describe "With commits" do
-      let(:project) { create(:project, :repository) }
+      context 'when repository is empty' do
+        let(:project) { create(:empty_project) }
 
-      before do
-        allow(@service).to receive(:project).and_return(project)
-        @testable = @service.can_test?
-      end
+        it 'test runs execute' do
+          expect(service).to receive(:execute).with(data)
 
-      describe '#can_test?' do
-        it { expect(@testable).to eq(true) }
+          service.test(data)
+        end
       end
     end
   end
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index 0a2860f2505..0bcebc27598 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -1556,6 +1556,16 @@ describe User, models: true do
         expect(ghost.email).to eq('ghost1@example.com')
       end
     end
+
+    context 'when a domain whitelist is in place' do
+      before do
+        stub_application_setting(domain_whitelist: ['gitlab.com'])
+      end
+
+      it 'creates a ghost user' do
+        expect(User.ghost).to be_persisted
+      end
+    end
   end
 
   describe '#update_two_factor_requirement' do