gin 1.1.2 → 1.2.0

data/test/test_gin.rb

@@ -23,9 +23,9 @@ class GinTest < Test::Unit::TestCase
 
 
   def test_build_query
-    hash = {a: "bob", b: [1,2.2,-3,{ba:"test"}], c:true, d:false}
-    expected = "a=bob&b[]=1&b[]=2.2&b[]=-3&b[][ba]=test&c=true&d=false"
-    assert_equal expected, Gin.build_query(hash)
+    hash = {:a => "bob", :b => [1,2.2,-3,{:ba =>"test"}], :c =>true, :d =>false}
+    expected = %w{a=bob b[]=1 b[]=2.2 b[]=-3 b[][ba]=test c=true d=false}
+    assert_equal expected.sort, Gin.build_query(hash).split("&").sort
   end
 
 
@@ -39,9 +39,10 @@ class GinTest < Test::Unit::TestCase
 
 
   def test_find_loadpath
-    assert_equal __FILE__, Gin.find_loadpath("test/test_gin")
-    assert_equal __FILE__, Gin.find_loadpath("test/test_gin.rb")
-    assert_equal __FILE__, Gin.find_loadpath(__FILE__)
+    curr_file = File.expand_path(__FILE__)
+    assert_equal curr_file, Gin.find_loadpath("test/test_gin")
+    assert_equal curr_file, Gin.find_loadpath("test/test_gin.rb")
+    assert_equal curr_file, Gin.find_loadpath(__FILE__)
     assert_nil Gin.find_loadpath("FUUUUU")
   end
 

data/test/test_request.rb

@@ -6,7 +6,8 @@ class RequestTest < Test::Unit::TestCase
     @env = {
       'HTTP_HOST' => 'example.com',
       'rack.input' => '',
-      'QUERY_STRING' => 'id=456&foo=bar&bar=5&bool=true',
+      'QUERY_STRING' =>
+        'id=456&foo=bar&bar=5&bool=true&zip=01234&nflt=01.123&neg=-12&negf=-2.1',
       'gin.path_query_hash' => {'id' => 123},
     }
     @req = Gin::Request.new @env
@@ -17,6 +18,10 @@ class RequestTest < Test::Unit::TestCase
     assert_equal 123, @req.params['id']
     assert_equal 'bar', @req.params['foo']
     assert_equal 5, @req.params['bar']
+    assert_equal '01234', @req.params['zip']
+    assert_equal '01.123', @req.params['nflt']
+    assert_equal -12, @req.params['neg']
+    assert_equal -2.1, @req.params['negf']
   end
 
 

data/test/test_response.rb

@@ -37,7 +37,7 @@ class ResponseTest < Test::Unit::TestCase
     @res.body = file
     resp = @res.finish
 
-    assert_equal file.size.to_s, resp[1]['Content-Length']
+    assert_equal File.size(file.path).to_s, resp[1]['Content-Length']
   end
 
 

data/test/test_router.rb

@@ -23,16 +23,16 @@ class RouterTest < Test::Unit::TestCase
       any  :thing
     end
 
-    assert_equal [MyCtrl, :bar, {}],
+    assert_equal [[MyCtrl, :bar], {}],
       @router.resources_for("GET", "/my_ctrl/bar")
 
-    assert_equal [MyCtrl, :foo, {}],
+    assert_equal [[MyCtrl, :foo], {}],
       @router.resources_for("post", "/my_ctrl/foo")
 
     assert_nil @router.resources_for("post", "/my_ctrl")
 
     %w{get post put delete head options trace}.each do |verb|
-      assert_equal [MyCtrl, :thing, {}],
+      assert_equal [[MyCtrl, :thing], {}],
         @router.resources_for(verb, "/my_ctrl/thing")
     end
   end
@@ -43,7 +43,7 @@ class RouterTest < Test::Unit::TestCase
       get  :bar, "/bar/:id"
     end
 
-    assert_equal [MyCtrl, :bar, {'id' => '123 456'}],
+    assert_equal [[MyCtrl, :bar], {'id' => '123 456'}],
       @router.resources_for("GET", "/my_ctrl/bar/123+456")
   end
 
