http_router 0.8.10 → 0.8.11

data/test/test_greedy.rb

@@ -1,24 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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
-    r6, r5, r4, r3, r2, r1 = router {
-      add('/:var1-:var2-:var3-:var4-:var5-:var6')
-      add('/:var1-:var2-:var3-:var4-:var5')
-      add('/:var1-:var2-:var3-:var4')
-      add('/:var1-:var2-:var3')
-      add('/:var1-:var2')
-      add('/:var1')
-    }
-    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_recognize.rb

@@ -1,106 +0,0 @@
-# encoding: utf-8
-class TestRecognition < MiniTest::Unit::TestCase
-  def test_empty
-    assert_route router.add(''),              '/'
-  end
-
-  def test_simple1
-    assert_route router.add('/'),             '/'
-  end
-
-  def test_simple2
-    assert_route router.add('/test'),         '/test'
-  end
-
-  def test_simple3
-    assert_route router.add('/test/one'),     '/test/one'
-  end
-
-  def test_simple4
-    assert_route router.add('/test/one/two'), '/test/one/two'
-  end
-
-  def test_simple5
-    assert_route router.add('/test.html'),    '/test.html'
-  end
-
-  def test_simple6
-    assert_route router.add('/.html'),        '/.html'
-  end
-
-  def test_passing
-    passed, working = router {
-      add('/').to { |env| throw :pass; [200, {}, ['pass']] }
-      add('/').to { |env| [200, {}, ['working']] }
-    }
-    assert_body 'working', router.call(Rack::MockRequest.env_for('/'))
-  end
-
-  def test_passing_with_cascade
-    passed, working = router {
-      add('/').to { |env| [200, {'X-Cascade' => 'pass'}, ['pass']] }
-      add('/').to { |env| [200, {}, ['working']] }
-    }
-    assert_body 'working', router.call(Rack::MockRequest.env_for('/'))
-  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'
-    assert_route route, '/one/two/three/four/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_unicode
-    assert_route router.add('/føø'), '/f%C3%B8%C3%B8'
-  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_request_mutation
-    got_this_far = false
-    non_matching, matching = router {
-      add("/test/:var/:var2/*glob").matching(:var2 => /123/, :glob => /[a-z]+/).get.arbitrary{|env, params| got_this_far = true; false}
-      add("/test/:var/:var2/*glob").matching(:var2 => /123/, :glob => /[a-z]+/).get
-    }
-    assert_route matching, '/test/123/123/asd/aasd/zxcqwe/asdzxc', {:var => '123', :var2 => '123', :glob => %w{asd aasd zxcqwe asdzxc}}
-    assert got_this_far, "matching should have gotten this far"
-  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

@@ -1,102 +0,0 @@
-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_simple_case_with_array
-    r = router { add('test', :conditions => {:request_method => ['POST', 'GET']}) }
-    assert_route r, Rack::MockRequest.env_for('/test', :method => 'POST')
-    assert_route r, Rack::MockRequest.env_for('/test', :method => 'GET')
-  end
-
-  def test_simple_case_with_non_array
-    r = router { add('test', :conditions => {:request_method => 'GET'}) }
-    assert_route r, Rack::MockRequest.env_for('/test', :method => 'GET')
-  end
-
-  def test_single_app_with_404
-    r = router { add('test').post.to{|env| [404, {}, []]} }
-    assert_route nil, Rack::MockRequest.env_for('/test', :method => 'POST')
-    assert_status(404, Rack::MockRequest.env_for('/test', :method => 'POST'))
-  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
-    post, general = router {
-      post("/test").default_destination
-      add("/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").post.host('host2')
-      add("/test").host('host2').get
-      add("/test").host('host2')
-      add("/test").post
-    }
-    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_variable.rb

