roda 3.28.0 → 3.29.0

data/spec/plugin/mailer_spec.rb

@@ -1,282 +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 "mailer plugin" do 
-  def deliveries
-    Mail::TestMailer.deliveries
-  end
-
-  after do
-    deliveries.clear
-  end
-
-  setup_email = lambda do 
-    from "f@example.com"
-    to "t@example.com"
-    subject 's'
-  end
-
-  it "supports sending emails via the routing tree" do
-    app(:mailer) do |r|
-      r.mail do
-        instance_exec(&setup_email)
-        cc "c@example.com"
-        bcc "b@example.com"
-        response['X-Foo'] = 'Bar'
-        "b"
-      end
-    end
-
-    m = app.mail('/foo')
-    deliveries.must_equal []
-    m.from.must_equal ['f@example.com']
-    m.to.must_equal ['t@example.com']
-    m.cc.must_equal ['c@example.com']
-    m.bcc.must_equal ['b@example.com']
-    m.subject.must_equal 's'
-    m.body.must_be :==, 'b'
-    m.header['X-Foo'].to_s.must_equal 'Bar'
-
-    m.deliver!
-    deliveries.must_equal [m]
-
-    deliveries.clear
-    m = app.sendmail('/foo')
-    deliveries.must_equal [m]
-    m.from.must_equal ['f@example.com']
-    m.to.must_equal ['t@example.com']
-    m.cc.must_equal ['c@example.com']
-    m.bcc.must_equal ['b@example.com']
-    m.subject.must_equal 's'
-    m.body.must_be :==, 'b'
-    m.header['X-Foo'].to_s.must_equal 'Bar'
-  end
-
-  it "supports arguments to mail/sendmail methods, yielding them to the route blocks" do
-    app(:mailer) do |r|
-      instance_exec(&setup_email)
-      r.mail "foo" do |*args|
-        "foo#{args.inspect}"
-      end
-      r.mail :d do |*args|
-        args.inspect
-      end
-    end
-
-    app.mail('/foo', 1, 2).body.must_be :==, 'foo[1, 2]'
-    app.sendmail('/bar', 1, 2).body.must_be :==, '["bar", 1, 2]'
-  end
-
-  it "supports no_mail! method for skipping mailing" do
-    app(:mailer) do |r|
-      instance_exec(&setup_email)
-      r.mail "foo" do |*args|
-        no_mail!
-        raise
-      end
-    end
-
-    app.mail('/foo', 1, 2).must_be_nil
-    app.sendmail('/foo', 1, 2).must_be_nil
-    deliveries.must_equal []
-  end
-
-  it "supports attachments" do
-    app(:mailer) do |r|
-      r.mail do
-        instance_exec(&setup_email)
-        add_file __FILE__
-      end
-    end
-
-    m = app.mail('foo')
-    m.attachments.length.must_equal 1
-    m.attachments.first.content_type.must_match(/mailer_spec\.rb/)
-    m.content_type.must_match(/\Amultipart\/mixed/)
-    m.parts.length.must_equal 1
-    m.parts.first.body.decoded.gsub("\r\n", "\n").must_equal File.read(__FILE__)
-  end
-
-  it "supports attachments with blocks" do
-    app(:mailer) do |r|
-      r.mail do
-        instance_exec(&setup_email)
-        add_file __FILE__ do
-          response.mail.attachments.last.content_type = 'text/foo'
-        end
-      end
-    end
-
-    m = app.mail('foo')
-    m.attachments.length.must_equal 1
-    m.attachments.first.content_type.must_equal 'text/foo'
-    m.content_type.must_match(/\Amultipart\/mixed/)
-    m.parts.length.must_equal 1
-    m.parts.first.body.decoded.gsub("\r\n", "\n").must_equal File.read(__FILE__)
-  end
-
-  it "supports plain-text attachments with an email body" do
-    app(:mailer) do |r|
-      r.mail do
-        instance_exec(&setup_email)
-        add_file :filename=>'a.txt', :content=>'b'
-        'c'
-      end
-    end
-
-    m = app.mail('foo')
-    m.parts.length.must_equal 2
-    m.parts.first.content_type.must_match(/text\/plain/)
-    m.parts.first.body.must_be :==, 'c'
-    m.parts.last.content_type.must_match(/text\/plain/)
-    m.parts.last.body.must_be :==, 'b'
-    m.attachments.length.must_equal 1
-    m.attachments.first.content_type.must_match(/a\.txt/)
-    m.content_type.must_match(/\Amultipart\/mixed/)
-  end
-
-  it "supports regular web requests in same application" do
-    app(:mailer) do |r|
-      r.get "foo", :bar do |bar|
-        "foo#{bar}"
-      end
-      r.mail "bar" do
-        instance_exec(&setup_email)
-        "b"
-      end
-    end
-
-    body("/foo/baz", 'rack.input'=>StringIO.new).must_equal 'foobaz'
-    app.mail('/bar').body.must_be :==, 'b'
-  end
-
-  it "supports multipart email using text_part/html_pat" do
-    app(:mailer) do |r|
-      r.mail do
-        instance_exec(&setup_email)
-        text_part "t"
-        html_part "h"
-      end
-    end
-
-    m = app.mail('/foo')
-    m.text_part.body.must_be :==, 't'
-    m.html_part.body.must_be :==, 'h'
-    m.content_type.must_match(/\Amultipart\/alternative/)
-  end
-
-  it "supports setting arbitrary email headers for multipart emails" do
-    app(:mailer) do |r|
-      r.mail do
-        instance_exec(&setup_email)
-        text_part "t", "X-Text"=>'T'
-        html_part "h", "X-HTML"=>'H'
-      end
-    end
-
-    m = app.mail('/foo')
-    m.text_part.body.must_be :==, 't'
-    m.text_part.header['X-Text'].to_s.must_equal 'T'
-    m.html_part.body.must_be :==, 'h'
-    m.html_part.header['X-HTML'].to_s.must_equal 'H'
-    m.content_type.must_match(/\Amultipart\/alternative/)
-  end
-
-  it "raises error if mail object is not returned" do
-    app(:mailer){}
-    proc{app.mail('/')}.must_raise(Roda::RodaPlugins::Mailer::Error)
-  end
-
-  it "does not raise an error when using an explicitly empty body" do
-    app(:mailer){""}
-    app.mail('/')
-  end
-
-  it "supports setting the default content-type for emails when loading the plugin" do
-    app(:bare) do
-      plugin :mailer, :content_type=>'text/html'
-      route{""}
-    end
-    app.mail('/').content_type.must_match(/\Atext\/html/)
-  end
-
-  it "supports loading the plugin multiple times" do
-    app(:bare) do
-      plugin :mailer, :content_type=>'text/html'
-      plugin :mailer
-      route{""}
-    end
-    app.mail('/').content_type.must_match(/\Atext\/html/)
-  end
-
-  it "supports manually overridding the default content-type for emails" do
-    app(:bare) do
-      plugin :mailer, :content_type=>'text/html'
-      route do
-        response['Content-Type'] = 'text/foo'
-        ""
-      end
-    end
-    app.mail('/').content_type.must_match(/\Atext\/foo/)
-  end
-
-  it "supports setting the default content type when attachments are used" do
-    app(:bare) do
-      plugin :mailer, :content_type=>'text/html'
-      route do
-        add_file 'spec/assets/css/raw.css'
-        "a"
-      end
-    end
-    m = app.mail('/')
-    m.content_type.must_match(/\Amultipart\/mixed/)
-    m.parts.length.must_equal 2
-    m.parts.first.content_type.must_match(/\Atext\/html/)
-    m.parts.first.body.must_be :==, "a"
-    m.parts.last.content_type.must_match(/\Atext\/css/)
-    m.parts.last.body.decoded.gsub("\r\n", "\n").must_equal File.read('spec/assets/css/raw.css')
-  end
-
-  it "works with route_block_args plugin" do
-    app(:bare) do
-      plugin :mailer
-      plugin :route_block_args do
-        [request.path]
-      end
-      route do |path|
-        path
-      end
-    end
-    app.mail('/').body.decoded.must_equal '/'
-    app.mail('/foo').body.decoded.must_equal '/foo'
-  end
-
-  it "works with hooks plugin" do
-    x = []
-    app(:bare) do
-      plugin :mailer
-      plugin :hooks
-      before do 
-        x << 1
-      end
-      after do
-        x << 2
-      end
-      route do
-        x << 3
-        ''
-      end
-    end
-    app.mail('/').body.decoded.must_equal ''
-    x.must_equal [1, 3, 2]
-  end
-end
-end