@@ -53,7 +53,7 @@ class RouterTest < Test::Unit::TestCase
       get  :bar, "/bar/:type/:id.:format"
     end
 
-    assert_equal [MyCtrl, :bar, {"type"=>"[I]", "id"=>"123 456", "format"=>"json"}],
+    assert_equal [[MyCtrl, :bar], {"type"=>"[I]", "id"=>"123 456", "format"=>"json"}],
       @router.resources_for("GET", "/my_ctrl/bar/%5BI%5D/123+456.json")
   end
 
@@ -65,11 +65,11 @@ class RouterTest < Test::Unit::TestCase
       post :create
     end
 
-    assert_equal [FooController, :bar, {}],
+    assert_equal [[FooController, :bar], {}],
       @router.resources_for("GET", "/foo/bar")
 
     assert_equal "/foo/bar", @router.path_to(:my_bar)
-    assert_equal "/foo/create", @router.path_to(:create_foo)
+    assert_equal "/foo", @router.path_to(:create_foo)
     assert_equal "/foo", @router.path_to(:all_foo)
   end
 
@@ -82,10 +82,10 @@ class RouterTest < Test::Unit::TestCase
 
     assert_nil @router.resources_for("post", "/my_ctrl")
 
-    assert_equal [MyCtrl, :bar, {'str' => 'item'}],
+    assert_equal [[MyCtrl, :bar], {'str' => 'item'}],
       @router.resources_for("GET", "/my_ctrl/item/bar")
 
-    assert_equal [MyCtrl, :foo, {'str' => 'item'}],
+    assert_equal [[MyCtrl, :foo], {'str' => 'item'}],
       @router.resources_for("post", "/my_ctrl/item")
   end
 
@@ -96,17 +96,121 @@ class RouterTest < Test::Unit::TestCase
     end
 
     expected_params = {'type' => 'sub', 'id' => '123', 'format' => 'json'}
-    assert_equal [MyCtrl, :bar, expected_params],
+    assert_equal [[MyCtrl, :bar], expected_params],
       @router.resources_for("GET", "/bar/sub/123.json")
   end
 
 
+  def test_add_and_retrieve_lambda
+    ctrl = lambda{ "foo" }
+    @router.add ctrl, "/foo"
+
+    assert_equal [[ctrl, :call],{}], @router.resources_for("GET", "/foo")
+  end
+
+
+  def test_add_and_retrieve_lambda_block
+    ctrl = lambda{ "foo" }
+    @router.add ctrl, "/foo" do
+      get :thing, "/thing"
+    end
+
+    assert_equal [[ctrl, :thing],{}], @router.resources_for("GET", "/foo/thing")
+  end
+
+
+  def test_add_lambda_no_path
+    ctrl = lambda{ "foo" }
+
+    assert_raises ArgumentError do
+      @router.add ctrl
+    end
+  end
+
+
+  def test_add_lambda_defaults
+    ctrl = lambda{ "foo" }
+
+    assert_raises TypeError do
+      @router.add ctrl, "/foo" do
+        get :thing, "/thing"
+        defaults
+      end
+    end
+  end
+
+
+  class MockCustomMount
+    def self.call env
+      [200, {}, ["OK"]]
+    end
+  end
+
+  def test_add_and_retrieve_custom_mount
+    @router.add MockCustomMount
+
+    assert_equal [[MockCustomMount, :call],{}],
+      @router.resources_for("GET", "/router_test/mock_custom_mount")
+
+    assert_equal [MockCustomMount, :call],
+      @router.route_to(MockCustomMount, :call).target
+
+    assert_equal [MockCustomMount, :call],
+      @router.route_to(:call_mock_custom_mount).target
+  end
+
+
+  def test_add_and_retrieve_custom_mount_block
+    @router.add MockCustomMount do
+      post :foo
+      get [:foo, 1, 2], "/ary"
+    end
+
+    assert_equal [[MockCustomMount, :foo],{}],
+      @router.resources_for("POST", "/router_test/mock_custom_mount/foo")
+
+    assert_equal [[MockCustomMount, [:foo, 1, 2]],{}],
+      @router.resources_for("GET", "/router_test/mock_custom_mount/ary")
+
+    assert_equal [MockCustomMount, :foo],
+      @router.route_to(:foo_mock_custom_mount).target
+
+    assert_nil @router.route_to(MockCustomMount, [:foo, 1, 2]).name
+  end
+
+
+  def test_add_custom_mount_action
+    assert_raises ArgumentError do
+      @router.add MockCustomMount do
+        post [:foo, 1, 2]
+      end
+    end
+  end
+
+
+  def test_add_custom_mount_defaults
+    assert_raises TypeError do
+      @router.add MockCustomMount, "/foo" do
+        get :thing, "/thing"
+        defaults
+      end
+    end
+  end
+
+
+  def test_add_and_retrieve_custom_mount_invalid
+    assert_raises ArgumentError do
+      @router.add TypeError
+    end
+  end
+
+
   def test_add_omit_base_path
     @router.add MyCtrl do
       get :bar
     end
 
