gin 1.1.2 → 1.2.0

data/test/mock_app.rb

@@ -5,22 +5,22 @@ class MockApp < Gin::App
     layout "foo"
 
     def index
-      view :bar, locals: {test_val: "LOCAL"}
+      view :bar, :locals => {:test_val => "LOCAL"}
     end
 
     def login
       set_cookie "foo_session", "12345",
-        expires: Time.parse("Fri, 01 Jan 2100 00:00:00 -0000")
+        :expires => Time.parse("Fri, 01 Jan 2100 00:00:00 -0000")
       "OK"
     end
 
     def supercookie
       set_cookie "supercookie", "SUPER!",
-        expires:  Time.parse("Fri, 01 Jan 2100 00:00:00 -0000"),
-        domain:   "mockapp.com",
-        path:     "/",
-        secure:   true,
-        httponly: true
+        :expires =>  Time.parse("Fri, 01 Jan 2100 00:00:00 -0000"),
+        :domain =>   "mockapp.com",
+        :path =>     "/",
+        :secure =>   true,
+        :httponly => true
       "OK"
     end
   end

data/test/test_app.rb

@@ -4,6 +4,7 @@ require "stringio"
 class FooController < Gin::Controller;
   def index; "FOO"; end
   def create; end
+  def show id; "FOO ID = #{id}"; end
   def error; raise "Something bad happened"; end
 end
 
@@ -21,6 +22,13 @@ class FooApp < Gin::App
     get  :index,  "/"
     post :create, "/"
     get  :error,  "/error"
+    get  :show, "/:id"
+  end
+
+  def call env
+    env['SERVER_NAME'] ||= 'foo.com'
+    env['SERVER_PORT'] ||= '80'
+    super
   end
 
   def reloaded?
@@ -71,6 +79,8 @@ end
 
 
 class AppTest < Test::Unit::TestCase
+  include Gin::Constants
+
   class NamespacedApp < Gin::App; end
 
   FOO_ROUTER = FooApp.router
@@ -122,6 +132,54 @@ class AppTest < Test::Unit::TestCase
   end
 
 
+  def test_hostname
+    FooApp.hostname 'example.com'
+    @app = FooApp.new
+
+    assert_equal 'example.com', FooApp.hostname
+    assert_equal 'example.com', @app.hostname
+    assert @app.send(:valid_host?,{})
+  end
+
+
+  def test_hostname_enforce
+    FooApp.hostname 'example.com', :enforce => true
+    @app = FooApp.new
+
+    assert_equal 'example.com', FooApp.hostname
+    assert_equal 'example.com', @app.hostname
+    assert !@app.send(:valid_host?,{'SERVER_NAME' => 'admin.example.com', 'SERVER_PORT' => '80'})
+    assert @app.send(:valid_host?,{'SERVER_NAME' => 'example.com', 'SERVER_PORT' => '443'})
+    assert @app.send(:valid_host?,{'SERVER_NAME' => 'example.com', 'SERVER_PORT' => '80'})
+  end
+
+
+  def test_hostname_enforce_port
+    FooApp.hostname 'example.com:80', :enforce => true
+    @app = FooApp.new
+
+    assert_equal 'example.com:80', FooApp.hostname
+    assert_equal 'example.com:80', @app.hostname
+    assert !@app.send(:valid_host?,{'SERVER_NAME' => 'admin.example.com', 'SERVER_PORT' => '80'})
+    assert !@app.send(:valid_host?,{'SERVER_NAME' => 'example.com', 'SERVER_PORT' => '443'})
+    assert @app.send(:valid_host?,{'SERVER_NAME' => 'example.com', 'SERVER_PORT' => '80'})
+  end
+
+
+  def test_hostname_enforce_regexp
+    FooApp.hostname 'admin.example.com',
+                    :enforce => /^admin\.(example\.com|localhost)$/
+
+    @app = FooApp.new
+
+    assert_equal 'admin.example.com', FooApp.hostname
+    assert_equal 'admin.example.com', @app.hostname
+    assert !@app.send(:valid_host?,{'SERVER_NAME' => 'example.com'})
+    assert @app.send(:valid_host?,{'SERVER_NAME' => 'admin.example.com'})
+    assert @app.send(:valid_host?,{'SERVER_NAME' => 'admin.localhost'})
+  end
+
+
   def test_namespace
     assert_nil FooApp.namespace
     assert_equal self.class, NamespacedApp.namespace
