roda 3.28.0 → 3.29.0

data/spec/plugin/error_handler_spec.rb

@@ -1,216 +0,0 @@
-require_relative "../spec_helper"
-
-describe "error_handler plugin" do 
-  it "executes only if error raised" do
-    app(:bare) do
-      plugin :error_handler
-
-      error do |e|
-        e.message
-      end
-
-      route do |r|
-        r.on "a" do
-          "found"
-        end
-
-        raise ArgumentError, "bad idea"
-      end
-    end
-
-    body("/a").must_equal 'found'
-    status("/a").must_equal 200
-    body.must_equal 'bad idea'
-    status.must_equal 500
-  end
-
-  deprecated "works if #call is overridden" do
-    app(:bare) do
-      plugin :error_handler
-
-      def call
-        super
-      end
-
-      error do |e|
-        e.message
-      end
-
-      route do |r|
-        r.on "a" do
-          "found"
-        end
-
-        raise ArgumentError, "bad idea"
-      end
-    end
-
-    body("/a").must_equal 'found'
-    status("/a").must_equal 200
-    body.must_equal 'bad idea'
-    status.must_equal 500
-  end
-
-  it "executes on SyntaxError exceptions" do
-    app(:bare) do
-      plugin :error_handler
-
-      error do |e|
-        e.message
-      end
-
-      route do |r|
-        r.on "a" do
-          "found"
-        end
-
-        raise SyntaxError, 'bad idea'
-      end
-    end
-
-    body("/a").must_equal 'found'
-    status("/a").must_equal 200
-    body.must_equal 'bad idea'
-    status.must_equal 500
-  end
-
-  it "executes on custom exception classes" do
-    app(:bare) do
-      plugin :error_handler, :classes=>[StandardError]
-
-      error do |e|
-        e.message
-      end
-
-      route do |r|
-        r.on "a" do
-          raise 'foo'
-        end
-
-        raise SyntaxError, 'bad idea'
-      end
-    end
-
-    proc{body}.must_raise SyntaxError
-    body("/a").must_equal 'foo'
-
-    @app = Class.new(@app)
-    proc{body}.must_raise SyntaxError
-    body("/a").must_equal 'foo'
-  end
-
-  it "can override status inside error block" do
-    app(:bare) do
-      plugin :error_handler do |e|
-        response.status = 501
-        e.message
-      end
-
-      route do |r|
-        raise ArgumentError, "bad idea"
-      end
-    end
-
-    status.must_equal 501
-  end
-
-  it "calculates correct Content-Length" do
-    app(:bare) do
-      plugin :error_handler do |e|
-        "a"
-      end
-
-      route do |r|
-        raise ArgumentError, "bad idea"
-      end
-    end
-
-    header('Content-Length').must_equal "1"
-  end
-
-  it "clears existing headers" do
-    app(:bare) do
-      plugin :error_handler do |e|
-        "a"
-      end
-
-      route do |r|
-        response['Content-Type'] = 'text/pdf'
-        response['Foo'] = 'bar'
-        raise ArgumentError, "bad idea"
-      end
-    end
-
-    header('Content-Type').must_equal 'text/html'
-    header('Foo').must_be_nil
-  end
-
-  it "can set error via the plugin block" do
-    app(:bare) do
-      plugin :error_handler do |e|
-        e.message
-      end
-
-      route do |r|
-        raise ArgumentError, "bad idea"
-      end
-    end
-
-    body.must_equal 'bad idea'
-  end
-
-  it "has default error handler also raise" do
-    app(:bare) do
-      plugin :error_handler
-
-      route do |r|
-        raise ArgumentError, "bad idea"
-      end
-    end
-
-    proc{req}.must_raise(ArgumentError)
-  end
-
-  it "logs exceptions during after processing of error handler" do
-    app(:bare) do
-      plugin :error_handler do |e|
-        e.message * 2
-      end
-      plugin :hooks
-
-      after do
-        raise "foo"
-      end
-
-      route do |r|
-        ''
-      end
-    end
-
-    errors = StringIO.new
-    body('rack.errors'=>errors).must_equal 'foofoo'
-    errors.rewind
-    errors.read.split("\n").first.must_equal "Error in after hook processing of error handler: RuntimeError: foo"
-  end
-
-  it "has access to current remaining_path" do
-    app(:bare) do
-      plugin :error_handler do |e|
-        request.remaining_path
-      end
-
-      route do |r|
-        r.on('a') do
-          raise ArgumentError, "bad idea"
-        end
-
-        raise ArgumentError, "bad idea"
-      end
-    end
-
-    body.must_equal '/'
-    body('/b').must_equal '/b'
-    body('/a').must_equal ''
-    body('/a/c').must_equal '/c'
-  end
-end

