gin 0.0.0 → 1.0.0

data/test/test_errorable.rb

@@ -0,0 +1,221 @@
+require 'test/test_helper'
+
+class ErrorableTest < Test::Unit::TestCase
+
+  class Foo
+    include Gin::Errorable
+
+    def self.delete_all_handlers!
+      @err_handlers = nil
+    end
+
+    attr_reader :env
+
+    def initialize
+      @status = 200
+      @env = {}
+    end
+
+    def status val=nil
+      @status = val if val
+      @status
+    end
+  end
+
+  class Bar < Foo; end
+
+
+  def setup
+    Foo.delete_all_handlers!
+    Bar.delete_all_handlers!
+  end
+
+
+  def test_handler_lookup
+    block_404 = lambda{|err| "404" }
+    block_err = lambda{|err| "ERROR'D!" }
+
+    Foo.error(404, &block_404)
+    Foo.error(Exception, &block_err)
+
+    assert_equal block_404, Foo.error_handler_for(404)
+    assert_equal block_err, Foo.error_handler_for(Exception.new)
+  end
+
+
+  def test_handler_local_fallback
+    block_def = lambda{|err| "default" }
+    Foo.error(&block_def)
+    assert_equal block_def, Foo.error_handler_for(404)
+    assert_equal block_def, Foo.error_handler_for(ArgumentError.new)
+
+    block_err = lambda{|err| "ERROR'D!" }
+    Foo.error(StandardError, &block_err)
+    assert_equal block_err, Foo.error_handler_for(ArgumentError.new)
+  end
+
+
+  def test_handler_inheritance
+    block_404 = lambda{|err| "404" }
+    block_err = lambda{|err| "ERROR'D!" }
+    Foo.error(StandardError, &block_err)
+    Foo.error(404, &block_404)
+
+    assert_equal block_404, Bar.error_handler_for(404)
+    assert_equal block_err, Bar.error_handler_for(ArgumentError.new)
+  end
+
+
+  def test_handler_inheritance_fallback
+    block_404 = lambda{|err| "404" }
+    block_def = lambda{|err| "default" }
+    Foo.error(&block_def)
+    Bar.error(404, &block_404)
+
+    assert_equal block_404, Bar.error_handler_for(404)
+    assert_equal block_def, Bar.error_handler_for(ArgumentError.new)
+  end
+
+
+  def test_handler_err_inheritance_order
+    block_err = lambda{|err| "ERROR'D!" }
+    block_def = lambda{|err| "default" }
+    Foo.error(ArgumentError, &block_err)
+    Bar.error(&block_def)
+
+    assert_equal block_def, Bar.error_handler_for(ArgumentError.new)
+
+    block_err2 = lambda{|err| "ERROR'D!" }
+    Bar.error(Exception, &block_err2)
+
+    assert_equal block_err2, Bar.error_handler_for(ArgumentError.new)
+  end
+
+
+  def test_handler_status_inheritance_order
+    block_404 = lambda{|err| "404" }
+    block_def = lambda{|err| "default" }
+    Foo.error(404, &block_404)
+    Bar.error(&block_def)
+
+    assert_equal block_def, Bar.error_handler_for(ArgumentError.new)
+  end
+
+
+  def test_handle_status
+    handlers = []
+    Foo.error{ handlers << :default }
+    Foo.all_errors{ handlers << :all }
+    Foo.error(404){ handlers << :s404 }
+
+    Foo.new.handle_status(404)
+    assert_equal [:s404], handlers
+  end
+
+
+  def test_handle_status_missing
+    assert_nil Foo.new.handle_status(404)
+  end
+
+
+  def test_handle_error
+    handlers = []
+    Foo.error{ handlers << :default }
+
+    err = ArgumentError.new
+    foo = Foo.new
+    foo.handle_error(err)
+
+    assert_equal [err], foo.env['gin.errors']
+    assert_equal [:default], handlers
+    assert_equal 500, foo.status
+  end
+
+
+  def test_all_errors_no_rescue_handler
+    handlers = []
+    Foo.all_errors{ handlers << :all }
+
+    err = ArgumentError.new
+    bar = Bar.new
+
+    assert_raises ArgumentError do
+      bar.handle_error err
+    end
+
+    assert_equal [err], bar.env['gin.errors']
+    assert_equal [:all], handlers
+    assert_equal 500, bar.status
+  end
+
+
+  def test_handle_error_all_errors
+    handlers = []
+    err = ArgumentError.new
+
+    Foo.error{|e| raise "Unexpected Error" unless err == e; handlers << :default }
+    Foo.all_errors{|e| raise "Unexpected Error" unless err == e; handlers << :all }
+
+    foo = Foo.new
+    foo.handle_error(err)
+
+    assert_equal [err], foo.env['gin.errors']
+    assert_equal [:default, :all], handlers
+    assert_equal 500, foo.status
+  end
+
+
+  def test_handle_error_with_status
+    Foo.error(Gin::NotFound){ "OOPS" }
+    foo = Foo.new
+
+    foo.status 200
+    foo.handle_error(Gin::NotFound.new)
+    assert_equal 404, foo.status
+
+    foo.status 302
+    foo.handle_error(Gin::NotFound.new)
+    assert_equal 404, foo.status
+  end
+
+
+  def test_handle_error_preset_status
+    Foo.error{ "OOPS" }
+    foo = Foo.new
+
+    foo.status(400)
+    foo.handle_error(ArgumentError.new)
+    assert_equal 400, foo.status
+
+    foo.status(302)
+    foo.handle_error(ArgumentError.new)
+    assert_equal 500, foo.status
+
+    foo.status(200)
+    foo.handle_error(ArgumentError.new)
+    assert_equal 500, foo.status
+  end
+
+
+  def test_handle_error_preset_status_with_status
+    Foo.error(Gin::NotFound){ "OOPS" }
+    foo = Foo.new
+    foo.status(400)
+    foo.handle_error(Gin::NotFound.new)
+
+    assert_equal 404, foo.status
+  end
+
+
+  def test_handle_error_missing
+    foo = Foo.new
+    err = ArgumentError.new
+
+    assert_raises ArgumentError do
+      foo.handle_error(err)
+    end
+
+    assert_equal [err], foo.env['gin.errors']
+    assert_equal 500, foo.status
+  end
+end

