roda 3.28.0 → 3.29.0

data/spec/plugin/slash_path_empty_spec.rb

@@ -1,22 +0,0 @@
-require_relative "../spec_helper"
-
-describe "slash_path_empty" do 
-  it "considers a / path as empty" do
-    app(:slash_path_empty) do |r|
-      r.is{"1"}
-      r.is("a"){"2"}
-      r.get("b"){"3"}
-    end
-
-    body("").must_equal '1'
-    body.must_equal '1'
-    body("a").must_equal ''
-    body("/a").must_equal '2'
-    body("/a/").must_equal '2'
-    body("/a/b").must_equal ''
-    body("b").must_equal ''
-    body("/b").must_equal '3'
-    body("/b/").must_equal '3'
-    body("/b/c").must_equal ''
-  end
-end

data/spec/plugin/static_routing_spec.rb

@@ -1,192 +0,0 @@
-require_relative "../spec_helper"
-
-describe "static_routing plugin" do 
-  it "adds support for static routes that are taken before normal routes" do
-    app(:bare) do
-      plugin :static_routing
-      static_route "/foo" do |r|
-        "#{r.path}:#{r.remaining_path}"
-      end
-      static_route "/bar" do |r|
-        r.get{"GET:#{r.path}:#{r.remaining_path}"}
-        r.post{"POST:#{r.path}:#{r.remaining_path}"}
-      end
-      static_get "/bar" do |r|
-        r.get{"GET2:#{r.path}:#{r.remaining_path}"}
-      end
-      static_route "/quux" do |r|
-         r.halt [500, {}, []]
-      end
-
-      route do |r|
-        r.on 'foo' do
-          r.get true do
-            'foo1'
-          end
-          r.root do
-            'foo2'
-          end
-        end
-
-        r.get 'baz' do
-          'baz'
-        end
-      end
-    end
-
-    2.times do
-      body('/foo').must_equal '/foo:'
-      body('/foo/').must_equal 'foo2'
-      body('/bar').must_equal 'GET2:/bar:'
-      body('/bar', 'REQUEST_METHOD'=>'POST').must_equal 'POST:/bar:'
-      status('/bar', 'REQUEST_METHOD'=>'PATCH').must_equal 404
-      body('/baz').must_equal 'baz'
-      status('/quux').must_equal 500
-      @app = Class.new(@app)
-    end
-  end
-
-  it "works with hooks plugin if loaded after" do
-    a = []
-    app(:bare) do
-      plugin :hooks
-      plugin :static_routing
-
-      before{a << 1}
-      after{a << 2}
-
-      static_route "/foo" do |r|
-        a << 3
-        "bar"
-      end
-
-      route{}
-    end
-    body('/foo').must_equal 'bar'
-    a.must_equal [1,3,2]
-  end
-
-  it "works with hooks plugin if loaded before" do
-    a = []
-    app(:bare) do
-      plugin :static_routing
-      plugin :hooks
-
-      before{a << 1}
-      after{a << 2}
-
-      static_route "/foo" do |r|
-        a << 3
-        "bar"
-      end
-
-      route{}
-    end
-    body('/foo').must_equal 'bar'
-    a.must_equal [1,3,2]
-  end
-
-  it "supports overridding static routes" do
-    app(:static_routing) do |r|
-    end
-    app.static_route('/foo'){'bar'}
-    body('/foo').must_equal 'bar'
-    app.static_route('/foo'){'baz'}
-    body('/foo').must_equal 'baz'
-  end
-
-  it "keeps existing routes when loading the plugin" do
-    app(:bare) do
-      plugin :static_routing
-      static_route "/foo" do |r|
-        "#{r.path}:#{r.remaining_path}"
-      end
-      plugin :static_routing
-
-      route{}
-    end
-    body('/foo').must_equal '/foo:'
-  end
-
-  it "does not allow placeholders in static routes" do
-    app(:bare) do
-      plugin :static_routing
-      static_route "/:foo" do |r|
-        "#{r.path}:#{r.remaining_path}"
-      end
-
-      route{}
-    end
-    body('/:foo').must_equal '/:foo:'
-    status('/a').must_equal 404
-  end
-
-  it "duplicates data structures in subclasses" do
-    app(:bare) do
-      plugin :static_routing
-      static_route "/foo" do |r|
-        'foo'
-      end
-
-      route{}
-    end
-
-    old_app = @app
-    @app = Class.new(old_app)
-    old_app.static_route '/bar' do |r|
-      'bar1'
-    end
-    old_app.static_get '/foo' do |r|
-      'foop'
-    end
-    @app.static_route '/bar' do |r|
-      'bar2'
-    end
-
-    body('/foo').must_equal 'foo'
-    body('/bar').must_equal 'bar2'
-    body('/foo', 'REQUEST_METHOD'=>'POST').must_equal 'foo'
-    @app = old_app
-    body('/foo').must_equal 'foop'
-    body('/bar').must_equal 'bar1'
-    body('/foo', 'REQUEST_METHOD'=>'POST').must_equal 'foo'
-  end
-
-  it "freezes static routes when app is frozen" do
-    app(:bare) do
-      plugin :static_routing
-      static_route("/foo"){}
-      freeze
-
-      proc do
-        static_get("/foo"){}
-      end.must_raise
-
-      proc do
-        static_route("/bar"){}
-      end.must_raise
-    end
-  end
-
-  it 'works with route_block_args plugin' do
-    app(:bare) do 
-      plugin :static_routing
-      plugin :route_block_args do
-        [request.request_method, request.path]
-      end
-      
-      static_route "/foo" do |meth, path|
-        "#{path}-#{meth}"
-      end
-
-      static_get "/bar" do |meth, path|
-        "#{path}-#{meth}-bar"
-      end
-
-      route{'a'}
-    end
-
-    body('/foo').must_equal '/foo-GET'
-    body('/bar').must_equal '/bar-GET-bar'
-  end
-end

