Auto merge of #5368 - savionok:sav-cover-Bundler-FriendlyErrors-with-tests, r=segiddins

Fix silent.rb method interface

Hi,
This is my first contribution to bundler, so I started by covering bundler/friendly_errors.rb with unit tests.

After covering it, I spotted a bug in lib/bundler/ui/silent.rb, trace method interface, so I fix it in this PR.

Waiting for feedback!

(cherry picked from commit c0de8f625f0ae2ed5cc2b26673c875e2900a9829)

2 files changed, 183 insertions, 3 deletions

diff --git a/lib/bundler/ui/silent.rb b/lib/bundler/ui/silent.rb
index 5e0037f488..61c7edd9b3 100644
--- a/lib/bundler/ui/silent.rb
+++ b/lib/bundler/ui/silent.rb
@@ -43,7 +43,7 @@ module Bundler
       def level(name = nil)
       end
 
-      def trace(message, newline = nil)
+      def trace(message, newline = nil, force = false)
       end
 
       def silence
diff --git a/spec/bundler/friendly_errors_spec.rb b/spec/bundler/friendly_errors_spec.rb
index 1d88403c0e..114e095dc4 100644
--- a/spec/bundler/friendly_errors_spec.rb
+++ b/spec/bundler/friendly_errors_spec.rb
@@ -44,14 +44,194 @@ describe Bundler, "friendly errors" do
     end
   end
 
-  it "rescues Thor::AmbiguousTaskError and raises SystemExit" do
+  it "calls log_error in case of exception" do
+    exception = Exception.new
+    expect(Bundler::FriendlyErrors).to receive(:exit_status).with(exception).and_return(1)
     expect do
       Bundler.with_friendly_errors do
-        raise Thor::AmbiguousTaskError.new("")
+        raise exception
       end
     end.to raise_error(SystemExit)
   end
 