-    assert_equal [MyCtrl, :bar, {}],
+    assert_equal [[MyCtrl, :bar], {}],
       @router.resources_for("GET", "/my_ctrl/bar")
   end
 
@@ -116,7 +220,7 @@ class RouterTest < Test::Unit::TestCase
       get :index, '/'
     end
 
-    assert_equal [FooController, :index, {}],
+    assert_equal [[FooController, :index], {}],
       @router.resources_for("GET", "/foo")
   end
 
@@ -126,7 +230,7 @@ class RouterTest < Test::Unit::TestCase
       get :bar, "/"
     end
 
-    assert_equal [MyCtrl, :bar, {}],
+    assert_equal [[MyCtrl, :bar], {}],
       @router.resources_for("GET", "/")
 
     assert !@router.has_route?(MyCtrl, :show)
@@ -155,33 +259,16 @@ class RouterTest < Test::Unit::TestCase
   end
 
 
-  def test_add_all_with_default_verb
-    @router.add MyCtrl, "/" do
-      get :show, "/:id"
-      defaults :post
-    end
-
-    assert_equal [MyCtrl, :index, {}],
-      @router.resources_for("GET", "/")
-
-    assert_equal [MyCtrl, :show, {'id' => '123'}],
-      @router.resources_for("GET", "/123")
-
-    assert_equal [MyCtrl, :unmounted_action, {}],
-      @router.resources_for("POST", "/unmounted_action")
-  end
-
-
   def test_add_all
     @router.add MyCtrl, "/"
 
-    assert_equal [MyCtrl, :index, {}],
+    assert_equal [[MyCtrl, :index], {}],
       @router.resources_for("GET", "/")
 
-    assert_equal [MyCtrl, :show, {'id' => '123'}],
+    assert_equal [[MyCtrl, :show], {'id' => '123'}],
       @router.resources_for("GET", "/123")
 
-    assert_equal [MyCtrl, :unmounted_action, {}],
+    assert_equal [[MyCtrl, :unmounted_action], {}],
       @router.resources_for("GET", "/unmounted_action")
   end
 
@@ -212,7 +299,7 @@ class RouterTest < Test::Unit::TestCase
       get :bar, "/bar"
     end
 
-    assert_raises Gin::Router::PathArgumentError do
+    assert_raises Gin::RouterError do
       @router.path_to(MyCtrl, :foo)
     end
   end
@@ -271,4 +358,39 @@ class RouterTest < Test::Unit::TestCase
     assert_equal "/bar/sub%2Fthing/123%264.json?more=hi+there",
       @router.path_to(MyCtrl, :bar, params)
   end
