http_router 0.4.1 → 0.5.0

data/test/sinatra/test_recognize.rb

@@ -0,0 +1,150 @@
+require "sinatra"
+require "http_router/interface/sinatra"
+
+module CallWithMockRequestMixin
+  def call_with_mock_request(url = "/sample", method = "GET", params = Hash.new)
+    params.merge!(:method => method)
+    request = Rack::MockRequest.new(self)
+    request.request(method, url, params)
+  end
+end
+
+class TestRecognize < MiniTest::Unit::TestCase
+
+  def setup
+    @app = Sinatra.new { register HttpRouter::Interface::Sinatra::Extension }
+    @app.extend(CallWithMockRequestMixin)
+    @app.reset!
+  end
+
+  def test_basic
+    response = @app.call_with_mock_request('/bar')
+    assert_equal 404, response.status
+  end
+  
+  def test_map_index
+    @app.get("/") { "index" }
+    response = @app.call_with_mock_request('/')
+    assert_equal 200, response.status
+    assert_equal "index", response.body
+  end
+  
+  def test_trailing_slash
+    @app.get("/foo") { "foo" }
+    response = @app.call_with_mock_request('/foo')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+    response = @app.call_with_mock_request('/foo/')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+  end
+  
+  def test_trailing_slash2
+    @app.get("/foo") { "foo" }
+    @app.get("/foo/bar") { "bar" }
+    response = @app.call_with_mock_request('/foo')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+    response = @app.call_with_mock_request('/foo/bar')
+    assert_equal 200, response.status
+    assert_equal "bar", response.body
+    response = @app.call_with_mock_request('/foo/')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+    response = @app.call_with_mock_request('/foo/bar/')
+    assert_equal 200, response.status
+    assert_equal "bar", response.body
+  end
+  
+  def test_trailing_slash_with_optional_param
+    @app.get("/foo/(:bar)") { params[:bar] }
+    @app.get("/bar(/:foo)") { params[:foo] }
+    response = @app.call_with_mock_request('/foo/bar')
+    assert_equal 200, response.status
+    assert_equal "bar", response.body
+    response = @app.call_with_mock_request('/bar/foo')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+    response = @app.call_with_mock_request('/bar')
+    assert_equal 200, response.status
+    assert_equal "", response.body
+    response = @app.call_with_mock_request('/bar/')
+    assert_equal 200, response.status
+    assert_equal "", response.body
+  end
+
+  def test_trailing_question_mark
+    @app.get("/foo/?") { "foo" }
+    response = @app.call_with_mock_request('/foo')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+    response = @app.call_with_mock_request('/foo/')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+  end
+  
+  def test_map_basic
+    @app.get('/hi', :name => :hi) { generate(:hi) }
+    response = @app.call_with_mock_request('/hi')
+    assert_equal 200, response.status
+    assert_equal "/hi", response.body
+  end
+
+  def test_map_basic2
+    @app.get('/hi', :name => :hi) { generate(:hi) }
+    response = @app.call_with_mock_request('/hi/')
+    assert_equal 200, response.status
+    assert_equal "/hi", response.body
+  end
+  
+  def test_map_param
+    @app.get('/hi/:id', :name => :hi) { generate(:hi, :id => 18) }
+    response = @app.call_with_mock_request('/hi/1')
+    assert_equal 200, response.status
+    assert_equal "/hi/18", response.body
+  end
+  
+  def test_map_param2
+    @app.get('/hi-:id', :name => :hi) { generate(:hi, :id => 18) }
+    response = @app.call_with_mock_request('/hi-1')
+    assert_equal 200, response.status
+    assert_equal "/hi-18", response.body
+  end
+  
+  def test_map_complex
+    @app.get('/hi/:foo/:bar/:baz(.:format)') { "/#{params[:foo]}/#{params[:bar]}/#{params[:baz]}/#{params[:format]}" }
+    response = @app.call_with_mock_request('/hi/foo/bar/baz')
+    assert_equal 200, response.status
+    assert_equal "/foo/bar/baz/", response.body
+    response = @app.call_with_mock_request('/hi/foo/bar-bax/baz')
+    assert_equal 200, response.status
+    assert_equal "/foo/bar-bax/baz/", response.body
+  end
+
+  def test_map_regexp
+    @app.get('/numbers/:digits', :matching => { :digits => /\d+/ }) { params[:digits] }
+    response = @app.call_with_mock_request('/numbers/2010')
+    assert_equal 200, response.status
+    assert_equal "2010", response.body
+  end
+
+  def test_not_map_regex
+    @app.get('/numbers/:digits', :matching => { :digits => /\d+/ }) { params[:digits] }
+    response = @app.call_with_mock_request('/numbers/nan')
+    assert_equal 404, response.status
+  end
+
+  def test_404
+    response = @app.call_with_mock_request('/bar')
+    assert_equal 404, response.status
+    assert_match response.body, /Sinatra doesn't know this ditty/
+  end
+
+  def test_405
+    @app.post('/bar') { 'found' }
+    @app.put('/bar') { 'found' }
+    response = @app.call_with_mock_request('/bar')
+    assert_equal 405, response.status
+    assert_equal ['POST', 'PUT'], response.headers['Allow'].split(/\s*,\s*/).sort
+  end
+end

