padrino-core 0.9.10 → 0.9.11

data/test/test_application.rb

@@ -1,34 +1,51 @@
 require File.expand_path(File.dirname(__FILE__) + '/helper')
 
+class PadrinoTestApp < Padrino::Application; end
+
 class TestApplication < Test::Unit::TestCase
   def teardown
     remove_views
   end
 
-  class PadrinoTestApp < Padrino::Application; end
-
   context 'for application functionality' do
 
     should 'check default options' do
-      assert_match __FILE__, PadrinoTestApp.app_file
+      assert File.identical?(__FILE__, PadrinoTestApp.app_file)
+      assert_equal :padrino_test_app, PadrinoTestApp.app_name
       assert_equal :test, PadrinoTestApp.environment
       assert_equal Padrino.root("views"), PadrinoTestApp.views
       assert PadrinoTestApp.raise_errors
       assert !PadrinoTestApp.logging
       assert !PadrinoTestApp.sessions
-      assert 'PadrinoTestApp', PadrinoTestApp.app_name
     end
 
     should 'check padrino specific options' do
       assert !PadrinoTestApp.instance_variable_get(:@_configured)
       PadrinoTestApp.send(:setup_application!)
+      assert_equal :padrino_test_app, PadrinoTestApp.app_name
+      assert_equal 'StandardFormBuilder', PadrinoTestApp.default_builder
       assert PadrinoTestApp.instance_variable_get(:@_configured)
       assert !PadrinoTestApp.reload?
-      assert 'padrino_test_app', PadrinoTestApp.app_name
-      assert 'StandardFormBuilder', PadrinoTestApp.default_builder
       assert !PadrinoTestApp.flash
-      assert !PadrinoTestApp.padrino_mailer
-      assert !PadrinoTestApp.padrino_helpers
     end
+
+    #compare to: test_routing: allow global provides
+    should "set content_type to :html if none can be determined" do
+      mock_app do
+        provides :xml
+
+        get("/foo"){ "Foo in #{content_type}" }
+        get("/bar"){ "Foo in #{content_type}" }
+      end
+
+      get '/foo', {}, { 'HTTP_ACCEPT' => 'application/xml' }
+      assert_equal 'Foo in xml', body
+      get '/foo'
+      assert not_found?
+
+      get '/bar', {}, { 'HTTP_ACCEPT' => 'application/xml' }
+      assert_equal "Foo in html", body
+    end
+
   end
 end

data/test/test_mounter.rb

@@ -23,11 +23,11 @@ class TestMounter < Test::Unit::TestCase
     end
 
     should 'check locate_app_file with __FILE__' do
-      mounter = Padrino::Mounter.new("test")
+      mounter = Padrino::Mounter.new("test", :app_file => __FILE__)
       mounter.to("/test")
       assert_equal "test", mounter.name
       assert_equal "Test", mounter.app_class
-      assert_match %r{test/app.rb}, mounter.app_file
+      assert_equal __FILE__, mounter.app_file
       assert_equal "/test", mounter.uri_root
       assert_equal File.dirname(mounter.app_file), mounter.app_root
     end
@@ -40,15 +40,25 @@ class TestMounter < Test::Unit::TestCase
     end
 
     should 'mount a core' do
-      mounter = Padrino.mount_core("test")
+      mounter = Padrino.mount_core("test", :app_file => __FILE__)
       assert_equal "core", mounter.name
       assert_equal "Test", mounter.app_class
       assert_equal Test, mounter.app_obj
-      assert_equal Padrino.root('app/app.rb'), mounter.app_file
+      assert_equal __FILE__, mounter.app_file
       assert_equal "/", mounter.uri_root
       assert_equal File.dirname(mounter.app_file), mounter.app_root
     end
 
+    should 'mount a core to url' do
+      mounter = Padrino.mount_core("test", :app_file => __FILE__).to('/me')
+      assert_equal "core", mounter.name
+      assert_equal "Test", mounter.app_class
+      assert_equal Test, mounter.app_obj
+      assert_equal __FILE__, mounter.app_file
+      assert_equal "/me", mounter.uri_root
+      assert_equal File.dirname(mounter.app_file), mounter.app_root
+    end
+
     should 'mount multiple apps' do
       class ::OneApp < Padrino::Application; end
       class ::TwoApp < Padrino::Application; end