data/test/test_filterable.rb

@@ -0,0 +1,126 @@
+require 'test/test_helper'
+
+class FilterableTest < Test::Unit::TestCase
+
+  FILTER_CALLS = []
+
+  class AppCtrl
+    include Gin::Filterable
+
+    class << self
+      attr_accessor :is_logged_in
+    end
+
+    self.is_logged_in = true
+
+    filter :logged_in do
+      FILTER_CALLS << :logged_in
+      self.class.is_logged_in
+    end
+
+    filter :find_device do
+      FILTER_CALLS << :find_device
+      "iPhone"
+    end
+
+    filter :log_action do
+      FILTER_CALLS << :log_action
+      "foo"
+    end
+
+    filter :set_login_cookie do
+      FILTER_CALLS << :set_login_cookie
+      "COOKIES"
+    end
+
+    filter :other_filter do
+      FILTER_CALLS << :other_filter
+      "other_filter"
+    end
+
+    before_filter :logged_in
+    before_filter :find_device
+
+    after_filter :log_action
+    after_filter :set_login_cookie, :other_filter, :except => :foo
+
+
+    private
+
+    def __call_filters__ type, action #:nodoc:
+      filter(*__send__(:"#{type}_filters_for", action))
+    end
+  end
+
+
+  class SessionCtrl < AppCtrl
+    class << self
+      attr_accessor :is_custom_thing
+    end
+
+    self.is_logged_in = true
+    self.is_custom_thing = true
+
+    filter :custom_thing do
+      FILTER_CALLS << :custom_thing
+      self.class.is_custom_thing
+    end
+
+    before_filter :custom_thing
+
+    skip_before_filter :find_device
+    skip_before_filter :logged_in, :only => [:create, :new]
+    skip_after_filter :set_login_cookie, :except => [:logout]
+  end
+
+
+
+  def setup
+    FILTER_CALLS.clear
+    @app_ctrl = AppCtrl.new
+    @session_ctrl = SessionCtrl.new
+    SessionCtrl.is_logged_in = true
+    SessionCtrl.is_custom_thing = true
+  end
+
+
+  def test_filter_chain_inheritance
+    assert_equal [:logged_in, :find_device],
+      AppCtrl.before_filters[nil]
+
+    assert_equal [:logged_in, :custom_thing],
+      SessionCtrl.before_filters[nil]
+
+    assert_equal [:log_action, :set_login_cookie, :other_filter],
+      AppCtrl.after_filters[nil]
+
+    assert_equal [:log_action, :other_filter],
+      SessionCtrl.after_filters[nil]
+  end
+
+
+  def test_call_filters
+    @app_ctrl.send(:__call_filters__, :before, :action)
+    assert_equal [:logged_in, :find_device], FILTER_CALLS
+
+    FILTER_CALLS.clear
+    @session_ctrl.send(:__call_filters__, :before, :action)
+    assert_equal [:logged_in, :custom_thing], FILTER_CALLS
+  end
+
+
+  def test_call_filters_with_restrictions
+    @app_ctrl.send(:__call_filters__, :before, :create)
+    assert_equal [:logged_in, :find_device], FILTER_CALLS
+
+    FILTER_CALLS.clear
+    @session_ctrl.send(:__call_filters__, :before, :create)
+    assert_equal [:custom_thing], FILTER_CALLS
+  end
+
+
+  def test_filter_calls
+    @session_ctrl.filter :logged_in, :custom_thing, :other_filter
+    assert_equal [:logged_in, :custom_thing, :other_filter], FILTER_CALLS
+  end
+end