@@ -131,8 +189,8 @@ class AppTest < Test::Unit::TestCase
   def test_protection
     assert_equal false, FooApp.protection
 
-    FooApp.protection(test: "thing")
-    assert_equal({test:"thing"}, FooApp.protection)
+    FooApp.protection(:test => "thing")
+    assert_equal({:test =>"thing"}, FooApp.protection)
 
     FooApp.protection false
     assert_equal false, FooApp.protection
@@ -174,8 +232,8 @@ class AppTest < Test::Unit::TestCase
   def test_sessions
     assert_equal false, FooApp.sessions
 
-    FooApp.sessions(test: "thing")
-    assert_equal({test:"thing"}, FooApp.sessions)
+    FooApp.sessions(:test => "thing")
+    assert_equal({:test =>"thing"}, FooApp.sessions)
 
     FooApp.sessions false
     assert_equal false, FooApp.sessions
@@ -313,7 +371,7 @@ class AppTest < Test::Unit::TestCase
 
   def test_template_for
     FooApp.default_template Tilt::ERBTemplate, "erb"
-    @app = FooApp.new root_dir: "./test/app"
+    @app = FooApp.new :root_dir => "./test/app"
     template = @app.template_for "./test/app/layouts/foo"
 
     assert Tilt::ERBTemplate === template
@@ -322,14 +380,14 @@ class AppTest < Test::Unit::TestCase
 
 
   def test_template_for_invalid
-    @app = FooApp.new root_dir: "./test/app"
+    @app = FooApp.new :root_dir => "./test/app"
     template = @app.template_for "./test/app/layouts/ugh"
     assert_nil template
   end
 
 
   def test_template_files
-    @app = FooApp.new root_dir: "./test/app"
+    @app = FooApp.new :root_dir => "./test/app"
 
     files = @app.template_files "./test/app/layouts/foo"
     assert_equal ["./test/app/layouts/foo.erb"], files
@@ -351,16 +409,97 @@ class AppTest < Test::Unit::TestCase
     assert_equal [FooMiddleware, :foo, :bar], FooApp.middleware[0]
     assert !FooMiddleware.called?
 
-    myapp = FooApp.new logger: @error_io
+    myapp = FooApp.new :logger => @error_io
     myapp.call({'rack.input' => "", 'PATH_INFO' => '/foo', 'REQUEST_METHOD' => 'GET'})
     assert FooMiddleware.called?
 
     FooMiddleware.reset!
-    myapp.dispatch({'rack.input' => "", 'PATH_INFO' => '/foo', 'REQUEST_METHOD' => 'GET'}, FooController, :index)
+    myapp.dispatch('rack.input' => "", 'PATH_INFO' => '/foo',
+      'REQUEST_METHOD' => 'GET', GIN_TARGET => [FooController, :index])
     assert !FooMiddleware.called?
   end
 
 