+
+
+  def test_route_to
+    @router.add MyCtrl, '/my_ctrl/' do
+      get :show, "/:id"
+    end
+
+    route = @router.route_to(MyCtrl, :show)
+    assert_equal [MyCtrl, :show], route.target
+    assert_equal '/my_ctrl/123', route.to_path(:id => 123)
+
+    named_route = @router.route_to(:show_my_ctrl)
+    assert_equal route, named_route
+  end
+
+
+  def test_route_to_env
+    @router.add MyCtrl, '/my_ctrl/' do
+      post :update, "/:id"
+    end
+
+    route = @router.route_to(MyCtrl, :update)
+    expected_env = {'rack.input' => '', 'PATH_INFO' => '/my_ctrl/123',
+      'REQUEST_METHOD' => 'POST', 'QUERY_STRING' => 'blah=456'}
+
+    assert_equal expected_env, route.to_env(:id => 123, :blah => 456)
+
+    assert_raises Gin::Router::PathArgumentError do
+      route.to_env(:blah => 456)
+    end
+
+    expected_env['rack.input'] = 'foo=bar'
+    assert_equal expected_env,
+      route.to_env({:id => 123, :blah => 456}, {'rack.input' => 'foo=bar'})
+  end
 end

data/test/test_test.rb

@@ -53,32 +53,37 @@ class TestTest < Test::Unit::TestCase
 
   def test_path_to
     assert_nil @tests.default_controller
-    assert_equal "/bar/123", @tests.path_to(:show_bar, id: 123)
-    assert_equal "/bar/123", @tests.path_to(MockApp::BarController, :show, id: 123)
-    assert_equal "/bar?id=123", @tests.path_to("/bar", id: 123)
+    assert_equal "/bar/123", @tests.path_to(:show_bar, :id => 123)
+    assert_equal "/bar/123", @tests.path_to(MockApp::BarController, :show, :id => 123)
+    assert_equal "/bar?id=123", @tests.path_to("/bar", :id => 123)
   end
 
 
   def test_path_to_default_ctrl
     @tests.default_controller MockApp::BarController
-    assert_equal "/bar/123", @tests.path_to(:show_bar, id: 123)
-    assert_equal "/bar/123", @tests.path_to(:show, id: 123)
+    assert_equal "/bar/123", @tests.path_to(:show_bar, :id => 123)
+    assert_equal "/bar/123", @tests.path_to(:show, :id => 123)
   end
 
 
   def test_path_to_no_ctrl
     assert_nil @tests.default_controller
-    assert_raises(Gin::Router::PathArgumentError) do
-      @tests.path_to(:show, id: 123)
+    assert_raises(Gin::RouterError) do
+      @tests.path_to(:show, :id => 123)
     end
   end
 
 
   def test_make_request
+    @tests.app.options[:host] = {:name => 'example.com:443'}
     resp = @tests.make_request :get, :show_bar,
-              {id: 123, foo: "BAR", bar: "BAZ Foo"},'REMOTE_ADDR' => '127.0.0.1'
+              {:id => 123, :foo => "BAR", :bar => "BAZ Foo"},'REMOTE_ADDR' => '127.0.0.1'
 
-    assert_equal "foo=BAR&bar=BAZ+Foo", @tests.req_env['QUERY_STRING']
+    assert_equal "example.com", @tests.req_env['SERVER_NAME']
+    assert_equal "443", @tests.req_env['SERVER_PORT']
+    assert_equal "example.com:443", resp[1]['Host']
+
+    assert_equal %w{bar=BAZ+Foo foo=BAR}, @tests.req_env['QUERY_STRING'].split('&').sort
     assert_equal "/bar/123", @tests.req_env['PATH_INFO']
     assert_equal "127.0.0.1", @tests.req_env['REMOTE_ADDR']
     assert_equal "127.0.0.1", @tests.request.ip
@@ -119,12 +124,13 @@ class TestTest < Test::Unit::TestCase
                  resp[1]["Set-Cookie"]
 
     time = Time.parse "2100-01-01 00:00:00 UTC"
-    cookie = {name: "foo_session", value: "12345", expires_at: time}
+    cookie = {:name => "foo_session", :value => "12345", :expires_at => time}
     assert_equal cookie, @tests.cookies["foo_session"]
 
     @tests.set_cookie "bar", 5678