data/test/test_reloader_simple.rb

@@ -55,7 +55,7 @@ class TestSimpleReloader < Test::Unit::TestCase
     should 'correctly reload SimpleDemo fixture' do
       @app = SimpleDemo
       get "/"
-      assert_equal 200, status
+      assert ok?
       new_phrase = "The magick number is: #{rand(100)}!"
       buffer     = File.read(SimpleDemo.app_file)
       new_buffer = buffer.gsub(/The magick number is: \d+!/, new_phrase)
@@ -66,6 +66,31 @@ class TestSimpleReloader < Test::Unit::TestCase
 
       # Now we need to prevent to commit a new changed file so we revert it
       File.open(SimpleDemo.app_file, "w") { |f| f.write(buffer) }
+      Padrino.reload!
+    end
+
+    should 'correctly reset SimpleDemo fixture' do
+      @app = SimpleDemo
+      get "/rand"
+      assert ok?
+      last_body = body
+      assert_equal 2, @app.before_filters.size # one is ours the other is default_filter for content type
+      assert_equal 1, @app.errors.size
+      assert_equal 1, @app.after_filters.size
+      assert_equal 2, @app.middleware.size # [Padrino::Logger::Rack, Padrino::Reloader::Rack]
+      assert_equal 4, @app.routes.size # GET+HEAD of "/" + GET+HEAD of "/rand" = 4
+      assert_equal 2, @app.extensions.size # [Padrino::Routing, Padrino::Rendering]
+      assert_equal 0, @app.templates.size
+      @app.reload!
+      get "/rand"
+      assert_not_equal last_body, body
+      assert_equal 2, @app.before_filters.size # one is ours the other is default_filter for content type
+      assert_equal 1, @app.errors.size
+      assert_equal 1, @app.after_filters.size
+      assert_equal 2, @app.middleware.size # only logger Padrino::Logger::Rack
+      assert_equal 4, @app.routes.size # GET+HEAD of "/" = 2
+      assert_equal 2, @app.extensions.size # [Padrino::Routing, Padrino::Rendering]
+      assert_equal 0, @app.templates.size
     end
   end
 end

data/test/test_rendering.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/helper')
+require 'i18n'
 
 class TestRendering < Test::Unit::TestCase
   def teardown
@@ -72,7 +73,7 @@ class TestRendering < Test::Unit::TestCase
       create_view :foo, "erb file"
       create_view :foo, "js file", :format => :js
       mock_app do
-        get('/layout_test', :respond_to => [:html, :js]){ render :foo }
+        get('/layout_test', :provides => [:html, :js]){ render :foo }
       end
       get "/layout_test"
       assert_equal "this is an erb file", body
@@ -86,7 +87,7 @@ class TestRendering < Test::Unit::TestCase
       create_view :foo, "erb file"
       create_view :foo, "xml file", :format => :xml
       mock_app do
-        get('/layout_test', :respond_to => [:html, :xml]){ render :foo }
+        get('/layout_test', :provides => [:html, :xml]){ render :foo }
       end
       get "/layout_test"
       assert_equal "this is an erb file", body
@@ -94,6 +95,38 @@ class TestRendering < Test::Unit::TestCase
       assert_equal "document start xml file end", body
     end
 
+    should 'by default use html file when no other is given' do
+      create_layout :foo, "html file", :format => :html
+
+      mock_app do
+        get('/content_type_test', :provides => [:html, :xml]) { render :foo }
+      end
+
+      get "/content_type_test"
+      assert_equal "html file", body
+      get "/content_type_test.xml"
+      assert_equal "html file", body
+    end
+
+    should 'not use html file when DEFAULT_RENDERING_OPTIONS[:strict_format] == true' do
+      create_layout :foo, "html file", :format => :html
+
+      mock_app do
+        get('/default_rendering_test', :provides => [:html, :xml]) { render :foo }
+      end
+
+      @save = Padrino::Rendering::DEFAULT_RENDERING_OPTIONS
+      Padrino::Rendering::DEFAULT_RENDERING_OPTIONS[:strict_format] = true
+
+      get "/default_rendering_test"
+      assert_equal "html file", body
+      assert_raise Padrino::Rendering::TemplateNotFound do
+        get "/default_rendering_test.xml"
+      end
+
+      Padrino::Rendering::DEFAULT_RENDERING_OPTIONS.merge(@save)
+    end
+
     should 'use correct layout with each controller' do
       create_layout :foo, "foo layout at <%= yield %>"
       create_layout :bar, "bar layout at <%= yield %>"