+  it "calls exit_status on exception" do
+    exception = Exception.new
+    expect(Bundler::FriendlyErrors).to receive(:log_error).with(exception)
+    expect do
+      Bundler.with_friendly_errors do
+        raise exception
+      end
+    end.to raise_error(SystemExit)
+  end
+
+  describe "#log_error" do
+    shared_examples "Bundler.ui receive error" do |error, message|
+      it "" do
+        expect(Bundler.ui).to receive(:error).with(message || error.message)
+        Bundler::FriendlyErrors.log_error(error)
+      end
+    end
+
+    shared_examples "Bundler.ui receive trace" do |error|
+      it "" do
+        expect(Bundler.ui).to receive(:trace).with(error)
+        Bundler::FriendlyErrors.log_error(error)
+      end
+    end
+
+    context "YamlSyntaxError" do
+      it_behaves_like "Bundler.ui receive error", Bundler::YamlSyntaxError.new(StandardError.new, "sample_message")
+
+      it "Bundler.ui receive trace" do
+        std_error = StandardError.new
+        exception = Bundler::YamlSyntaxError.new(std_error, "sample_message")
+        expect(Bundler.ui).to receive(:trace).with(std_error)
+        Bundler::FriendlyErrors.log_error(exception)
+      end
+    end
+
+    context "Dsl::DSLError, GemspecError" do
+      it_behaves_like "Bundler.ui receive error", Bundler::Dsl::DSLError.new("description", "dsl_path", "backtrace")
+      it_behaves_like "Bundler.ui receive error", Bundler::GemspecError.new
+    end
+
+    context "GemRequireError" do
+      let(:orig_error) { StandardError.new }
+      let(:error) { Bundler::GemRequireError.new(orig_error, "sample_message") }
+
+      before do
+        allow(orig_error).to receive(:backtrace).and_return([])
+      end
+
+      it "Bundler.ui receive error" do
+        expect(Bundler.ui).to receive(:error).with(error.message)
+        Bundler::FriendlyErrors.log_error(error)
+      end
+
+      it "writes to Bundler.ui.trace" do
+        expect(Bundler.ui).to receive(:trace).with(orig_error, nil, true)
+        Bundler::FriendlyErrors.log_error(error)
+      end
+    end
+
+    context "BundlerError" do
+      it "Bundler.ui receive error" do
+        error = Bundler::BundlerError.new
+        expect(Bundler.ui).to receive(:error).with(error.message, :wrap => true)
+        Bundler::FriendlyErrors.log_error(error)
+      end
+      it_behaves_like "Bundler.ui receive trace", Bundler::BundlerError.new
+    end
+
+    context "Thor::Error" do
+      it_behaves_like "Bundler.ui receive error", Bundler::Thor::Error.new
+    end
+
+    context "LoadError" do
+      let(:error) { LoadError.new("cannot load such file -- openssl") }
+
+      it "Bundler.ui receive error" do
+        expect(Bundler.ui).to receive(:error).with("\nCould not load OpenSSL.")
+        Bundler::FriendlyErrors.log_error(error)
+      end
+
+      it "Bundler.ui receive warn" do
+        expect(Bundler.ui).to receive(:warn).with(any_args, :wrap => true)
+        Bundler::FriendlyErrors.log_error(error)
+      end
+
+      it "Bundler.ui receive trace" do
+        expect(Bundler.ui).to receive(:trace).with(error)
+        Bundler::FriendlyErrors.log_error(error)
+      end
+    end
+
+    context "Interrupt" do
+      it "Bundler.ui receive error" do
+        expect(Bundler.ui).to receive(:error).with("\nQuitting...")
+        Bundler::FriendlyErrors.log_error(Interrupt.new)
+      end
+      it_behaves_like "Bundler.ui receive trace", Interrupt.new
+    end
+
+    context "Gem::InvalidSpecificationException" do
+      it "Bundler.ui receive error" do
+        error = Gem::InvalidSpecificationException.new
+        expect(Bundler.ui).to receive(:error).with(error.message, :wrap => true)
+        Bundler::FriendlyErrors.log_error(error)
+      end
+    end
+
+    context "SystemExit" do
+      # Does nothing
+    end
+
+    context "Java::JavaLang::OutOfMemoryError" do
+      module Java
+        module JavaLang
+          class OutOfMemoryError < StandardError; end
+        end
+      end
+
+      it "Bundler.ui receive error" do
+        error = Java::JavaLang::OutOfMemoryError.new
+        expect(Bundler.ui).to receive(:error).with(/JVM has run out of memory/)
+        Bundler::FriendlyErrors.log_error(error)
+      end
+    end
+
+    context "unexpected error" do
+      it "calls request_issue_report_for with error" do
+        error = StandardError.new
+        expect(Bundler::FriendlyErrors).to receive(:request_issue_report_for).with(error)
+        Bundler::FriendlyErrors.log_error(error)
+      end
+    end
+  end
+
+  describe "#exit_status" do
+    it "calls status_code for BundlerError" do
+      error = Bundler::BundlerError.new
+      expect(error).to receive(:status_code).and_return("sample_status_code")
+      expect(Bundler::FriendlyErrors.exit_status(error)).to eq("sample_status_code")
+    end
+
+    it "returns 15 for Thor::Error" do
+      error = Bundler::Thor::Error.new
+      expect(Bundler::FriendlyErrors.exit_status(error)).to eq(15)
+    end
+
+    it "calls status for SystemExit" do
+      error = SystemExit.new
+      expect(error).to receive(:status).and_return("sample_status")
+      expect(Bundler::FriendlyErrors.exit_status(error)).to eq("sample_status")
+    end
+
+    it "returns 1 in other cases" do
+      error = StandardError.new
+      expect(Bundler::FriendlyErrors.exit_status(error)).to eq(1)
+    end
+  end
+
+  describe "#request_issue_report_for" do
+    it "calls relevant methods for Bundler.ui" do
+      expect(Bundler.ui).to receive(:info)
+      expect(Bundler.ui).to receive(:error)
+      expect(Bundler.ui).to receive(:warn)
+      Bundler::FriendlyErrors.request_issue_report_for(StandardError.new)
+    end
+
+    it "includes error class, message and backlog" do
+      error = StandardError.new
+      allow(Bundler::FriendlyErrors).to receive(:issues_url).and_return("")
+
+      expect(error).to receive(:class).at_least(:once)
+      expect(error).to receive(:message).at_least(:once)
+      expect(error).to receive(:backtrace).at_least(:once)
+      Bundler::FriendlyErrors.request_issue_report_for(error)
+    end
+  end
+
   describe "#issues_url" do
     it "generates a search URL for the exception message" do
       exception = Exception.new("Exception message")