better_errors 2.2.0 → 2.3.0

data/spec/better_errors/code_formatter_spec.rb

@@ -1,92 +0,0 @@
-require "spec_helper"
-
-module BetterErrors
-  describe CodeFormatter do
-    let(:filename) { File.expand_path("../support/my_source.rb", __FILE__) }
-
-    let(:formatter) { CodeFormatter.new(filename, 8) }
-
-    it "picks an appropriate scanner" do
-      expect(formatter.coderay_scanner).to eq(:ruby)
-    end
-
-    it "shows 5 lines of context" do
-      expect(formatter.line_range).to eq(3..13)
-
-      expect(formatter.context_lines).to eq([
-          "three\n",
-          "four\n",
-          "five\n",
-          "six\n",
-          "seven\n",
-          "eight\n",
-          "nine\n",
-          "ten\n",
-          "eleven\n",
-          "twelve\n",
-          "thirteen\n"
-        ])
-    end
-
-    it "works when the line is right on the edge" do
-      formatter = CodeFormatter.new(filename, 20)
-      expect(formatter.line_range).to eq(15..20)
-    end
-
-    describe CodeFormatter::HTML do
-      it "highlights the erroring line" do
-        formatter = CodeFormatter::HTML.new(filename, 8)
-        expect(formatter.output).to match(/highlight.*eight/)
-      end
-
-      it "works when the line is right on the edge" do
-        formatter = CodeFormatter::HTML.new(filename, 20)
-        expect(formatter.output).not_to eq(formatter.source_unavailable)
-      end
-
-      it "doesn't barf when the lines don't make any sense" do
-        formatter = CodeFormatter::HTML.new(filename, 999)
-        expect(formatter.output).to eq(formatter.source_unavailable)
-      end
-
-      it "doesn't barf when the file doesn't exist" do
-        formatter = CodeFormatter::HTML.new("fkdguhskd7e l", 1)
-        expect(formatter.output).to eq(formatter.source_unavailable)
-      end
-    end
-
-    describe CodeFormatter::Text do
-      it "highlights the erroring line" do
-        formatter = CodeFormatter::Text.new(filename, 8)
-        expect(formatter.output).to eq <<-TEXT.gsub(/^        /, "")
-            3   three
-            4   four
-            5   five
-            6   six
-            7   seven
-        >   8   eight
-            9   nine
-           10   ten
-           11   eleven
-           12   twelve
-           13   thirteen
-        TEXT
-      end
-
-      it "works when the line is right on the edge" do
-        formatter = CodeFormatter::Text.new(filename, 20)
-        expect(formatter.output).not_to eq(formatter.source_unavailable)
-      end
-
-      it "doesn't barf when the lines don't make any sense" do
-        formatter = CodeFormatter::Text.new(filename, 999)
-        expect(formatter.output).to eq(formatter.source_unavailable)
-      end
-
-      it "doesn't barf when the file doesn't exist" do
-        formatter = CodeFormatter::Text.new("fkdguhskd7e l", 1)
-        expect(formatter.output).to eq(formatter.source_unavailable)
-      end
-    end
-  end
-end

data/spec/better_errors/error_page_spec.rb

@@ -1,92 +0,0 @@
-require "spec_helper"
-
-module BetterErrors
-  describe ErrorPage do
-    let!(:exception) { raise ZeroDivisionError, "you divided by zero you silly goose!" rescue $! }
-
-    let(:error_page) { ErrorPage.new exception, { "PATH_INFO" => "/some/path" } }
-
-    let(:response) { error_page.render }
-
-    let(:empty_binding) {
-      local_a = :value_for_local_a
-      local_b = :value_for_local_b
-
-      @inst_c = :value_for_inst_c
-      @inst_d = :value_for_inst_d
-
-      binding
-    }
-
-    it "includes the error message" do
-      expect(response).to include("you divided by zero you silly goose!")
-    end
-
-    it "includes the request path" do
-      expect(response).to include("/some/path")
-    end
-
-    it "includes the exception class" do
-      expect(response).to include("ZeroDivisionError")
-    end
-
-    context "variable inspection" do
-      let(:exception) { empty_binding.eval("raise") rescue $! }
-
-      if BetterErrors.binding_of_caller_available?
-        it "shows local variables" do
-          html = error_page.do_variables("index" => 0)[:html]
-          expect(html).to include("local_a")
-          expect(html).to include(":value_for_local_a")
-          expect(html).to include("local_b")
-          expect(html).to include(":value_for_local_b")
-        end
-      else
-        it "tells the user to add binding_of_caller to their gemfile to get fancy features" do
-          html = error_page.do_variables("index" => 0)[:html]
-          expect(html).to include(%{gem "binding_of_caller"})
-        end
-      end
-
-      it "shows instance variables" do
-        html = error_page.do_variables("index" => 0)[:html]
-        expect(html).to include("inst_c")
-        expect(html).to include(":value_for_inst_c")
-        expect(html).to include("inst_d")
-        expect(html).to include(":value_for_inst_d")
-      end
-
-      it "shows filter instance variables" do
-        allow(BetterErrors).to receive(:ignored_instance_variables).and_return([ :@inst_d ])
-        html = error_page.do_variables("index" => 0)[:html]
-        expect(html).to include("inst_c")
-        expect(html).to include(":value_for_inst_c")
-        expect(html).not_to include('<td class="name">@inst_d</td>')
-        expect(html).not_to include("<pre>:value_for_inst_d</pre>")
-      end
-    end
-
-    it "doesn't die if the source file is not a real filename" do
-      allow(exception).to receive(:backtrace).and_return([
-        "<internal:prelude>:10:in `spawn_rack_application'"
-      ])
-      expect(response).to include("Source unavailable")
-    end
-
-    context 'with an exception with blank lines' do
-      class SpacedError < StandardError
-        def initialize(message = nil)
-          message = "\n\n#{message}" if message
-          super
-        end
-      end
-
-      let!(:exception) { raise SpacedError, "Danger Warning!" rescue $! }
-
-      it 'should not include leading blank lines from exception_message' do
-        expect(exception.message).to match(/\A\n\n/)
-        expect(error_page.exception_message).not_to match(/\A\n\n/)
-      end
-    end
-  end
-end