+  def test_rewrite_env
+    time = Time.now
+    env = {'rack.input' => 'id=foo', 'PATH_INFO' => '/foobar', 'REQUEST_METHOD' => 'GET',
+          'REMOTE_ADDR' => '127.0.0.1', GIN_RELOADED => true, GIN_TIMESTAMP => time,
+          GIN_TARGET => [FooController, :index]}
+
+    expected_env = env.dup
+    expected_env.delete(GIN_TARGET)
+    expected_env['REQUEST_METHOD'] = 'POST'
+    expected_env['PATH_INFO'] = '/foo'
+    expected_env['QUERY_STRING'] = nil
+
+    assert_equal expected_env, @app.rewrite_env(env, FooController, :create)
+
+    assert_raises Gin::RouterError do
+      @app.rewrite_env(env, FooController, :bad_action)
+    end
+
+    assert_raises Gin::Router::PathArgumentError do
+      @app.rewrite_env(env, FooController, :show)
+    end
+
+    expected_env['REQUEST_METHOD'] = 'GET'
+    expected_env['PATH_INFO'] = '/foo/123'
+    expected_env['QUERY_STRING'] = 'blah=456'
+
+    assert_equal expected_env,
+      @app.rewrite_env(env, FooController, :show, {:id => 123, :blah => 456}, 'REQUEST_METHOD' => 'POST')
+  end
+
+
+  def test_rewrite_env_custom_path
+    time = Time.now
+    env = {'rack.input' => 'id=foo', 'PATH_INFO' => '/foobar', 'REQUEST_METHOD' => 'GET',
+          'REMOTE_ADDR' => '127.0.0.1', GIN_RELOADED => true, GIN_TIMESTAMP => time,
+          GIN_TARGET => [FooController, :index]}
+
+    expected_env = env.dup
+    expected_env.delete(GIN_TARGET)
+    expected_env['REQUEST_METHOD'] = 'POST'
+    expected_env['PATH_INFO'] = '/foo'
+    expected_env['QUERY_STRING'] = nil
+
+    assert_equal expected_env, @app.rewrite_env(env, '/foo', {}, 'REQUEST_METHOD' => 'POST')
+    assert_raises Gin::Router::PathArgumentError do
+      @app.rewrite_env(env, '/foo/:id', {}, 'REQUEST_METHOD' => 'POST')
+    end
+
+    expected_env['PATH_INFO'] = '/foo/123'
+    expected_env['QUERY_STRING'] = 'blah=456'
+
+    assert_equal expected_env,
+      @app.rewrite_env(env, '/foo/:id', {:id => 123, :blah => 456}, 'REQUEST_METHOD' => 'POST')
+  end
+
+
+  def test_rewrite
+    env = {'rack.input' => 'id=foo', 'PATH_INFO' => '/foobar', 'REQUEST_METHOD' => 'GET',
+          'REMOTE_ADDR' => '127.0.0.1'}
+
+    resp = @app.rewrite!(env, FooController, :show, :id => 123)
+    @app.logger.rewind
+
+    assert_equal ["FOO ID = 123"], resp[2]
+    assert_equal "[REWRITE] GET /foobar -> GET /foo/123\n", @app.logger.readline
+  end
+
+
+  def test_rewrite_path
+    env = {'rack.input' => 'id=foo', 'PATH_INFO' => '/foobar', 'REQUEST_METHOD' => 'GET',
+          'REMOTE_ADDR' => '127.0.0.1'}
+
+    resp = @app.rewrite!(env, '/other/path/:id', {:id => 123}, 'REQUEST_METHOD' => 'PUT')
+    @app.logger.rewind
+
+    assert_equal 404, resp[0]
+    assert_equal "[REWRITE] GET /foobar -> PUT /other/path/123\n", @app.logger.readline
+  end
+
+
   def test_call_reload
     FooApp.autoreload true
     myapp = FooApp.new @error_io
@@ -393,6 +532,116 @@ class AppTest < Test::Unit::TestCase
   end
 
 