data/test/test_gin.rb

@@ -0,0 +1,59 @@
+require 'test/test_helper'
+
+class GinTest < Test::Unit::TestCase
+
+  def test_underscore
+    assert_equal "foo_bar", Gin.underscore("FooBar")
+    assert_equal "foo_bar", Gin.underscore("fooBar")
+    assert_equal "foo_bar", Gin.underscore("foo_Bar")
+    assert_equal "foo_http", Gin.underscore("fooHTTP")
+    assert_equal "foo_http_thing", Gin.underscore("fooHTTPThing")
+    assert_equal "foo/bar", Gin.underscore("Foo::Bar")
+    assert_equal "foo/http", Gin.underscore("Foo::HTTP")
+  end
+
+
+  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)
+  end
+
+
+  def test_build_query_non_hash
+    [[1,2,3], 1, 1.2, "str"].each do |obj|
+      assert_raises(ArgumentError, "#{obj.class} did not raise ArgumentError") do
+        Gin.build_query obj
+      end
+    end
+  end
+
+
+  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__)
+    assert_nil Gin.find_loadpath("FUUUUU")
+  end
+
+
+  def test_const_find
+    assert_equal Test::Unit, Gin.const_find("Test::Unit")
+    assert_equal Test::Unit, Gin.const_find("Unit", Test)
+    assert_raises(NameError){ Gin.const_find("Unit", Gin) }
+  end
+
+
+  def test_app_trace
+    trace = [
+      Gin::LIB_DIR + "/thing",
+      "/path/to/app/thing",
+      Gin::LIB_DIR + "/gin/app.rb:123:in `dispatch'",
+      Gem.path[0]  + "/foo",
+      "/stuff/to/ignore"
+    ]
+
+    assert_equal [Gin::LIB_DIR + "/thing", "/path/to/app/thing"],
+                  Gin.app_trace(trace)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+$: << "."
+$: << "lib"
+require "test/unit"
+require "gin"
+require "mocha/setup"

data/test/test_request.rb

@@ -0,0 +1,81 @@
+require 'test/test_helper'
+
+class RequestTest < Test::Unit::TestCase
+
+  def setup
+    @env = {
+      'HTTP_HOST' => 'example.com',
+      'rack.input' => '',
+      'QUERY_STRING' => 'id=456&foo=bar&bar=5&bool=true',
+      'gin.path_query_hash' => {'id' => 123},
+    }
+    @req = Gin::Request.new @env
+  end
+
+
+  def test_query_hash_as_param
+    assert_equal 123, @req.params['id']
+    assert_equal 'bar', @req.params['foo']
+    assert_equal 5, @req.params['bar']
+  end
+
+
+  def test_params_symbol_accessible
+    [:id, :foo, :bar].each do |key|
+      assert @req.params[key]
+    end
+  end
+
+
+  def test_forwarded
+    assert !@req.forwarded?
+    @env["HTTP_X_FORWARDED_HOST"] = "example.com"
+    assert @req.forwarded?
+  end
+
+
+  def test_ssl
+    assert !@req.ssl?
+
+    @env['HTTPS'] = 'on'
+    assert @req.ssl?
+  end
+
+
+  def test_safe
+    @env['REQUEST_METHOD'] = 'POST'
+    assert !@req.safe?, "Verb POST should NOT be safe"
+
+    %w{GET HEAD OPTIONS TRACE}.each do |verb|
+      @env['REQUEST_METHOD'] = verb
+      assert @req.safe?, "Verb #{verb} should be safe"
+    end
+  end
+
+
+  def test_idempotent
+    @env['REQUEST_METHOD'] = 'POST'
+    assert !@req.idempotent?, "Verb POST should NOT be idempotent"
+
+    %w{GET HEAD OPTIONS TRACE PUT DELETE}.each do |verb|
+      @env['REQUEST_METHOD'] = verb
+      assert @req.idempotent?, "Verb #{verb} should be idempotent"
+    end
+  end
+
+
+  def test_process_params
+    assert_equal true,  @req.send(:process_params, "true")
+    assert_equal false, @req.send(:process_params, "false")
+    assert_equal 1,     @req.send(:process_params, "1")
+    assert_equal 1.1,   @req.send(:process_params, "1.1")
+    assert_equal "not_true", @req.send(:process_params, "not_true")
+
+    ary = @req.send(:process_params, ["true", "1", "foo"])
+    assert_equal [true, 1, "foo"], ary
+
+    hash = @req.send(:process_params, {'key' => ["true", "1", "foo"]})
+    assert_equal [true, 1, "foo"], hash['key']
+    assert_equal hash['key'].object_id, hash[:key].object_id
+  end
+end