data/spec/better_errors/middleware_spec.rb

@@ -1,188 +0,0 @@
-require "spec_helper"
-
-module BetterErrors
-  describe Middleware do
-    let(:app) { Middleware.new(->env { ":)" }) }
-    let(:exception) { RuntimeError.new("oh no :(") }
-
-    it "passes non-error responses through" do
-      expect(app.call({})).to eq(":)")
-    end
-
-    it "calls the internal methods" do
-      expect(app).to receive :internal_call
-      app.call("PATH_INFO" => "/__better_errors/1/preform_awesomness")
-    end
-
-    it "calls the internal methods on any subfolder path" do
-      expect(app).to receive :internal_call
-      app.call("PATH_INFO" => "/any_sub/folder/path/__better_errors/1/preform_awesomness")
-    end
-
-    it "shows the error page" do
-      expect(app).to receive :show_error_page
-      app.call("PATH_INFO" => "/__better_errors/")
-    end
-
-    it "shows the error page on any subfolder path" do
-      expect(app).to receive :show_error_page
-      app.call("PATH_INFO" => "/any_sub/folder/path/__better_errors/")
-    end
-
-    it "doesn't show the error page to a non-local address" do
-      expect(app).not_to receive :better_errors_call
-      app.call("REMOTE_ADDR" => "1.2.3.4")
-    end
-
-    it "shows to a whitelisted IP" do
-      BetterErrors::Middleware.allow_ip! '77.55.33.11'
-      expect(app).to receive :better_errors_call
-      app.call("REMOTE_ADDR" => "77.55.33.11")
-    end
-
-    it "respects the X-Forwarded-For header" do
-      expect(app).not_to receive :better_errors_call
-      app.call(
-        "REMOTE_ADDR"          => "127.0.0.1",
-        "HTTP_X_FORWARDED_FOR" => "1.2.3.4",
-      )
-    end
-
-    it "doesn't blow up when given a blank REMOTE_ADDR" do
-      expect { app.call("REMOTE_ADDR" => " ") }.to_not raise_error
-    end
-
-    it "doesn't blow up when given an IP address with a zone index" do
-      expect { app.call("REMOTE_ADDR" => "0:0:0:0:0:0:0:1%0" ) }.to_not raise_error
-    end
-
-    context "when requesting the /__better_errors manually" do
-      let(:app) { Middleware.new(->env { ":)" }) }
-
-      it "shows that no errors have been recorded" do
-        status, headers, body = app.call("PATH_INFO" => "/__better_errors")
-        expect(body.join).to match /No errors have been recorded yet./
-      end
-
-      it 'does not attempt to use ActionDispatch::ExceptionWrapper with a nil exception' do
-        ad_ew = double("ActionDispatch::ExceptionWrapper")
-        stub_const('ActionDispatch::ExceptionWrapper', ad_ew)
-        ad_ew.should_not_receive :new
-
-        status, headers, body = app.call("PATH_INFO" => "/__better_errors")
-      end
-
-      it "shows that no errors have been recorded on any subfolder path" do
-        status, headers, body = app.call("PATH_INFO" => "/any_sub/folder/path/__better_errors")
-        expect(body.join).to match /No errors have been recorded yet./
-      end
-    end
-
-    context "when handling an error" do
-      let(:app) { Middleware.new(->env { raise exception }) }
-
-      it "returns status 500" do
-        status, headers, body = app.call({})
-
-        expect(status).to eq(500)
-      end
-
-      if Exception.new.respond_to?(:cause)
-        context "cause" do
-          class OtherException < Exception
-            def initialize(message)
-              super(message)
-            end
-          end
-
-          it "shows Original Exception if it responds_to and has an cause" do
-            app = Middleware.new(->env {
-              begin
-                raise "Original Exception"
-              rescue
-                raise OtherException.new("Other Exception")
-              end
-            })
-
-            status, _, body = app.call({})
-
-            expect(status).to eq(500)
-            expect(body.join).not_to match(/\n> Other Exception\n/)
-            expect(body.join).to match(/\n> Original Exception\n/)
-          end
-        end
-      else
-        context "original_exception" do
-          class OriginalExceptionException < Exception
-            attr_reader :original_exception
-
-            def initialize(message, original_exception = nil)
-              super(message)
-              @original_exception = original_exception
-            end
-          end
-
-          it "shows Original Exception if it responds_to and has an original_exception" do
-            app = Middleware.new(->env {
-              raise OriginalExceptionException.new("Other Exception", Exception.new("Original Exception"))
-            })
-
-            status, _, body = app.call({})
-
-            expect(status).to eq(500)
-            expect(body.join).not_to match(/Other Exception/)
-            expect(body.join).to match(/Original Exception/)
-          end
-
-          it "won't crash if the exception responds_to but doesn't have an original_exception" do
-            app = Middleware.new(->env {
-              raise OriginalExceptionException.new("Other Exception")
-            })
-
-            status, _, body = app.call({})
-
-            expect(status).to eq(500)
-            expect(body.join).to match(/Other Exception/)
-          end
-        end
-      end
-
-      it "returns ExceptionWrapper's status_code" do
-        ad_ew = double("ActionDispatch::ExceptionWrapper")
-        allow(ad_ew).to receive('new').with({}, exception) { double("ExceptionWrapper", status_code: 404) }
-        stub_const('ActionDispatch::ExceptionWrapper', ad_ew)
-
-        status, headers, body = app.call({})
-
-        expect(status).to eq(404)
-      end
-
-      it "returns UTF-8 error pages" do
-        status, headers, body = app.call({})
-
-        expect(headers["Content-Type"]).to match /charset=utf-8/
-      end
-
-      it "returns text pages by default" do
-        status, headers, body = app.call({})
-
-        expect(headers["Content-Type"]).to match /text\/plain/
-      end
-
-      it "returns HTML pages by default" do
-        # Chrome's 'Accept' header looks similar this.
-        status, headers, body = app.call("HTTP_ACCEPT" => "text/html,application/xhtml+xml;q=0.9,*/*")
-
-        expect(headers["Content-Type"]).to match /text\/html/
-      end
-
-      it "logs the exception" do
-        logger = Object.new
-        expect(logger).to receive :fatal
-        allow(BetterErrors).to receive(:logger).and_return(logger)
-
-        app.call({})
-      end
-    end
-  end
-end