+  def test_call_host
+    env = {'rack.input' => "", 'PATH_INFO' => '/foo', 'REQUEST_METHOD' => 'GET',
+           'SERVER_NAME' => 'foo.com', 'SERVER_PORT' => '80'}
+    FooApp.hostname 'example.com'
+    @app = FooApp.new
+    resp = @app.call env
+
+    assert_equal 200, resp[0]
+    assert_equal 'example.com:80', resp[1]['Host']
+  end
+
+
+  def test_call_validate_host
+    env = {'rack.input' => "", 'PATH_INFO' => '/foo', 'REQUEST_METHOD' => 'GET',
+           'SERVER_NAME' => 'foo.com', 'SERVER_PORT' => '80'}
+    FooApp.hostname 'example.com', :enforce => true
+    @app = FooApp.new
+    resp = @app.call env
+
+    assert_equal 400, resp[0]
+    assert_equal 'example.com:80', resp[1]['Host']
+    assert resp[2][0].include?("No route for host &#39;foo.com:80&#39;")
+
+    env['SERVER_NAME'] = 'example.com'
+    resp = @app.call env
+
+    assert_equal 200, resp[0]
+    assert_equal 'example.com:80', resp[1]['Host']
+  end
+
+
+  def test_call_validate_host_regexp
+    env = {'rack.input' => "", 'PATH_INFO' => '/foo', 'REQUEST_METHOD' => 'GET',
+           'SERVER_NAME' => 'foo.com', 'SERVER_PORT' => '80'}
+    FooApp.hostname 'admin.example.com', :enforce => /^admin\.(example\.com|localhost)$/
+    @app = FooApp.new
+    resp = @app.call env
+
+    assert_equal 400, resp[0]
+    assert_equal 'admin.example.com:80', resp[1]['Host']
+    assert resp[2][0].include?("No route for host &#39;foo.com:80&#39;")
+
+    env['SERVER_NAME'] = 'admin.example.com'
+    env['SERVER_PORT'] = '443'
+    resp = @app.call env
+
+    assert_equal 200, resp[0]
+    assert_equal 'admin.example.com:443', resp[1]['Host']
+  end
+
+
+  def test_call_validate_host_and_port
+    env = {'rack.input' => "", 'PATH_INFO' => '/foo', 'REQUEST_METHOD' => 'GET',
+           'SERVER_NAME' => 'example.com', 'SERVER_PORT' => '80'}
+    FooApp.hostname 'example.com:443', :enforce => true
+    @app = FooApp.new
+    resp = @app.call env
+
+    assert_equal 400, resp[0]
+    assert_equal 'example.com:80', resp[1]['Host']
+    assert resp[2][0].include?("No route for host &#39;example.com:80&#39;")
+
+    env['SERVER_PORT'] = '443'
+    resp = @app.call env
+
+    assert_equal 200, resp[0]
+    assert_equal 'example.com:443', resp[1]['Host']
+  end
+
+
+  def test_call_validate_host_static
+    env = {'rack.input' => "", 'PATH_INFO' => '/gin.css', 'REQUEST_METHOD' => 'GET',
+           'SERVER_NAME' => 'foo.com', 'SERVER_PORT' => '80'}
+    FooApp.hostname 'example.com', :enforce => true
+    @app = FooApp.new
+    resp = @app.call env
+
+    assert_equal 400, resp[0]
+    assert_equal 'example.com:80', resp[1]['Host']
+    assert resp[2][0].include?("No route for host &#39;foo.com:80&#39;")
+
+    env['SERVER_NAME'] = 'example.com'
+    resp = @app.call env
+
+    assert_equal 200, resp[0]
+    assert_equal 'example.com:80', resp[1]['Host']
+  end
+
+
+  def test_call_validate_host_rack_app
+    env = {'rack.input' => "", 'PATH_INFO' => '/gin.css', 'REQUEST_METHOD' => 'GET',
+           'SERVER_NAME' => 'foo.com', 'SERVER_PORT' => '80'}
+
+    FooApp.hostname 'example.com', :enforce => true
+
+    expected = [200, {'Content-Length'=>"5", 'Host' => 'foo.com:80'}, "AHOY!"]
+    myapp = lambda{|_| expected }
+    @app = FooApp.new myapp
+    resp = @app.call env
+
+    assert_equal expected, resp
+
+    env['SERVER_NAME'] = 'example.com'
+    resp = @app.call env
+
+    assert_equal 200, resp[0]
+    assert_equal 'example.com:80', resp[1]['Host']
+    assert resp[2].is_a?(File)
+  end
+
 
   def test_call!
     resp = @app.call! 'rack.input' => "",
@@ -409,7 +658,7 @@ class AppTest < Test::Unit::TestCase
     FooApp.environment 'test'
     env = {'rack.input' => "", 'PATH_INFO' => '/foo', 'REQUEST_METHOD' => 'GET'}
 
-    resp = @app.dispatch env, FooController, :index
+    resp = @app.dispatch env.merge(GIN_TARGET => [FooController, :index])
     assert_equal 200, resp[0]
     assert_equal "3", resp[1]['Content-Length']
     assert_equal 'text/html;charset=UTF-8', resp[1]['Content-Type']
@@ -422,7 +671,7 @@ class AppTest < Test::Unit::TestCase
     @app = FooApp.new
     env = {'rack.input' => "", 'PATH_INFO' => '/foo', 'REQUEST_METHOD' => 'GET'}
 
-    resp = @app.dispatch env, FooController, :bad
+    resp = @app.dispatch env.merge(GIN_TARGET => [FooController, :bad])
     assert_equal 404, resp[0]
     assert_equal "288", resp[1]['Content-Length']
     assert_equal 'text/html;charset=UTF-8', resp[1]['Content-Type']
@@ -435,13 +684,13 @@ class AppTest < Test::Unit::TestCase
     @app = FooApp.new
     env = {'rack.input' => "", 'PATH_INFO' => '/foo', 'REQUEST_METHOD' => 'GET'}
 
-    resp = @app.dispatch env, FooController, nil
+    resp = @app.dispatch env.merge(GIN_TARGET => [FooController, nil])
     assert_equal 404, resp[0]
     assert_equal "288", resp[1]['Content-Length']
     assert_equal 'text/html;charset=UTF-8', resp[1]['Content-Type']
     assert_equal @app.asset("404.html"), resp[2].path
 