data/spec/plugin/static_spec.rb

@@ -1,30 +0,0 @@
-require_relative "../spec_helper"
-
-describe "static plugin" do 
-  it "adds support for serving static files" do
-    app(:bare) do
-      plugin :static, ['/about'], :root=>'spec/views'
-
-      route do
-        'a'
-      end
-    end
-
-    body.must_equal 'a'
-    body('/about/_test.erb').must_equal File.read('spec/views/about/_test.erb')
-  end
-
-  it "respects the application's :root option" do
-    app(:bare) do
-      opts[:root] = File.expand_path('../../', __FILE__)
-      plugin :static, ['/about'], :root=>'views'
-
-      route do
-        'a'
-      end
-    end
-
-    body.must_equal 'a'
-    body('/about/_test.erb').must_equal File.read('spec/views/about/_test.erb')
-  end
-end

data/spec/plugin/status_303_spec.rb

@@ -1,28 +0,0 @@
-require_relative "../spec_helper"
-
-describe "status_303 plugin" do
-  it 'uses a 302 for get requests' do
-    app(:status_303) do
-      request.redirect '/foo'
-      fail 'redirect should halt'
-    end
-    status.must_equal 302
-    body.must_equal ''
-    header('Location').must_equal '/foo'
-  end
-
-  it 'uses the code given when specified' do
-    app(:status_303) do
-      request.redirect '/foo', 301
-    end
-    status.must_equal 301
-  end
-
-  it 'uses 303 for post requests if request is HTTP 1.1, 302 for 1.0' do
-    app(:status_303) do
-      request.redirect '/foo'
-    end
-    status('HTTP_VERSION' => 'HTTP/1.1', 'REQUEST_METHOD'=>'POST').must_equal 303
-    status('HTTP_VERSION' => 'HTTP/1.0', 'REQUEST_METHOD'=>'POST').must_equal 302
-  end
-end

data/spec/plugin/status_handler_spec.rb