-    resp = @tests.make_request :get, :show_bar, id: 123
-    assert_equal "foo_session=12345; bar=5678", @tests.req_env['HTTP_COOKIE']
+    resp = @tests.make_request :get, :show_bar, :id => 123
+    assert_equal %w{bar=5678 foo_session=12345},
+                 @tests.req_env['HTTP_COOKIE'].split('; ').sort
   end
 
 
@@ -136,18 +142,18 @@ class TestTest < Test::Unit::TestCase
 
     time = Time.parse "2100-01-01 00:00:00 UTC"
 
-    expected = {name: "foo_session", value: "12345", expires_at: time}
+    expected = {:name => "foo_session", :value => "12345", :expires_at => time}
     assert_equal expected, @tests.cookies['foo_session']
 
-    expected = {name: "supercookie", value: "SUPER!", domain: "mockapp.com",
-      path: "/", expires_at: time, secure: true, http_only: true}
+    expected = {:name => "supercookie", :value => "SUPER!", :domain => "mockapp.com",
+      :path => "/", :expires_at => time, :secure => true, :http_only => true}
     assert_equal expected, @tests.cookies['supercookie']
   end
 
 
   def test_make_request_verb_methods
     %w{get post put patch delete head options}.each do |verb|
-      resp = @tests.send verb, :show_bar, id: 123
+      resp = @tests.send verb, :show_bar, :id => 123
       assert_equal verb.upcase, @tests.req_env['REQUEST_METHOD']
       if verb == 'get'
         assert_equal MockApp::BarController,
@@ -326,50 +332,50 @@ class TestTest < Test::Unit::TestCase
   def test_assert_data_json
     @tests.rack_response[1]['Content-Type'] = 'application/json'
     @tests.rack_response[2] =
-      [{name:"bob",addresses:[{street:"123 bob st"},{street:"321 foo st"}]}.to_json]
+      [{:name =>"bob",:addresses =>[{:street =>"123 bob st"},{:street =>"321 foo st"}]}.to_json]
 
     assert @tests.assert_data("name=bob")
-    assert @tests.assert_data("name", value: "bob", count: 1)
-    assert @tests.assert_data("addresses/*/street", count: 2)
+    assert @tests.assert_data("name", :value => "bob", :count => 1)
+    assert @tests.assert_data("addresses/*/street", :count => 2)
   end
 
 
   def test_assert_data_bson
     @tests.rack_response[1]['Content-Type'] = 'application/bson'
     @tests.rack_response[2] =
-      [BSON.serialize({name:"bob",addresses:[{street:"123 bob st"},{street:"321 foo st"}]}).to_s]
+      [BSON.serialize({:name =>"bob",:addresses =>[{:street =>"123 bob st"},{:street =>"321 foo st"}]}).to_s]
 
     assert @tests.assert_data("name=bob")
-    assert @tests.assert_data("name", value: "bob", count: 1)
-    assert @tests.assert_data("addresses/*/street", count: 2)
+    assert @tests.assert_data("name", :value => "bob", :count => 1)
+    assert @tests.assert_data("addresses/*/street", :count => 2)
   end
 
 
   def test_assert_data_plist
     @tests.rack_response[1]['Content-Type'] = 'application/plist'
     @tests.rack_response[2] =
-      [{name:"bob",addresses:[{street:"123 bob st"},{street:"321 foo st"}]}.to_plist]
+      [{:name =>"bob",:addresses =>[{:street =>"123 bob st"},{:street =>"321 foo st"}]}.to_plist]
 
     assert @tests.assert_data("name=bob")
-    assert @tests.assert_data("name", value: "bob", count: 1)
-    assert @tests.assert_data("addresses/*/street", count: 2)
+    assert @tests.assert_data("name", :value => "bob", :count => 1)
+    assert @tests.assert_data("addresses/*/street", :count => 2)
   end
 
 
   def test_assert_xpath