-    msg = "[ERROR] Gin::NotFound: No route exists for: GET /foo"
+    msg = "[ERROR] Gin::NotFound: No action exists for: GET /foo"
     @error_io.rewind
     assert @error_io.read.include?(msg)
   end
@@ -451,7 +700,7 @@ class AppTest < Test::Unit::TestCase
     FooApp.environment 'test'
     @app = FooApp.new
     env  = {'rack.input' => "", 'PATH_INFO' => '/bad', 'REQUEST_METHOD' => 'GET'}
-    resp = @app.dispatch env, FooController, :error
+    resp = @app.dispatch env.merge(GIN_TARGET => [FooController, :error])
 
     assert_equal 500, resp[0]
     assert_equal @app.asset("500.html"), resp[2].path
@@ -496,7 +745,7 @@ class AppTest < Test::Unit::TestCase
     env = {'rack.input' => "", 'PATH_INFO' => '/bad', 'REQUEST_METHOD' => 'GET'}
     err = ArgumentError.new("Unexpected Argument")
 
-    resp = @app.handle_error ArgumentError.new("Unexpected Argument"), env
+    resp = @app.handle_error err, env
     assert_equal 500, resp[0]
     assert_equal File.read(@app.asset("500.html")), resp[2].read
     assert_equal({"Content-Type"=>"text/html;charset=UTF-8", "Content-Length"=>"348"}, resp[1])
@@ -663,14 +912,14 @@ class AppTest < Test::Unit::TestCase
 
 
   def test_init_missing_routes
-    assert_raises Gin::App::RouterError do
+    assert_raises Gin::RouterError do
       MissingRouteApp.new
     end
   end
 
 
   def test_init_extra_routes
-    assert_raises Gin::App::RouterError do
+    assert_raises Gin::RouterError do
       ExtraRouteApp.new
     end
   end

data/test/test_cache.rb

@@ -7,6 +7,15 @@ class CacheTest < Test::Unit::TestCase
   end
 
 
+  def test_clear
+    @cache[:foo] = "blah"
+    assert @cache[:foo]
+
+    @cache.clear
+    assert_nil @cache[:foo]
+  end
+
+
   def test_write_timeout
     assert_equal 0.05, @cache.write_timeout
     @cache.write_timeout = 0.1
@@ -15,20 +24,79 @@ class CacheTest < Test::Unit::TestCase
   end
 
 
-  def test_write_thread_safe
+  # This test only valid for non-GC Ruby implementations
+  def test_readwrite_thread_safe
     @cache[:num] = 0
-    @mutex = Mutex.new
     @num = 0
 
     threads = []
-    30.times do
-      threads << Thread.new{ @cache[:num] += 1 }
+    15.times do
+      threads << Thread.new{ @cache[:num] = Thread.current.object_id }
+    end
+    15.times do
+      threads << Thread.new{ assert @cache[:num] }
+    end
+    threads.each do |t|
+      t.join
+    end
+  end
+
+
+  def test_increase
+    assert_equal 1, @cache.increase(:num)
+    assert_equal 1, @cache[:num]
+
+    @cache.increase(:num, 0.2)
+    assert_equal 1.2, @cache[:num]
+  end
+
+
+  def test_increase_invalid
+    @cache[:num] = "foo"
+    assert_nil @cache.increase(:num)
+    assert_equal "foo", @cache[:num]
+  end
+
+
+  def test_decrease
+    @cache.decrease(:num)
+    assert_equal -1, @cache[:num]
+
+    @cache.decrease(:num, 0.2)
+    assert_equal -1.2, @cache[:num]
+  end
+
+
+  def test_decrease_invalid
+    @cache[:num] = "foo"
+    assert_nil @cache.decrease(:num)
+    assert_equal "foo", @cache[:num]
+  end
+
+
+  def test_increase_thread_safe
+    threads = []
+    15.times do
+      threads << Thread.new{ @cache.increase(:num) }
+    end
+    threads.each do |t|
+      t.join
+    end
+
+    assert_equal 15, @cache[:num]
+  end
+
+
+  def test_decrease_thread_safe
+    threads = []
+    15.times do
+      threads << Thread.new{ @cache.decrease(:num) }
     end
     threads.each do |t|
       t.join
     end
 
-    assert_equal 30, @cache[:num]
+    assert_equal -15, @cache[:num]
   end