@@ -1,158 +0,0 @@
-require_relative "../spec_helper"
-
-describe "status_handler plugin" do
-  it "executes on no arguments" do
-    app(:bare) do
-      plugin :status_handler
-
-      status_handler(404) do
-        "not found"
-      end
-
-      route do |r|
-        r.on "a" do
-          "found"
-        end
-      end
-    end
-
-    body.must_equal 'not found'
-    status.must_equal 404
-    body("/a").must_equal 'found'
-    status("/a").must_equal 200
-  end
-
-  it "passes request if block accepts argument" do
-    app(:bare) do
-      plugin :status_handler
-
-      status_handler(404) do |r|
-        r.path + 'foo'
-      end
-
-      route do |r|
-      end
-    end
-
-    body('/').must_equal '/foo'
-    body("/a").must_equal '/afoo'
-    status("/").must_equal 404
-  end
-
-  it "allows overriding status inside status_handler" do
-    app(:bare) do
-      plugin :status_handler
-
-      status_handler(404) do
-        response.status = 403
-        "not found"
-      end
-
-      route do |r|
-      end
-    end
-
-    status.must_equal 403
-  end
-
-  it "calculates correct Content-Length" do
-    app(:bare) do
-      plugin :status_handler
-
-      status_handler(404) do
-        "a"
-      end
-
-      route{}
-    end
-
-    header('Content-Length').must_equal "1"
-  end
-
-  it "clears existing headers" do
-    app(:bare) do
-      plugin :status_handler
-
-      status_handler(404) do
-        "a"
-      end
-
-      route do |r|
-        response['Content-Type'] = 'text/pdf'
-        response['Foo'] = 'bar'
-        nil
-      end
-    end
-
-    header('Content-Type').must_equal 'text/html'
-    header('Foo').must_be_nil
-  end
-
-  it "does not modify behavior if status_handler is not called" do
-    app(:status_handler) do |r|
-      r.on "a" do
-        "found"
-      end
-    end
-
-    body.must_equal ''
-    body("/a").must_equal 'found'
-  end
-
-  it "does not modify behavior if body is not an array" do
-    app(:bare) do
-      plugin :status_handler
-
-      status_handler(404) do
-        "not found"
-      end
-
-      o = Object.new
-      def o.each; end
-      route do |r|
-        r.halt [404, {}, o]
-      end
-    end
-
-    body.must_equal ''
-  end
-
-  it "does not modify behavior if body is not an empty array" do
-    app(:bare) do
-      plugin :status_handler
-
-      status_handler(404) do
-        "not found"
-      end
-
-      route do |r|
-        response.status = 404
-        response.write 'a'
-      end
-    end
-
-    body.must_equal 'a'
-  end
-
-  it "does not allow further status handlers to be added after freezing" do
-    app(:bare) do
-      plugin :status_handler
-
-      status_handler(404) do
-        "not found"
-      end
-
-      route{}
-    end
-
-    app.freeze
-
-    body.must_equal 'not found'
-    status.must_equal 404
-
-    proc{app.status_handler(404) { "blah" }}.must_raise
-
-    body.must_equal 'not found'
-  end
-
-end

data/spec/plugin/streaming_spec.rb