data/test/test_arbitrary.rb

@@ -0,0 +1,50 @@
+class TestArbitrary < MiniTest::Unit::TestCase
+  def test_match
+    hello, love80, love8080 = router {
+      add('test').arbitrary(Proc.new{|req, params| req.host == 'hellodooly' })
+      add("test").arbitrary(Proc.new{|req, params| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 80}
+      add("test").arbitrary(Proc.new{|req, params| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 8080}
+    }
+    assert_route love8080, 'http://lovelove:8080/test'
+  end
+
+  def test_less_specific_node
+    general, hello, love80, love8080 = router {
+      add("/test")
+      add("/test").arbitrary(Proc.new{|req, params| req.host == 'hellodooly' })
+      add("/test").arbitrary(Proc.new{|req, params| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 80}
+      add("/test").arbitrary(Proc.new{|req, params| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 8080}
+    }
+    assert_route general,  'http://lovelove:8081/test'
+    assert_route hello,    'http://hellodooly:8081/test'
+    assert_route love80,   'http://lovelove:80/test'
+    assert_route love8080, 'http://lovelove:8080/test'
+  end
+
+  def test_match_request
+    love80, love8080 = router {
+      add("/test").get.arbitrary(Proc.new{|req, params| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 80}
+      add("/test").get.arbitrary(Proc.new{|req, params| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 8080}
+    }
+    assert_route love80,   'http://lovelove:80/test'
+    assert_route love8080, 'http://lovelove:8080/test'
+  end
+
+  def test_less_specific_with_request
+    love80, love8080, general = router {
+      add("test").post.arbitrary(Proc.new{|req, params| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 80}
+      add("test").post.arbitrary(Proc.new{|req, params| req.host == 'lovelove' }).arbitrary{|req, params, dest| req.port == 8080}
+      add("test").post
+    }
+    assert_route love8080, Rack::MockRequest.env_for('http://lovelove:8080/test', :method => :post)
+    assert_route love80,   Rack::MockRequest.env_for('http://lovelove:80/test', :method => :post)
+    assert_route general,  Rack::MockRequest.env_for('/test', :method => :post)
+  end
+
+  def test_pass_params
+    r = router {
+      add(":test").get.arbitrary(Proc.new{|req, params, dest| params[:test] == 'test' })
+    }
+    assert_route r, '/test', {:test => 'test'}
+  end
+end

data/test/test_generate.rb

@@ -0,0 +1,93 @@
+class TestGenerate < MiniTest::Unit::TestCase
+
+  def test_static
+    router {
+      add('/').name(:a)
+      add('/test').name(:b)
+      add('/test/time').name(:c)
+      add('/one/more/what').name(:d)
+      add('/test.html').name(:e)
+    }
+    assert_generate '/', :a
+    assert_generate '/test', :b
+    assert_generate '/test/time', :c
+    assert_generate '/one/more/what', :d
+    assert_generate '/test.html', :e
+  end
+
+  def test_dynamic
+    assert_generate '/test', '/:var', :var => 'test'
+    assert_generate '/test', '/:var', 'test'
+  end
+  
+  def test_array_with_extras
+    assert_generate '/test?query=string', '/:var', :var => 'test', :query => 'string'
+    assert_generate '/test?query=string', '/:var', 'test', :query => 'string'
+  end
+  
+  def test_multiple_dynamics
+    assert_generate '/one/two', "/:var/:baz", :var => 'one', :baz => 'two'
+    assert_generate '/one/two', "/:var/:baz", 'one', 'two'
+  end
+
+  def test_extension
+    assert_generate '/test.html', "/test.:format", :format => 'html'
+    assert_generate '/test.html', "/test.:format", 'html'
+  end
+
+  def test_optional_extension
+    assert_generate '/test.html', "/test(.:format)", :format => 'html'
+    assert_generate '/test.html', "/test(.:format)", 'html'
+    assert_generate '/test',      "/test(.:format)"
+  end
+
+  def test_variable_with_extension
+    assert_generate '/test.html', "/:var.:format", :var => 'test', :format => 'html'
+    assert_generate '/test.html', "/:var.:format", 'test', 'html'
+  end
+
+  def test_variable_with_optional_extension
+    assert_generate '/test.html', "/:var(.:format)", :var => 'test', :format => 'html'
+    assert_generate '/test.html', "/:var(.:format)", 'test', 'html'
+    assert_generate '/test',      "/:var(.:format)", :var => 'test'
+    assert_generate '/test',      "/:var(.:format)", 'test'
+  end
+
+  def test_optionals
+    assert_generate '/var',      "/:var1(/:var2)", 'var'
+    assert_generate '/var/fooz', "/:var1(/:var2)", 'var', 'fooz'
+    assert_generate '/var',      "/:var1(/:var2)", :var1 => 'var'
+    assert_generate '/var/fooz', "/:var1(/:var2)", :var1 => 'var', :var2 => 'fooz'
+    assert_raises(HttpRouter::UngeneratableRouteException) { router.url(router.add("/:var1(/:var2)").to(:test), :var2 => 'fooz') }
+  end
+    
+  def test_optionals_with_format
+    assert_generate '/var',           "/:var1(/:var2.:format)", 'var'
+    assert_generate '/var/fooz.html', "/:var1(/:var2.:format)", 'var', 'fooz', 'html'
+    assert_generate '/var',           "/:var1(/:var2.:format)", :var1 => 'var'
+    assert_generate '/var/fooz.html', "/:var1(/:var2.:format)", :var1 => 'var', :var2 => 'fooz', :format => 'html'
+  end
+
+  def test_nested_optionals
+    assert_generate '/var',          "/:var1(/:var2(/:var3))", 'var'
+    assert_generate '/var/fooz',     "/:var1(/:var2(/:var3))", 'var', 'fooz'
+    assert_generate '/var/fooz/baz', "/:var1(/:var2(/:var3))", 'var', 'fooz', 'baz'
+    assert_generate '/var',          "/:var1(/:var2(/:var3))", :var1 => 'var'
+    assert_generate '/var/fooz',     "/:var1(/:var2(/:var3))", :var1 => 'var', :var2 => 'fooz'
+    assert_generate '/var/fooz/baz', "/:var1(/:var2(/:var3))", :var1 => 'var', :var2 => 'fooz', :var3 => 'baz'
+  end
+
+  def test_default_value
+    assert_generate "/123?page=1", router.add("/:var").default(:page => 1),         123
+    assert_generate "/1/123",      router.add("/:page/:entry").default(:page => 1), :entry => '123'
+  end
+
+  def test_nil_values
+    assert_generate '/url', "/url(/:var)", :var => nil
+  end
+
+  def test_raise
+    r = router { add(':var').matching(:var => /\d+/) }
+    assert_raises(HttpRouter::InvalidRouteException) { router.url(r, 'asd') }
+  end
+end

data/test/test_greedy.rb

@@ -0,0 +1,24 @@
+class TestGreedy < MiniTest::Unit::TestCase
+  def test_mix_regex_with_greedy
+    regex, greedy = router { 
+      add("/:test/number").matching(:test => /\d+/)
+      add("/:test/anything")
+    }
+    assert_route regex, '/123/number', {:test => '123'}
+    assert_route greedy, '/123/anything', {:test => '123'}
+  end
+
+  def test_trailing_slash
+    assert_route router.add("/:test").matching(:test => /.*/), '/test/', {:test => 'test/'}
+  end
+
+  def test_extension
+    assert_route router.add("/:test").matching(:test => /.*/), '/test.html', {:test => 'test.html'}
+  end
+
+  def test_match_at_beginning
+    r = router { add(':test', :test => /\d+/)}
+    assert_route r, '/123', {:test => '123'}
+    assert_route nil, '/a123'
+  end
+end

data/test/test_interstitial.rb

@@ -0,0 +1,47 @@
+class TestInterstitial < MiniTest::Unit::TestCase
+  def test_recognize
+    assert_route '/one-:variable-time', '/one-value-time', {:variable => 'value'}
+  end
+
+  def test_regex
+    r = router { add('/one-:variable-time').matching(:variable => /\d+/) }
+    assert_route r,   '/one-123-time', {:variable => '123'}
+    assert_route nil, '/one-value-time'
+  end
+
+  def test_regex_as_options
+    r = router { add('/one-:variable-time', :variable => /\d+/) }
+    assert_route r,   '/one-123-time', {:variable => '123'}
+    assert_route nil, '/one-value-time'
+  end
+
+  def test_extension
+    assert_route 'hey.:greed.html', '/hey.greedybody.html', {:greed => 'greedybody'}
+  end
+
+  def test_multi
+    r1, r2, r3, r4, r5, r6 = router {
+      add('/:var1')
+      add('/:var1-:var2')
+      add('/:var1-:var2-:var3')
+      add('/:var1-:var2-:var3-:var4')
+      add('/:var1-:var2-:var3-:var4-:var5')
+      add('/:var1-:var2-:var3-:var4-:var5-:var6')
+    }
+    assert_route r1, '/one',                           {:var1 => 'one'}
+    assert_route r2, '/one-value',                     {:var1 => 'one', :var2 => 'value'}
+    assert_route r3, '/one-value-time',                {:var1 => 'one', :var2 => 'value', :var3 => 'time'}
+    assert_route r4, '/one-value-time-one',            {:var1 => 'one', :var2 => 'value', :var3 => 'time', :var4 => 'one'}
+    assert_route r5, '/one-value-time-one-variable',   {:var1 => 'one', :var2 => 'value', :var3 => 'time', :var4 => 'one', :var5 => 'variable'}
+    assert_route r6, '/one-value-time-one-value-time', {:var1 => 'one', :var2 => 'value', :var3 => 'time', :var4 => 'one', :var5 => 'value', :var6 => 'time'}    
+  end
+  
+  def test_regex_with_mutliple_variables
+    with_regex, without_regex = router {
+      add("/:common_variable.:matched").matching(:matched => /\d+/)
+      add("/:common_variable.:unmatched")
+    }
+    assert_route with_regex,    '/common.123',   {:common_variable => 'common', :matched => '123'}
+    assert_route without_regex, '/common.other', {:common_variable => 'common', :unmatched => 'other'}
+  end
+end

data/test/test_misc.rb

@@ -0,0 +1,30 @@
+class TestMisc < MiniTest::Unit::TestCase
+  def test_exceptions
+    assert_raises(HttpRouter::AmbiguousRouteException) {HttpRouter.new.add("/:var1(/:var2)(/:var3)").compile}
+    assert_raises(HttpRouter::AmbiguousVariableException) {HttpRouter.new.add("/:var1(/:var1)(/:var1)").compile}
+    assert_raises(HttpRouter::UnsupportedRequestConditionError) {HttpRouter.new.add("/").condition(:flibberty => 'gibet').compile}
+  end
+
+  def test_cloning
+    r1 = HttpRouter.new {
+      add('/test').name(:test_route).to :test
+    }
+    r2 = r1.clone
+
+    r2.add('/test2').name(:test).to(:test2)
+    assert_equal 2, r2.routes.size
+
+    assert r1.recognize(Rack::MockRequest.env_for('/test2')).nil?
+    assert !r2.recognize(Rack::MockRequest.env_for('/test2')).nil?
+    assert_equal r1.routes.first, r1.named_routes[:test_route]
+    assert_equal r2.routes.first, r2.named_routes[:test_route]
+
+    r1.add('/another').name(:test).to(:test2)
+
+    assert_equal r1.routes.size, r2.routes.size
+    assert_equal '/another', r1.url(:test)
+    assert_equal '/test2',   r2.url(:test)
+    assert_equal :test, r1.routes.first.dest
+    assert_equal :test, r2.routes.first.dest
+  end
+end

data/test/test_mounting.rb

@@ -0,0 +1,89 @@
+class TestMounting < MiniTest::Unit::TestCase
+  def setup
+    @r1 = HttpRouter.new
+    @r2 = HttpRouter.new
+    @r2.add("/bar").name(:test).compile
+  end
+
+  def test_url_mount_for_child_route
+    route = @r1.add("/foo").to(@r2)
+    assert_equal "/foo", @r2.url_mount.url
+    assert_equal "/foo/bar", @r2.url(:test)
+  end
+
+  def test_default_values
+    route = @r1.add("/foo/:bar").default(:bar => "baz").to(@r2)
+    assert_equal "/foo/baz/bar", @r2.url(:test)
+    assert_equal "/foo/haha/bar", @r2.url(:test, :bar => "haha")
+  end
+
+  def test_multiple_values
+    @r1.add("/foo/:bar/:baz").default(:bar => "bar").to(@r2)
+    assert_equal "/foo/bar/baz/bar", @r2.url(:test, :baz => "baz")
+  end
+  
+  def test_bubble_params
+    route = @r1.add("/foo/:bar").default(:bar => "baz").to(@r2)
+    assert_equal "/foo/baz/bar?bang=ers",  @r2.url(:test, :bang => "ers")
+    assert_equal "/foo/haha/bar?bang=ers", @r2.url(:test, :bar => "haha", :bang => "ers")
+  end
+
+  def test_path_with_optional
+    @r1.add("/foo(/:bar)").to(@r2)
+    @r2.add("/hey(/:there)").name(:test).compile
+    assert_equal "/foo/hey", @r2.url(:test)
+    assert_equal "/foo/bar/hey", @r2.url(:test, :bar => "bar")
+    assert_equal "/foo/bar/hey/there", @r2.url(:test, :bar => "bar", :there => "there")
+  end
+
+  def test_nest3
+    @r3 = HttpRouter.new
+    @r1.add("/foo(/:bar)").default(:bar => "barry").to(@r2)
+    @r2.add("/hi").name(:hi).compile
+    @r2.add("/mounted").to(@r3)
+    @r3.add("/endpoint").name(:endpoint).compile
+    
+    assert_equal "/foo/barry/hi",                @r2.url(:hi)
+    assert_equal "/foo/barry/mounted/endpoint",  @r3.url(:endpoint)
+    assert_equal "/foo/flower/mounted/endpoint", @r3.url(:endpoint, :bar => "flower")
+  end
+
+  def test_with_default_host
+    @r1.add("/mounted").default(:host => "example.com").to(@r2)
+    assert_equal "http://example.com/mounted/bar", @r2.url(:test)
+  end
+
+  def test_with_host
+    @r1.add("/mounted").to(@r2)
+    assert_equal "/mounted/bar", @r2.url(:test)
+    assert_equal "http://example.com/mounted/bar", @r2.url(:test, :host => "example.com")
+  end
+
+  def test_with_scheme
+    @r1.add("/mounted").to(@r2)
+    assert_equal "/mounted/bar", @r2.url(:test)
+    assert_equal "https://example.com/mounted/bar", @r2.url(:test, :scheme => "https", :host => "example.com")
+  end
+
+  def test_clone
+    @r3 = HttpRouter.new
+    @r1.add("/first").to(@r2)
+    @r2.add("/second").to(@r3)
+    r1 = @r1.clone
+    assert @r1.routes.first
+    r2 = r1.routes.first.dest
+    assert r2
+    assert_equal @r1.routes.first.dest.object_id, @r2.object_id
+    assert r2.object_id != @r2.object_id
+    assert_equal 2, r2.routes.size
+    r3 = r2.routes.last.dest
+    assert_instance_of HttpRouter, r3
+    assert r3.object_id != @r3.object_id
+  end
+end
+
+#      it "should clone my nested structure" do
+#      end
+#    end
+#  end
+#end

data/test/test_recognize.rb

@@ -0,0 +1,56 @@
+class TestRecognition < MiniTest::Unit::TestCase
+  def test_simple
+    assert_route router.add(''),              '/'
+    assert_route router.add('/'),             '/'
+    assert_route router.add('/test'),         '/test'
+    assert_route router.add('/test/one'),     '/test/one'
+    assert_route router.add('/test/one/two'), '/test/one/two'
+    assert_route router.add('/test.html'),    '/test.html'
+    assert_route router.add('/.html'),        '/.html'
+  end
+
+  def test_optional
+    route = router {
+      add 'one(/two(/three(/four)(/five)))'
+    }
+    assert_route route, '/one'
+    assert_route route, '/one/two'
+    assert_route route, '/one/two/three'
+    assert_route route, '/one/two/three/four'
+    assert_route route, '/one/two/three/five'
+  end
+
+  def test_escape_paren
+    assert_route router.add('/test\(:variable\)'), '/test(hello)', {:variable => 'hello'}
+  end
+
+  def test_escape_colon
+    assert_route router.add('/test\:variable'), '/test:variable'
+  end
+
+  def test_escape_star
+    assert_route router.add('/test\*variable'), '/test*variable'
+  end
+
+  def test_partial
+    router.add("/test*").to { |env| Rack::Response.new(env['PATH_INFO']).finish }
+    assert_body '/optional', router.call(Rack::MockRequest.env_for('/test/optional'))
+    assert_body '/',         router.call(Rack::MockRequest.env_for('/test'))
+  end
+  
+  def test_partial_root
+    router.add("/*").to { |env| Rack::Response.new(env['PATH_INFO']).finish }
+    assert_body '/optional', router.call(Rack::MockRequest.env_for('/optional'))
+    assert_body '/',         router.call(Rack::MockRequest.env_for('/'))
+  end
+
+  def test_multiple_partial
+    test, root = router {
+      add("/test").partial.to{|env| [200, {}, ['/test',env['PATH_INFO']]]}
+      add("/").partial.to{|env| [200, {}, ['/',env['PATH_INFO']]]}
+    }
+    assert_body ['/test', '/optional'],     router.call(Rack::MockRequest.env_for('/test/optional'))
+    assert_body ['/test', '/optional/'],    router.call(Rack::MockRequest.env_for('/test/optional/'))
+    assert_body ['/', '/testing/optional'], router.call(Rack::MockRequest.env_for('/testing/optional'))
+  end
+end

data/test/test_request.rb

@@ -0,0 +1,85 @@
+class TestRequest < MiniTest::Unit::TestCase
+  def test_simple_case
+    r = router { add('test').post }
+    assert_route r, Rack::MockRequest.env_for('/test', :method => 'POST')
+    assert_header({'Allow' => 'POST'}, Rack::MockRequest.env_for('/test', :method => 'GET'))
+    assert_status(405, Rack::MockRequest.env_for('/test', :method => 'GET'))
+  end
+
+  def test_with_optional_parts_and_405
+    get, post, delete = router {
+      get('test(.:format)')
+      post('test(.:format)')
+      delete('test(.:format)')
+    }
+    assert_route get,    Rack::MockRequest.env_for('/test', :method => 'GET')
+    assert_route post,   Rack::MockRequest.env_for('/test', :method => 'POST')
+    assert_route delete, Rack::MockRequest.env_for('/test', :method => 'DELETE')
+    assert_route get,    Rack::MockRequest.env_for('/test.html', :method => 'GET'),    {:format => 'html'}
+    assert_route post,   Rack::MockRequest.env_for('/test.html', :method => 'POST'),   {:format => 'html'}
+    assert_route delete, Rack::MockRequest.env_for('/test.html', :method => 'DELETE'), {:format => 'html'}
+    put = router.call(Rack::MockRequest.env_for('/test', :method => 'PUT'))
+    assert_status 405, put
+    assert_equal %w{DELETE GET POST}, put[1]['Allow'].split(/\s*,\s*/).sort
+  end
+
+  def test_deeply
+    test_post, test_post_post, test_get, test_post_get, test_post_catchall, test_catchall = router {
+      post("/test")
+      post("/test/post")
+      get("/test")
+      get("/test/post")
+      add("/test/post")
+      add("/test")
+    }
+    assert_route test_post,          Rack::MockRequest.env_for('/test', :method => 'POST')
+    assert_route test_get,           Rack::MockRequest.env_for('/test', :method => 'GET')
+    assert_route test_catchall,      Rack::MockRequest.env_for('/test', :method => 'PUT')
+    assert_route test_post_post,     Rack::MockRequest.env_for('/test/post', :method => 'POST')
+    assert_route test_post_get,      Rack::MockRequest.env_for('/test/post', :method => 'GET')
+    assert_route test_post_catchall, Rack::MockRequest.env_for('/test/post', :method => 'PUT')
+  end
+
+  def test_move_node
+    general, post = router {
+      add("/test").default_destination
+      post("/test").default_destination
+    }
+    assert_route post,    Rack::MockRequest.env_for('/test', :method => 'POST')
+    assert_route general, Rack::MockRequest.env_for('/test', :method => 'PUT')
+  end
+
+  def test_complex_routing
+    host2, post, host2_get, host2_post = router {
+      add("/test").host('host2')
+      add("/test").post
+      add("/test").host('host2').get
+      add("/test").post.host('host2')
+    }
+    assert_route host2,      Rack::MockRequest.env_for('http://host2/test', :method => 'PUT')
+    assert_route post,       Rack::MockRequest.env_for('http://host1/test', :method => 'POST')
+    assert_route host2_get,  Rack::MockRequest.env_for('http://host2/test', :method => 'GET')
+    assert_route host2_post, Rack::MockRequest.env_for('http://host2/test', :method => 'POST')
+  end
+
+  def test_regexp
+    with, without = router {
+      get("/test").host(/host1/)
+      get("/test")
+    }
+    assert_route without, 'http://host2/test'
+    assert_route with,    'http://host2.host1.com/test'
+  end
+
+  def test_all_routes
+    router {
+      post("/test").host('host1')
+    }
+    assert_route router.add("/test").host('host2'), Rack::MockRequest.env_for('http://host2/test', :method => 'POST')
+  end
+  
+  def test_match_on_scheme
+    http, https = router { get("/test").scheme('http'); get("/test").scheme('https') }
+    assert_status 405, Rack::MockRequest.env_for('https://example.org/test', :method => 'POST')
+  end
+end

data/test/test_trailing_slash.rb

@@ -0,0 +1,28 @@
+class TestVariable < MiniTest::Unit::TestCase
+  def test_ignore_trailing_slash
+    assert_route router.add('/test'), '/test/'
+  end
+
+  def test_ignore_trailing_slash_disabled
+    assert_route router(:ignore_trailing_slash => false).add('/test/?'), '/test/'
+  end
+
+  def test_ignore_trailing_slash_enabled
+    router(:ignore_trailing_slash => false).add('/test/?')
+    assert_route nil, '/test/'
+  end
+
+  def test_capture_with_trailing_slash
+    assert_route router.add('/:test'), '/test/', {:test => 'test'}
+  end
+
+  def test_trailing_slash_confusion
+    more_general, more_specific = router {
+      add('foo')
+      add('foo/:bar/:id')
+    }
+    assert_route more_general, '/foo'
+    assert_route more_general, '/foo/'
+    assert_route more_specific, '/foo/5/10', {:bar => '5', :id => '10'}
+  end
+end