data/spec/plugin/match_affix_spec.rb

@@ -1,43 +0,0 @@
-require_relative "../spec_helper"
-
-describe "match_affix plugin" do 
-  it "allows changing the match prefix/suffix" do
-    app(:bare) do
-      plugin :match_affix, "", /(\/|\z)/
-
-      route do |r|
-        r.on "/albums" do |b|
-          r.on "b/:id" do |id, s|
-            "b-#{b}-#{id}-#{s.inspect}"
-          end
-
-          "albums-#{b}"
-        end
-      end
-    end
-
-    body("/albums/a/1").must_equal 'albums-/'
-    body("/albums/b/1").must_equal 'b-/-1-""'
-  end
-
-  it "handles extra trailing slash only" do
-    app(:bare) do
-      plugin :match_affix, nil, /(?:\/\z|(?=\/|\z))/
-
-      route do |r|
-        r.on "albums" do
-          r.on "b" do
-            "albums/b:#{r.remaining_path}"
-          end
-
-          "albums:#{r.remaining_path}"
-        end
-      end
-    end
-
-    body("/albums/a").must_equal 'albums:/a'
-    body("/albums/a/").must_equal 'albums:/a/'
-    body("/albums/b").must_equal 'albums/b:'
-    body("/albums/b/").must_equal 'albums/b:'
-  end
-end

