egalite 0.0.1

data/test/test_errorconsole.rb

@@ -0,0 +1,91 @@
+
+require 'rubygems'
+require 'sequel'
+require 'test/unit'
+require 'egalite'
+require 'helper'
+require 'auth/basic'
+require 'errorconsole'
+
+require 'rack/test'
+require 'setup'
+
+class T_ErrorConsole < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    Egalite::Handler.new
+  end
+  def setup
+    db = Sequel.sqlite
+    db.execute("
+CREATE TABLE logs (
+    id SERIAL PRIMARY KEY,
+    severity TEXT NOT NULL,
+    
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    checked_at TIMESTAMP,
+    ipaddress INET,
+    text TEXT,
+    url TEXT,
+    md5 TEXT
+);
+")
+    db[:logs] << {:id => 1, :severity=>'exception', :ipaddress=>'127.0.0.1', :text=>'hogehoge', :md5=>'1234', :url=>'/hoge'}
+    db[:logs] << {:id => 2, :severity=>'exception', :ipaddress=>'127.0.0.1', :text=>'hogehoge', :md5=>'1234', :url=>'/hoge'}
+    db[:logs] << {:id => 3, :created_at => Time.now + 60, :severity=>'exception', :ipaddress=>'127.0.0.1', :text=>'piyopiyo', :md5=>'5678', :url=>'/hoge'}
+    db[:logs] << {:id => 4, :severity=>'security', :ipaddress=>'127.0.0.1', :text=>'foobar', :md5=>'1111', :url=>'/hoge'}
+    
+    EgaliteErrorController.database=db
+    EgaliteErrorController.password='9999'
+  end
+  def test_latest
+    basic_authorize('admin','9999')
+    get "/egalite/error/latest/1"
+    assert_match %r|5678</a></td><td>1</td>|, last_response.body
+    assert_no_match %r|1234</a></td><td>2</td>|, last_response.body
+    assert_no_match %r|1111</a></td><td>1</td>|, last_response.body
+  end
+  def test_frequent
+    basic_authorize('admin','9999')
+    get "/egalite/error/frequent/1"
+    assert_match %r|1234</a></td><td>2</td>|, last_response.body
+    assert_no_match %r|1111</a></td><td>1</td>|, last_response.body
+    assert_no_match %r|5678</a></td><td>1</td>|, last_response.body
+  end
+  def test_security
+    basic_authorize('admin','9999')
+    get "/egalite/error/security"
+    assert_no_match %r|5678</a></td><td>1</td>|, last_response.body
+    assert_no_match %r|1234</a></td><td>2</td>|, last_response.body
+    assert_match %r|1111</a></td><td>1</td>|, last_response.body
+  end
+  def test_group
+    basic_authorize('admin','9999')
+    get "/egalite/error/group/1234"
+    assert_match %r|<li>/hoge</li>\n*<li>hogehoge</li>|, last_response.body
+  end
+  def test_detail
+    basic_authorize('admin','9999')
+    get "/egalite/error/detail/1"
+    assert_not_equal "no record found.", last_response.body
+    assert_match %r|<li>127.0.0.1</li>\n*<li>/hoge</li>\n*<li>hogehoge</li>|, last_response.body
+    
+    get "/egalite/error/detail/100"
+    assert_equal "no record found.", last_response.body
+  end
+  def test_delete
+    basic_authorize('admin','9999')
+    get "/egalite/error/latest"
+    assert_match %r|5678</a></td><td>1</td>|, last_response.body
+    assert_match %r|1234</a></td><td>2</td>|, last_response.body
+
+    get "/egalite/error/delete/1234"
+    assert last_response.redirect?
+    assert_equal "/egalite/error", last_response.headers['location']
+    
+    get "/egalite/error/latest"
+    assert_match %r|5678</a></td><td>1</td>|, last_response.body
+    assert_no_match %r|1234</a></td><td>2</td>|, last_response.body
+  end
+end

data/test/test_handler.rb

@@ -0,0 +1,155 @@
+$LOAD_PATH << File.dirname(__FILE__)
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..')
+
+require 'rubygems'
+require 'test/unit'
+require 'egalite'
+
+require 'rack'
+require 'rack/multipart'
+require 'rack/test'
+
+require 'setup'
+
+class TestController < Egalite::Controller
+  def parameters
+    raise "param foo is not bar: #{params[:foo].inspect}" unless params[:foo] == 'bar'
+    raise "param hash isnt okay: #{params[:hash].inspect}" unless params[:hash][:a] == '1' and params[:hash][:b] == '2'
+    "okay"
+  end
+  def exception
+    raise
+  end
+  def notfoundtest
+    notfound
+  end
+  def delegatetest
+    delegate(:action => :test)
+  end
+  def test
+    "delegated"
+  end
+  def niltest
+    nil
+  end
+  def ipaddr
+    req.ipaddr.to_s
+  end
+  def accesslog
+    @log_values = [1,2,3]
+    "accesslog"
+  end
+  private
+  def priv
+    "private!"
+  end
+end
+class BeforefilterController < TestController
+  def before_filter
+    case params[:test]
+      when /notfound/: notfound
+      when /delegate/: delegate(:controller => :test,:action => :test)
+      when /forbidden/: false
+      else redirect(:action => :test)
+    end
+  end
+end
+
+
+class T_Handler < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    Egalite::Handler.new
+  end
+  def test_exception
+    $raise_exception = false
+    get "/test/exception"
+    assert last_response.server_error?
+    assert last_response.body =~ /Exception/
+  ensure
+    $raise_exception = true
+  end
+  def test_private
+    get "/priv"
+    assert_no_match /private!/, last_response.body
+  end
+  def test_parameters
+    post("/test/parameters", {'foo' => 'bar', 'hash[a]' => '1', 'hash[b]' => '2'})
+    assert last_response.ok?
+    assert last_response.body =~ /okay/
+    assert last_response.content_type =~ /text\/html/i
+  end
+  def test_notfound
+    get "/test/notfoundtest"
+    assert last_response.not_found?
+  end
+  def test_delegate
+    get "/test/delegatetest"
+    assert last_response.ok?
+    assert last_response.body =~ /delegated/
+  end
+  def test_nil
+    $raise_exception = false
+    get "/test/niltest"
+    assert last_response.server_error?
+    assert last_response.body =~ /Exception/
+    assert last_response.body =~ /nil/
+  ensure
+    $raise_exception = true
+  end
+  def test_beforefilter
+    get "/beforefilter/niltest"
+    assert last_response.redirect?
+    assert last_response.headers['location'] == "/beforefilter/test"
+    get "/beforefilter/niltest?test=delegate"
+    assert last_response.ok?
+    assert last_response.body =~ /delegated/
+    get "/beforefilter/niltest?test=notfound"
+    assert last_response.not_found?
+    get "/beforefilter/niltest?test=forbidden"
+    assert last_response.forbidden?
+  end
+  def test_ipaddr
+    get "/test/ipaddr"
+    assert last_response.ok?
+    assert last_response.body =~ /[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/
+  end
+  def test_accesslog
+    io = StringIO.new
+    Egalite::AccessLogger.io = io
+    get("http://localhost/test/accesslog",nil, {'HTTP_REFERER' => 'http://yahoo.com'})
+    assert last_response.ok?
+    
+    io.rewind
+    s = io.read
+    a = s.chomp.split(/\t/)
+    assert_match /\A[0-9-]+T[0-9:]+\+[0-9:]+\z/, a[0]
+    assert_equal "127.0.0.1", a[1]
+    assert_match /\A[0-9]+\.[0-9]+\z/, a[2]
+    assert_equal "http://localhost/test/accesslog", a[3]
+    assert_equal "http://yahoo.com", a[4]
+    assert_equal "1", a[5]
+    assert_equal "2", a[6]
+    assert_equal "3", a[7]
+  end
+end
+
+class T_StaticController < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    Egalite::Handler.new(:static_root=>'test/static/')
+  end
+  def test_default_controller
+    get "/static/foo"
+    assert last_response.ok? == false
+    assert last_response.not_found?
+    get "/static/../../hoge/hoge/"
+    assert last_response.ok? == false
+    assert last_response.forbidden?
+    get "/static/test.txt"
+    assert last_response.ok?
+    assert last_response.body =~ /piyo/
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,296 @@
+$LOAD_PATH << File.dirname(__FILE__)
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..')
+
+require 'rubygems'
+require 'test/unit'
+require 'egalite'
+require 'rexml/xpath'
+require 'rexml/document'
+
+module XPathTestingHelper
+
+  def to_doc(text)
+    REXML::Document.new(StringIO.new(text))
+  end
+
+  def assert_xpath_match_count(exp, n, doc)
+    assert_equal(n, REXML::XPath::match(doc, exp).size)
+  end
+
+  def X(doc, exp)
+    doc = to_doc(doc) unless doc.kind_of?(REXML::Document)
+    REXML::XPath::match(doc, exp)
+  end
+
+  def X1(doc, exp)
+    doc = to_doc(doc) unless doc.kind_of?(REXML::Document)
+    REXML::XPath::first(doc, exp)
+  end
+
+end
+
+class T_TableHelper < Test::Unit::TestCase
+  include Egalite
+  include XPathTestingHelper
+
+  def make_hash_content(n=1)
+    [{
+      :foo => "Foo",
+      :bar => "Bar",
+      :baz => "Baz",
+      :ika => "Ika",
+    }]*n
+  end
+
+  def make_array_content(n=1)
+    [["Foo", "Bar", "Baz"]]*n
+  end
+
+  def make_header
+    ["header1", "header2", "header3"]
+  end
+
+  def test_table_by_hash_hello
+    table = to_doc(TableHelper.table_by_hash([:foo, :bar, :baz], 
+                                             make_header,
+                                             make_hash_content))
+    assert_xpath_match_count("/table", 1, table) 
+    assert_xpath_match_count("/table/tr", 2, table) 
+    assert_xpath_match_count("/table/tr/th", 3, table) 
+    assert_xpath_match_count("/table/tr/td", 3, table) 
+  end
+
+  def test_table_by_hash_table_opts_should_appear_as_attribute
+    table = to_doc(TableHelper.table_by_hash([], [], [],
+                                             {"foo_attr"=>"foo_value"}))
+    t = X1(table, "/table")
+    assert_equal("foo_value", t.attributes["foo_attr"])
+  end
+
+  def test_table_by_hash_should_raise_if_header_content_mismatch
+    assert_raise(ArgumentError) do
+      TableHelper.table_by_hash([:foo, :bar], 
+                                make_header,
+                                make_hash_content)
+    end
+  end
+
+  def test_table_by_hash_should_handle_multiple_rows
+    count = 3
+    table = to_doc(TableHelper.table_by_hash([:foo, :bar, :baz], 
+                                             make_header,
+                                             make_hash_content(count)))
+    assert_xpath_match_count("/table/tr", 1 + count, table) # + 1 for header <tr>
+  end
+
+  def test_table_by_hash_should_show_empty_cell_for_nonexist_key
+    table = to_doc(TableHelper.table_by_hash([:foo, :bar, :notexist], 
+                                             make_header,
+                                             make_hash_content))
+    assert_nil(REXML::XPath::match(table, "/table/tr/td").map{ |i| i.text }[2])
+  end
+
+  def test_table_by_array_hello
+    table = to_doc(TableHelper.table_by_array(make_header,
+                                              make_array_content))
+    assert_xpath_match_count("/table/tr", 2, table) 
+    assert_xpath_match_count("/table/tr/th", 3, table) 
+    assert_xpath_match_count("/table/tr/td", 3, table) 
+
+    assert_equal(2, X(table, "/table/tr").size)
+    assert_equal(3, X(table, "/table/tr/th").size)
+    assert_equal(3, X(table, "/table/tr/td").size)
+  end
+
+end
+
+class T_FormHelper < Test::Unit::TestCase
+  include Egalite
+  include XPathTestingHelper
+
+  def test_should_instantiatable
+    FormHelper.new({})
+  end
+
+  def test_form_hello
+    action = "/action"
+    f = FormHelper.new({:foo => "Foo"})
+    i = X(f.form(:GET, action) + f.close, "/form")
+    assert_equal(i.size, 1)
+    assert_equal("GET", i[0].attributes["method"])
+    assert_equal(action, i[0].attributes["action"])
+  end
+
+  def test_form_should_allow_nil_action
+    f = FormHelper.new({:foo => "Foo"})
+    i = X1(f.form(:GET) + f.close, "/form")
+    assert_equal(nil, i.attributes["action"])
+  end
+
+  def test_text_should_result_text_input
+    f = FormHelper.new({:foo => "Foo"})
+    i = X1(f.text(:foo), "/input")
+    assert_equal("Foo", i.attributes["value"])
+    assert_equal("text", i.attributes["type"])
+    assert_equal("foo", i.attributes["name"])
+  end
+
+  def test_text_should_use_default_if_no_data
+    f = FormHelper.new({:foo => "Foo"})
+    i = X1(f.text(:bar, {:default => "Default"}), "/input")
+    assert_equal("Default", i.attributes["value"])
+    assert_equal("text",i.attributes["type"])
+    assert_equal("bar", i.attributes["name"])
+  end
+
+  def test_text_timestamp_should_be_ok
+    input    = "2009/01/02 12:30:45"
+    expected = "2009-01-02 12:30:45"
+    f = FormHelper.new({:foo => Time.parse(input)})
+    i = X1(f.timestamp_text(:foo), "/input")
+    assert_equal(expected, i.attributes["value"])
+    assert_equal("text", i.attributes["type"])
+    assert_equal("foo", i.attributes["name"])
+  end
+
+  def test_hidden_should_be_ok
+    f = FormHelper.new({:foo => "Foo"})
+    i = X1(f.hidden(:foo), "/input")
+    assert_equal("Foo", i.attributes["value"])
+    assert_equal("hidden", i.attributes["type"])
+    assert_equal("foo", i.attributes["name"])
+  end
+
+  def test_password_should_be_ok
+    f = FormHelper.new({:foo => "Foo"})
+    i = X1(f.password(:foo), "/input")
+    assert_equal("Foo", i.attributes["value"])
+    assert_equal("password", i.attributes["type"])
+    assert_equal("foo", i.attributes["name"])
+  end
+
+  def test_checkbox_should_be_checked_if_data_given
+    f = FormHelper.new({:foo => "OK"})
+    i = X1(f.checkbox(:foo, "Bar", :nohidden => true), "/input")
+    assert_equal("Bar", i.attributes["value"])
+    assert_equal("checked", i.attributes["checked"])
+    assert_equal("foo", i.attributes["name"])
+    assert_equal("checkbox", i.attributes["type"])
+  end
+
+  def test_checkbox_should_NOT_be_checked_unless_something_given
+    f = FormHelper.new({:foo => "OK"})
+    i = X1(f.checkbox(:bar, "Bar", :nohidden => true), "/input")
+    assert_equal(nil, i.attributes["checked"])
+  end
+
+  def _test_checkbox_should_be_checked_if_opt_default_given(option_name)
+    f = FormHelper.new({})
+    i = X1(f.checkbox(:foo, "Bar", {option_name => 'OK', :nohidden => true}), "/input")
+    assert_equal("checked", i.attributes["checked"])
+    assert_equal("foo", i.attributes["name"])
+  end
+
+  def test_checkbox_should_be_checked_if_opt_default_given
+    _test_checkbox_should_be_checked_if_opt_default_given(:default)
+  end
+
+  def test_checkbox_should_be_checked_if_opt_checked_given
+    _test_checkbox_should_be_checked_if_opt_default_given(:checked)
+  end
+
+  def test_radio_should_be_ok
+    f = FormHelper.new({:foo => "Foo"})
+    i = X1(f.radio(:foo, "Foo"), "/input")
+    assert_equal("Foo", i.attributes["value"])
+    assert_equal("radio", i.attributes["type"])
+    assert_equal("foo", i.attributes["name"])
+    assert_equal("selected", i.attributes["selected"])
+  end
+
+  def test_radio_should_not_be_checked_if_choice_mismatch
+    f = FormHelper.new({:bar => "Foo"})
+    i = X1(f.radio(:foo, "Foo"), "/input")
+    assert_equal("Foo", i.attributes["value"])
+    assert_equal(nil, i.attributes["selected"])
+  end
+
+  def test_textarea_should_be_ok
+    f = FormHelper.new({:foo => "Foo"})
+    t = X(f.textarea(:foo), "/textarea")
+    assert_equal(1, t.size)
+    assert_equal("Foo", t[0].text)
+  end
+
+  def test_file_should_be_ok
+    f = FormHelper.new({:foo => "Foo"})
+    i = X1(f.file(:foo), "/input")
+    assert_equal("file", i.attributes["type"])
+    assert_equal("foo", i.attributes["name"])
+  end
+
+  def test_submit_should_be_ok
+    f = FormHelper.new()
+    i = X1(f.submit("foovalue", "fooname"), "/input")
+    assert_equal("foovalue", i.attributes["value"])
+    assert_equal("submit", i.attributes["type"])
+    assert_equal("fooname", i.attributes["name"])
+  end
+
+  def make_select_options
+    [{:optname => "optvalue0", :id=> "id0"},
+     {:optname => "optvalue1", :id=> "id1"}]
+  end
+
+  def test_select_by_association_hello
+    f = FormHelper.new()
+    d = to_doc(f.select_by_association("Name", make_select_options, :optname))
+    assert_equal(1, X(d, "/select").size)
+    assert_equal(2, X(d, "/select/option").size)
+    o0 = X(d, "/select/option")[0]
+    assert_equal("optvalue0", o0.text)
+    assert_equal("id0", o0.attributes["value"])
+  end
+
+  def test_select_by_association_should_add_option_if_nil_opt
+    options = make_select_options
+    niltext = "NILTEXT"
+    f = FormHelper.new()
+    d = to_doc(f.select_by_association("Name", options, :optname, {:nil => niltext}))
+    assert_equal(1, X(d, "/select").size)
+    assert_equal(options.size + 1, X(d, "/select/option").size)
+    last = X1(d, "/select/option")
+    assert_equal("", last.attributes["value"])
+    assert_equal(niltext, last.text)
+  end
+
+  def make_opt_div(opts)
+    f = FormHelper.new()
+    "<div #{f.opt(opts)} />"
+  end
+
+  def test_opt_hello
+    d = X1(to_doc(make_opt_div({:foo => "Foo", :bar => "Bar"})), "/div")
+    assert_equal("Foo", d.attributes["foo"])
+    assert_equal("Bar", d.attributes["bar"])
+  end
+
+  def _test_opt_should_skip_special_keys(key)
+    opts = {:foo => "Foo"}
+    opts[key] = "Val"
+    d = X1(to_doc(make_opt_div(opts)), "/div")
+    assert_equal("Foo", d.attributes["foo"])
+    assert_equal(nil, d.attributes[key.to_s])
+  end    
+
+  def test_opt_should_skip_special_keys
+    _test_opt_should_skip_special_keys(:default)
+    _test_opt_should_skip_special_keys(:checked)
+    _test_opt_should_skip_special_keys(:selected)
+    _test_opt_should_skip_special_keys(:nil)
+  end
+
+end
+
+# XXX: test form
+# XXX: test expand_name

data/test/test_keitai.rb

@@ -0,0 +1,107 @@
+#!ruby -Ku
+
+$KCODE = 'UTF8'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..')
+$LOAD_PATH << File.join(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'test/unit'
+require 'egalite'
+require 'keitai/keitai'
+
+require 'rack'
+require 'rack/multipart'
+require 'rack/test'
+
+require 'kconv'
+
+require 'setup'
+
+class KeitaiController < Egalite::Keitai::Controller
+  def post(id)
+    return "false" unless params[:foo][:bar] == "あいうえお" # utf8
+    "foobar:#{params[:foo][:bar]}"
+  end
+  def login(id)
+    session.create(:user_id => id)
+    redirect_to :controller => :mobile
+  end
+end
+class MobileController < Egalite::Keitai::Controller
+  def before_filter
+    super
+
+    return redirect_to :controller => :keitai, :action => :login unless session[:user_id].to_i > 0
+    true
+  end
+  def get
+    {}
+  end
+  def get_userid
+    session[:user_id].to_s
+  end
+end
+
+class RedirectorController < Egalite::Keitai::Redirector
+end
+
+class T_Keitai < Test::Unit::TestCase
+  include Rack::Test::Methods
+  
+  def app
+    db = Sequel.sqlite
+    Egalite::SessionSequel.create_table(db)
+    db.alter_table :sessions do
+      add_column :user_id, :integer
+    end
+
+    Rack::Builder.new {
+      use Rack::Ketai
+      run Egalite::Handler.new(
+        :db => db,
+        :session_handler => Egalite::SessionSequel,
+        :template_path => File.dirname(__FILE__)
+      )
+    }
+  end
+    
+  def test_ctler_should_see_utf8_for_sjis_query_parameter
+    s = "あいうえお".tosjis
+    post("/keitai", {"foo[bar]" => s}, {'HTTP_USER_AGENT' => 'DoCoMo/2.0 P903i'})
+    assert last_response.ok?
+    assert_equal("foobar:#{s}", last_response.body)
+  end
+  def test_session
+    get("/keitai/login/1234")
+    assert last_response.redirect?
+    assert_match(%r|/mobile\?sessionid=[0-9]+_[0-9a-f]+|,last_response.location)
+    location = last_response.location
+    
+    clear_cookies
+    
+    get(location)
+    assert last_response.ok?
+    assert_match(%r|<a\s+href='mailto:arai\@example\.com'\s*>mail</a>|,last_response.body)
+    assert_match(%r|<a\s+href='tel:03-1234-5678'\s*>tel</a>|,last_response.body)
+    assert_match(%r|<a\s+href='(/mobile/get_userid\?sessionid=[0-9]+_[0-9a-f]+)'\s*>hoge</a>|,last_response.body)
+    %r|<a\s+href='(/mobile/get_userid\?sessionid=[0-9]+_[0-9a-f]+)'\s*>hoge</a>| =~ last_response.body
+    get_userid = $1
+    assert_match(%r|<a\s+href='(/redirector/[0-9a-zA-Z._-]+)'\s*>yahoo</a>|,last_response.body)
+    %r|<a\s+href='(/redirector/[0-9a-zA-Z._-]+)'\s*>yahoo</a>| =~ last_response.body
+    redirector = $1
+ 	assert_match(%r|<input.+?value='[0-9]+_[0-9a-f]+'.+?>|, last_response.body)
+ 	
+    clear_cookies
+    
+ 	get(get_userid)
+    assert last_response.ok?
+    assert_equal("1234", last_response.body)
+
+    clear_cookies
+
+    get(redirector)
+    assert last_response.ok?
+    assert_match(%r|http://www.yahoo.com|, last_response.body)
+  end
+end