@@ -175,7 +208,7 @@ class TestRendering < Test::Unit::TestCase
       create_view :foo, "Im Js", :format => :js
       create_view :foo, "Im Erb"
       mock_app do
-        get("/foo", :respond_to => :js) { render :foo }
+        get("/foo", :provides => :js) { render :foo }
         get("/bar.js") { render :foo }
       end
       get "/foo.js"
@@ -190,9 +223,9 @@ class TestRendering < Test::Unit::TestCase
       create_view :foo, "Im Haml", :format => :haml
       create_view :foo, "Im Xml", :format => :xml
       mock_app do
-        get("/foo_normal", :respond_to => :js) { render 'foo' }
-        get("/foo_haml", :respond_to => :js) { render 'foo.haml' }
-        get("/foo_xml", :respond_to => :js) { render 'foo.xml' }
+        get("/foo_normal", :provides => :js) { render 'foo' }
+        get("/foo_haml", :provides => :js) { render 'foo.haml' }
+        get("/foo_xml", :provides => :js) { render 'foo.xml' }
       end
       get "/foo_normal.js"
       assert_equal "Im Js", body
@@ -202,6 +235,18 @@ class TestRendering < Test::Unit::TestCase
       assert_equal "Im Xml", body
     end
 
+    should 'resolve without explict template format' do
+      create_view :foo, "Im Html"
+      create_view :foo, "xml.rss", :format => :rss
+      mock_app do
+        get(:index, :map => "/", :provides => [:html, :rss]){ render 'foo' }
+      end
+      get "/", {}, { 'HTTP_ACCEPT' => 'text/html;q=0.9' }
+      assert_equal "Im Html", body
+      get ".rss"
+      assert_equal "<rss/>\n", body
+    end
+
     should "ignore files ending in tilde and not render them" do
       create_view :foo, "Im Wrong", :format => 'haml~'
       create_view :foo, "Im Haml",  :format => :haml
@@ -237,7 +282,7 @@ class TestRendering < Test::Unit::TestCase
       create_view :foo, "Im English Js",  :format => :js, :locale => :en
       create_view :foo, "Im Italian Js",  :format => :js, :locale => :it
       mock_app do
-        get("/foo", :respond_to => [:html, :js]) { render :foo }
+        get("/foo", :provides => [:html, :js]) { render :foo }
       end
       I18n.locale = :none
       get "/foo.js"
@@ -276,7 +321,7 @@ class TestRendering < Test::Unit::TestCase
       create_view   :bar, "Im a json",      :format => :json
       mock_app do
         layout :foo
-        get("/bar", :respond_to => [:html, :js, :json]) { render :bar }
+        get("/bar", :provides => [:html, :js, :json]) { render :bar }
       end
       I18n.locale = :none
       get "/bar.js"

data/test/test_router.rb

@@ -26,7 +26,7 @@ class TestRouter < Test::Unit::TestCase
     res = Rack::MockRequest.new(map).get("/foo")
     assert res.ok?
     assert_equal "/foo", res["X-ScriptName"]
-    assert_equal "", res["X-PathInfo"]
+    assert_equal "/", res["X-PathInfo"]
 
     res = Rack::MockRequest.new(map).get("/foo/")
     assert res.ok?
@@ -36,7 +36,7 @@ class TestRouter < Test::Unit::TestCase
     res = Rack::MockRequest.new(map).get("/foo/bar")
     assert res.ok?
     assert_equal "/foo/bar", res["X-ScriptName"]
-    assert_equal "", res["X-PathInfo"]
+    assert_equal "/", res["X-PathInfo"]
 
     res = Rack::MockRequest.new(map).get("/foo/bar/")
     assert res.ok?
@@ -57,7 +57,7 @@ class TestRouter < Test::Unit::TestCase
     res = Rack::MockRequest.new(map).get("/bar", 'HTTP_HOST' => 'foo.org')
     assert res.ok?
     assert_equal "/bar", res["X-ScriptName"]