data/spec/plugin/match_hook_spec.rb

@@ -1,79 +0,0 @@
-require_relative "../spec_helper"
-
-describe "match hook plugin" do
-  it "matches verbs" do
-    matches = []
-    app(:bare) do
-      plugin :match_hook
-      match_hook do
-        matches << [request.matched_path, request.remaining_path]
-      end
-      route do |r|
-        r.on "foo" do
-          r.on "bar" do
-            r.get "baz" do
-              "fbb"
-            end
-            "fb"
-          end
-          "f"
-        end
-
-        r.get "bar" do
-          "b"
-        end
-
-        r.root do
-          "r"
-        end
-
-        "n"
-      end
-    end
-
-    body("/foo").must_equal 'f'
-    matches.must_equal [["/foo", ""]]
-
-    matches.clear
-    body("/foo/bar").must_equal 'fb'
-    matches.must_equal [["/foo", "/bar"], ["/foo/bar", ""]]
-
-    matches.clear
-    body("/foo/bar/baz").must_equal 'fbb'
-    matches.must_equal [["/foo", "/bar/baz"], ["/foo/bar", "/baz"], ["/foo/bar/baz", ""]]
-
-    matches.clear
-    body("/bar").must_equal 'b'
-    matches.must_equal [["/bar", ""]]
-
-    matches.clear
-    body.must_equal 'r'
-    matches.must_equal [["", "/"]]
-
-    matches.clear
-    body('/x').must_equal 'n'
-    matches.must_be_empty
-
-    matches.clear
-    body("/foo/baz").must_equal 'f'
-    matches.must_equal [["/foo", "/baz"]]
-
-    matches.clear
-    body("/foo/bar/bar").must_equal 'fb'
-    matches.must_equal [["/foo", "/bar/bar"], ["/foo/bar", "/bar"]]
-
-    app.match_hook{matches << :x }
-
-    matches.clear
-    body("/foo/bar/baz").must_equal 'fbb'
-    matches.must_equal [["/foo", "/bar/baz"], :x, ["/foo/bar", "/baz"], :x, ["/foo/bar/baz", ""], :x]
-
-    app.freeze
-
-    matches.clear
-    body("/foo/bar/baz").must_equal 'fbb'
-    matches.must_equal [["/foo", "/bar/baz"], :x, ["/foo/bar", "/baz"], :x, ["/foo/bar/baz", ""], :x]
-
-    app.opts[:match_hooks].must_be :frozen?
-  end
-end

data/spec/plugin/middleware_spec.rb