data/spec/plugin/error_mail_spec.rb

@@ -1,93 +0,0 @@
-require_relative "../spec_helper"
-
-begin
-  require 'mail'
-rescue LoadError
-  warn "mail not installed, skipping mail plugin test"  
-else
-Mail.defaults do
-  delivery_method :test
-end
-
-describe "error_mail plugin" do 
-  def app(opts={})
-    @emails = [] unless defined?(@emails)
-    @app ||= super(:bare) do
-      plugin :error_mail, {:to=>'t', :from=>'f'}.merge(opts)
-
-      route do |r|
-        r.get('noerror'){error_mail("Problem"); 'g'}
-        raise ArgumentError, 'bad foo' rescue error_mail($!)
-        'e'
-      end
-    end
-  end
-
-  after do
-    Mail::TestMailer.deliveries.clear
-  end
-
-  def email
-    Mail::TestMailer.deliveries.last
-  end
-
-  it "adds error_mail method for emailing exceptions" do
-    app
-    body('rack.input'=>StringIO.new, 'QUERY_STRING'=>'b=c', 'rack.session'=>{'d'=>'e'}).must_equal 'e'
-    email.to.must_equal ['t']
-    email.from.must_equal ['f']
-    email.header.to_s.must_match(/^Subject: ArgumentError: bad foo/)
-    email.body.to_s.must_match(/^Backtrace:$.+^ENV:$.+^"rack\.input" => .+^Params:$\s+^"b" => "c"$\s+^Session:$\s+^"d" => "e"$/m)
-  end
-
-  it "have error_mail method support string arguments" do
-    app
-    body('/noerror', 'rack.input'=>StringIO.new, 'QUERY_STRING'=>'b=c', 'rack.session'=>{'d'=>'e'}).must_equal 'g'
-    email.to.must_equal ['t']
-    email.from.must_equal ['f']
-    email.header.to_s.must_match(/^Subject: Problem/)
-    email.body.to_s.must_match(/^ENV:$.+^"rack\.input" => .+^Params:$\s+^"b" => "c"$\s+^Session:$\s+^"d" => "e"$/m)
-    email.body.to_s.wont_include('Backtrace')
-  end
-
-  it "supports error_mail_content for the content of the email" do
-    app.route do |r|
-      raise ArgumentError, 'bad foo' rescue error_mail_content($!)
-    end
-    b = body('rack.input'=>StringIO.new, 'QUERY_STRING'=>'b=c', 'rack.session'=>{'d'=>'e'})
-    b.must_match(/^Subject: ArgumentError: bad foo/)
-    b.must_match(/^Backtrace:.+^ENV:.+^"rack\.input" => .+^Params:\s+^"b" => "c"\s+^Session:\s+^"d" => "e"/m)
-  end
-
-  it "adds :prefix option to subject line" do
-    app(:prefix=>'TEST ')
-    body('rack.input'=>StringIO.new).must_equal 'e'
-    email.header.to_s.must_match(/^Subject: TEST ArgumentError/)
-  end
-
-  it "uses :headers option for additional headers" do
-    app(:headers=>{'Foo'=>'Bar', 'Baz'=>'Quux'})
-    body('rack.input'=>StringIO.new).must_equal 'e'
-    email.header.to_s.must_match(/^Foo: Bar/)
-    email.header.to_s.must_match(/^Baz: Quux/)
-  end
-
-  it "requires the :to and :from options" do
-    proc{app :from=>nil}.must_raise(Roda::RodaError)
-    proc{app :to=>nil}.must_raise(Roda::RodaError)
-  end
-
-  it "works correctly in subclasses" do
-    @app = Class.new(app)
-    @app.route do |r|
-      raise ArgumentError rescue error_mail($!)
-      'e'
-    end
-    body('rack.input'=>StringIO.new).must_equal 'e'
-    email.to.must_equal ['t']
-    email.from.must_equal ['f']
-    email.header.to_s.must_match(/^Subject: ArgumentError: ArgumentError/)
-    email.body.to_s.must_match(/^Backtrace:$.+^ENV:$.+^"rack\.input" => .+/m)
-  end
-end
-end