-    assert_equal "", res["X-PathInfo"]
+    assert_equal "/", res["X-PathInfo"]
 
     res = Rack::MockRequest.new(map).get("/bar/", 'HTTP_HOST' => 'foo.org')
     assert res.ok?
@@ -136,7 +136,7 @@ class TestRouter < Test::Unit::TestCase
     assert res.not_found?
 
     res = Rack::MockRequest.new(Padrino.application).get("/foo", "HTTP_HOST" => "bar.padrino.org")
-    assert res.not_found?
+    assert res.ok?
 
     res = Rack::MockRequest.new(Padrino.application).get("/foo/", "HTTP_HOST" => "bar.padrino.org")
     assert res.ok?

data/test/test_routing.rb

@@ -1,15 +1,19 @@
 require File.expand_path(File.dirname(__FILE__) + '/helper')
 
 class TestRouting < Test::Unit::TestCase
-
-  should 'ignore trailing delimiters' do
+  should 'ignore trailing delimiters for basic route' do
     mock_app do
       get("/foo"){ "okey" }
+      get(:test) { "tester" }
     end
     get "/foo"
     assert_equal "okey", body
     get "/foo/"
     assert_equal "okey", body
+    get "/test"
+    assert_equal "tester", body
+    get "/test/"
+    assert_equal "tester", body
   end
 
   should 'fail with unrecognized route exception when not found' do
@@ -49,18 +53,41 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "2", body
   end
 
+  should "not generate overlapping head urls" do
+    app = mock_app do
+      get("/main"){ "hello" }
+      post("/main"){ "hello" }
+    end
+    assert_equal 3, app.routes.size, "should generate GET, HEAD and PUT"
+    assert_equal ["GET"],  app.routes[0].as_options[:conditions][:request_method]
+    assert_equal ["HEAD"], app.routes[1].as_options[:conditions][:request_method]
+    assert_equal ["POST"], app.routes[2].as_options[:conditions][:request_method]
+  end
+
   should 'generate basic urls'do
     mock_app do
-      get(:foo){ url(:foo) }
-      get(:bar, :with => :id){ url(:bar, :id => 1) }
+      get(:foo){ "/foo" }
+      get(:foo, :with => :id){ |id| "/foo/#{id}" }
+      get(:hash, :with => :id){ url(:hash, :id => 1) }
+      get(:array, :with => :id){ url(:array, 23) }
+      get(:hash_with_extra, :with => :id){ url(:hash_with_extra, :id => 1, :query => 'string') }
+      get(:array_with_extra, :with => :id){ url(:array_with_extra, 23, :query => 'string') }
       get("/old-bar/:id"){ params[:id] }
       post(:mix, :map => "/mix-bar/:id"){ params[:id] }
       get(:mix, :map => "/mix-bar/:id"){ params[:id] }
     end
     get "/foo"
     assert_equal "/foo", body
-    get "/bar/2"
-    assert_equal "/bar/1", body
+    get "/foo/123"
+    assert_equal "/foo/123", body
+    get "/hash/2"
+    assert_equal "/hash/1", body
+    get "/array/23"
+    assert_equal "/array/23", body
+    get "/hash_with_extra/1"
+    assert_equal "/hash_with_extra/1?query=string", body
+    get "/array_with_extra/23"
+    assert_equal "/array_with_extra/23?query=string", body
     get "/old-bar/3"
     assert_equal "3", body
     post "/mix-bar/4"
@@ -88,12 +115,39 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "/c.json", body
     get "/c.ru"
     assert_equal 404, status
-    get "/d.json"
-    assert 404, status
     get "/d"
     assert_equal "/d.js?foo=bar", body
     get "/d.js"
     assert_equal "/d.js?foo=bar", body
+    get "/e.xml"
+    assert_equal 404, status
+  end
+
+  should "not allow Accept-Headers it does not provide" do
+    mock_app do
+      get(:a, :provides => [:html, :js]){ content_type }
+    end
+
+    get "/a", {}, {"HTTP_ACCEPT" => "application/yaml"}
+    assert_equal 404, status
+  end
+
+  should "not default to HTML if HTML is not provided and no type is given" do
+    mock_app do
+      get(:a, :provides => [:js]){ content_type }
+    end
+
+    get "/a", {}, {}
+    assert_equal 404, status
+  end
+
+  should "not match routes if url_format and http_accept is provided but not included" do
+    mock_app do
+      get(:a, :provides => [:js, :html]){ content_type }
+    end
+
+    get "/a.xml", {}, {"HTTP_ACCEPT" => "text/html"}
+    assert_equal 404, status
   end
 
   should "generate routes for format simple" do