data/spec/better_errors/raised_exception_spec.rb

@@ -1,73 +0,0 @@
-require "spec_helper"
-require "rspec/its"
-
-module BetterErrors
-  describe RaisedException do
-    let(:exception) { RuntimeError.new("whoops") }
-    subject { RaisedException.new(exception) }
-
-    its(:exception) { should == exception }
-    its(:message)   { should == "whoops" }
-    its(:type)      { should == RuntimeError }
-
-    context "when the exception wraps another exception" do
-      let(:original_exception) { RuntimeError.new("something went wrong!") }
-      let(:exception) { double(:original_exception => original_exception) }
-
-      its(:exception) { should == original_exception }
-      its(:message)   { should == "something went wrong!" }
-    end
-
-    context "when the exception is a syntax error" do
-      let(:exception) { SyntaxError.new("foo.rb:123: you made a typo!") }
-
-      its(:message) { should == "you made a typo!" }
-      its(:type)    { should == SyntaxError }
-
-      it "has the right filename and line number in the backtrace" do
-        expect(subject.backtrace.first.filename).to eq("foo.rb")
-        expect(subject.backtrace.first.line).to eq(123)
-      end
-    end
-
-    context "when the exception is a HAML syntax error" do
-      before do
-        stub_const("Haml::SyntaxError", Class.new(SyntaxError))
-      end
-
-      let(:exception) {
-        Haml::SyntaxError.new("you made a typo!").tap do |ex|
-          ex.set_backtrace(["foo.rb:123", "haml/internals/blah.rb:123456"])
-        end
-      }
-
-      its(:message) { should == "you made a typo!" }
-      its(:type)    { should == Haml::SyntaxError }
-
-      it "has the right filename and line number in the backtrace" do
-        expect(subject.backtrace.first.filename).to eq("foo.rb")
-        expect(subject.backtrace.first.line).to eq(123)
-      end
-    end
-
-    context "when the exception is a Coffeelint syntax error" do
-      before do
-        stub_const("Sprockets::Coffeelint::Error", Class.new(SyntaxError))
-      end
-
-      let(:exception) {
-        Sprockets::Coffeelint::Error.new("[stdin]:11:88: error: unexpected=").tap do |ex|
-          ex.set_backtrace(["app/assets/javascripts/files/index.coffee:11", "sprockets/coffeelint.rb:3"])
-        end
-      }
-
-      its(:message) { should == "[stdin]:11:88: error: unexpected=" }
-      its(:type)    { should == Sprockets::Coffeelint::Error }
-
-      it "has the right filename and line number in the backtrace" do
-        expect(subject.backtrace.first.filename).to eq("app/assets/javascripts/files/index.coffee")
-        expect(subject.backtrace.first.line).to eq(11)
-      end
-    end
-  end
-end