@@ -1,246 +0,0 @@
-require_relative "../spec_helper"
-
-describe "streaming plugin" do 
-  it "adds stream method for streaming responses" do
-    app(:streaming) do |r|
-      stream do |out|
-        %w'a b c'.each do |v|
-          (out << v).must_equal out
-          out.write(v).must_equal 1
-        end
-      end
-    end
-
-    s, h, b = req
-    s.must_equal 200
-    h.must_equal('Content-Type'=>'text/html')
-    b.to_a.must_equal %w'a a b b c c'
-  end
-
-  it "works with IO.copy_stream" do
-    app(:streaming) do |r|
-      stream do |out|
-        %w'a b c'.each{|v| IO.copy_stream(StringIO.new(v), out) }
-      end
-    end
-
-    s, h, b = req
-    s.must_equal 200
-    h.must_equal('Content-Type'=>'text/html')
-    # dup as copy_stream reuses the buffer
-    b.map(&:dup).must_equal %w'a b c'
-  end
-
-  it "should handle errors when streaming, and run callbacks" do
-    a = []
-    app(:streaming) do |r|
-      stream(:callback=>proc{a << 'e'}) do |out|
-        %w'a b'.each{|v| out << v}
-        raise Roda::RodaError, 'foo'
-        out << 'c'
-      end
-    end
-
-    s, h, b = req
-    s.must_equal 200
-    h.must_equal('Content-Type'=>'text/html')
-    proc{b.each{|v| a << v}}.must_raise(Roda::RodaError)
-    a.must_equal %w'a b e'
-  end
-
-  it "should handle :loop option to loop" do
-    a = []
-    app(:streaming) do |r|
-      b = %w'a b c'
-      stream(:loop=>true, :callback=>proc{a << 'e'}) do |out|
-        out << b.shift
-        raise Roda::RodaError, 'foo' if b.length == 1
-      end
-    end
-
-    s, h, b = req
-    s.must_equal 200
-    h.must_equal('Content-Type'=>'text/html')
-    proc{b.each{|v| a << v}}.must_raise(Roda::RodaError)
-    a.must_equal %w'a b e'
-  end
-
-  it "uses handle_stream_error for handling errors when streaming" do
-    a = []
-    app(:streaming) do |r|
-      b = %w'a b c'
-      stream(:loop=>true, :callback=>proc{a << 'e'}) do |out|
-        out << b.shift
-        raise Roda::RodaError, 'foo' if b.length == 1
-      end
-    end
-
-    app.send(:define_method, :handle_stream_error) do |error, out|
-      out << '1'
-      raise error
-    end
-
-    s, h, b = req
-    s.must_equal 200
-    h.must_equal('Content-Type'=>'text/html')
-    proc{b.each{|v| a << v}}.must_raise(Roda::RodaError)
-    a.must_equal %w'a b 1 e'
-  end
-
-  it "should allow closing the stream when handling an error" do
-    a = []
-    app(:streaming) do |r|
-      b = %w'a b c'
-      stream(:loop=>true, :callback=>proc{a << 'e'}) do |out|
-        out << b.shift
-        raise Roda::RodaError, 'foo' if b.length == 1
-      end
-    end
-
-    app.send(:define_method, :handle_stream_error) do |error, out|
-      out.close
-    end
-
-    s, h, b = req
-    s.must_equal 200
-    h.must_equal('Content-Type'=>'text/html')
-    b.each{|v| a << v}
-    a.must_equal %w'a b e'
-  end
-
-  it "should allow ignoring errors when streaming" do
-    a = []
-    b2 = %w'a b c'
-
-    app(:streaming) do |r|
-      stream(:loop=>true, :callback=>proc{a << 'e'}) do |out|
-        out << b2.shift
-        raise Roda::RodaError
-      end
-    end
-
-    app.send(:define_method, :handle_stream_error) do |error, out|
-      out << '1'
-      out.close if b2.empty?
-    end
-
-    s, h, b = req
-    s.must_equal 200
-    h.must_equal('Content-Type'=>'text/html')
-    b.each{|v| a << v}
-    a.must_equal %w'a 1 b 1 c 1 e'
-  end
-
-  describe "with :async" do
-    it "should stream in a thread" do
-      main_thread = Thread.current
-      minitest = self
-      app(:streaming) do |r|
-        stream(:async=>true) do |out|
-          minitest.refute_equal Thread.current, main_thread
-          %w'a b c'.each do |v|
-            out << v
-          end
-        end
-      end
-
-      s, h, b = req
-      s.must_equal 200
-      h.must_equal('Content-Type'=>'text/html')
-      b.to_a.must_equal %w'a b c'
-    end
-
-    it "should propagate exceptions" do
-      app(:streaming) do |r|
-        stream(:async=>true) do |out|
-          Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception=)
-          %w'a b'.each{|v| out << v}
-          raise Roda::RodaError, 'foo'
-          out << 'c'
-        end
-      end
-
-      s, h, b = req
-      s.must_equal 200
-      h.must_equal('Content-Type'=>'text/html')
-      a = []
-      proc{b.each{|v| a << v}}.must_raise(Roda::RodaError)
-      a.must_equal %w'a b'
-    end
-
-    it "should terminate the thread on close" do
-      q = Queue.new
-      app(:streaming) do |r|
-        stream(:async=>true) do |out|
-          %w'a b c d e f g h i j'.each{|v| out << v}
-          q.deq
-          out << 'k'
-        end
-      end
-
-      *, b = req
-      e = b.enum_for(:each)
-      10.times{e.next}
-      b.close
-      q.enq 'x'
-      proc{e.next}.must_raise(StopIteration)
-    end
-
-    it "should still run callbacks on close" do
-      callback = false
-      app(:streaming) do |r|
-        stream(:async=>true, :callback=>proc{callback = true}) do |out|
-          %w'a b c'.each{|v| out << v}
-        end
-      end
-
-      *, b = req
-      b.close
-      callback.must_equal true
-    end
-
-    it "should apply backpressure by default" do
-      q = Queue.new
-      a = []
-      app(:streaming) do |r|
-        stream(:async=>true) do |out|
-          %w'a b c d e f g h i j'.each do |v|
-            out << v
-            a << v
-          end
-
-          q.enq 'x'
-
-          out << 'k'
-          a << 'k'
-        end
-      end
-
-      req
-      q.deq
-      a.must_equal %w'a b c d e f g h i j'
-    end
-
-    it "should handle :queue option to override queue" do
-      q = Queue.new
-      a = []
-      app(:streaming) do |r|
-        stream(:async=>true, queue: SizedQueue.new(5)) do |out|
-          %w'a b c d e'.each do |v|
-            out << v
-            a << v
-          end
-
-          q.enq 'x'
-
-          out << 'f'
-          a << 'f'
-        end
-      end
-
-      req
-      q.deq
-      a.must_equal %w'a b c d e'
-    end
-  end if RUBY_VERSION >= '2.3'
-end