@@ -106,6 +160,31 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "Test\n", body
   end
 
+  should "should inject the controller name into the request" do
+    mock_app do
+      controller :posts do
+        get(:index) { request.controller }
+        controller :mini do
+          get(:index) { request.controller }
+        end
+      end
+    end
+    get "/posts"
+    assert_equal "posts", body
+    get "/mini"
+    assert_equal "mini", body
+  end
+
+  should "should inject the route into the request" do
+    mock_app do
+      controller :posts do
+        get(:index) { request.route.named.to_s }
+      end
+    end
+    get "/posts"
+    assert_equal "posts_index", body
+  end
+
   should "generate routes for format with controller" do
     mock_app do
       controller :posts do
@@ -168,6 +247,14 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "/print/9", @app.url(:print, :id => 9)
   end
 
+  should '405 on wrong request_method' do
+    mock_app do
+      post('/bar'){ "bar" }
+    end
+    get "/bar"
+    assert_equal 405, status
+  end
+
   should 'respond to' do
     mock_app do
       get(:a, :provides => :js){ "js" }
@@ -253,6 +340,52 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "foo_bar_index", body
   end
 
+  should "ignore trailing delimiters within a named controller" do
+    mock_app do
+      controller :posts do
+        get(:index, :provides => [:html, :js]){ "index" }
+        get(:new)  { "new" }
+        get(:show, :with => :id){ "show #{params[:id]}" }
+      end
+    end
+    get "/posts"
+    assert_equal "index", body
+    get "/posts/"
+    assert_equal "index", body
+    get "/posts.js"
+    assert_equal "index", body
+    get "/posts.js/"
+    assert_equal "index", body
+    get "/posts/new"
+    assert_equal "new", body
+    get "/posts/new/"
+    assert_equal "new", body
+  end
+
+  should "ignore trailing delimiters within a named controller for unnamed actions" do
+    mock_app do
+      controller :accounts do
+        get("/") { "account_index" }
+        get("/new") { "new" }
+      end
+      controller :votes do
+        get("/") { "vote_index" }
+      end
+    end
+    get "/accounts"
+    assert_equal "account_index", body
+    get "/accounts/"
+    assert_equal "account_index", body
+    get "/accounts/new"
+    assert_equal "new", body
+    get "/accounts/new/"
+    assert_equal "new", body
+    get "/votes"
+    assert_equal "vote_index", body
+    get "/votes/"
+    assert_equal "vote_index", body
+  end
+
   should 'use named controllers with array routes' do
     mock_app do
       controller :admin do
@@ -273,6 +406,42 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "foo_bar_index", body
   end
 
+  should 'use uri_root' do
+    mock_app do
+      get(:foo){ "foo" }
+    end
+    @app.uri_root = '/'
+    assert_equal "/foo", @app.url(:foo)
+    @app.uri_root = '/testing'
+    assert_equal "/testing/foo", @app.url(:foo)
+    @app.uri_root = '/testing/'
+    assert_equal "/testing/foo", @app.url(:foo)
+    @app.uri_root = 'testing/bar///'
+    assert_equal "/testing/bar/foo", @app.url(:foo)
+  end
+
+  should 'use uri_root with controllers' do
+    mock_app do
+      controller :foo do
+        get(:bar){ "bar" }
+      end
+    end
+    @app.uri_root = '/testing'
+    assert_equal "/testing/foo/bar", @app.url(:foo, :bar)
+  end
+
+  should 'use RACK_BASE_URI' do
+    mock_app do
+      get(:foo){ "foo" }
+    end
+    # Wish there was a side-effect free way to test this...
+    ENV['RACK_BASE_URI'] = '/'
+    assert_equal "/foo", @app.url(:foo)
+    ENV['RACK_BASE_URI'] = '/testing'
+    assert_equal "/testing/foo", @app.url(:foo)
+    ENV['RACK_BASE_URI'] = nil
+  end
+
   should 'reset routes' do
     mock_app do
       get("/"){ "foo" }