@@ -1,237 +0,0 @@
-require_relative "../spec_helper"
-
-describe "middleware plugin" do 
-  [false, true].each do |def_call|
-    meth = def_call ? :deprecated : :it
-    send meth, "turns Roda app into middlware" do
-      a2 = app(:bare) do
-        plugin :middleware
-
-        if def_call
-          def call
-            super
-          end
-        end
-
-        route do |r|
-          r.is "a" do
-            "a2"
-          end
-          r.post "b" do
-            "b2"
-          end
-        end
-      end
-
-      a3 = app(:bare) do
-        plugin :middleware
-
-        route do |r|
-          r.get "a" do
-            "a3"
-          end
-          r.get "b" do
-            "b3"
-          end
-        end
-      end
-
-      app(:bare) do
-        use a3
-        use a2
-
-        route do |r|
-          r.is "a" do
-            "a1"
-          end
-          r.is "b" do
-            "b1"
-          end
-        end
-      end
-
-      body('/a').must_equal 'a3'
-      body('/b').must_equal 'b3'
-      body('/a', 'REQUEST_METHOD'=>'POST').must_equal 'a2'
-      body('/b', 'REQUEST_METHOD'=>'POST').must_equal 'b2'
-      body('/a', 'REQUEST_METHOD'=>'PATCH').must_equal 'a2'
-      body('/b', 'REQUEST_METHOD'=>'PATCH').must_equal 'b1'
-    end
-  end
-
-  it "makes it still possible to use the Roda app normally" do
-    app(:middleware) do
-      "a"
-    end
-    body.must_equal 'a'
-  end
-
-  deprecated "makes it still possible to use the Roda app normally when #call is overwritten" do
-    app(:bare) do
-      plugin :middleware
-      def call
-        super
-      end
-
-      route do
-        "a"
-      end
-    end
-    app
-    body.must_equal 'a'
-  end
-
-  it "makes middleware always use a subclass of the app" do
-    app(:middleware) do |r|
-      r.get{opts[:a]}
-    end
-    app.opts[:a] = 'a'
-    a = app
-    app(:bare) do
-      use a
-      route{}
-    end
-    body.must_equal 'a'
-    a.opts[:a] = 'b'
-    body.must_equal 'a'
-  end
-
-  it "should raise error if attempting to use options for Roda application that does not support configurable middleware" do
-    a1 = app(:bare){plugin :middleware}
-    proc{app(:bare){use a1, :foo; route{}; build_rack_app}}.must_raise Roda::RodaError
-    proc{app(:bare){use(a1){}; route{}; build_rack_app}}.must_raise Roda::RodaError
-  end
-
-  it "supports configuring middleware via a block" do
-    a1 = app(:bare) do
-      plugin :middleware do |mid, *args, &block|
-        mid.opts[:a] = args.concat(block.call(:quux)).join(' ')
-      end
-      opts[:a] = 'a1'
-
-      route do |r|
-        r.is 'a' do opts[:a] end
-      end
-    end
-
-    body('/a').must_equal 'a1'
-    
-    app(:bare) do
-      use a1, :foo, :bar do |baz|
-        [baz, :a1]
-      end
-
-      route do
-        'b1'
-      end
-    end
-
-    body.must_equal 'b1'
-    body('/a').must_equal 'foo bar quux a1'
-
-    @app = a1
-    body('/a').must_equal 'a1'
-  end
-
-  it "is compatible with the multi_route plugin" do
-    app(:bare) do
-      plugin :multi_route
-      plugin :middleware
-
-      route("a") do |r|
-        r.is "b" do
-          "ab"
-        end
-      end
-
-      route do |r|
-        r.multi_route
-      end
-    end
-
-    body('/a/b').must_equal 'ab'
-  end
-
-  it "uses the app's middleware if :include_middleware option is given" do
-    mid = Struct.new(:app) do
-      def call(env)
-        env['foo'] = 'bar'
-        app.call(env)
-      end
-    end
-    app(:bare) do
-      plugin :middleware, :include_middleware=>true
-      use mid
-      route{}
-    end
-    mid2 = app
-    app(:bare) do
-      use mid2
-      route{env['foo']}
-    end
-    body.must_equal 'bar'
-  end
-
-  it "calls :handle_result option with env and response" do
-    app(:bare) do
-      plugin :middleware, :handle_result=>(proc do |env, res|
-        res[2] << env['foo']
-      end)
-      route{}
-    end
-    mid2 = app
-    app(:bare) do
-      use mid2
-      route{env['foo'] = 'bar'; 'baz'}
-    end
-    body.must_equal 'bazbar'
-  end
-
-  it "works with the route_block_args block when loaded before" do
-    app(:bare) do
-      plugin :middleware
-      plugin :route_block_args do
-        [request.path, response]
-      end
-
-      route do |path, res|
-        request.get 'a' do
-          res.write(path + '2')
-        end
-      end
-    end
-    a = app
-
-    app(:bare) do
-      use a
-      route{|r| 'b'}
-    end
-
-    body('/a').must_equal '/a2'
-    body('/x').must_equal 'b'
-  end
-
-  it "works with the route_block_args block when loaded after" do
-    app(:bare) do
-      plugin :route_block_args do
-        [request.path, response]
-      end
-      plugin :middleware
-
-      route do |path, res|
-        request.get 'a' do
-          res.write(path + '2')
-        end
-      end
-    end
-    a = app
-
-    app(:bare) do
-      use a
-      route{|r| 'b'}
-    end
-
-    body('/a').must_equal '/a2'
-    body('/x').must_equal 'b'
-  end
-end