RubyGems - runo - Versions diffs - 0.1.0 - Mend

runo 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (149) hide show

data/LICENSE +19 -0
data/README.rdoc +120 -0
data/bin/runo +35 -0
data/lib/_error.rb +14 -0
data/lib/_field.rb +260 -0
data/lib/_i18n.rb +141 -0
data/lib/_parser.rb +243 -0
data/lib/_path.rb +86 -0
data/lib/_storage/_storage.rb +213 -0
data/lib/_storage/file.rb +200 -0
data/lib/_storage/sequel.rb +174 -0
data/lib/_storage/temp.rb +73 -0
data/lib/_widget/action_create.rb +23 -0
data/lib/_widget/action_login.rb +22 -0
data/lib/_widget/action_signup.rb +16 -0
data/lib/_widget/action_update.rb +16 -0
data/lib/_widget/crumb.rb +24 -0
data/lib/_widget/done.rb +16 -0
data/lib/_widget/login.rb +25 -0
data/lib/_widget/me.rb +31 -0
data/lib/_widget/message.rb +51 -0
data/lib/_widget/navi.rb +88 -0
data/lib/_widget/submit.rb +49 -0
data/lib/_widget/view_ym.rb +77 -0
data/lib/_workflow/_workflow.rb +89 -0
data/lib/_workflow/attachment.rb +50 -0
data/lib/_workflow/blog.rb +28 -0
data/lib/_workflow/contact.rb +23 -0
data/lib/_workflow/forum.rb +26 -0
data/lib/_workflow/register.rb +39 -0
data/lib/meta/_meta.rb +20 -0
data/lib/meta/group.rb +19 -0
data/lib/meta/id.rb +59 -0
data/lib/meta/owner.rb +21 -0
data/lib/meta/timestamp.rb +118 -0
data/lib/runo.rb +396 -0
data/lib/scalar/checkbox.rb +68 -0
data/lib/scalar/file.rb +144 -0
data/lib/scalar/img.rb +112 -0
data/lib/scalar/password.rb +58 -0
data/lib/scalar/radio.rb +47 -0
data/lib/scalar/select.rb +47 -0
data/lib/scalar/text.rb +38 -0
data/lib/scalar/textarea.rb +35 -0
data/lib/scalar/textarea_pre.rb +14 -0
data/lib/scalar/textarea_wiki.rb +173 -0
data/lib/set/_set.rb +195 -0
data/lib/set/dynamic.rb +177 -0
data/lib/set/static.rb +102 -0
data/lib/set/static_folder.rb +96 -0
data/locale/en/index.po +242 -0
data/locale/index.pot +243 -0
data/locale/ja/index.po +242 -0
data/locale/lazy_parser.rb +54 -0
data/skel/config.ru +27 -0
data/skel/skin/_users/00000000_frank-avatar.jpg +0 -0
data/skel/skin/_users/00000000_frank-avatar_small.jpg +0 -0
data/skel/skin/_users/00000000_frank.yaml +12 -0
data/skel/skin/_users/00000000_root-avatar.jpg +0 -0
data/skel/skin/_users/00000000_root-avatar_small.jpg +0 -0
data/skel/skin/_users/00000000_root.yaml +11 -0
data/skel/skin/_users/css/users.css +21 -0
data/skel/skin/_users/css/users.less +25 -0
data/skel/skin/_users/done.html +42 -0
data/skel/skin/_users/index.html +46 -0
data/skel/skin/_users/index.yaml +3 -0
data/skel/skin/_users/summary.html +40 -0
data/skel/skin/css/base.css +93 -0
data/skel/skin/css/base.less +139 -0
data/skel/skin/css/coax.css +199 -0
data/skel/skin/css/coax.less +244 -0
data/skel/skin/examples/blog/20091214_0001.yaml +8 -0
data/skel/skin/examples/blog/20100630_0001.yaml +8 -0
data/skel/skin/examples/blog/20100630_0002.yaml +14 -0
data/skel/skin/examples/blog/20100701_0001.yaml +8 -0
data/skel/skin/examples/blog/20100701_0002-a-20100701_0001-f.jpg +0 -0
data/skel/skin/examples/blog/20100701_0002-a-20100701_0001-f_small.jpg +0 -0
data/skel/skin/examples/blog/20100701_0002.yaml +19 -0
data/skel/skin/examples/blog/frank/20100701_0001.yaml +10 -0
data/skel/skin/examples/blog/frank/index.yaml +4 -0
data/skel/skin/examples/blog/index.html +51 -0
data/skel/skin/examples/blog/rss.xml +18 -0
data/skel/skin/examples/contact/20100701_0001-file.txt +1 -0
data/skel/skin/examples/contact/20100701_0001.yaml +15 -0
data/skel/skin/examples/contact/20100701_0002.yaml +8 -0
data/skel/skin/examples/contact/20100701_0003.yaml +9 -0
data/skel/skin/examples/contact/index.html +47 -0
data/skel/skin/examples/contact/js/contact.js +13 -0
data/skel/skin/examples/contact/summary.html +54 -0
data/skel/skin/examples/forum/20100701_0001.yaml +41 -0
data/skel/skin/examples/forum/20100701_0002.yaml +25 -0
data/skel/skin/examples/forum/index.html +68 -0
data/skel/skin/examples/forum/summary.html +47 -0
data/skel/skin/examples/index.html +75 -0
data/skel/skin/index.html +41 -0
data/skel/skin/js/base.js +50 -0
data/t/locale/de/index.po +19 -0
data/t/locale/en-GB/index.po +25 -0
data/t/locale/ja/index.po +30 -0
data/t/skin/_users/00000000_test.yaml +3 -0
data/t/skin/_users/index.html +13 -0
data/t/skin/foo/20091120_0001.yaml +7 -0
data/t/skin/foo/bar/20091120_0001.yaml +5 -0
data/t/skin/foo/bar/index.yaml +5 -0
data/t/skin/foo/baz/css/baz.css +1 -0
data/t/skin/foo/css/foo.css +1 -0
data/t/skin/foo/index.html +14 -0
data/t/skin/foo/index.yaml +7 -0
data/t/skin/foo/not_css/foo.css +1 -0
data/t/skin/foo/sub-20100306_0001.yaml +3 -0
data/t/skin/index.yaml +3 -0
data/t/skin/t_attachment/index.html +13 -0
data/t/skin/t_contact/done.html +6 -0
data/t/skin/t_contact/index.html +9 -0
data/t/skin/t_file/index.html +16 -0
data/t/skin/t_img/index.html +14 -0
data/t/skin/t_img/test.jpg +0 -0
data/t/skin/t_select/index.html +9 -0
data/t/skin/t_store/index.html +9 -0
data/t/skin/t_summary/20100326_0001.yaml +3 -0
data/t/skin/t_summary/create.html +9 -0
data/t/skin/t_summary/index.html +9 -0
data/t/skin/t_summary/summary.html +9 -0
data/t/t.rb +27 -0
data/t/test_checkbox.rb +273 -0
data/t/test_field.rb +330 -0
data/t/test_file.rb +900 -0
data/t/test_id.rb +215 -0
data/t/test_img.rb +328 -0
data/t/test_meta.rb +57 -0
data/t/test_parser.rb +1266 -0
data/t/test_password.rb +188 -0
data/t/test_radio.rb +226 -0
data/t/test_role.rb +249 -0
data/t/test_runo.rb +742 -0
data/t/test_runo_call.rb +1286 -0
data/t/test_runo_i18n.rb +318 -0
data/t/test_select.rb +182 -0
data/t/test_set_complex.rb +527 -0
data/t/test_set_dynamic.rb +1504 -0
data/t/test_set_folder.rb +515 -0
data/t/test_set_permit.rb +246 -0
data/t/test_set_static.rb +445 -0
data/t/test_storage.rb +915 -0
data/t/test_text.rb +125 -0
data/t/test_textarea.rb +138 -0
data/t/test_timestamp.rb +473 -0
data/t/test_workflow.rb +367 -0
metadata +345 -0