@@ -323,12 +492,21 @@ class TestRouting < Test::Unit::TestCase
         get(:show, :with => :id, :parent => :product) { "show #{params[:id]} #{params[:user_id]} #{params[:product_id]}"}
       end
     end
-    get "/user/1/project"
+
+    user_project_url = "/user/1/project"
+    get user_project_url
     assert_equal "index 1", body
-    get "/user/1/project/edit/2"
+    assert_equal user_project_url, @app.url(:project, :index, :user_id => 1)
+
+    user_project_edit_url = "/user/1/project/edit/2"
+    get user_project_edit_url
     assert_equal "edit 2 1", body
-    get "/user/1/product/2/project/show/3"
+    assert_equal user_project_edit_url, @app.url(:project, :edit, :user_id => 1, :id => 2)
+
+    user_product_project_url = "/user/1/product/2/project/show/3"
+    get user_product_project_url
     assert_equal "show 3 1 2", body
+    assert_equal user_product_project_url, @app.url(:project, :show, :user_id => 1, :product_id => 2, :id => 3)
   end
 
   should "use default values" do
@@ -407,6 +585,31 @@ class TestRouting < Test::Unit::TestCase
     assert_equal 'Bar in html', body
   end
 
+  should "set content_type to :html for both empty Accept as well as Accept text/html" do
+    mock_app do
+      provides :html
+
+      get("/foo"){ content_type.to_s }
+    end
+
+    get '/foo', {}, {}
+    assert_equal 'html', body
+
+    get '/foo', {}, { 'HTTP_ACCEPT' => 'text/html' }
+    assert_equal 'html', body
+  end
+
+  should "set content_type to :html if Accept */*" do
+    mock_app do
+      get("/foo", :provides => [:html, :js]) { content_type.to_s }
+    end
+    get '/foo', {}, {}
+    assert_equal 'html', body
+
+    get '/foo', {}, { 'HTTP_ACCEPT' => '*/*;q=0.5' }
+    assert_equal 'html', body
+  end
+
   should 'allows custom route-conditions to be set via route options' do
     protector = Module.new {
       def protect(*args)
@@ -470,4 +673,158 @@ class TestRouting < Test::Unit::TestCase
     get "/"
     assert_equal "global", body
   end
-end
+
+  should 'works with optionals params' do
+    mock_app do
+      get("/foo(/:bar)") { params[:bar] }
+    end
+
+    get "/foo/bar"
+    assert_equal "bar", body
+
+    get "/foo"
+    assert_equal "", body
+  end
+
+  should 'work with multiple dashed params' do
+    mock_app do
+      get "/route/:foo/:bar/:baz", :provides => :html do
+        "#{params[:foo]};#{params[:bar]};#{params[:baz]}"
+      end
+    end
+
+    get "/route/foo/bar/baz"
+    assert_equal 'foo;bar;baz', body
+
+    get "/route/foo/bar-whatever/baz"
+    assert_equal 'foo;bar-whatever;baz', body
+  end
+
+  should 'work with arbitrary params' do
+    mock_app do
+      get(:testing) { params[:foo] }
+    end
+
+    url = @app.url(:testing, :foo => 'bar')
+    assert_equal "/testing?foo=bar", url
+    get url
+    assert_equal "bar", body
+  end
+
+  should 'work with controller and arbitrary params' do
+    mock_app do
+      get(:testing) { params[:foo] }
+      controller :test1 do
+        get(:url1) { params[:foo] }
+        get(:url2, :provides => [:html, :json]) { params[:foo] }
+      end
+    end
+
+    url = @app.url(:test1, :url1, :foo => 'bar1')
+    assert_equal "/test1/url1?foo=bar1", url
+    get url
+    assert_equal "bar1", body
+
+    url = @app.url(:test1, :url2, :foo => 'bar2')
+    assert_equal "/test1/url2?foo=bar2", url
+    get url
+    assert_equal "bar2", body
+  end
+
+  should "work with params and parent options" do
+    mock_app do
+      controller :test2, :parent => :parent1, :parent1_id => 1 do
+        get(:url3) { params[:foo] }
+        get(:url4, :with => :with1) { params[:foo] }
+        get(:url5, :with => :with2, :provides => [:html]) { params[:foo] }
+      end
+    end
+
+    url = @app.url(:test2, :url3, :foo => 'bar3')
+    assert_equal "/parent1/1/test2/url3?foo=bar3", url
+    get url
+    assert_equal "bar3", body
+
+    url = @app.url(:test2, :url4, :with1 => 'awith1', :foo => 'bar4')
+    assert_equal "/parent1/1/test2/url4/awith1?foo=bar4", url
+    get url
+    assert_equal "bar4", body
+
+    url = @app.url(:test2, :url5, :with2 => 'awith1', :foo => 'bar5')
+    assert_equal "/parent1/1/test2/url5/awith1?foo=bar5", url
+    get url
+    assert_equal "bar5", body
+  end
+
+  should "parse params without explicit provides for every matching route" do
+    mock_app do
+      get(:index, :map => "/foos/:bar") { "get bar = #{params[:bar]}" }
+      post :create, :map => "/foos/:bar", :provides => [:html, :js] do
+        "post bar = #{params[:bar]}"
+      end
+    end
+
+    get "/foos/hello"
+    assert_equal "get bar = hello", body
+    post "/foos/hello"
+    assert_equal "post bar = hello", body
+    post "/foos/hello.js"
+    assert_equal "post bar = hello", body
+  end
+
+  should "properly route to first foo with two similar routes" do
+    mock_app do
+      controllers do
+        get('/foo/') { "this is foo" }
+        get(:show, :map => "/foo/:bar/:id") { "/foo/#{params[:bar]}/#{params[:id]}" }
+      end
+    end
+    get "/foo"
+    assert_equal "this is foo", body
+    # TODO fix this in http_router, should pass
+    get "/foo/"
+    assert_equal "this is foo", body
+    get '/foo/5/10'
+    assert_equal "/foo/5/10", body
+  end
+
+  should "parse params with class level provides" do
+    mock_app do
+      controllers :posts, :provides => [:html, :js] do
+        post(:create, :map => "/foo/:bar/:baz/:id") {
+          "POST CREATE #{params[:bar]} - #{params[:baz]} - #{params[:id]}"
+        }
+      end
+      controllers :topics, :provides => [:js, :html] do
+        get(:show, :map => "/foo/:bar/:baz/:id") { render "topics/show" }
+        post(:create, :map => "/foo/:bar/:baz") { "TOPICS CREATE #{params[:bar]} - #{params[:baz]}" }
+      end
+    end
+    post "/foo/bar/baz.js"
+    assert_equal "TOPICS CREATE bar - baz", body, "should parse params with explicit .js"
+    post @app.url(:topics, :create, :format => :js, :bar => 'bar', :baz => 'baz')
+    assert_equal "TOPICS CREATE bar - baz", body, "should parse params from generated url"
+    post "/foo/bar/baz/5.js"
+    assert_equal "POST CREATE bar - baz - 5", body
+    post @app.url(:posts, :create, :format => :js, :bar => 'bar', :baz => 'baz', :id => 5)
+    assert_equal "POST CREATE bar - baz - 5", body
+  end
+
+  should "parse params properly with inline provides" do
+    mock_app do
+      controllers :posts do
+        post(:create, :map => "/foo/:bar/:baz/:id", :provides => [:html, :js]) {
+          "POST CREATE #{params[:bar]} - #{params[:baz]} - #{params[:id]}"
+        }
+      end
+      controllers :topics do
+        get(:show, :map => "/foo/:bar/:baz/:id", :provides => [:html, :js]) { render "topics/show" }
+        post(:create, :map => "/foo/:bar/:baz", :provides => [:html, :js]) { "TOPICS CREATE #{params[:bar]} - #{params[:baz]}" }
+      end
+    end
+    post @app.url(:topics, :create, :format => :js, :bar => 'bar', :baz => 'baz')
+    assert_equal "TOPICS CREATE bar - baz", body, "should properly post to topics create action"
+    post @app.url(:posts, :create, :format => :js, :bar => 'bar', :baz => 'baz', :id => 5)
+    assert_equal "POST CREATE bar - baz - 5", body, "should properly post to create action"
+  end
+end