@@ -1,163 +0,0 @@
-# encoding: utf-8
-class TestVariable < MiniTest::Unit::TestCase
-  def test_variable
-    assert_route ':one',      '/two',        {:one => 'two'}
-    assert_route 'test/:one', '/test/three', {:one => 'three'}
-  end
-
-  def test_variable_vs_static
-    static, dynamic = router { add 'one'; add ':one' }
-    assert_route dynamic, '/two', {:one => 'two'}
-    assert_route static,  '/one'
-  end
-
-  def test_variable_with_static_after
-    variable, static = router { 
-      add '/:var/one'
-      add 'one'
-    }
-    assert_route variable,     '/two/one', {:var => 'two'}
-    assert_route static,       '/one'
-    assert_route nil,          '/two'
-  end
-
-  def test_variable_and_static
-    dynamic, static = router {
-      add("/foo/:id")
-      add("/foo")
-    }
-    assert_route dynamic, '/foo/id', {:id => 'id'}
-    assert_route static,  '/foo'
-  end
-
-  def test_variable_mixed_with_static
-    static, dynamic = router {
-      add("/foo/foo")
-      add("/:foo/foo2")
-    }
-    assert_route dynamic, '/foo/foo2', {:foo => 'foo'}
-    assert_route static,  '/foo/foo'
-  end
-
-  def test_encoding
-    assert_route '/:var', '/%E6%AE%BA%E3%81%99', {:var => "\346\256\272\343\201\231"}
-  end
-
-  def test_match_path
-    r = router { add %r{/(test123|\d+)} }
-    assert_route r, '/test123'
-    assert_route r, '/123'
-    assert_route nil, '/test123andmore'
-    assert_route nil, '/lesstest123'
-  end
-
-  def test_format
-    assert_route '/test.:format', '/test.html', {:format => 'html'}
-  end
-
-  def test_optional_format
-    r = router {add('/test(.:format)')}
-    assert_route r, '/test.html', {:format => 'html'}
-    assert_route r, '/test'
-  end
-
-  def test_bare_optional_format
-    r = router {add('(.:format)')}
-    assert_route r, '/.html', {:format => 'html'}
-    assert_route r, '/'
-  end
-
-  def test_var_with_format
-    assert_route '/:test.:format', '/foo.bar', {:test => 'foo', :format => 'bar'}
-  end
-
-  def test_var_with_optional_format
-    r = router { add('/:test(.:format)') }
-    assert_route r, '/foo.bar', {:test => 'foo', :format => 'bar'}
-    assert_route r, '/foo', {:test => 'foo'}
-  end
-
-  def test_var_with_optional_format_and_regex
-    r = router { add('/:test(.:format)', :format => /[^\.]+/) }
-    assert_route r, '/asd@asd.com.json', {:test => 'asd@asd.com', :format => 'json'}
-  end
-
-  def test_glob
-    assert_route '/test/*variable', 'test/one/two/three', {:variable => ['one', 'two', 'three']}
-  end
-
-  def test_glob_with_static
-    assert_route '/test/*variable/test', '/test/one/two/three/test', {:variable => ['one', 'two', 'three']}
-  end
-
-  def test_double_glob_all_the_way
-    assert_route '/test/*variable/test/*variable2', '/test/one/two/three/test/four/five/six', {:variable => ['one', 'two', 'three'], :variable2 => ['four', 'five', 'six']}
-  end
-
-  def test_var_glob_var
-    assert_route '/test/:test-*variable.:format', '/test/one-two/three/four/five.six', {:test=> 'one', :variable => ['two', 'three', 'four', 'five'], :format => 'six'}
-  end
-
-  def test_glob_with_regexp
-    r = router { add('/test/*variable', :variable => /[a-z]+/) }
-    assert_route nil, '/test/asd/123'
-    assert_route nil, '/test/asd/asd123'
-    assert_route r, '/test/asd/qwe', :variable => ['asd', 'qwe']
-  end
-
-  def test_glob_with_regexp_and_static
-    r = router { add('/test/*variable/test', :variable => /[a-z]+/) }
-    assert_route nil, '/test/asd/123/test'
-    assert_route r, '/test/asd/qwe/test', :variable => ['asd', 'qwe']
-  end
-
-  def test_glob_with_variable
-    assert_route '/test/*variable/:test', '/test/one/two/three', {:variable => ['one', 'two'], :test => 'three'}
-  end
-
-  def test_glob_with_format
-    assert_route '/test/*variable.:format', 'test/one/two/three.html', {:variable => ['one', 'two', 'three'], :format => 'html'}
-  end
-
-  def test_glob_regexp_with_format
-    r = router { add('/test/*variable.:format', :variable => /[a-z]+/, :format => 'html') }
-    assert_route nil, 'test/one/2/three.html'
-    assert_route nil, 'test/one/two/three.xml'
-    assert_route r, 'test/one/two/three.html', {:variable => ['one', 'two', 'three'], :format => 'html'}
-  end
-
-  def test_glob_with_optional_format
-    assert_route '/test/*variable(.:format)', 'test/one/two/three.html', {:variable => ['one', 'two', 'three'], :format => 'html'}
-  end
-
-  def test_glob_with_literal
-    assert_route '/test/*variable.html', 'test/one/two/three.html', {:variable => ['one', 'two', 'three']}
-  end
-
-  def test_glob_with_regex
-    r = router { add('/test/*variable/anymore')}
-    assert_route r, '/test/123/345/567/anymore', {:variable => ['123', '345', '567']}
-    assert_route nil, '/test/123/345/567'
-  end
-
-  def test_regex_and_greedy
-    with_regex, with_post, without_regex = router {
-      add("/:common_variable/:matched").matching(:matched => /\d+/)
-      post("/:common_variable/:unmatched")
-      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'}
-    assert_route with_regex,    Rack::MockRequest.env_for('/common/123', :method => 'POST'),   {:common_variable => 'common', :matched => '123'}
-    assert_route with_post, Rack::MockRequest.env_for('/common/other', :method => 'POST'), {:common_variable => 'common', :unmatched => 'other'}
-  end
-
-  if //.respond_to?(:names)
-    eval "
-    def test_match_path_with_groups
-      r = router { add(%r{/(?<year>\\d{4})/(?<month>\\d{2})/(?<day>\\d{2})/?}) }
-      assert_route r, '/1234/23/56', {:year => '1234', :month => '23', :day => '56'}
-    end
-    "
-  end
-end