data/spec/plugin/exception_page_spec.rb

@@ -1,168 +0,0 @@
-require_relative "../spec_helper"
-
-describe "exception_page plugin" do 
-  def ep_app(&block)
-    app(:exception_page) do |r|
-      raise "foo" rescue block ? instance_exec($!, &block) : exception_page($!)
-    end
-  end
-
-  def req(path = '/', headers={})
-    if path.is_a?(Hash)
-      super(path.merge('rack.input'=>StringIO.new))
-    else
-      super(path, headers.merge('rack.input'=>StringIO.new))
-    end
-  end
-
-  it "returns HTML page with exception information if text/html is accepted" do
-    ep_app
-    s, h, body = req('HTTP_ACCEPT'=>'text/html')
-
-    s.must_equal 200
-    h['Content-Type'].must_equal 'text/html'
-    body = body.join
-    body.must_include "<title>RuntimeError at /"
-    body.must_include "<h1>RuntimeError at /</h1>"
-    body.must_include "<h2>foo</h2>"
-    body.must_include __FILE__
-    body.must_include "No GET data"
-    body.must_include "No POST data"
-    body.must_include "No cookie data"
-    body.must_include "Rack ENV"
-    body.must_include "HTTP_ACCEPT"
-    body.must_include "text/html"
-    body.must_include "table td.code"
-    body.must_include "function toggle()"
-    body.wont_include "\"/exception_page.css\""
-    body.wont_include "\"/exception_page.js\""
-
-    size = body.size
-    ep_app{|e| exception_page(e, :context=>10)}
-    body('HTTP_ACCEPT'=>'text/html').size.must_be :>, size
-
-    ep_app{|e| exception_page(e, :assets=>true, :context=>0)}
-    body = body('HTTP_ACCEPT'=>'text/html')
-    body.wont_include "table td.code"
-    body.wont_include "function toggle()"
-    body.must_include "\"/exception_page.css\""
-    body.must_include "\"/exception_page.js\""
-
-    ep_app{|e| exception_page(e, :assets=>"/static", :context=>0)}
-    body = body('HTTP_ACCEPT'=>'text/html')
-    body.wont_include "table td.code"
-    body.wont_include "function toggle()"
-    body.must_include "\"/static/exception_page.css\""
-    body.must_include "\"/static/exception_page.js\""
-
-    ep_app{|e| exception_page(e, :css_file=>"/foo.css", :context=>0)}
-    body = body('HTTP_ACCEPT'=>'text/html')
-    body.wont_include "table td.code"
-    body.must_include "function toggle()"
-    body.must_include "\"/foo.css\""
-
-    ep_app{|e| exception_page(e, :js_file=>"/foo.js", :context=>0)}
-    body = body('HTTP_ACCEPT'=>'text/html')
-    body.must_include "table td.code"
-    body.wont_include "function toggle()"
-    body.must_include "\"/foo.js\""
-
-    ep_app{|e| exception_page(e, :assets=>false, :context=>0)}
-    body = body('HTTP_ACCEPT'=>'text/html')
-    body.wont_include "table td.code"
-    body.wont_include "function toggle()"
-    body.wont_include "\"/exception_page.css\""
-    body.wont_include "\"/exception_page.js\""
-
-    ep_app{|e| exception_page(e, :assets=>false, :css_file=>"/foo.css", :context=>0)}
-    body = body('HTTP_ACCEPT'=>'text/html')
-    body.wont_include "table td.code"
-    body.wont_include "function toggle()"
-    body.must_include "\"/foo.css\""
-
-    ep_app{|e| exception_page(e, :assets=>false, :js_file=>"/foo.js", :context=>0)}
-    body = body('HTTP_ACCEPT'=>'text/html')
-    body.wont_include "table td.code"
-    body.wont_include "function toggle()"
-    body.must_include "\"/foo.js\""
-
-    ep_app{|e| exception_page(e, :css_file=>false, :context=>0)}
-    body = body('HTTP_ACCEPT'=>'text/html')
-    body.wont_include "table td.code"
-    body.must_include "function toggle()"
-    body.wont_include "\"/exception_page.css\""
-    body.wont_include "\"/exception_page.js\""
-
-    ep_app{|e| exception_page(e, :js_file=>false, :context=>0)}
-    body = body('HTTP_ACCEPT'=>'text/html')
-    body.must_include "table td.code"
-    body.wont_include "function toggle()"
-    body.wont_include "\"/exception_page.css\""
-    body.wont_include "\"/exception_page.js\""
-  end
-
-  it "returns plain text page with exception information if text/html is not accepted" do
-    ep_app
-    s, h, body = req
-
-    s.must_equal 200
-    h['Content-Type'].must_equal 'text/plain'
-    body = body.join
-    first, *bt = body.split("\n")
-    first.must_equal "RuntimeError: foo"
-    bt.first.must_include __FILE__
-  end
-
-  it "returns JSON with exception information if :json information is used" do
-    ep_app{|e| exception_page(e, :json=>true)}
-    @app.plugin :json
-    s, h, body = req
-
-    s.must_equal 200
-    h['Content-Type'].must_equal 'application/json'
-    hash = JSON.parse(body.join)
-    bt = hash["exception"].delete("backtrace")
-    hash.must_equal("exception"=>{"class"=>"RuntimeError", "message"=>"foo"})
-    bt.must_be_kind_of Array
-    bt.each{|line| line.must_be_kind_of String}
-  end
-
-  it "should handle backtrace lines in unexpected forms" do
-    ep_app do |e|
-      e.backtrace.first.upcase!
-      e.backtrace[-1] = ''
-      exception_page(e)
-    end
-    body = body('HTTP_ACCEPT'=>'text/html')
-    body.must_include "RuntimeError: foo"
-    body.must_include __FILE__
-    body.wont_include 'id="c0"'
-  end
-
-  it "should still show line numbers if the line content cannot be displayed" do
-    app(:exception_page) do |r|
-      instance_eval('raise "foo"', 'foo-bar.rb', 4200+42) rescue exception_page($!)
-    end
-    body = body('HTTP_ACCEPT'=>'text/html')
-    body.must_include "RuntimeError: foo"
-    body.must_include "foo-bar.rb:#{4200+42}"
-    body.must_include __FILE__
-    body.wont_include 'id="c0"'
-  end
-
-  it "should serve exception page assets" do
-    app(:exception_page) do |r|
-      r.exception_page_assets
-    end
-
-    s, h, b = req('/exception_page.css')
-    s.must_equal 200
-    h['Content-Type'].must_equal 'text/css'
-    b.join.must_equal Roda::RodaPlugins::ExceptionPage.css
-
-    s, h, b = req('/exception_page.js')
-    s.must_equal 200
-    h['Content-Type'].must_equal 'application/javascript'
-    b.join.must_equal Roda::RodaPlugins::ExceptionPage.js
-  end
-end