data/t/test_runo_call.rb ADDED

@@ -0,0 +1,1286 @@
+# encoding: UTF-8
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+require "#{::File.dirname __FILE__}/t"
+class TC_Runo_Call < Test::Unit::TestCase
+  def setup
+    @runo = Runo.new
+  end
+  def teardown
+  end
+  def test_get
+    Runo.client = nil
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/'
+    )
+    assert_match(
+      /<html/,
+      res.body,
+      'Runo#call() should return the folder.get if the base field is a SD'
+    )
+  end
+  def test_get_non_exist
+    Runo.client = nil
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/non/exist/'
+    )
+    assert_equal(
+      404,
+      res.status,
+      'Runo#call() should return 404 if the given path is non-existent'
+    )
+  end
+  def test_get_partial
+    Runo.client = nil
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/20091120_0001/name/'
+    )
+    assert_equal(
+      'FZ',
+      res.body,
+      'Runo#call() should return the base.get unless the base field is a SD'
+    )
+  end
+  def test_get_sub
+    Runo.client = nil
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/'
+    )
+    assert_match(
+      %r{<li><a>qux</a></li>},
+      res.body,
+      "Runo#call() should return sets other than 'main' as well"
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/sub/d=2010/'
+    )
+    assert_match(
+      %r{<li><a>qux</a></li>},
+      res.body,
+      "Runo#call() should pass args for a sd other than 'main' as well"
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/sub/d=2009/'
+    )
+    assert_no_match(
+      %r{<li><a>qux</a></li>},
+      res.body,
+      "Runo#call() should pass args for a sd other than 'main' as well"
+    )
+  end
+  def test_get_contact
+    Runo.client = nil
+    Runo::Set::Static::Folder.root.item('t_contact', 'main').storage.clear
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/1234567890.0123/t_contact/'
+    )
+    assert_equal(
+      200,
+      res.status,
+      'Runo#call to contact by nobody should return status 200'
+    )
+    assert_equal(
+      <<_html,
+<html>
+  <head><base href="http:///t_contact/" /><title></title></head>
+  <body>
+    <h1></h1>
+<form id="form_main" method="post" enctype="multipart/form-data" action="/t_contact/1234567890.0123/update.html">
+<input name="_token" type="hidden" value="#{Runo.token}" />
+    <ul id="main" class="runo-contact">
+      <li><a><span class="text"><input type="text" name="_001-name" value="foo" size="32" /></span></a>: <span class="text"><input type="text" name="_001-comment" value="bar!" size="64" /></span></li>
+    </ul>
+<div class="submit">
+  <input name=".status-public" type="submit" value="create" />
+</div>
+</form>
+  </body>
+</html>
+_html
+      res.body,
+      'Runo#call to contact by nobody should return :create'
+    )
+  end
+  def test_get_contact_forbidden
+    Runo.client = nil
+    Runo::Set::Static::Folder.root.item('t_contact', 'main').storage.build(
+      '20100425_1234' => {'name' => 'cz', 'comment' => 'howdy.'}
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/t_contact/20100425/1234/index.html'
+    )
+    assert_no_match(
+      /howdy/,
+      res.body,
+      'getting an contact by nobody should not return any contents'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/t_contact/20100425_1234/'
+    )
+    assert_no_match(
+      /howdy/,
+      res.body,
+      'peeking an contact by nobody should not return any contents'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/t_contact/20100425_1234/comment/'
+    )
+    assert_no_match(
+      /howdy/,
+      res.body,
+      'peeking an contact by nobody should not return any contents'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/t_contact/20100425/1234/done.html'
+    )
+    assert_no_match(
+      /howdy/,
+      res.body,
+      'getting an contact by nobody should not return any contents'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/t_contact/20100425_1234/done.html'
+    )
+    assert_no_match(
+      /howdy/,
+      res.body,
+      'peeking an contact by nobody should not return any contents'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/t_contact/20100425_1234/comment/done.html'
+    )
+    assert_no_match(
+      /howdy/,
+      res.body,
+      'peeking an contact by nobody should not return any contents'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/t_contact/20100425/1234/preview_create.html'
+    )
+    assert_no_match(
+      /howdy/,
+      res.body,
+      'getting an contact by nobody should not return any contents'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/t_contact/20100425_1234/preview_create.html'
+    )
+    assert_no_match(
+      /howdy/,
+      res.body,
+      'peeking an contact by nobody should not return any contents'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/t_contact/20100425_1234/comment/preview_create.html'
+    )
+    assert_no_match(
+      /howdy/,
+      res.body,
+      'peeking an contact by nobody should not return any contents'
+    )
+  end
+  def test_get_summary
+    Runo.client = nil
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/t_summary/p=1/'
+    )
+    assert_equal(
+      <<'_html',
+<html>
+<head><base href="http:///t_summary/" /><title>summary</title></head>
+<body>
+<h1>summary</h1>
+<table id="main" class="runo-blog">
+  <tr><td><a href="/t_summary/20100326/1/read_detail.html">frank</a></td><td>hi.</td></tr>
+</table>
+</body>
+</html>
+_html
+      res.body,
+      'Runo#call() should use [:tmpl][:summary] when available and appropriate'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/t_summary/p=1/read_detail.html'
+    )
+    assert_equal(
+      <<'_html',
+<html>
+<head><base href="http:///t_summary/" /><title>index</title></head>
+<body>
+<h1>index</h1>
+<ul id="main" class="runo-blog">
+  <li><a>frank</a>: hi.</li>
+</ul>
+</body>
+</html>
+_html
+      res.body,
+      'Runo#call() should use [:tmpl] when the action is :read -> :detail'
+    )
+    Runo.client = 'root'
+    res = Rack::MockRequest.new(@runo).get(
+      "http://example.com/t_summary/p=1/update.html"
+    )
+    tid = res.body[%r{/(#{Runo::REX::TID})/}, 1]
+    assert_equal(
+      <<"_html",
+<html>
+<head><base href="http:///t_summary/" /><title>index</title></head>
+<body>
+<h1>index</h1>
+<form id="form_main" method="post" enctype="multipart/form-data" action="/t_summary/#{tid}/update.html">
+<input name="_token" type="hidden" value="#{Runo.token}" />
+<ul id="main" class="runo-blog">
+  <li><a><span class="text"><input type="text" name="20100326_0001-name" value="frank" size="32" /></span></a>: <span class="text"><input type="text" name="20100326_0001-comment" value="hi." size="64" /></span></li>
+</ul>
+<div class="submit">
+  <input name=".status-public" type="submit" value="update" />
+  <input name=".action-preview_delete" type="submit" value="delete..." />
+</div>
+</form>
+</body>
+</html>
+_html
+      res.body,
+      'Runo#call() should use [:tmpl] unless the action is :read'
+    )
+  end
+  def test_get_static
+    Runo.client = 'root'
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/css/foo.css'
+    )
+    assert_equal(
+      200,
+      res.status,
+      'Runo#call should return a static file if the given path is under css/, js/, etc.'
+    )
+    assert_equal(
+      'text/css',
+      res.headers['Content-Type'],
+      'Runo#call should return a static file if the given path is under css/, js/, etc.'
+    )
+    assert_equal(
+      "#foo {bar: baz;}\n",
+      res.body,
+      'Runo#call should return a static file if the given path is under css/, js/, etc.'
+    )
+  end
+  def test_get_static_not_css
+    Runo.client = 'root'
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/not_css/foo.css'
+    )
+    assert_not_equal(
+      "#foo {bar: baz;}\n",
+      res.body,
+      'Runo#call should not return a static file if the step is not exactly css/, js/, etc.'
+    )
+  end
+  def test_get_static_non_exist
+    Runo.client = 'root'
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/css/non-exist.css'
+    )
+    assert_equal(
+      404,
+      res.status,
+      'Runo#call should return 404 if the static file is not found'
+    )
+  end
+  def test_get_static_ambiguous
+    Runo.client = 'root'
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/css/0123456789.1234/_001/img/bar.jpg'
+    )
+    assert_equal(
+      'Not Found', # from Runo#call
+      res.body,
+      'Runo#call should not look for a static file if the path includes a tid'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/css/20100613_1234/img/bar.jpg'
+    )
+    assert_equal(
+      'Not Found', # from Runo#call
+      res.body,
+      'Runo#call should not look for a static file if the path includes an id'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/css/0123456789.1234/20100613_1234/img/bar.jpg'
+    )
+    assert_equal(
+      'Not Found', # from Runo#call
+      res.body,
+      'Runo#call should not look for a static file if the path includes an id'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/css/20100613_1234/bar/id=img/'
+    )
+    assert_equal(
+      'Not Found', # from Runo#call
+      res.body,
+      'Runo#call should not look for a static file if the path includes an id'
+    )
+  end
+  def test_get_static_forbidden
+    Runo.client = 'root'
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/_users/00000000_test.yaml'
+    )
+    assert_no_match(
+      /^password/,
+      res.body,
+      'Runo#call should not return meta files nor raw data'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/_users/css/../00000000_test.yaml'
+    )
+    assert_no_match(
+      /password/,
+      res.body,
+      'Runo#call should not allow bad paths'
+    )
+  end
+  def test_get_static_cascade
+    Runo.client = 'root'
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/bar/css/foo.css'
+    )
+    assert_equal(
+      "#foo {bar: baz;}\n",
+      res.body,
+      'Runo#call should look the acnestor dirs for the static directory'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/bar/css/non_exist.css'
+    )
+    assert_equal(
+      404,
+      res.status,
+      'Runo#call should return 404 if the file is not found in the nearest static dir'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/baz/css/foo.css'
+    )
+    assert_equal(
+      404,
+      res.status,
+      'Runo#call should not look the ancestor dirs if the file is not found in the nearest dir'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      'http://example.com/foo/bar/js/non_exist.css'
+    )
+    assert_equal(
+      404,
+      res.status,
+      'Runo#call should return 404 if the static dir is not found in any ancestor dirs'
+    )
+  end
+  def test_post_simple_create
+    Runo.client = 'root'
+    Runo::Set::Static::Folder.root.item('t_store', 'main').storage.clear
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input => "_1-name=fz&_1-comment=hi.&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_equal(
+      303,
+      res.status,
+      'Runo#call with post method should return status 303'
+    )
+    assert_match(
+      Runo::REX::PATH_ID,
+      res.headers['Location'],
+      'Runo#call with post method should return a proper location'
+    )
+    res.headers['Location'] =~ Runo::REX::PATH_ID
+    new_id = sprintf('%.8d_%.4d', $1, $2)
+    val = Runo::Set::Static::Folder.root.item('t_store', 'main', new_id).val
+    assert_instance_of(
+      ::Hash,
+      val,
+      'Runo#call with post method should store the item in the storage'
+    )
+    val.delete '_timestamp'
+    assert_equal(
+      {'_owner' => 'root', 'name' => 'fz', 'comment' => 'hi.'},
+      val,
+      'Runo#call with post method should store the item in the storage'
+    )
+  end
+  def test_post_invalid_create
+    Runo.client = 'root'
+    Runo::Set::Static::Folder.root.item('t_store', 'main').storage.clear
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/t_store/main/update.html",
+      {
+        :input => "_1-name=tooooooooooooloooooooooooooooooooooooooooong&_1-comment=hi.&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    tid = res.body[%r{/(#{Runo::REX::TID})/}, 1]
+    assert_equal(
+      422,
+      res.status,
+      'Runo#post with an invalid new item should be an error'
+    )
+    assert_instance_of(
+      Runo::Set::Dynamic,
+      Runo.transaction[tid],
+      'the suspended SD should be kept in Runo.transaction'
+    )
+  end
+  def test_post_empty_create
+    Runo.client = 'root'
+    Runo::Set::Static::Folder.root.item('t_store', 'main').storage.clear
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input => "_1-name=&_1-comment=&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_equal(
+      422,
+      res.status,
+      'Runo#post with an empty new item should be an error'
+    )
+  end
+  def test_post_empty_update
+    Runo.client = 'root'
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input => "_1-name=don&_1-comment=brown.&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    res.headers['Location'] =~ Runo::REX::PATH_ID
+    new_id   = sprintf('%.8d_%.4d', $1, $2)
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input => "#{new_id}-name=don&.status-public=update&_token=#{Runo.token}"
+      }
+    )
+    assert_equal(
+      303,
+      res.status,
+      'Runo#post without any update on the item should not raise an error'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      res.headers['Location']
+    )
+    assert_no_match(
+      /message/,
+      res.body,
+      'Runo#post without any update on the item should not set any messages'
+    )
+  end
+  def test_post_back_and_forth
+    Runo.client = 'root'
+    # post from a form without status
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/1234567890.9999/update.html',
+      {
+        :input => "_1-comment=brown."
+      }
+    )
+    # back to the form, post again with status
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/1234567890.9999/update.html',
+      {
+        :input => "_1-name=don&_1-comment=brown.&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_equal(
+      303,
+      res.status,
+      'Runo#post twice from the same form should work if the previous post is without status'
+    )
+    # back to the form one more time, post again with status
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/1234567890.9999/update.html',
+      {
+        :input => "_1-name=roy&_1-comment=brown.&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_equal(
+      422,
+      res.status,
+      'Runo#post twice from the same form should not work if the previous post is with status'
+    )
+    assert_equal(
+      'transaction expired',
+      res.body,
+      'Runo#post twice from the same form should not work if the previous post is with status'
+    )
+  end
+  def test_post_with_invalid_token
+    Runo.client = 'root'
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input => "_1-name=fz&_1-comment=hi.&.status-public=create&_token=invalid"
+      }
+    )
+    assert_equal(
+      403,
+      res.status,
+      'Runo#call without a valid token should return status 403'
+    )
+    assert_equal(
+      'invalid token',
+      res.body,
+      'Runo#call without a valid token should return status 403'
+    )
+  end
+  def test_post_with_attachment
+    Runo.client = 'root'
+    Runo::Set::Static::Folder.root.item('t_attachment', 'main').storage.clear
+    # post an attachment
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_attachment/main/update.html',
+      {
+        :input => "_012-files-_1-file=wow.jpg&_012-files-_1.action-create=create&_token=#{Runo.token}"
+      }
+    )
+    assert_match(
+      'update.html',
+      res.headers['Location'],
+      'Runo#call without the root status should always return :update'
+    )
+    assert_equal(
+      {},
+      Runo::Set::Static::Folder.root.item('t_attachment', 'main').val,
+      'Runo#call without the root status should not update the persistent storage'
+    )
+    tid = res.headers['Location'][Runo::REX::TID]
+    assert_instance_of(
+      Runo::Set::Dynamic,
+      Runo.transaction[tid],
+      'the suspended SD should be kept in Runo.transaction'
+    )
+    # post the item
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/#{tid}/update.html",
+      {
+        :input => "_012-comment=hello.&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_no_match(
+      /update\.html/,
+      res.headers['Location'],
+      'Runo#call with the root status should commit the transaction'
+    )
+    assert_not_equal(
+      {},
+      Runo::Set::Static::Folder.root.item('t_attachment', 'main').val,
+      'Runo#call with the root status should update the persistent storage'
+    )
+    res.headers['Location'] =~ Runo::REX::PATH_ID
+    new_id   = sprintf('%.8d_%.4d', $1, $2)
+    new_item = Runo::Set::Static::Folder.root.item('t_attachment', 'main', new_id)
+    assert_not_equal(
+      {},
+      new_item.val,
+      'Runo#call with the root status should commit all the pending items'
+    )
+    assert_equal(
+      'hello.',
+      new_item.val['comment'],
+      'Runo#call with the root status should commit the root items'
+    )
+    assert_equal(
+      {'file' => 'wow.jpg'},
+      new_item.val['files'].values.first,
+      'Runo#call with the root status should commit the descendant items'
+    )
+    # post a reply
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/t_attachment/main/#{new_id}/replies/update.html",
+      {
+        :input => "_001-reply=wow.&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_equal(303, res.status)
+    assert_match(
+      %r{/#{Runo::REX::TID}/t_attachment/#{new_id}/replies/read_detail.html},
+      res.headers['Location'],
+      'Runo#call with a sub-app status should commit the root item'
+    )
+    assert_not_equal(
+      {},
+      Runo::Set::Static::Folder.root.item('t_attachment', 'main', new_id, 'replies').val,
+      'Runo#call with a sub-app status should update the persistent storage'
+    )
+  end
+  def test_post_only_attachment
+    Runo.client = 'root'
+    Runo::Set::Static::Folder.root.item('t_attachment', 'main').storage.clear
+    # post an item
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/t_attachment/main/update.html",
+      {
+        :input => "_012-comment=abc&.status-public=create"
+      }
+    )
+    res.headers['Location'] =~ Runo::REX::PATH_ID
+    new_id = sprintf('%.8d_%.4d', $1, $2)
+    # post an attachment
+    tid = '1234567890.1234'
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/#{tid}/t_attachment/update.html",
+      {
+        :input => "#{new_id}-files-_1-file=boo.jpg&#{new_id}-files-_1.action-create=create&_token=#{Runo.token}"
+      }
+    )
+    attachment_id = Runo.transaction[tid].item(new_id, 'files').val.keys.first
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/#{tid}/update.html",
+      {
+        :input => "#{new_id}-files-#{attachment_id}-file=boo.jpg&#{new_id}-files-_1-file=&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_not_nil(
+      Runo::Set::Static::Folder.root.item('t_attachment', 'main', new_id).val['files'],
+      'Runo#call should treat the post with only an attachement nicely'
+    )
+  end
+  def test_post_with_invalid_attachment
+    Runo.client = 'root'
+    Runo::Set::Static::Folder.root.item('t_attachment', 'main').storage.clear
+    # post an invalid empty attachment
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_attachment/main/update.html',
+      {
+        :input => "_012-files-_1-file=&_012-files-_1.action-create=create&_token=#{Runo.token}"
+      }
+    )
+    tid = res.headers['Location'][Runo::REX::TID]
+    # post the root item
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/#{tid}/update.html",
+      {
+        :input => "_012-comment=hello.&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_equal(
+      303,
+      res.status,
+      'Runo#call with the root status should ignore the invalid empty attachment'
+    )
+    assert_not_equal(
+      {},
+      Runo::Set::Static::Folder.root.item('t_attachment', 'main').val,
+      'Runo#call with the root status should ignore the invalid empty attachment'
+    )
+    # post an invalid non-empty attachment
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_attachment/main/update.html',
+      {
+        :input => "_012-files-_1-file=tooloooooooooooong&_012-files-_1.action-create=create&_token=#{Runo.token}"
+      }
+    )
+    tid = res.headers['Location'][Runo::REX::TID]
+    # post the root item
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/#{tid}/update.html",
+      {
+        :input => "_012-comment=hello.&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_equal(
+      422,
+      res.status,
+      'Runo#call with the root status should not ignore the invalid non-empty attachment'
+    )
+  end
+  def test_post_preview_update
+    Runo.client = 'root'
+    Runo::Set::Static::Folder.root.item('t_store', 'main').storage.clear
+    base_uri = ''
+    res = Rack::MockRequest.new(@runo).post(
+      "http://#{base_uri}/t_store/main/update.html",
+      {
+        :input => ".action-preview_update=submit&_1-name=fz&_1-comment=howdy.&.status-public=create"
+      }
+    )
+    tid = res.headers['Location'][Runo::REX::TID]
+    assert_equal(
+      303,
+      res.status,
+      'Runo#call with :preview action should return status 303 upon success'
+    )
+    assert_equal(
+      "http://#{base_uri}/#{tid}/id=_1/preview_update.html",
+      res.headers['Location'],
+      'Runo#call with :preview action should return a proper location'
+    )
+    assert_instance_of(
+      Runo::Set::Dynamic,
+      Runo.transaction[tid],
+      'the suspended SD should be kept in Runo.transaction'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      "http://#{base_uri}/#{tid}/id=_1/preview_update.html"
+    )
+    assert_equal(
+      <<"_html",
+<html>
+  <head><base href="http://#{base_uri}/t_store/" /><title></title></head>
+  <body>
+    <h1></h1>
+<ul class="message notice">
+  <li>please confirm.</li>
+</ul>
+<form id="form_main" method="post" enctype="multipart/form-data" action="/#{tid}/update.html">
+<input name="_token" type="hidden" value="#{Runo.token}" />
+    <ul id="main" class="runo-blog">
+      <li><a>fz</a>: howdy.<input type="hidden" name="_1.action" value="create" /></li>
+    </ul>
+<div class="submit">
+  <input name=".status-public" type="submit" value="create" />
+</div>
+</form>
+  </body>
+</html>
+_html
+      res.body,
+      'Runo#call with :preview action should set a proper transaction upon success'
+    )
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/#{tid}/update.html",
+      {
+        :input => "_1.action=create&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_equal(
+      303,
+      res.status,
+      'Runo#call with post method should return status 303'
+    )
+    assert_match(
+      Runo::REX::PATH_ID,
+      res.headers['Location'],
+      'Runo#call with post method should return a proper location'
+    )
+    res.headers['Location'] =~ Runo::REX::PATH_ID
+    new_id = sprintf('%.8d_%.4d', $1, $2)
+    val = Runo::Set::Static::Folder.root.item('t_store', 'main', new_id).val
+    assert_instance_of(
+      ::Hash,
+      val,
+      'Runo#call with post method should store the item in the storage'
+    )
+    val.delete '_timestamp'
+    assert_equal(
+      {'_owner' => 'root', 'name' => 'fz', 'comment' => 'howdy.'},
+      val,
+      'Runo#call with post method should store the item in the storage'
+    )
+  end
+  def test_post_preview_invalid
+    Runo.client = 'root'
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input => ".action-preview_update=submit&_1-name=verrrrrrrrrrrrrrrrrrrrrrrrrrrrrrylong&_1-comment=howdy.&.status-public=create"
+      }
+    )
+    assert_equal(
+      422,
+      res.status,
+      'Runo#call with :preview action & malformed input should return status 422'
+    )
+    assert_match(
+      /malformed input\./,
+      res.body,
+      'Runo#call with :preview action & malformed input should return :update'
+    )
+    tid = res.body[%r{/(#{Runo::REX::TID})/}, 1]
+    assert_instance_of(
+      Runo::Set::Dynamic,
+      Runo.transaction[tid],
+      'the suspended SD should be kept in Runo.transaction'
+    )
+  end
+  def test_post_contact
+    Runo.client = nil
+    Runo::Set::Static::Folder.root.item('t_contact', 'main').storage.clear
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_contact/main/update.html',
+      {
+        :input => "_1-name=fz&_1-comment=hi.&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_equal(
+      303,
+      res.status,
+      'Runo#call with post method should return status 303'
+    )
+    assert_no_match(
+      Runo::REX::PATH_ID,
+      res.headers['Location'],
+      'Runo#call should not tell the item location when the workflow is contact'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      res.headers['Location'],
+      {}
+    )
+    assert_match(
+      /thank you!/,
+      res.body,
+      'Runo#call should refer to (action).html if available'
+    )
+    assert_no_match(
+      /message/,
+      res.body,
+      'Runo#call should not include messages for action :done'
+    )
+    assert_no_match(
+      /login/,
+      res.body,
+      'Runo#call should always allow action :done'
+    )
+  end
+  def test_post_contact_forbidden
+    Runo.client = nil
+    Runo::Set::Static::Folder.root.item('t_contact', 'main').storage.build(
+      '20100425_1234' => {'_owner' => 'nobody', 'name' => 'cz', 'comment' => 'howdy.'}
+    )
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_contact/main/update.html',
+      {
+        :input => "20100425_1234-comment=modified&20100425_1234.action=create&.status-public=create"
+      }
+    )
+    assert_equal(
+      403,
+      res.status,
+      'Runo#call should not allow nobody to update an existing contact'
+    )
+    assert_equal(
+      {'20100425_1234' => {'_owner' => 'nobody', 'name' => 'cz', 'comment' => 'howdy.'}},
+      Runo::Set::Static::Folder.root.item('t_contact', 'main').storage.val,
+      'Runo#call should not allow nobody to update an existing contact'
+    )
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_contact/main/create.html',
+      {
+        :input => "20100425_1234-comment=modified&20100425_1234.action=create&.status-public=create"
+      }
+    )
+    assert_equal(
+      403,
+      res.status,
+      'Runo#call should not allow nobody to update an existing contact'
+    )
+    assert_equal(
+      {'20100425_1234' => {'_owner' => 'nobody', 'name' => 'cz', 'comment' => 'howdy.'}},
+      Runo::Set::Static::Folder.root.item('t_contact', 'main').storage.val,
+      'Runo#call should not allow nobody to update an existing contact'
+    )
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_contact/main/20100425_1234/create.html',
+      {
+        :input => "comment=modified&.action=create&.status-public=create"
+      }
+    )
+    assert_equal(
+      403,
+      res.status,
+      'Runo#call should not allow nobody to update an existing contact'
+    )
+    assert_equal(
+      {'20100425_1234' => {'_owner' => 'nobody', 'name' => 'cz', 'comment' => 'howdy.'}},
+      Runo::Set::Static::Folder.root.item('t_contact', 'main').storage.val,
+      'Runo#call should not allow nobody to update an existing contact'
+    )
+  end
+  def test_post_wrong_action
+    Runo.client = nil
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/read.html',
+      {
+        :input => "_1-name=fz&_1-comment=hi.&.status-public=create"
+      }
+    )
+    assert_equal(
+      403,
+      res.status,
+      'post with an action other than :update should be regarded as :update'
+    )
+    Runo.client = 'root'
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/read.html',
+      {
+        :input => "_1-name=fz&_1-comment=hi.&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_equal(
+      303,
+      res.status,
+      'post with an action other than :update should be regarded as :update'
+    )
+  end
+  def test_post_login
+    Runo.client = nil
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/foo/20100222/1/login.html",
+      {
+        :input => "id=test&pw=test&dest_action=update"
+      }
+    )
+    assert_equal(
+      'test',
+      Runo.client,
+      'Runo#call with :login action should set Runo.client upon success'
+    )
+    assert_equal(
+      303,
+      res.status,
+      'Runo#call with :login action should return status 303'
+    )
+    assert_match(
+      %r{/foo/20100222/1/update.html},
+      res.headers['Location'],
+      'Runo#call with :login action should return a proper location'
+    )
+  end
+  def test_post_login_with_wrong_pw
+    Runo.client = nil
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/foo/20100222/1/login.html",
+      {
+        :input => "id=test&pw=wrong&dest_action=update"
+      }
+    )
+    assert_equal(
+      'nobody',
+      Runo.client,
+      'Runo#call with :login action should not set Runo.client upon failure'
+    )
+    assert_equal(
+      422,
+      res.status,
+      'Runo#call with :login action should return status 422 upon failure'
+    )
+  end
+  def test_post_logout
+    Runo.client = 'frank'
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/foo/20100222/1/logout.html?_token=#{Runo.token}",
+      {}
+    )
+    assert_equal(
+      'nobody',
+      Runo.client,
+      'Runo#call with :logout action should unset Runo.client'
+    )
+    assert_equal(
+      303,
+      res.status,
+      'Runo#call with :logout action should return status 303'
+    )
+    assert_match(
+      %r{/foo/20100222/1/index.html},
+      res.headers['Location'],
+      'Runo#call with :logout action should return a proper location'
+    )
+  end
+  def test_post_logout_with_invalid_token
+    Runo.client = 'frank'
+    res = Rack::MockRequest.new(@runo).post(
+      "http://example.com/foo/20100222/1/logout.html?_token=invalid",
+      {}
+    )
+    assert_equal(
+      403,
+      res.status,
+      'Runo#call without a valid token should return status 403'
+    )
+    assert_equal(
+      'invalid token',
+      res.body,
+      'Runo#call without a valid token should return status 403'
+    )
+    assert_equal(
+      'frank',
+      Runo.client,
+      'Runo#call without a valid token should return status 403'
+    )
+  end
+  def test_get_logout
+    Runo.client = 'frank'
+    res = Rack::MockRequest.new(@runo).get(
+      "http://example.com/foo/20100222/1/logout.html?_token=#{Runo.token}",
+      {}
+    )
+    assert_equal(
+      'nobody',
+      Runo.client,
+      'Runo#call with :logout action should work via both get and post'
+    )
+    assert_match(
+      %r{/foo/20100222/1/index.html},
+      res.headers['Location'],
+      'Runo#call with :logout action should work via both get and post'
+    )
+  end
+  def test_message_notice
+    Runo.client = 'root'
+    Runo::Set::Static::Folder.root.item('t_store', 'main').storage.clear
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input => "_2-name=fz&_2-comment=hi.&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_match(
+      %r{#{Runo::REX::TID}/t_store/},
+      res.headers['Location'],
+      'Runo#call should return both the base path and tid at :done'
+    )
+    tid    = res.headers['Location'][Runo::REX::TID]
+    new_id = res.headers['Location'][Runo::REX::PATH_ID]
+    res = Rack::MockRequest.new(@runo).get(
+      res.headers['Location']
+    )
+    assert_match(
+      /created 1 entry\./,
+      res.body,
+      'Runo#call should include the current message'
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      "http://example.com/#{tid}/#{new_id}index.html"
+    )
+    assert_no_match(
+      /created 1 entry\./,
+      res.body,
+      'Runo#call should not include the message twice'
+    )
+    res.headers['Location'] =~ Runo::REX::PATH_ID
+    new_id = sprintf('%.8d_%.4d', $1, $2)
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input => "#{new_id}-comment=howdy.&.status-public=update&_token=#{Runo.token}"
+      }
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      res.headers['Location']
+    )
+    assert_match(
+      /updated 1 entry\./,
+      res.body,
+      'Runo#call should include a message according to the action'
+    )
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input => "#{new_id}.action=delete&.status-public=delete&_token=#{Runo.token}"
+      }
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      res.headers['Location']
+    )
+    assert_match(
+      /deleted 1 entry\./,
+      res.body,
+      'Runo#call should include a message according to the action'
+    )
+  end
+  def test_message_notice_plural
+    Runo.client = 'root'
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_attachment/main/update.html',
+      {
+        :input => "_1-comment=foo&_2-comment=bar&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    res = Rack::MockRequest.new(@runo).get(
+      res.headers['Location']
+    )
+    assert_match(
+      /created 2 tArticles\./,
+      res.body,
+      'the message should be plural if more than one item have results.'
+    )
+  end
+  def test_message_alert
+    Runo.client = 'nobody'
+    res = Rack::MockRequest.new(@runo).get(
+      "http://example.com/foo/20091120/1/update.html"
+    )
+    assert_match(
+      /please login\./,
+      res.body,
+      'Runo#call should include the current message'
+    )
+  end
+  def test_message_error
+    Runo.client = 'root'
+    Runo::Set::Static::Folder.root.item('t_store', 'main').storage.clear
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input => "_2-name=verrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrylongname&.status-public=create&_token=#{Runo.token}"
+      }
+    )
+    assert_match(
+      /malformed input\./,
+      res.body,
+      'Runo#call should include the current message'
+    )
+  end
+  def test_message_i18n
+    Runo.client = 'root'
+    Runo::Set::Static::Folder.root.item('t_store', 'main').storage.clear
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input                 => "_3-name=&.status-public=create&_token=#{Runo.token}",
+        'HTTP_ACCEPT_LANGUAGE' => 'en, de',
+      }
+    )
+    assert_match(
+      /malformed input/,
+      res.body,
+      "Runo::I18n.find_msg should return at least an empty hash for 'en' as HTTP_ACCEPT_LANGUAGE."
+    )
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input                 => "_3-name=&.status-public=create&_token=#{Runo.token}",
+        'HTTP_ACCEPT_LANGUAGE' => 'en-US, de',
+      }
+    )
+    assert_match(
+      /malformed input/,
+      res.body,
+      "Runo::I18n.find_msg should return at least an empty hash for 'en' as HTTP_ACCEPT_LANGUAGE."
+    )
+    res = Rack::MockRequest.new(@runo).post(
+      'http://example.com/t_store/main/update.html',
+      {
+        :input                 => "_3-name=&.status-public=create&_token=#{Runo.token}",
+        'HTTP_ACCEPT_LANGUAGE' => 'de, en',
+      }
+    )
+    assert_match(
+      /Fehlerhafte Eingabe/,
+      res.body,
+      'Set::Dynamic#_g_message should be i18nized according to HTTP_ACCEPT_LANGUAGE.'
+    )
+  end
+end