-    data = Nokogiri::XML::Builder.new do
-      root{
-        name "bob"
-        address{ street "123 bob st" }
-        address{ street "321 foo st" }
+    data = Nokogiri::XML::Builder.new do |xml|
+      xml.root{
+        xml.name "bob"
+        xml.address{ xml.street "123 bob st" }
+        xml.address{ xml.street "321 foo st" }
       }
     end.to_xml
 
     @tests.rack_response[1]['Content-Type'] = 'application/xml'
     @tests.rack_response[2] = [data]
 
-    assert @tests.assert_xpath("/root/name", value: "bob", count: 1)
-    assert @tests.assert_xpath(".//street", count: 2)
+    assert @tests.assert_xpath("/root/name", :value => "bob", :count => 1)
+    assert @tests.assert_xpath(".//street", :count => 2)
   end
 
 
@@ -388,8 +394,8 @@ class TestTest < Test::Unit::TestCase
     @tests.rack_response[1]['Content-Type'] = 'application/html'
     @tests.rack_response[2] = [html]
 
-    assert @tests.assert_css(".name", value: "bob", count: 1)
-    assert @tests.assert_css(".address>.street", count: 2)
+    assert @tests.assert_css(".name", :value => "bob", :count => 1)
+    assert @tests.assert_css(".address>.street", :count => 2)
   end
 
 
@@ -397,7 +403,7 @@ class TestTest < Test::Unit::TestCase
     @tests.rack_response[1]['Content-Type'] = 'application/json'
     @tests.rack_response[2] = ['{"foo":123}']
     assert_raises(RuntimeError) do
-      @tests.assert_select(".name", selector: :foo)
+      @tests.assert_select(".name", :selector => :foo)
     end
   end
 
@@ -413,13 +419,13 @@ class TestTest < Test::Unit::TestCase
                   @tests.last_message
 
     assert_raises(MockAssertionError) do
-      @tests.assert_select "/foo", count: 2
+      @tests.assert_select "/foo", :count => 2
     end
     assert_equal "Expected 2 items matching '/foo' but found 1",
                   @tests.last_message
 
     assert_raises(MockAssertionError) do
-      @tests.assert_select "/foo", value: 321
+      @tests.assert_select "/foo", :value => 321
     end
 
     assert_equal "Expected at least one item matching '/foo' with value 321 but found none",
@@ -431,11 +437,11 @@ class TestTest < Test::Unit::TestCase
     @tests.get :supercookie_foo
 
     assert @tests.assert_cookie("supercookie")
-    assert @tests.assert_cookie("supercookie", value: "SUPER!")
-    assert @tests.assert_cookie("supercookie", domain: "mockapp.com")
+    assert @tests.assert_cookie("supercookie", :value => "SUPER!")
+    assert @tests.assert_cookie("supercookie", :domain => "mockapp.com")
 
-    attribs = {domain: "mockapp.com", value: "SUPER!", path: "/", secure: true,
-      http_only: true, expires_at: Time.parse("Fri, 01 Jan 2100 00:00:00 -0000")}
+    attribs = {:domain => "mockapp.com", :value => "SUPER!", :path => "/", :secure => true,
+      :http_only => true, :expires_at => Time.parse("Fri, 01 Jan 2100 00:00:00 -0000")}
     assert @tests.assert_cookie("supercookie", attribs)
   end
 
@@ -469,7 +475,7 @@ class TestTest < Test::Unit::TestCase
     @tests.get :supercookie_foo
 
     assert_raises(MockAssertionError) do
-      @tests.assert_cookie "supercookie", value: "BLAH"
+      @tests.assert_cookie "supercookie", :value => "BLAH"
     end
     assert_equal "Expected cookie value to be \"BLAH\" but was \"SUPER!\"",
                  @tests.last_message
@@ -586,9 +592,9 @@ got MockApp::FooController#index", @tests.last_message
       Assertion = MockAssertionError unless const_defined?(:Assertion)
     end
 
-    def raise err, msg=nil
-      err, msg = RuntimeError, err if String === err && msg.nil?
-      @last_message = err.respond_to?(:message) ? err.message : msg
+    def raise *args
+      @last_message = String === args.last && args.last ||
+                      args.last.respond_to?(:message) && args.last.message
       super
     end
   end