keight 0.2.0 → 0.3.0

data/test/keight_test.rb

@@ -4,6 +4,7 @@ $LOAD_PATH << "lib"  unless $LOAD_PATH.include?("lib")
 $LOAD_PATH << "test" unless $LOAD_PATH.include?("test")
 
 require 'stringio'
+require 'set'
 
 require 'rack/test_app'
 require 'oktest'
@@ -96,6 +97,17 @@ Oktest.scope do
     return Rack::TestApp.new_env(meth, path, opts)
   end
 
+  def capture_output
+    stdout_bkup, stderr_bkup, $stdout, $stderr = \
+      $stdout, $stderr, StringIO.new, StringIO.new
+    begin
+      yield
+      return $stdout.string, $stderr.string
+    ensure
+      $stdout, $stderr = stdout_bkup, stderr_bkup
+    end
+  end
+
 
   topic K8::Util do
 
@@ -138,12 +150,12 @@ Oktest.scope do
 
     topic '.parse_query_string()' do
 
-      spec "[!fzt3w] parses query string and returns Hahs object." do
+      spec "[!fzt3w] parses query string and returns Hash/dict object." do
         d = K8::Util.parse_query_string("x=123&y=456&z=")
         ok {d} == {"x"=>"123", "y"=>"456", "z"=>""}
       end
 
-      spec "[!engr6] returns empty Hash object when query string is empty." do
+      spec "[!engr6] returns empty Hash/dict object when query string is empty." do
         d = K8::Util.parse_query_string("")
         ok {d} == {}
       end
@@ -239,7 +251,7 @@ Oktest.scope do
     end
 
 
-    topic '#http_utc_time()' do
+    topic '.http_utc_time()' do
 
       spec "[!5k50b] converts Time object into HTTP date format string." do
         require 'time'
@@ -258,6 +270,279 @@ Oktest.scope do
     end
 
 
+    topic 'TemporaryFile' do
+
+
+      topic '.new_path()' do
+
+        spec "[!hvnzd] generates new temorary filepath under temporary directory." do
+          fpath = K8::Util::TemporaryFile.new_path('/var/tmp')
+          ok {fpath}.start_with?('/var/tmp/')
+          ok {fpath} =~ %r`\A/var/tmp/tmp-\d+\.tmp\z`
+          #
+          paths = 1000.times.map { K8::Util::TemporaryFile.new_path('/var/tmp') }
+          ok {Set.new(paths).size} == 1000
+        end
+
+        spec "[!ulb2e] uses default temporary directory path if tmpdir is not specified." do
+          fpath = K8::Util::TemporaryFile.new_path()
+          ok {fpath}.start_with?(K8::Util::TemporaryFile::TMPDIR + '/')
+          ok {fpath} =~ %r"\A#{Regexp.escape(K8::Util::TemporaryFile::TMPDIR)}/tmp-\d+\.tmp\z"
+        end
+
+      end
+
+
+      topic '#initialize()' do
+
+        spec "[!ljilm] generates temporary filepath automatically when filepath is not specified." do
+          n = 1000
+          paths = n.times.map { K8::Util::TemporaryFile.new().path }
+          ok {Set.new(paths).size} == n
+        end
+
+      end
+
+
+      topic '#each()' do
+
+        spec "[!d9suq] opens temporary file with binary mode." do
+          tmpf = K8::Util::TemporaryFile.new()
+          File.open(tmpf.path, 'wb') {|f| f.write("hogehoge") }
+          called = false
+          tmpf.each do |s|
+            called = true
+            ok {s.encoding} == Encoding::BINARY
+          end
+          ok {called} == true
+        end
+
+        spec "[!68xdj] reads chunk size data from temporary file per iteration." do
+          tmpf = K8::Util::TemporaryFile.new(chunk_size: 3)
+          File.open(tmpf.path, 'wb') {|f| f.write("hogehoge") }
+          i = 0
+          tmpf.each do |s|
+            case i
+            when 0; ok {s} == "hog"
+            when 1; ok {s} == "eho"
+            when 2; ok {s} == "ge"
+            else
+              raise "unreachable"
+            end
+            i += 1
+          end
+        end
+
+        spec "[!i0dmd] removes temporary file automatically at end of loop." do
+          tmpf = K8::Util::TemporaryFile.new()
+          File.open(tmpf.path, 'wb') {|f| f.write("hogehoge") }
+          ok {tmpf.path}.file_exist?
+          tmpf.each do |s|
+            ok {tmpf.path}.file_exist?
+          end
+          ok {tmpf.path}.NOT.file_exist?
+        end
+
+        spec "[!347an] removes temporary file even if error raised in block." do
+          tmpf = K8::Util::TemporaryFile.new()
+          File.open(tmpf.path, 'wb') {|f| f.write("hogehoge") }
+          ok {tmpf.path}.file_exist?
+          pr = proc { tmpf.each {|s| 1/0 } }
+          ok {pr}.raise?(ZeroDivisionError)
+          ok {tmpf.path}.NOT.file_exist?
+        end
+
+      end
+
+
+    end
+
+
+    topic K8::Util::ShellCommand do
+
+
+      topic '#initialize()' do
+
+        spec "[!j95pi] takes shell command and input string." do
+          command = "psql -AF',' dbname | gzip"
+          input   = "select * from table1"
+          sc = K8::Util::ShellCommand.new(command, input: input)
+          ok {sc.command} == command
+          ok {sc.input}   == input
+          #
+          sc2 = K8::Util::ShellCommand.new(command)
+          ok {sc2.command} == command
+          ok {sc2.input}   == nil
+        end
+
+      end
+
+
+      topic '#start()' do
+
+        fixture :sc do
+          K8::Util::ShellCommand.new("echo yes")
+        end
+
+        spec "[!66uck] not allowed to start more than once." do |sc|
+          ok {proc { sc.start() }}.NOT.raise?(Exception)
+          ok {proc { sc.start() }}.raise?(K8::Util::ShellCommandError, 'Already started (comand: "echo yes")')
+        end
+
+        spec "[!9seos] invokes shell command." do |sc|
+          ok {sc.process_id} == nil
+          sc.start()
+          ok {sc.process_id} != nil
+          ok {sc.process_id}.is_a?(Fixnum)
+        end
+
+        spec "[!d766y] writes input string if provided to initializer." do |sc|
+          input = "a\nb\nc\n"
+          sc = K8::Util::ShellCommand.new("cat -n", input: input, chunk_size: 2)
+          sc.start()
+          buf = ""
+          sc.each {|s| buf << s }
+          ok {buf} == ("     1	a\n" + \
+                       "     2	b\n" + \
+                       "     3	c\n")
+        end
+
+        spec "[!f651x] reads first chunk data." do
+          sc = K8::Util::ShellCommand.new("echo abcdefg", chunk_size: 2)
+          t = sc.instance_variable_get('@tuple')
+          ok {t} == nil
+          sc.start()
+          t = sc.instance_variable_get('@tuple')
+          ok {t} != nil
+          sout, serr, waiter, chunk = t
+          ok {chunk} == "ab"
+        end
+
+        spec "[!cjstj] raises ShellCommandError when command prints something to stderr." do
+          sc = K8::Util::ShellCommand.new("echo abcdefg 1>&2")
+          capture_output do
+            pr = proc { sc.start() }
+            ok {pr}.raise?(K8::Util::ShellCommandError, "abcdefg\n")
+          end
+        end
+
+        spec "[!bt12n] saves stdout, stderr, command process, and first chunk data." do
+          sc = K8::Util::ShellCommand.new("echo abcdefg", chunk_size: 2)
+          sc.start()
+          t = sc.instance_variable_get('@tuple')
+          ok {t} != nil
+          sout, serr, waiter, chunk = t
+          ok {sout}.is_a?(IO)
+          ok {serr}.is_a?(IO)
+          ok {waiter}.is_a?(Process::Waiter)
+          ok {chunk} == "ab"
+        end
+
+        spec "[!kgnel] yields callback (if given) when command invoked successfully." do
+          sc = K8::Util::ShellCommand.new("echo abcdefg")
+          called = false
+          sc.start() do
+            called = true
+          end
+          ok {called} == true      # called
+          #
+          capture_output do
+            sc = K8::Util::ShellCommand.new("echo abcdefg 1>&2")
+            called = false
+            sc.start() do
+              called = true
+            end rescue nil
+            ok {called} == false   # not called
+          end
+        end
+
+        spec "[!2989u] closes both stdout and stderr when error raised." do
+          skip_when(true, "hard to test")
+        end
+
+        spec "[!fp98i] returns self." do
+          sc = K8::Util::ShellCommand.new("echo abcdefg")
+          ok {sc.start()}.same?(sc)
+        end
+
+      end
+
+
+      topic '#each()' do
+
+        fixture :sc do
+          K8::Util::ShellCommand.new("echo yes")
+        end
+
+        spec "[!ssgmm] '#start()' should be called before '#each()'." do |sc|
+          ok {proc { sc.each() }}.raise?(K8::Util::ShellCommandError, 'Not started yet (command: "echo yes").')
+        end
+
+        spec "[!vpmbw] yields each chunk data." do |sc|
+          sc = K8::Util::ShellCommand.new("echo abcdef", chunk_size: 2)
+          sc.start()
+          arr = []
+          sc.each {|s| arr << s }
+          ok {arr} == ["ab", "cd", "ef", "\n"]
+        end
+
+        spec "[!70xdy] logs stderr output." do
+          buf = ""
+          sout, serr = capture_output do
+            sc = K8::Util::ShellCommand.new("time echo abcdef")
+            sc.start()
+            sc.each {|s| buf << s }
+          end
+          ok {buf} == "abcdef\n"
+          ok {sout} == ""
+          ok {serr} != ""
+          ok {serr} == ("[ERROR] ShellCommand: \"time echo abcdef\" #-------\n" + \
+                        "        0.00 real         0.00 user         0.00 sys\n" + \
+                        "--------------------\n")
+        end
+
+        spec "[!2wll8] closes stdout and stderr, even if error raised." do
+          sc = K8::Util::ShellCommand.new("echo abcdef")
+          sc.start()
+          sout, serr, _, _ = sc.instance_variable_get('@tuple')
+          ok {sout.closed?} == false
+          ok {serr.closed?} == false
+          sc.each {|s| s }
+          ok {sout.closed?} == true
+          ok {serr.closed?} == true
+          #
+          sc = K8::Util::ShellCommand.new("time echo abcdef")
+          sc.start()
+          sout, serr, _, _ = sc.instance_variable_get('@tuple')
+          ok {sout.closed?} == false
+          ok {serr.closed?} == false
+          capture_output do sc.each {|s| s } end
+          ok {sout.closed?} == true
+          ok {serr.closed?} == true
+        end
+
+        spec "[!0ebq5] calls callback specified at initializer with error object." do
+          arg = false
+          sc = K8::Util::ShellCommand.new("echo abcdef") {|x| arg = x }
+          ok {arg} == false
+          sc.start()
+          ok {arg} == false
+          sc.each {|s| s }
+          ok {arg} == nil
+        end
+
+        spec "[!ln8we] returns self." do |sc|
+          sc.start()
+          ret = sc.each {|s| s }
+          ok {ret}.same?(sc)
+        end
+
+      end
+
+
+    end
+
+
   end
 
 
@@ -325,10 +610,10 @@ Oktest.scope do
   end
 
 
-  topic K8::Request do
+  topic K8::RackRequest do
 
     fixture :req do
-      K8::Request.new(new_env("GET", "/123"))
+      K8::RackRequest.new(new_env("GET", "/123"))
     end
 
     fixture :data_dir do
@@ -348,28 +633,28 @@ Oktest.scope do
 
       spec "[!yb9k9] sets @env." do
         env = new_env()
-        req = K8::Request.new(env)
+        req = K8::RackRequest.new(env)
         ok {req.env}.same?(env)
       end
 
-      spec "[!yo22o] sets @method as Symbol value." do
-        req1 = K8::Request.new(new_env("GET"))
-        ok {req1.method} == :GET
-        req2 = K8::Request.new(new_env("POST"))
-        ok {req2.method} == :POST
+      spec "[!yo22o] sets @meth as Symbol value." do
+        req1 = K8::RackRequest.new(new_env("GET"))
+        ok {req1.meth} == :GET
+        req2 = K8::RackRequest.new(new_env("POST"))
+        ok {req2.meth} == :POST
       end
 
       spec "[!twgmi] sets @path." do
-        req1 = K8::Request.new(new_env("GET", "/123"))
+        req1 = K8::RackRequest.new(new_env("GET", "/123"))
         ok {req1.path} == "/123"
       end
 
       spec "[!ae8ws] uses SCRIPT_NAME as urlpath when PATH_INFO is not provided." do
         env = new_env("GET", "/123", env: {'SCRIPT_NAME'=>'/index.cgi'})
         env['PATH_INFO'] = ''
-        ok {K8::Request.new(env).path} == "/index.cgi"
+        ok {K8::RackRequest.new(env).path} == "/index.cgi"
         env.delete('PATH_INFO')
-        ok {K8::Request.new(env).path} == "/index.cgi"
+        ok {K8::RackRequest.new(env).path} == "/index.cgi"
       end
 
     end
@@ -378,7 +663,7 @@ Oktest.scope do
     topic '#method()' do
 
       fixture :req do
-        K8::Request.new({"REQUEST_METHOD"=>"POST"})
+        K8::RackRequest.new({"REQUEST_METHOD"=>"POST"})
       end
 
       spec "[!084jo] returns current request method when argument is not specified." do
@@ -395,13 +680,32 @@ Oktest.scope do
     end
 
 
+    topic '#path_ext()' do
+
+      spec "[!tf6yz] returns extension of request path such as '.html' or '.json'." do
+        req1 = K8::RackRequest.new(new_env("GET", "/api/books/123.html"))
+        ok {req1.path_ext} == ".html"
+        req2 = K8::RackRequest.new(new_env("GET", "/api/books/123.json"))
+        ok {req2.path_ext} == ".json"
+      end
+
+      spec "[!xnurj] returns empty string when no extension." do
+        req1 = K8::RackRequest.new(new_env("GET", "/api/books/123"))
+        ok {req1.path_ext} == ""
+        req2 = K8::RackRequest.new(new_env("GET", "/api/books.d/123"))
+        ok {req2.path_ext} == ""
+      end
+
+    end
+
+
     topic '#header()' do
 
       spec "[!1z7wj] returns http header value from environment." do
         env = new_env("GET", "/",
                       headers: {'Accept-Encoding'=>'gzip,deflate'},
                       env:     {'HTTP_ACCEPT_LANGUAGE'=>'en,ja'})
-        req = K8::Request.new(env)
+        req = K8::RackRequest.new(env)
         ok {req.header('Accept-Encoding')} == 'gzip,deflate'
         ok {req.header('Accept-Language')} == 'en,ja'
       end
@@ -412,7 +716,7 @@ Oktest.scope do
     topic '#request_method' do
 
       spec "[!y8eos] returns env['REQUEST_METHOD'] as string." do
-        req = K8::Request.new(new_env(:POST, "/"))
+        req = K8::RackRequest.new(new_env(:POST, "/"))
         ok {req.request_method} == "POST"
       end
 
@@ -423,9 +727,9 @@ Oktest.scope do
 
       spec "[!95g9o] returns env['CONTENT_TYPE']." do
         ctype = "text/html"
-        req = K8::Request.new(new_env("GET", "/", env: {'CONTENT_TYPE'=>ctype}))
+        req = K8::RackRequest.new(new_env("GET", "/", env: {'CONTENT_TYPE'=>ctype}))
         ok {req.content_type} == ctype
-        req = K8::Request.new(new_env("GET", "/", env: {}))
+        req = K8::RackRequest.new(new_env("GET", "/", env: {}))
         ok {req.content_type} == nil
       end
 
@@ -435,7 +739,7 @@ Oktest.scope do
     topic '#content_length' do
 
       spec "[!0wbek] returns env['CONTENT_LENGHT'] as integer." do
-        req = K8::Request.new(new_env("GET", "/", env: {'CONTENT_LENGTH'=>'0'}))
+        req = K8::RackRequest.new(new_env("GET", "/", env: {'CONTENT_LENGTH'=>'0'}))
         ok {req.content_length} == 0
         req.env.delete('CONTENT_LENGTH')
         ok {req.content_length} == nil
@@ -448,9 +752,9 @@ Oktest.scope do
 
       spec "[!hsgkg] returns true when 'X-Requested-With' header is 'XMLHttpRequest'." do
         env = new_env("GET", "/", headers: {'X-Requested-With'=>'XMLHttpRequest'})
-        ok {K8::Request.new(env).xhr?} == true
+        ok {K8::RackRequest.new(env).xhr?} == true
         env = new_env("GET", "/", headers: {})
-        ok {K8::Request.new(env).xhr?} == false
+        ok {K8::RackRequest.new(env).xhr?} == false
       end
 
     end
@@ -462,20 +766,20 @@ Oktest.scope do
         env = new_env("GET", "/",
                       headers: {'X-Real-IP'=>'192.168.1.23'},
                       env: {'REMOTE_ADDR'=>'192.168.0.1'})
-        ok {K8::Request.new(env).client_ip_addr} == '192.168.1.23'
+        ok {K8::RackRequest.new(env).client_ip_addr} == '192.168.1.23'
       end
 
       spec "[!qdlyl] returns first item of 'X-Forwarded-For' header if provided." do
         env = new_env("GET", "/",
                       headers: {'X-Forwarded-For'=>'192.168.1.1, 192.168.1.2, 192.168.1.3'},
                       env: {'REMOTE_ADDR'=>'192.168.0.1'})
-        ok {K8::Request.new(env).client_ip_addr} == '192.168.1.1'
+        ok {K8::RackRequest.new(env).client_ip_addr} == '192.168.1.1'
       end
 
       spec "[!8nzjh] returns 'REMOTE_ADDR' if neighter 'X-Real-IP' nor 'X-Forwarded-For' provided." do
         env = new_env("GET", "/",
                       env: {'REMOTE_ADDR'=>'192.168.0.1'})
-        ok {K8::Request.new(env).client_ip_addr} == '192.168.0.1'
+        ok {K8::RackRequest.new(env).client_ip_addr} == '192.168.0.1'
       end
 
     end
@@ -485,15 +789,15 @@ Oktest.scope do
 
       spec "[!jytwy] returns 'https' when env['HTTPS'] is 'on'." do
         env = new_env("GET", "/", env: {'HTTPS'=>'on'})
-        ok {K8::Request.new(env).scheme} == 'https'
+        ok {K8::RackRequest.new(env).scheme} == 'https'
       end
 
       spec "[!zg8r2] returns env['rack.url_scheme'] ('http' or 'https')." do
         env = new_env("GET", "/", env: {'HTTPS'=>'off'})
         env['rack.url_scheme'] = 'http'
-        ok {K8::Request.new(env).scheme} == 'http'
+        ok {K8::RackRequest.new(env).scheme} == 'http'
         env['rack.url_scheme'] = 'https'
-        ok {K8::Request.new(env).scheme} == 'https'
+        ok {K8::RackRequest.new(env).scheme} == 'https'
       end
 
     end
@@ -501,62 +805,102 @@ Oktest.scope do
 
     topic '#params_query' do
 
-      spec "[!6ezqw] parses QUERY_STRING and returns it as Hash object." do
+      spec "[!6ezqw] parses QUERY_STRING and returns it as Hash/dict object." do
         qstr = "x=1&y=2"
-        req = K8::Request.new(new_env("GET", "/", env: {'QUERY_STRING'=>qstr}))
+        req = K8::RackRequest.new(new_env("GET", "/", env: {'QUERY_STRING'=>qstr}))
         ok {req.params_query()} == {'x'=>'1', 'y'=>'2'}
       end
 
       spec "[!o0ws7] unquotes both keys and values." do
         qstr = "arr%5Bxxx%5D=%3C%3E+%26%3B"
-        req = K8::Request.new(new_env("GET", "/", env: {'QUERY_STRING'=>qstr}))
+        req = K8::RackRequest.new(new_env("GET", "/", env: {'QUERY_STRING'=>qstr}))
         ok {req.params_query()} == {'arr[xxx]'=>'<> &;'}
       end
 
+      spec "[!2fhrk] returns same value when called more than once." do
+        req = K8::RackRequest.new(new_env("GET", "/", query: "x=1&y=2"))
+        val1st = req.params_query()
+        val2nd = req.params_query()
+        ok {val2nd}.same?(val1st)
+      end
+
     end
 
 
     topic '#params_form' do
 
-      spec "[!q88w9] raises error when content length is missing." do
-        env = new_env("POST", "/", form: "x=1")
-        env['CONTENT_LENGTH'] = nil
-        req = K8::Request.new(env)
+      spec "[!iultp] returns same value when called more than once." do
+        req = K8::RackRequest.new(new_env("POST", "/", form: "x=1"))
+        val1st = req.params_form
+        val2nd = req.params_form
+        ok {val2nd}.same?(val1st)
+      end
+
+      spec "[!uq46o] raises 400 error when payload is not form data." do
+        |multipart_env|
+        env = multipart_env
+        req = K8::RackRequest.new(env)
         pr = proc { req.params_form }
-        ok {pr}.raise?(K8::HttpException, 'Content-Length header expected.')
+        ok {pr}.raise?(K8::HttpException, /^expected form data, but Content-Type header is "multipart\/form-data;boundary=.*".$/)
       end
 
-      spec "[!gi4qq] raises error when content length is invalid." do
+      spec "[!puxlr] raises 400 error when content length is too large (> 10MB)." do
         env = new_env("POST", "/", form: "x=1")
-        env['CONTENT_LENGTH'] = "abc"
-        req = K8::Request.new(env)
+        env['CONTENT_LENGTH'] = (10*1024*1024 + 1).to_s
+        req = K8::RackRequest.new(env)
         pr = proc { req.params_form }
-        ok {pr}.raise?(K8::HttpException, 'Content-Length should be an integer.')
+        ok {pr}.raise?(K8::HttpException, 'Content-Length is too large (max: 10485760, actual: 10485761).')
       end
 
-      spec "[!59ad2] parses form parameters and returns it as Hash object when form requested." do
+      spec "[!59ad2] parses form parameters and returns it as Hash/dict object." do
         form = "x=1&y=2&arr%5Bxxx%5D=%3C%3E+%26%3B"
-        req = K8::Request.new(new_env("POST", "/", form: form))
+        req = K8::RackRequest.new(new_env("POST", "/", form: form))
         ok {req.params_form} == {'x'=>'1', 'y'=>'2', 'arr[xxx]'=>'<> &;'}
       end
 
-      spec "[!puxlr] raises error when content length is too long (> 10MB)." do
-        env = new_env("POST", "/", form: "x=1")
-        env['CONTENT_LENGTH'] = (10*1024*1024 + 1).to_s
-        req = K8::Request.new(env)
-        pr = proc { req.params_form }
-        ok {pr}.raise?(K8::HttpException, 'Content-Length is too long.')
-      end
-
     end
 
 
     topic '#params_multipart' do
 
-      spec "[!y1jng] parses multipart when multipart form requested." do
+      spec "[!gbdxu] returns same values when called more than once." do
+        |multipart_env|
+        req = K8::RackRequest.new(multipart_env)
+        d1, d2 = req.params_multipart
+        d3, d4 = req.params_multipart
+        ok {d3}.same?(d1)
+        ok {d4}.same?(d2)
+      end
+
+      spec "[!ho5ii] raises 400 error when not multipart data." do
+        env = new_env("POST", "/", form: "x=1")
+        req = K8::RackRequest.new(env)
+        pr = proc { req.params_multipart }
+        ok {pr}.raise?(K8::HttpException, 'expected multipart data, but Content-Type header is "application/x-www-form-urlencoded".')
+      end
+
+      spec "[!davzs] raises 400 error when boundary is missing." do
+        |multipart_env, data_dir|
+        env = multipart_env
+        env['CONTENT_TYPE'] = env['CONTENT_TYPE'].split(';').first
+        req = K8::RackRequest.new(env)
+        pr = proc { req.params_multipart }
+        ok {pr}.raise?(K8::HttpException, 'bounday attribute of multipart required.')
+      end
+
+      spec "[!mtx6t] raises 400 error when content length of multipart is too large (> 100MB)." do
+        |multipart_env|
+        env = multipart_env
+        env['CONTENT_LENGTH'] = (100*1024*1024 + 1).to_s
+        req = K8::RackRequest.new(env)
+        pr = proc { req.params_multipart }
+        ok {pr}.raise?(K8::HttpException, 'Content-Length is too large (max: 104857600, actual: 104857601).')
+      end
+
+      spec "[!y1jng] parses multipart when multipart data posted." do
         |multipart_env, data_dir|
         env = multipart_env
-        req = K8::Request.new(env)
+        req = K8::RackRequest.new(env)
         form, files = req.params_multipart
         ok {form} == {
           "text1" => "test1",
@@ -585,53 +929,110 @@ Oktest.scope do
 
       end
 
-      spec "[!mtx6t] raises error when content length of multipart is too long (> 100MB)." do
-        |multipart_env|
-        env = multipart_env
-        env['CONTENT_LENGTH'] = (100*1024*1024 + 1).to_s
-        req = K8::Request.new(env)
-        pr = proc { req.params_multipart }
-        ok {pr}.raise?(K8::HttpException, 'Content-Length of multipart is too long.')
-      end
-
     end
 
 
     topic '#params_json' do
 
+      spec "[!5kwij] returns same value when called more than once." do
+        req = K8::RackRequest.new(new_env("POST", "/", json: {"x"=>1}))
+        val1st = req.params_json
+        val2nd = req.params_json
+        ok {val2nd}.same?(val1st)
+      end
+
+      spec "[!qjgfz] raises 400 error when not JSON data." do
+        req = K8::RackRequest.new(new_env("POST", "/", form: "x=1"))
+        pr = proc { req.params_json }
+        ok {pr}.raise?(K8::HttpException, "expected JSON data, but Content-Type header is \"application/x-www-form-urlencoded\".")
+      end
+
+      spec "[!on107] raises error when content length of JSON is too large (> 10MB)." do
+        env = new_env("POST", "/", json: {"x"=>1})
+        env['CONTENT_LENGTH'] = (10*1024*1024 + 1).to_s
+        req = K8::RackRequest.new(env)
+        pr = proc { req.params_json }
+        ok {pr}.raise?(K8::HttpException, 'Content-Length is too large (max: 10485760, actual: 10485761).')
+      end
+
       spec "[!ugik5] parses json data and returns it as hash object when json data is sent." do
         data = '{"x":1,"y":2,"arr":["a","b","c"]}'
-        req = K8::Request.new(new_env("POST", "/", json: data))
+        req = K8::RackRequest.new(new_env("POST", "/", json: data))
         ok {req.params_json} == {"x"=>1, "y"=>2, "arr"=>["a", "b", "c"]}
       end
 
     end
 
 
+    topic '#get_content_length()' do
+
+      spec "[!q88w9] raises 400 error when content length is missing." do
+        env = new_env("POST", "/", form: "x=1")
+        env['CONTENT_LENGTH'] = nil
+        req = K8::RackRequest.new(env)
+        req.instance_exec(self) do |_|
+          pr = proc { get_content_length(100) }
+          _.ok {pr}.raise?(K8::HttpException, 'Content-Length header expected.')
+        end
+      end
+
+      spec "[!ls6ir] raises error when content length is too large." do
+        env = new_env("POST", "/", form: "x=1")
+        env['CONTENT_LENGTH'] = '101'
+        req = K8::RackRequest.new(env)
+        req.instance_exec(self) do |_|
+          pr = proc { get_content_length(100) }
+          _.ok {pr}.raise?(K8::HttpException, 'Content-Length is too large (max: 100, actual: 101).')
+        end
+      end
+
+    end
+
+
+    topic '#get_input_stream()' do
+
+      spec "[!2buc6] returns input stream." do
+        env = new_env("POST", "/", form: "x=1")
+        req = K8::RackRequest.new(env)
+        req.instance_exec(self) do |_|
+          _.ok { get_input_stream() }.same?(req.env['rack.input'])
+        end
+      end
+
+    end
+
+
     topic '#params' do
 
       spec "[!erlc7] parses QUERY_STRING when request method is GET or HEAD." do
         qstr = "a=8&b=9"
         form = "x=1&y=2"
-        req = K8::Request.new(new_env('GET', '/', query: qstr, form: form))
+        req = K8::RackRequest.new(new_env('GET', '/', query: qstr, form: form))
         ok {req.params} == {"a"=>"8", "b"=>"9"}
       end
 
-      spec "[!cr0zj] parses JSON when content type is 'application/json'." do
-        qstr = "a=8&b=9"
-        json = '{"n":123}'
-        req = K8::Request.new(new_env('POST', '/', query: qstr, json: json))
-        ok {req.params} == {"n"=>123}
-      end
-
       spec "[!j2lno] parses form parameters when content type is 'application/x-www-form-urlencoded'." do
         qstr = "a=8&b=9"
         form = "x=1&y=2"
-        req = K8::Request.new(new_env('POST', '/', query: qstr, form: form))
+        req = K8::RackRequest.new(new_env('POST', '/', query: qstr, form: form))
         ok {req.params} == {"x"=>"1", "y"=>"2"}
       end
 
-      spec "[!4rmn9] parses multipart when content type is 'multipart/form-data'."
+      spec "[!z5w4k] raises error when content type is 'multipart/form-data' (because params_multipart() returns two values)." do
+        env = new_env('POST', '/', form: "x=1")
+        env['CONTENT_TYPE'] = "multipart/form-data"
+        req = K8::RackRequest.new(env)
+        pr = proc { req.params }
+        ok {pr}.raise?(K8::PayloadParseError, "don't use `@req.params' for multipart data; use `@req.params_multipart' instead.")
+      end
+
+      spec "[!td6fw] raises error when content type is 'application/json' (because JSON data can contain non-string values)." do
+        qstr = "a=8&b=9"
+        json = '{"n":123}'
+        req  = K8::RackRequest.new(new_env('POST', '/', query: qstr, json: json))
+        pr = proc { req.params }
+        ok {pr}.raise?(K8::PayloadParseError, "use `@req.json' for JSON data instead of `@req.params'.")
+      end
 
     end
 
@@ -639,7 +1040,7 @@ Oktest.scope do
     topic '#cookies' do
 
       spec "[!c9pwr] parses cookie data and returns it as hash object." do
-        req = K8::Request.new(new_env('POST', '/', cookies: "aaa=homhom; bbb=madmad"))
+        req = K8::RackRequest.new(new_env('POST', '/', cookies: "aaa=homhom; bbb=madmad"))
         ok {req.cookies} == {"aaa"=>"homhom", "bbb"=>"madmad"}
       end
 
@@ -650,7 +1051,7 @@ Oktest.scope do
 
       spec "[!0jdal] removes uploaded files." do
         |multipart_env|
-        req = K8::Request.new(multipart_env)
+        req = K8::RackRequest.new(multipart_env)
         form, files = req.params_multipart
         ok {files.empty?} == false
         tmpfile1 = files['file1'].tmp_filepath
@@ -669,37 +1070,66 @@ Oktest.scope do
   end
 
 
-  topic K8::Response do
-  end
+  topic K8::RackResponse do
 
 
-  topic 'K8::REQUEST_CLASS=' do
+    topic '#initialize()' do
 
-    spec "[!7uqb4] changes default request class." do
-      original = K8::REQUEST_CLASS
-      begin
-        K8.REQUEST_CLASS = Array
-        ok {K8::REQUEST_CLASS} == Array
-      ensure
-        K8.REQUEST_CLASS = original
+      spec "[!ehdkl] default status code is 200." do
+        resp = K8::RackResponse.new
+        ok {resp.status_code} == 200
       end
+
     end
 
-  end
 
+    topic '#status_line' do
+
+      spec "[!apy81] returns status line such as '200 OK'." do
+        resp = K8::RackResponse.new
+        ok {resp.status_line} == "200 OK"
+        resp.status_code = 302
+        ok {resp.status_line} == "302 Found"
+        resp.status_code = 404
+        ok {resp.status_line} == "404 Not Found"
+        resp.status_code = 500
+        ok {resp.status_line} == "500 Internal Server Error"
+      end
+
+    end
+
+
+    topic '#set_cookie()' do
+
+      spec "[!58tby] adds 'Set-Cookie' response header." do
+        resp = K8::RackResponse.new
+        resp.set_cookie("hom", "HOMHOM")
+        ok {resp.headers['Set-Cookie']} == "hom=HOMHOM"
+      end
+
+      spec "[!u9w9l] supports multiple cookies." do
+        resp = K8::RackResponse.new
+        resp.set_cookie("foo", "FOO")
+        resp.set_cookie("bar", "BAR")
+        resp.set_cookie("baz", "BAZ")
+        ok {resp.headers['Set-Cookie']} == "foo=FOO\nbar=BAR\nbaz=BAZ"
+      end
 
-  topic 'K8::RESPONSE_CLASS=' do
+      spec "[!7otip] returns cookie string." do
+        resp = K8::RackResponse.new
+        ok {resp.set_cookie("foo", "FOO")} == "foo=FOO"
+        ok {resp.set_cookie("bar", "BAR", path: '/', httponly: true)} == "bar=BAR; Path=/; HttpOnly"
+      end
 
-    spec "[!c1bd0] changes default response class." do
-      original = K8::RESPONSE_CLASS
-      begin
-        K8.RESPONSE_CLASS = Hash
-        ok {K8::RESPONSE_CLASS} == Hash
-      ensure
-        K8.RESPONSE_CLASS = original
+      spec "[!oanme] converts Time object into HTTP timestamp string." do
+        resp = K8::RackResponse.new
+        resp.set_cookie("hom", "HOMHOM", expires: Time.utc(2001, 11, 30, 12, 34, 56))
+        ok {resp.headers['Set-Cookie']} == "hom=HOMHOM; Expires=Fri, 30 Nov 2001 12:34:56 GMT"
       end
+
     end
 
+
   end
 
 
@@ -707,29 +1137,20 @@ Oktest.scope do
 
     fixture :action do
       env  = new_env("GET", "/books")
-      TestBaseAction.new(K8::Request.new(env), K8::Response.new())
+      TestBaseAction.new(K8::RackRequest.new(env), K8::RackResponse.new())
     end
 
 
     topic '#initialize()' do
 
       spec "[!uotpb] accepts request and response objects." do
-        req    = K8::Request.new(new_env("GET", "/books"))
-        resp   = K8::Response.new()
+        req    = K8::RackRequest.new(new_env("GET", "/books"))
+        resp   = K8::RackResponse.new()
         action = K8::BaseAction.new(req, resp)
         ok {action.instance_variable_get('@req')}.same?(req)
         ok {action.instance_variable_get('@resp')}.same?(resp)
       end
 
-      spec "[!7sfyf] sets session object." do
-        d = {'a'=>1}
-        req    = K8::Request.new(new_env("GET", "/books", env: {'rack.session'=>d}))
-        resp   = K8::Response.new()
-        action = K8::BaseAction.new(req, resp)
-        ok {action.instance_variable_get('@sess')}.same?(d)
-        ok {action.sess}.same?(d)
-      end
-
     end
 
 
@@ -776,7 +1197,7 @@ Oktest.scope do
           mapping '/{code}', :GET=>:do_show, :PUT=>:do_update
         end
         args_list = []
-        cls._action_method_mapping.each do |*args|
+        cls._mappings.each do |args|
           args_list << args
         end
         ok {args_list} == [
@@ -794,12 +1215,12 @@ Oktest.scope do
         infos = BooksAction._build_action_info('/api/books')
         #
         ok {infos[:do_index]}.is_a?(K8::ActionInfo)
-        ok {infos[:do_index].method} == :GET
-        ok {infos[:do_index].urlpath} == '/api/books/'
+        ok {infos[:do_index].meth} == :GET
+        ok {infos[:do_index].path} == '/api/books/'
         #
         ok {infos[:do_update]}.is_a?(K8::ActionInfo)
-        ok {infos[:do_update].method} == :PUT
-        ok {infos[:do_update].urlpath(123)} == '/api/books/123'
+        ok {infos[:do_update].meth} == :PUT
+        ok {infos[:do_update].path(123)} == '/api/books/123'
       end
 
     end
@@ -812,12 +1233,12 @@ Oktest.scope do
         cls = BooksAction
         #
         ok {cls[:do_create]}.is_a?(K8::ActionInfo)
-        ok {cls[:do_create].method} == :POST
-        ok {cls[:do_create].urlpath} == '/api/books/'
+        ok {cls[:do_create].meth} == :POST
+        ok {cls[:do_create].path} == '/api/books/'
         #
         ok {cls[:do_show]}.is_a?(K8::ActionInfo)
-        ok {cls[:do_show].method} == :GET
-        ok {cls[:do_show].urlpath(123)} == '/api/books/123'
+        ok {cls[:do_show].meth} == :GET
+        ok {cls[:do_show].path(123)} == '/api/books/123'
       end
 
       spec "[!6g2iw] returns nil when not mounted yet." do
@@ -838,7 +1259,7 @@ Oktest.scope do
 
     fixture :action_obj do
       env = new_env("GET", "/", env: {'rack.session'=>{}})
-      BooksAction.new(K8::Request.new(env), K8::Response.new())
+      BooksAction.new(K8::RackRequest.new(env), K8::RackResponse.new())
     end
 
 
@@ -873,6 +1294,20 @@ Oktest.scope do
     end
 
 
+    topic '#initialize()' do
+
+      spec "[!7sfyf] sets session object." do
+        d = {'a'=>1}
+        req    = K8::RackRequest.new(new_env("GET", "/books", env: {'rack.session'=>d}))
+        resp   = K8::RackResponse.new()
+        action = K8::Action.new(req, resp)
+        ok {action.instance_variable_get('@sess')}.same?(d)
+        ok {action.sess}.same?(d)
+      end
+
+    end
+
+
     topic '#before_action()' do
     end
 
@@ -895,7 +1330,7 @@ Oktest.scope do
 
       spec "[!d5v0l] handles exception when handler method defined." do
         env = new_env("POST", "/", env: {'rack.session'=>{}})
-        action_obj = TestExceptionAction.new(K8::Request.new(env), K8::Response.new())
+        action_obj = TestExceptionAction.new(K8::RackRequest.new(env), K8::RackResponse.new())
         result = nil
         pr = proc { result = action_obj.handle_action(:do_create, []) }
         ok {pr}.raise?(ZeroDivisionError)
@@ -1167,13 +1602,13 @@ Oktest.scope do
 
       fixture :action_obj do
         env = new_env('GET', '/')
-        action = K8::Action.new(K8::Request.new(env), K8::Response.new)
+        action = K8::Action.new(K8::RackRequest.new(env), K8::RackResponse.new)
       end
 
       spec "[!8chgu] returns false when requested with 'XMLHttpRequest'." do
         headers = {'X-Requested-With'=>'XMLHttpRequest'}
         env = new_env('GET', '/', headers: headers)
-        action = K8::Action.new(K8::Request.new(env), K8::Response.new)
+        action = K8::Action.new(K8::RackRequest.new(env), K8::RackResponse.new)
         action.instance_exec(self) do |_|
           _.ok {csrf_protection_required?} == false
         end
@@ -1182,7 +1617,7 @@ Oktest.scope do
       spec "[!vwrqv] returns true when request method is one of POST, PUT, or DELETE." do
         ['POST', 'PUT', 'DELETE'].each do |meth|
           env = new_env(meth, '/')
-          action = K8::Action.new(K8::Request.new(env), K8::Response.new)
+          action = K8::Action.new(K8::RackRequest.new(env), K8::RackResponse.new)
           action.instance_exec(self) do |_|
             _.ok {csrf_protection_required?} == true
           end
@@ -1192,7 +1627,7 @@ Oktest.scope do
       spec "[!jfhla] returns true when request method is GET or HEAD." do
         ['GET', 'HEAD'].each do |meth|
           env = new_env(meth, '/')
-          action = K8::Action.new(K8::Request.new(env), K8::Response.new)
+          action = K8::Action.new(K8::RackRequest.new(env), K8::RackResponse.new)
           action.instance_exec(self) do |_|
             _.ok {csrf_protection_required?} == false
           end
@@ -1208,7 +1643,7 @@ Oktest.scope do
         headers = {'Cookie'=>"_csrf=abc123"}
         form    = {"_csrf"=>"abc123"}
         env = new_env('POST', '/', form: form, headers: headers)
-        action = K8::Action.new(K8::Request.new(env), K8::Response.new)
+        action = K8::Action.new(K8::RackRequest.new(env), K8::RackResponse.new)
         action.instance_exec(self) do |_|
           pr = proc { csrf_protection() }
           _.ok {pr}.NOT.raise?
@@ -1219,7 +1654,7 @@ Oktest.scope do
         headers = {'Cookie'=>"_csrf=abc123"}
         form    = {"_csrf"=>"abc999"}
         env = new_env('POST', '/', form: form, headers: headers)
-        action = K8::Action.new(K8::Request.new(env), K8::Response.new)
+        action = K8::Action.new(K8::RackRequest.new(env), K8::RackResponse.new)
         action.instance_exec(self) do |_|
           pr = proc { csrf_protection() }
           _.ok {pr}.raise?(K8::HttpException, "invalid csrf token")
@@ -1260,7 +1695,7 @@ Oktest.scope do
 
       spec "[!pal33] returns csrf token in request parameter." do
         env = new_env("POST", "/", form: {"_csrf"=>"foobar999"})
-        action_obj = K8::Action.new(K8::Request.new(env), K8::Response.new)
+        action_obj = K8::Action.new(K8::RackRequest.new(env), K8::RackResponse.new)
         action_obj.instance_exec(self) do |_|
           _.ok {csrf_get_param()} == "foobar999"
         end
@@ -1467,36 +1902,36 @@ Oktest.scope do
       spec "[!btt2g] returns ActionInfoN object when number of urlpath parameter <= 4." do
         info = K8::ActionInfo.create('GET', '/books')
         ok {info}.is_a?(K8::ActionInfo0)
-        ok {info.urlpath} == '/books'
-        ok {->{ info.urlpath('a') }}.raise?(ArgumentError, /^wrong number of arguments \((1 for 0|given 1, expected 0)\)$/)
+        ok {info.path} == '/books'
+        ok {->{ info.path('a') }}.raise?(ArgumentError, /^wrong number of arguments \((1 for 0|given 1, expected 0)\)$/)
         #
         info = K8::ActionInfo.create('GET', '/books/{id}')
         ok {info}.is_a?(K8::ActionInfo1)
-        ok {info.urlpath('a')} == '/books/a'
-        ok {->{ info.urlpath() }}.raise?(ArgumentError, /^wrong number of arguments \((0 for 1|given 0, expected 1)\)$/)
+        ok {info.path('a')} == '/books/a'
+        ok {->{ info.path() }}.raise?(ArgumentError, /^wrong number of arguments \((0 for 1|given 0, expected 1)\)$/)
         #
         info = K8::ActionInfo.create('GET', '/books/{id}/comments/{comment_id}')
         ok {info}.is_a?(K8::ActionInfo2)
-        ok {info.urlpath('a', 'b')} == '/books/a/comments/b'
-        ok {->{info.urlpath('a')}}.raise?(ArgumentError, /^wrong number of arguments \((1 for 2|given 1, expected 2)\)$/)
+        ok {info.path('a', 'b')} == '/books/a/comments/b'
+        ok {->{info.path('a')}}.raise?(ArgumentError, /^wrong number of arguments \((1 for 2|given 1, expected 2)\)$/)
         #
         info = K8::ActionInfo.create('GET', '/books/{id}/{title}/{code}')
         ok {info}.is_a?(K8::ActionInfo3)
-        ok {info.urlpath('a', 'b', 'c')} == '/books/a/b/c'
-        ok {->{info.urlpath(1,2)}}.raise?(ArgumentError, /^wrong number of arguments \((2 for 3|given 2, expected 3)\)$/)
+        ok {info.path('a', 'b', 'c')} == '/books/a/b/c'
+        ok {->{info.path(1,2)}}.raise?(ArgumentError, /^wrong number of arguments \((2 for 3|given 2, expected 3)\)$/)
         #
         info = K8::ActionInfo.create('GET', '/books/{id}/{title}/{code}/{ref}')
         ok {info}.is_a?(K8::ActionInfo4)
-        ok {info.urlpath('a', 'b', 'c', 'd')} == '/books/a/b/c/d'
-        ok {->{info.urlpath}}.raise?(ArgumentError, /^wrong number of arguments \((0 for 4|given 0, expected 4)\)$/)
+        ok {info.path('a', 'b', 'c', 'd')} == '/books/a/b/c/d'
+        ok {->{info.path}}.raise?(ArgumentError, /^wrong number of arguments \((0 for 4|given 0, expected 4)\)$/)
       end
 
       spec "[!x5yx2] returns ActionInfo object when number of urlpath parameter > 4." do
         info = K8::ActionInfo.create('GET', '/books/{id}/{title}/{code}/{ref}/{x}')
         ok {info}.is_a?(K8::ActionInfo)
-        ok {info.urlpath('a', 'b', 'c', 'd', 'e')} == "/books/a/b/c/d/e"
+        ok {info.path('a', 'b', 'c', 'd', 'e')} == "/books/a/b/c/d/e"
         #
-        ok {->{info.urlpath('a','b','c')}}.raise?(ArgumentError, "too few arguments")
+        ok {->{info.path('a','b','c')}}.raise?(ArgumentError, "too few arguments")
       end
 
     end
@@ -1520,249 +1955,82 @@ Oktest.scope do
   end
 
 
-  topic K8::DefaultPatterns do
+  topic K8::ActionMapping do
 
 
-    topic '#register()' do
+    topic '#initialize()' do
 
-      spec "[!yfsom] registers urlpath param name, default pattern and converter block." do
-        K8::DefaultPatterns.new.instance_exec(self) do |_|
-          _.ok {@patterns.length} == 0
-          register(/_id\z/, '\d+') {|x| x.to_i }
-          _.ok {@patterns.length} == 1
-          _.ok {@patterns[0][0]} == /_id\z/
-          _.ok {@patterns[0][1]} == '\d+'
-          _.ok {@patterns[0][2]}.is_a?(Proc)
-          _.ok {@patterns[0][2].call("123")} == 123
+      spec "[!buj0d] prepares LRU cache if cache size specified." do
+        mapping = K8::ActionMapping.new([], urlpath_cache_size: 3)
+        mapping.instance_exec(self) do |_|
+          _.ok {@urlpath_cache_size} == 3
+          _.ok {@urlpath_lru_cache}  == {}
         end
-      end
-
-    end
-
-
-    topic '#unregister()' do
-
-      spec "[!3gplv] deletes matched record." do
-        K8::DefaultPatterns.new.instance_exec(self) do |_|
-          register("id",    '\d+') {|x| x.to_i }
-          register(/_id\z/, '\d+') {|x| x.to_i }
-          _.ok {@patterns.length} == 2
-          unregister(/_id\z/)
-          _.ok {@patterns.length} == 1
-          _.ok {@patterns[0][0]} == "id"
+        #
+        mapping = K8::ActionMapping.new([], urlpath_cache_size: 0)
+        mapping.instance_exec(self) do |_|
+          _.ok {@urlpath_cache_size} == 0
+          _.ok {@urlpath_lru_cache}  == nil
         end
       end
 
-    end
-
-
-    topic '#lookup()' do
-
-      spec "[!dvbqx] returns default pattern string and converter proc when matched." do
-        K8::DefaultPatterns.new.instance_exec(self) do |_|
-          register("id",    '\d+') {|x| x.to_i }
-          register(/_id\z/, '\d+') {|x| x.to_i }
-          _.ok {lookup("id")}.is_a?(Array).length(2)
-          _.ok {lookup("id")[0]} == '\d+'
-          _.ok {lookup("id")[1].call("123")} == 123
-          _.ok {lookup("book_id")[0]} == '\d+'
-          _.ok {lookup("book_id")[1]}.is_a?(Proc)
-          _.ok {lookup("book_id")[1].call("123")} == 123
+      spec "[!wsz8g] compiles urlpath mapping passed." do
+        mapping = K8::ActionMapping.new([
+            ['/api/books', BooksAction],
+        ])
+        ok {mapping.urlpath_rexp} == %r'\A/api/books/\d+(?:(\z)|/edit(\z))\z'
+        mapping.instance_exec(self) do |_|
+          _.ok {@fixed_endpoints.keys} == ['/api/books/', '/api/books/new']
+          _.ok {@variable_endpoints.map{|x| x[0]}} == ['/api/books/{id}', '/api/books/{id}/edit']
         end
       end
 
-      spec "[!6hblo] returns '[^/]*?' and nil as default pattern and converter proc when nothing matched." do
-        K8::DefaultPatterns.new.instance_exec(self) do |_|
-          register("id",    '\d+') {|x| x.to_i }
-          register(/_id\z/, '\d+') {|x| x.to_i }
-          _.ok {lookup("code")}.is_a?(Array).length(2)
-          _.ok {lookup("code")[0]} == '[^/]+?'
-          _.ok {lookup("code")[1]} == nil
+      spec "[!34o67] keyword arg 'enable_urlpath_param_range' controls to generate range object or not." do
+        arr  = [['/books', BooksAction]]
+        #
+        mapping1 = K8::ActionMapping.new(arr, enable_urlpath_param_range: true)
+        mapping1.instance_exec(self) do |_|
+          tuple = @variable_endpoints.find {|a| a[0] == '/books/{id}' }
+          _.ok {tuple[-1]} == (7..-1)
+        end
+        #
+        mapping2 = K8::ActionMapping.new(arr, enable_urlpath_param_range: false)
+        mapping2.instance_exec(self) do |_|
+          tuple = @variable_endpoints.find {|a| a[0] == '/books/{id}' }
+          _.ok {tuple[-1]} == nil
         end
       end
 
     end
 
-  end
 
+    topic '#build()' do
 
-  topic K8::DEFAULT_PATTERNS do
-
-    spec "[!i51id] registers '\d+' as default pattern of param 'id' or /_id\z/." do
-      pat, proc_ = K8::DEFAULT_PATTERNS.lookup('id')
-      ok {pat} == '\d+'
-      ok {proc_.call("123")} == 123
-      pat, proc_ = K8::DEFAULT_PATTERNS.lookup('book_id')
-      ok {pat} == '\d+'
-      ok {proc_.call("123")} == 123
-    end
-
-    spec "[!2g08b] registers '(?:\.\w+)?' as default pattern of param 'ext'." do
-      pat, proc_ = K8::DEFAULT_PATTERNS.lookup('ext')
-      ok {pat} == '(?:\.\w+)?'
-      ok {proc_} == nil
-    end
-
-    spec "[!8x5mp] registers '\d\d\d\d-\d\d-\d\d' as default pattern of param 'date' or /_date\z/." do
-      pat, proc_ = K8::DEFAULT_PATTERNS.lookup('date')
-      ok {pat} == '\d\d\d\d-\d\d-\d\d'
-      ok {proc_.call("2014-12-24")} == Date.new(2014, 12, 24)
-      pat, proc_ = K8::DEFAULT_PATTERNS.lookup('birth_date')
-      ok {pat} == '\d\d\d\d-\d\d-\d\d'
-      ok {proc_.call("2015-02-14")} == Date.new(2015, 2, 14)
-    end
-
-    spec "[!wg9vl] raises 404 error when invalid date (such as 2012-02-30)." do
-      pat, proc_ = K8::DEFAULT_PATTERNS.lookup('date')
-      pr = proc { proc_.call('2012-02-30') }
-      ok {pr}.raise?(K8::HttpException, "2012-02-30: invalid date.")
-      ok {pr.exception.status_code} == 404
-    end
-
-  end
-
-
-  topic K8::ActionMethodMapping do
-
-    fixture :mapping do
-      mapping = K8::ActionMethodMapping.new
-      mapping.map '/',         :GET=>:do_index, :POST=>:do_create
-      mapping.map '/{id:\d+}', :GET=>:do_show, :PUT=>:do_update
-      mapping
-    end
-
-    fixture :methods1 do
-      {:GET=>:do_index, :POST=>:do_create}
-    end
-
-    fixture :methods2 do
-      {:GET=>:do_show, :PUT=>:do_update}
-    end
-
-
-    topic '#map()' do
-
-      spec "[!s7cs9] maps urlpath and methods." do
-        |mapping|
-        arr = mapping.instance_variable_get('@mappings')
-        ok {arr}.is_a?(Array)
-        ok {arr.length} == 2
-        ok {arr[0]} == ['/',         {:GET=>:do_index, :POST=>:do_create}]
-        ok {arr[1]} == ['/{id:\d+}', {:GET=>:do_show, :PUT=>:do_update}]
-      end
-
-      spec "[!o6cxr] returns self." do
-        |mapping|
-        ok {mapping.map '/new', :GET=>:do_new}.same?(mapping)
-      end
-
-    end
-
-
-    topic '#each()' do
-
-      spec "[!62y5q] yields each urlpath pattern and action methods." do
-        |mapping, methods1, methods2|
-        arr = []
-        mapping.each do |urlpath_pat, action_methods|
-          arr << [urlpath_pat, action_methods]
-        end
-        ok {arr} == [
-          ['/',         methods1],
-          ['/{id:\d+}', methods2],
-        ]
-      end
-
-    end
-
-
-  end
-
-
-  topic K8::ActionMapping do
-
-
-    topic '#initialize()' do
-
-      spec "[!buj0d] prepares LRU cache if cache size specified." do
-        mapping = K8::ActionMapping.new([], urlpath_cache_size: 3)
-        mapping.instance_exec(self) do |_|
-          _.ok {@urlpath_cache_size} == 3
-          _.ok {@urlpath_lru_cache}  == {}
-        end
-        #
-        mapping = K8::ActionMapping.new([], urlpath_cache_size: 0)
-        mapping.instance_exec(self) do |_|
-          _.ok {@urlpath_cache_size} == 0
-          _.ok {@urlpath_lru_cache}  == nil
-        end
-      end
-
-      spec "[!wsz8g] compiles urlpath mapping passed." do
-        mapping = K8::ActionMapping.new([
-            ['/api/books', BooksAction],
-        ])
-        mapping.instance_exec(self) do |_|
-          _.ok {@urlpath_rexp} == %r'\A/api/books(?:/\d+(\z)|/\d+/edit(\z))\z'
-          _.ok {@fixed_endpoints.keys} == ['/api/books/', '/api/books/new']
-          _.ok {@variable_endpoints.map{|x| x[0]}} == ['/api/books/{id}', '/api/books/{id}/edit']
-        end
-      end
-
-      spec "[!34o67] keyword arg 'enable_urlpath_param_range' controls to generate range object or not." do
-        arr  = [['/books', BooksAction]]
-        #
-        mapping1 = K8::ActionMapping.new(arr, enable_urlpath_param_range: true)
-        mapping1.instance_exec(self) do |_|
-          tuple = @variable_endpoints.find {|a| a[0] == '/books/{id}' }
-          _.ok {tuple[-1]} == (7..-1)
-        end
-        #
-        mapping2 = K8::ActionMapping.new(arr, enable_urlpath_param_range: false)
-        mapping2.instance_exec(self) do |_|
-          tuple = @variable_endpoints.find {|a| a[0] == '/books/{id}' }
-          _.ok {tuple[-1]} == nil
-        end
-      end
-
-    end
-
-
-    topic '#compile()' do
-
-      fixture :proc1 do
-        proc {|x| x.to_i }
-      end
-
-      fixture :proc2 do
-        proc {|x| x.to_i }
+      fixture :proc_int do
+        K8::ActionMapping::URLPATH_PARAM_TYPES[0][3]
       end
 
       fixture :mapping do
-        |proc1, proc2|
-        dp = K8::DefaultPatterns.new
-        dp.register('id',    '\d+', &proc1)
-        dp.register(/_id\z/, '\d+', &proc2)
         K8::ActionMapping.new([
             ['/api', [
                 ['/books', BooksAction],
                 ['/books/{book_id}', BookCommentsAction],
             ]],
-        ], default_patterns: dp)
+        ])
       end
 
       spec "[!6f3vl] compiles urlpath mapping." do
         |mapping|
-        mapping.instance_exec(self) do |_|
-          _.ok {@urlpath_rexp}.is_a?(Regexp)
-          _.ok {@urlpath_rexp} == Regexp.compile('
+        ok {mapping.urlpath_rexp}.is_a?(Regexp)
+        ok {mapping.urlpath_rexp} == Regexp.compile('
                  \A/api
                     (?: /books
-                          (?: /\d+(\z) | /\d+/edit(\z) )
+                          /\d+ (?: (\z) | /edit(\z) )
                      |  /books/\d+
                           (?: /comments(\z) | /comments/\d+(\z) )
                     )
                  \z'.gsub(/\s/, ''))
+        mapping.instance_exec(self) do |_|
           _.ok {@fixed_endpoints.keys} == ["/api/books/", "/api/books/new"]
           _.ok {@variable_endpoints.map{|x| x[0..2] }} == [
             ["/api/books/{id}", BooksAction, {:GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete}],
@@ -1774,76 +2042,76 @@ Oktest.scope do
       end
 
       spec "[!w45ad] can compile nested array." do
-        |mapping, proc1, proc2|
-        mapping.instance_exec(self) do |_|
-          _.ok {@urlpath_rexp} == Regexp.compile('
+        |mapping, proc_int|
+        ok {mapping.urlpath_rexp} == Regexp.compile('
             \A  /api
                     (?: /books
-                            (?: /\d+(\z) | /\d+/edit(\z) )
+                            /\d+ (?: (\z) | /edit(\z) )
                      |  /books/\d+
                             (?: /comments(\z) | /comments/\d+(\z) )
                     )
             \z'.gsub(/\s/, ''))
+        mapping.instance_exec(self) do |_|
           _.ok {@variable_endpoints} == [
             ["/api/books/{id}",
               BooksAction,
               {:GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete},
               /\A\/api\/books\/(\d+)\z/,
-              ["id"], [proc1], (11..-1),
+              ["id"], [proc_int], (11..-1),
             ],
             ["/api/books/{id}/edit",
               BooksAction,
               {:GET=>:do_edit},
               /\A\/api\/books\/(\d+)\/edit\z/,
-              ["id"], [proc1], (11..-6),
+              ["id"], [proc_int], (11..-6),
             ],
             ["/api/books/{book_id}/comments",
               BookCommentsAction,
               {:GET=>:do_comments},
               /\A\/api\/books\/(\d+)\/comments\z/,
-              ["book_id"], [proc2], (11..-10),
+              ["book_id"], [proc_int], (11..-10),
             ],
             ["/api/books/{book_id}/comments/{comment_id}",
               BookCommentsAction,
               {:GET=>:do_comment},
               /\A\/api\/books\/(\d+)\/comments\/(\d+)\z/,
-              ["book_id", "comment_id"], [proc2, proc2], nil,
+              ["book_id", "comment_id"], [proc_int, proc_int], nil,
             ],
           ]
           _.ok {@fixed_endpoints} == {
-            "/api/books/"   =>["/api/books/", BooksAction, {:GET=>:do_index, :POST=>:do_create}],
-            "/api/books/new"=>["/api/books/new", BooksAction, {:GET=>:do_new}],
+            "/api/books/"   =>["/api/books/", BooksAction, {:GET=>:do_index, :POST=>:do_create}, []],
+            "/api/books/new"=>["/api/books/new", BooksAction, {:GET=>:do_new}, []],
           }
         end
       end
 
       spec "[!z2iax] classifies urlpath contains any parameter as variable one." do
-        |mapping, proc1, proc2|
+        |mapping, proc_int|
         mapping.instance_exec(self) do |_|
           _.ok {@variable_endpoints} == [
             ["/api/books/{id}",
               BooksAction,
               {:GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete},
               /\A\/api\/books\/(\d+)\z/,
-              ["id"], [proc1], (11..-1),
+              ["id"], [proc_int], (11..-1),
             ],
             ["/api/books/{id}/edit",
               BooksAction,
               {:GET=>:do_edit},
               /\A\/api\/books\/(\d+)\/edit\z/,
-              ["id"], [proc1], (11..-6),
+              ["id"], [proc_int], (11..-6),
             ],
             ["/api/books/{book_id}/comments",
               BookCommentsAction,
               {:GET=>:do_comments},
               /\A\/api\/books\/(\d+)\/comments\z/,
-              ["book_id"], [proc2], (11..-10),
+              ["book_id"], [proc_int], (11..-10),
             ],
             ["/api/books/{book_id}/comments/{comment_id}",
               BookCommentsAction,
               {:GET=>:do_comment},
               /\A\/api\/books\/(\d+)\/comments\/(\d+)\z/,
-              ["book_id", "comment_id"], [proc2, proc2], nil,
+              ["book_id", "comment_id"], [proc_int, proc_int], nil,
             ],
           ]
         end
@@ -1853,8 +2121,8 @@ Oktest.scope do
         |mapping|
         mapping.instance_exec(self) do |_|
           _.ok {@fixed_endpoints} == {
-            "/api/books/" => ["/api/books/", BooksAction, {:GET=>:do_index, :POST=>:do_create}],
-            "/api/books/new" => ["/api/books/new", BooksAction, {:GET=>:do_new}],
+            "/api/books/" => ["/api/books/", BooksAction, {:GET=>:do_index, :POST=>:do_create}, []],
+            "/api/books/new" => ["/api/books/new", BooksAction, {:GET=>:do_new}, []],
           }
         end
       end
@@ -1878,56 +2146,55 @@ Oktest.scope do
         ])
         #
         ok {Ex_6xwhq[:do_create]} != nil
-        ok {Ex_6xwhq[:do_create].method} == :POST
-        ok {Ex_6xwhq[:do_create].urlpath} == '/test/example4'
+        ok {Ex_6xwhq[:do_create].meth} == :POST
+        ok {Ex_6xwhq[:do_create].path} == '/test/example4'
         ok {Ex_6xwhq[:do_update]} != nil
-        ok {Ex_6xwhq[:do_update].method} == :PUT
-        ok {Ex_6xwhq[:do_update].urlpath(123)} == '/test/example4/123'
+        ok {Ex_6xwhq[:do_update].meth} == :PUT
+        ok {Ex_6xwhq[:do_update].path(123)} == '/test/example4/123'
       end
 
       spec "[!wd2eb] accepts subclass of Action class." do
-        _, proc1 = K8::DEFAULT_PATTERNS.lookup('id')
-        _, proc2 = K8::DEFAULT_PATTERNS.lookup('book_id')
+        proc_int = K8::ActionMapping::URLPATH_PARAM_TYPES[0][3]
         mapping = K8::ActionMapping.new([
             ['/api/books', BooksAction],
             ['/api/books/{book_id}', BookCommentsAction],
         ])
-        mapping.instance_exec(self) do |_|
-          _.ok {@urlpath_rexp} == Regexp.compile('
+        ok {mapping.urlpath_rexp} == Regexp.compile('
             \A  (?: /api/books
-                       (?: /\d+(\z) | /\d+/edit(\z) )
+                       /\d+ (?: (\z) | /edit(\z) )
                  |  /api/books/\d+
                        (?: /comments(\z) | /comments/\d+(\z) )
                 )
             \z'.gsub(/\s/, ''))
+        mapping.instance_exec(self) do |_|
           _.ok {@fixed_endpoints} == {
-            "/api/books/"   =>["/api/books/", BooksAction, {:GET=>:do_index, :POST=>:do_create}],
-            "/api/books/new"=>["/api/books/new", BooksAction, {:GET=>:do_new}],
+            "/api/books/"   =>["/api/books/", BooksAction, {:GET=>:do_index, :POST=>:do_create}, []],
+            "/api/books/new"=>["/api/books/new", BooksAction, {:GET=>:do_new}, []],
           }
           _.ok {@variable_endpoints} == [
             ["/api/books/{id}",
               BooksAction,
               {:GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete},
               /\A\/api\/books\/(\d+)\z/,
-              ["id"], [proc1], (11..-1),
+              ["id"], [proc_int], (11..-1),
             ],
             ["/api/books/{id}/edit",
               BooksAction,
               {:GET=>:do_edit},
               /\A\/api\/books\/(\d+)\/edit\z/,
-              ["id"], [proc1], (11..-6),
+              ["id"], [proc_int], (11..-6),
             ],
             ["/api/books/{book_id}/comments",
               BookCommentsAction,
               {:GET=>:do_comments},
               /\A\/api\/books\/(\d+)\/comments\z/,
-              ["book_id"], [proc2], (11..-10),
+              ["book_id"], [proc_int], (11..-10),
             ],
             ["/api/books/{book_id}/comments/{comment_id}",
               BookCommentsAction,
               {:GET=>:do_comment},
               /\A\/api\/books\/(\d+)\/comments\/(\d+)\z/,
-              ["book_id", "comment_id"], [proc2, proc2], nil,
+              ["book_id", "comment_id"], [proc_int, proc_int], nil,
             ],
           ]
         end
@@ -1962,17 +2229,16 @@ Oktest.scope do
         File.open(filename, 'w') {|f| f << content }
         at_end { File.unlink filename; Dir.rmdir dirname }
         #
-        _, proc1 = K8::DEFAULT_PATTERNS.lookup('id')
-        _, proc2 = K8::DEFAULT_PATTERNS.lookup('book_id')
+        proc_int = K8::ActionMapping::URLPATH_PARAM_TYPES[0][3]
         mapping = K8::ActionMapping.new([
             ['/api/example', './test_l2kz5/sample:Ex_l2kz5::Example_l2kz5'],
         ])
         mapping.instance_exec(self) do |_|
           _.ok {@fixed_endpoints} == {
-            "/api/example"=>["/api/example", Ex_l2kz5::Example_l2kz5, {:GET=>:do_index}],
+            "/api/example"=>["/api/example", Ex_l2kz5::Example_l2kz5, {:GET=>:do_index}, []],
           }
           _.ok {@variable_endpoints} == [
-            ["/api/example/{id}", Ex_l2kz5::Example_l2kz5, {:GET=>:do_show}, /\A\/api\/example\/(\d+)\z/, ["id"], [proc1], (13..-1)],
+            ["/api/example/{id}", Ex_l2kz5::Example_l2kz5, {:GET=>:do_show}, /\A\/api\/example\/(\d+)\z/, ["id"], [proc_int], (13..-1)],
           ]
         end
       end
@@ -2000,17 +2266,17 @@ Oktest.scope do
                 ['/books/{book_id}', BookCommentsAction],
             ]],
         ])
-        mapping.instance_exec(self) do |_|
-          _.ok {@urlpath_rexp} == Regexp.compile('
+        ok {mapping.urlpath_rexp} == Regexp.compile('
               \A  /api
                       (?:  /books
-                               (?:/\d+(\z)|/\d+/edit(\z))
+                               /\d+(?:(\z)|/edit(\z))
                       |    /books/\d+
                                (?:/comments(\z)|/comments/\d+(\z))
                       )
               \z'.gsub(/\s+/, ''))
-          _.ok {@fixed_endpoints['/api/samples/']} == ["/api/samples/", klass, {:GET=>:do_index}]
-          _.ok {@fixed_endpoints['/api/samples/new']} == ["/api/samples/new", klass, {:GET=>:do_new}]
+        mapping.instance_exec(self) do |_|
+          _.ok {@fixed_endpoints['/api/samples/']} == ["/api/samples/", klass, {:GET=>:do_index}, []]
+          _.ok {@fixed_endpoints['/api/samples/new']} == ["/api/samples/new", klass, {:GET=>:do_new}, []]
         end
       end
 
@@ -2024,90 +2290,124 @@ Oktest.scope do
                 ['/test', klass],
             ]],
         ])
-        mapping.instance_exec(self) do |_|
-          #_.ok {@urlpath_rexp} == %r'\A(?:/api(?:/test(?:/\d+(\z))))\z'
-          _.ok {@urlpath_rexp} == %r'\A/api/test/\d+(\z)\z'
+        ok {mapping.urlpath_rexp} == %r'\A/api/test/\d+(\z)\z'
+      end
+
+      spec "[!abj34] ex: (?:/\d+(\z)|/\d+/edit(\z)) -> /d+(?:(\z)|/edit(\z))" do
+        klass = Class.new(K8::Action) do
+          mapping '/'             , :GET=>:do_index
+          mapping '/{id}'         , :GET=>:do_show
+          mapping '/{id}/edit'    , :GET=>:do_edit
+          mapping '/{id}/comments', :GET=>:do_comments
+          def do_index; end
+          def do_show(id); end
+          def do_edit(id); end
+          def do_comments(id); end
         end
+        mapping = K8::ActionMapping.new([
+            ['/api', [
+                ['/books', BooksAction],
+                ['/samples', klass],
+            ]],
+        ])
+        ok {mapping.urlpath_rexp} == Regexp.compile('
+              \A  /api
+                      (?:  /books
+                               /\d+(?:(\z)|/edit(\z))
+                      |    /samples
+                               /\d+(?:(\z)|/edit(\z)|/comments(\z))
+                      )
+              \z'.gsub(/\s+/, ''))
       end
 
-    end
+      spec "[!m51yy] regards '.*' at end of urlpath pattern as extension." do
+        cls = Class.new(K8::Action) do
+          mapping '.*',      :GET=>:do_index
+          mapping '/{id}.*', :GET=>:do_show
+          def do_index; end
+          def do_show(id); end
+        end
+        am = K8::ActionMapping.new([
+            ['/api', [
+                ['/foo', cls],
+            ]],
+        ])
+        ok {am.urlpath_rexp} == Regexp.compile('
+              \A /api
+                     /foo (?:      (?:\.\w+)? (\z)
+                           |  /\d+ (?:\.\w+)? (\z)
+                          )
+              \z'.gsub(/\s+/, ''))
+      end
 
+    end
 
-    topic '#lookup()' do
 
-      fixture :proc1 do
-        proc {|x| x.to_i }
-      end
+    topic '#find()' do
 
       fixture :mapping do
-        |proc1|
-        dp = K8::DefaultPatterns.new
-        dp.register('id',   '\d+', &proc1)
-        dp.register(/_id$/, '\d+', &proc1)
         K8::ActionMapping.new([
             ['/api', [
                 ['/books', BooksAction],
                 ['/books/{book_id}', BookCommentsAction],
             ]],
-        ], default_patterns: dp, urlpath_cache_size: 3)
+        ], urlpath_cache_size: 3)
       end
 
-      spec "[!jyxlm] returns action class and methods, parameter names and values." do
+      spec "[!jyxlm] returns action class, action methods and urlpath param args." do
         |mapping|
-        tuple = mapping.lookup('/api/books/123')
-        ok {tuple} == [BooksAction, {:GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete}, ['id'], [123]]
-        tuple = mapping.lookup('/api/books/123/comments/999')
-        ok {tuple} == [BookCommentsAction, {:GET=>:do_comment}, ['book_id', 'comment_id'], [123, 999]]
+        tuple = mapping.find('/api/books/123')
+        ok {tuple} == [BooksAction, {:GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete}, [123]]
+        tuple = mapping.find('/api/books/123/comments/999')
+        ok {tuple} == [BookCommentsAction, {:GET=>:do_comment}, [123, 999]]
       end
 
       spec "[!j34yh] finds from fixed urlpaths at first." do
         |mapping|
         mapping.instance_exec(self) do |_|
-          _.ok {lookup('/books')} == nil
+          _.ok {find('/books')} == nil
           tuple = @fixed_endpoints['/api/books/']
           _.ok {tuple} != nil
           @fixed_endpoints['/books'] = tuple
-          expected = [BooksAction, {:GET=>:do_index, :POST=>:do_create}, [], []]
-          _.ok {lookup('/books')} != nil
-          _.ok {lookup('/books')} == expected
-          _.ok {lookup('/api/books/')} == expected
+          expected = [BooksAction, {:GET=>:do_index, :POST=>:do_create}, []]
+          _.ok {find('/books')} != nil
+          _.ok {find('/books')} == expected
+          _.ok {find('/api/books/')} == expected
         end
       end
 
       spec "[!95q61] finds from variable urlpath patterns when not found in fixed ones." do
         |mapping|
-        ok {mapping.lookup('/api/books/123')} == \
+        ok {mapping.find('/api/books/123')} == \
           [
             BooksAction,
             {:GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete},
-            ["id"],
             [123],
           ]
-        ok {mapping.lookup('/api/books/123/comments/999')} == \
+        ok {mapping.find('/api/books/123/comments/999')} == \
           [
             BookCommentsAction,
             {:GET=>:do_comment},
-            ["book_id", "comment_id"],
             [123, 999],
           ]
       end
 
       spec "[!sos5i] returns nil when request path not matched to urlpath patterns." do
         |mapping|
-        ok {mapping.lookup('/api/booking')} == nil
+        ok {mapping.find('/api/booking')} == nil
       end
 
       spec "[!1k1k5] converts urlpath param values by converter procs." do
         |mapping|
-        tuple = mapping.lookup('/api/books/123')
-        ok {tuple[2..3]} == [['id'], [123]]
-        tuple = mapping.lookup('/api/books/123/comments/999')
-        ok {tuple[2..3]} == [['book_id', 'comment_id'], [123, 999]]
+        tuple = mapping.find('/api/books/123')
+        ok {tuple[-1]} == [123]   # id
+        tuple = mapping.find('/api/books/123/comments/999')
+        ok {tuple[-1]} == [123, 999]  # book_id, comment_id
       end
 
       spec "[!uqwr7] stores result into cache if cache is enabled." do
         |mapping|
-        tuple = mapping.lookup('/api/books/111')
+        tuple = mapping.find('/api/books/111')
         mapping.instance_exec(self) do |_|
           _.ok {@urlpath_lru_cache} == {'/api/books/111' => tuple}
         end
@@ -2115,11 +2415,11 @@ Oktest.scope do
 
       spec "[!3ps5g] deletes item from cache when cache size over limit." do
         |mapping|
-        mapping.lookup('/api/books/1')
-        mapping.lookup('/api/books/2')
-        mapping.lookup('/api/books/3')
-        mapping.lookup('/api/books/4')
-        mapping.lookup('/api/books/5')
+        mapping.find('/api/books/1')
+        mapping.find('/api/books/2')
+        mapping.find('/api/books/3')
+        mapping.find('/api/books/4')
+        mapping.find('/api/books/5')
         mapping.instance_exec(self) do |_|
           _.ok {@urlpath_lru_cache.length} == 3
         end
@@ -2128,18 +2428,18 @@ Oktest.scope do
       spec "[!uqwr7] uses LRU as cache algorithm." do
         |mapping|
         mapping.instance_exec(self) do |_|
-          t1 = lookup('/api/books/1')
-          t2 = lookup('/api/books/2')
-          t3 = lookup('/api/books/3')
+          t1 = find('/api/books/1')
+          t2 = find('/api/books/2')
+          t3 = find('/api/books/3')
           _.ok {@urlpath_lru_cache.values} == [t1, t2, t3]
-          t4 = lookup('/api/books/4')
+          t4 = find('/api/books/4')
           _.ok {@urlpath_lru_cache.values} == [t2, t3, t4]
-          t5 = lookup('/api/books/5')
+          t5 = find('/api/books/5')
           _.ok {@urlpath_lru_cache.values} == [t3, t4, t5]
           #
-          lookup('/api/books/4')
+          find('/api/books/4')
           _.ok {@urlpath_lru_cache.values} == [t3, t5, t4]
-          lookup('/api/books/3')
+          find('/api/books/3')
           _.ok {@urlpath_lru_cache.values} == [t5, t4, t3]
         end
       end
@@ -2147,103 +2447,148 @@ Oktest.scope do
     end
 
 
-    topic '#_compile_urlpath_pat()' do
+    topic '#compile_urlpath()' do
+
+      fixture :proc_int do
+        K8::ActionMapping::URLPATH_PARAM_TYPES[0][3]  # for 'int' type
+      end
 
-      fixture :proc1 do
-        proc {|x| x.to_i }
+      fixture :proc_date do
+        K8::ActionMapping::URLPATH_PARAM_TYPES[1][3]  # for 'date' type
       end
 
-      fixture :default_patterns do
-        |proc1|
-        x = K8::DefaultPatterns.new
-        x.register('id',   '\d+', &proc1)
-        x.register(/_id$/, '\d+', &proc1)
-        x
+      fixture :proc_str do
+        K8::ActionMapping::URLPATH_PARAM_TYPES[2][3]  # for 'str' type
       end
 
       spec "[!awfgs] returns regexp string, param names, and converter procs." do
-        |default_patterns, proc1|
-        mapping = K8::ActionMapping.new([], default_patterns: default_patterns)
+        |proc_int|
+        mapping = K8::ActionMapping.new([])
         mapping.instance_exec(self) do |_|
           #
-          actual = _compile_urlpath_pat('/books/{id}')
-          _.ok {actual} == ['/books/\d+', ['id'], [proc1]]
+          actual = compile_urlpath('/books/{id}')
+          _.ok {actual} == ['/books/\d+', ['id'], [proc_int]]
           #
-          actual = _compile_urlpath_pat('/books/{book_id}/comments/{comment_id}')
-          _.ok {actual} == ['/books/\d+/comments/\d+', ['book_id', 'comment_id'], [proc1, proc1]]
+          actual = compile_urlpath('/books/{book_id}/comments/{comment_id}')
+          _.ok {actual} == ['/books/\d+/comments/\d+', ['book_id', 'comment_id'], [proc_int, proc_int]]
           #
-          actual = _compile_urlpath_pat('/books/{id:[0-9]+}')
-          _.ok {actual} == ['/books/[0-9]+', ['id'], [nil]]
+          actual = compile_urlpath('/books/{id:<[0-9]+>}')
+          _.ok {actual} == ['/books/[0-9]+', ['id'], [proc_int]]
         end
       end
 
       spec "[!bi7gr] captures urlpath params when 2nd argument is truthy." do
-        |default_patterns, proc1|
-        mapping = K8::ActionMapping.new([], default_patterns: default_patterns)
+        |proc_int|
+        mapping = K8::ActionMapping.new([])
         mapping.instance_exec(self) do |_|
-          actual = _compile_urlpath_pat('/books/{id}', true)
-          _.ok {actual} == ['/books/(\d+)', ['id'], [proc1]]
+          actual = compile_urlpath('/books/{id}', true)
+          _.ok {actual} == ['/books/(\d+)', ['id'], [proc_int]]
           #
-          actual = _compile_urlpath_pat('/books/{book_id}/comments/{comment_id}', true)
-          _.ok {actual} == ['/books/(\d+)/comments/(\d+)', ['book_id', 'comment_id'], [proc1, proc1]]
+          actual = compile_urlpath('/books/{book_id}/comments/{comment_id}', true)
+          _.ok {actual} == ['/books/(\d+)/comments/(\d+)', ['book_id', 'comment_id'], [proc_int, proc_int]]
           #
-          actual = _compile_urlpath_pat('/books/{id:[0-9]+}', true)
-          _.ok {actual} == ['/books/([0-9]+)', ['id'], [nil]]
+          actual = compile_urlpath('/books/{id:<[0-9]+>}', true)
+          _.ok {actual} == ['/books/([0-9]+)', ['id'], [proc_int]]
         end
       end
 
       spec "[!mprbx] ex: '/{id:x|y}' -> '/(x|y)', '/{:x|y}' -> '/(?:x|y)'" do
-        |default_patterns|
-        mapping = K8::ActionMapping.new([], default_patterns: default_patterns)
+        mapping = K8::ActionMapping.new([])
         mapping.instance_exec(self) do |_|
-          _.ok {_compile_urlpath_pat('/item/{key:x|y}', true)}  == ['/item/(x|y)', ['key'], [nil]]
-          _.ok {_compile_urlpath_pat('/item/{key:x|y}', false)} == ['/item/(?:x|y)', ['key'], [nil]]
-          _.ok {_compile_urlpath_pat('/item/{:x|y}',    true)}  == ['/item/(?:x|y)', [], []]
-          _.ok {_compile_urlpath_pat('/item/{:x|y}',    false)} == ['/item/(?:x|y)', [], []]
+          _.ok {compile_urlpath('/item/{key:<x|y>}', true)}  == ['/item/(x|y)', ['key'], [nil]]
+          _.ok {compile_urlpath('/item/{key:<x|y>}', false)} == ['/item/(?:x|y)', ['key'], [nil]]
+          _.ok {compile_urlpath('/item/{:<x|y>}',    true)}  == ['/item/(?:x|y)', [], []]
+          _.ok {compile_urlpath('/item/{:<x|y>}',    false)} == ['/item/(?:x|y)', [], []]
         end
       end
 
       spec "[!iln54] param names and conveter procs are nil when no urlpath params." do
-        |default_patterns|
-        mapping = K8::ActionMapping.new([], default_patterns: default_patterns)
+        mapping = K8::ActionMapping.new([])
         mapping.instance_exec(self) do |_|
-          actual = _compile_urlpath_pat('/books/new')
+          actual = compile_urlpath('/books/new')
           _.ok {actual} == ['/books/new', nil, nil]
         end
       end
 
+      spec "[!9ofdd] supports urlpath param type, for example '{id:int}'." do
+        |proc_int, proc_date, proc_str|
+        mapping = K8::ActionMapping.new([])
+        mapping.instance_exec(self) do |_|
+          actual = compile_urlpath('/books/{id:int}')
+          _.ok {actual} == ['/books/\d+', ['id'], [proc_int]]
+          actual = compile_urlpath('/books/{book_id:int}')
+          _.ok {actual} == ['/books/\d+', ['book_id'], [proc_int]]
+          actual = compile_urlpath('/books/{code:int}')
+          _.ok {actual} == ['/books/\d+', ['code'], [proc_int]]
+          #
+          actual = compile_urlpath('/diary/{today:date}')
+          _.ok {actual} == ['/diary/\d\d\d\d-\d\d-\d\d', ['today'], [proc_date]]
+          #
+          actual = compile_urlpath('/books/{id:str}')
+          _.ok {actual} == ['/books/[^/]+', ['id'], [proc_str]]
+        end
+      end
+
       spec "[!lhtiz] skips empty param name." do
-        |default_patterns, proc1|
-        K8::ActionMapping.new([], default_patterns: default_patterns).instance_exec(self) do |_|
-          actual = _compile_urlpath_pat('/api/{:\d+}/books')
+        |proc_int|
+        K8::ActionMapping.new([]).instance_exec(self) do |_|
+          actual = compile_urlpath('/api/{:<\d+>}/books')
           _.ok {actual} == ['/api/\d+/books', [], []]
-          actual = _compile_urlpath_pat('/api/{:\d+}/books/{id}')
-          _.ok {actual} == ['/api/\d+/books/\d+', ['id'], [proc1]]
+          actual = compile_urlpath('/api/{:<\d+>}/books/{id}')
+          _.ok {actual} == ['/api/\d+/books/\d+', ['id'], [proc_int]]
         end
       end
 
       spec "[!66zas] skips param name starting with '_'." do
-        |default_patterns, proc1|
-        K8::ActionMapping.new([], default_patterns: default_patterns).instance_exec(self) do |_|
-          actual = _compile_urlpath_pat('/api/{_ver:\d+}/books')
+        |proc_int|
+        K8::ActionMapping.new([]).instance_exec(self) do |_|
+          actual = compile_urlpath('/api/{_ver:<\d+>}/books')
           _.ok {actual} == ['/api/\d+/books', [], []]
-          actual = _compile_urlpath_pat('/api/{_ver:\d+}/books/{id}')
-          _.ok {actual} == ['/api/\d+/books/\d+', ['id'], [proc1]]
+          actual = compile_urlpath('/api/{_ver:<\d+>}/books/{id}')
+          _.ok {actual} == ['/api/\d+/books/\d+', ['id'], [proc_int]]
         end
       end
 
       spec "[!92jcn] '{' and '}' are available in urlpath param pattern." do
-        |default_patterns, proc1|
-        K8::ActionMapping.new([], default_patterns: default_patterns).instance_exec(self) do |_|
-          actual = _compile_urlpath_pat('/blog/{date:\d{4}-\d{2}-\d{2}}')
-          _.ok {actual} == ['/blog/\d{4}-\d{2}-\d{2}', ['date'], [nil]]
+        |proc_date|
+        K8::ActionMapping.new([]).instance_exec(self) do |_|
+          actual = compile_urlpath('/blog/{date:<\d{4}-\d{2}-\d{2}>}')
+          _.ok {actual} == ['/blog/\d{4}-\d{2}-\d{2}', ['date'], [proc_date]]
+        end
+      end
+
+      spec "[!do1zi] param type is optional (ex: '{id}' or '{id:<\d+>}')." do
+        |proc_int|
+        K8::ActionMapping.new([]).instance_exec(self) do |_|
+          actual = compile_urlpath('/books/{book_id}')
+          _.ok {actual} == ['/books/\d+', ['book_id'], [proc_int]]
+          actual = compile_urlpath('/books/{xxx:<\d\d\d>}')
+          _.ok {actual} == ['/books/\d\d\d', ['xxx'], [nil]]
+        end
+      end
+
+      spec "[!my6as] param pattern is optional (ex: '{id}' or '{id:int}')." do
+        |proc_int|
+        K8::ActionMapping.new([]).instance_exec(self) do |_|
+          actual = compile_urlpath('/books/{book_id}')
+          _.ok {actual} == ['/books/\d+', ['book_id'], [proc_int]]
+          actual = compile_urlpath('/books/{xxx:int}')
+          _.ok {actual} == ['/books/\d+', ['xxx'], [proc_int]]
+        end
+      end
+
+      spec "[!3diea] '{id:<\d+>}' is ok but '{id<\d+>}' raises error." do
+        |proc_int|
+        K8::ActionMapping.new([]).instance_exec(self) do |_|
+          pr = proc { compile_urlpath('/books/{book_id<\d+>}') }
+          _.ok {pr}.raise?(K8::ActionMappingError)
         end
       end
 
     end
 
 
-    topic '#_require_action_class()' do
+    topic '#require_action_class()' do
 
       spec "[!px9jy] requires file and finds class object." do
         filename = 'test_px9jy.rb'
@@ -2251,7 +2596,7 @@ Oktest.scope do
         File.open(filename, 'w') {|f| f << content }
         at_end { File.unlink filename }
         K8::ActionMapping.new([]).instance_exec(self) do |_|
-          _.ok { _require_action_class './test_px9jy:Ex_px9jy' } == Ex_px9jy
+          _.ok { require_action_class './test_px9jy:Ex_px9jy' } == Ex_px9jy
         end
       end
 
@@ -2261,7 +2606,7 @@ Oktest.scope do
         File.open(filename, 'w') {|f| f << content }
         at_end { File.unlink filename }
         K8::ActionMapping.new([]).instance_exec(self) do |_|
-          pr = proc { _require_action_class './test_dlcks:Ex_dlcks' }
+          pr = proc { require_action_class './test_dlcks:Ex_dlcks' }
           _.ok {pr}.raise?(LoadError, "cannot load such file -- homhomhom")
           _.ok {pr.exception.path} == "homhomhom"
         end
@@ -2270,7 +2615,7 @@ Oktest.scope do
       spec "[!mngjz] raises error when failed to load file." do
         filename = 'test_mngjz.rb'
         K8::ActionMapping.new([]).instance_exec(self) do |_|
-          pr = proc { _require_action_class './test_mngjz:Ex_mngjz' }
+          pr = proc { require_action_class './test_mngjz:Ex_mngjz' }
           _.ok {pr}.raise?(LoadError, "'./test_mngjz:Ex_mngjz': cannot load './test_mngjz'.")
         end
       end
@@ -2281,7 +2626,7 @@ Oktest.scope do
         File.open(filename, 'w') {|f| f << content }
         at_end { File.unlink filename }
         K8::ActionMapping.new([]).instance_exec(self) do |_|
-          _.ok { _require_action_class './test_8n6pf:Ex_8n6pf::Sample' } == Ex_8n6pf::Sample
+          _.ok { require_action_class './test_8n6pf:Ex_8n6pf::Sample' } == Ex_8n6pf::Sample
         end
       end
 
@@ -2291,7 +2636,7 @@ Oktest.scope do
         File.open(filename, 'w') {|f| f << content }
         at_end { File.unlink filename }
         K8::ActionMapping.new([]).instance_exec(self) do |_|
-          pr = proc { _require_action_class './test_6lv7l:Ex_6lv7l::Sample' }
+          pr = proc { require_action_class './test_6lv7l:Ex_6lv7l::Sample' }
           _.ok {pr}.raise?(NameError, "'./test_6lv7l:Ex_6lv7l::Sample': class not found (Ex_6lv7l::Sample).")
         end
       end
@@ -2302,7 +2647,7 @@ Oktest.scope do
         File.open(filename, 'w') {|f| f << content }
         at_end { File.unlink filename }
         K8::ActionMapping.new([]).instance_exec(self) do |_|
-          pr = proc { _require_action_class './test_thf7t:Ex_thf7t' }
+          pr = proc { require_action_class './test_thf7t:Ex_thf7t' }
           _.ok {pr}.raise?(TypeError, "'./test_thf7t:Ex_thf7t': class name expected but got \"XXX\".")
         end
       end
@@ -2313,7 +2658,7 @@ Oktest.scope do
         File.open(filename, 'w') {|f| f << content }
         at_end { File.unlink filename }
         K8::ActionMapping.new([]).instance_exec(self) do |_|
-          pr = proc { _require_action_class './test_yqcgx:Ex_yqcgx' }
+          pr = proc { require_action_class './test_yqcgx:Ex_yqcgx' }
           _.ok {pr}.raise?(TypeError, "'./test_yqcgx:Ex_yqcgx': expected subclass of K8::Action but not.")
         end
       end
@@ -2373,6 +2718,30 @@ Oktest.scope do
     end
 
 
+    topic 'K8::REQUEST_CLASS=' do
+
+      spec "[!7uqb4] changes default request class." do
+        original = K8::RackApplication::REQUEST_CLASS
+        at_end { K8::RackApplication.REQUEST_CLASS = original }
+        K8::RackApplication.REQUEST_CLASS = Array
+        ok {K8::RackApplication::REQUEST_CLASS} == Array
+      end
+
+    end
+
+
+    topic 'K8::RESPONSE_CLASS=' do
+
+      spec "[!c1bd0] changes default response class." do
+        original = K8::RackApplication::RESPONSE_CLASS
+        at_end { K8::RackApplication.RESPONSE_CLASS = original }
+        K8::RackApplication.RESPONSE_CLASS = Hash
+        ok {K8::RackApplication::RESPONSE_CLASS} == Hash
+      end
+
+    end
+
+
     topic '#initialize()' do
 
       spec "[!vkp65] mounts urlpath mappings." do
@@ -2414,14 +2783,83 @@ Oktest.scope do
     end
 
 
-    topic '#lookup()' do
+    topic '#find()' do
 
       spec "[!o0rnr] returns action class, action methods, urlpath names and values." do
         |app|
-        ret = app.lookup('/api/books/')
-        ok {ret} == [BooksAction, {:GET=>:do_index, :POST=>:do_create}, [], []]
-        ret = app.lookup('/api/books/123')
-        ok {ret} == [BooksAction, {:GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete}, ["id"], [123]]
+        ret = app.find('/api/books/')
+        ok {ret} == [BooksAction, {:GET=>:do_index, :POST=>:do_create}, []]
+        ret = app.find('/api/books/123')
+        ok {ret} == [BooksAction, {:GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete}, [123]]
+      end
+
+    end
+
+
+    topic '#lookup()' do
+
+      spec "[!7476i] uses '_method' value of query string as request method when 'POST' method." do
+        |app|
+        tuple = app.lookup(:POST, "/api/books/123", "_method=DELETE")
+        ok {tuple} == [BooksAction, :do_delete, [123]]  # found :do_delete
+      end
+
+      spec "[!c0job] redirects only when request method is GET or HEAD." do
+        |app|
+        ## not redirect on :POST
+        pr3 = proc { app.lookup(:POST, "/api/books", "") }
+        ok {pr3}.raise?(K8::HttpException)
+        ex3 = pr3.exception
+        ok {ex3.status_code} == 404
+      end
+
+      spec "[!u1qfv] raises 301 when urlpath not found but found with tailing '/'." do
+        |app|
+        pr = proc { app.lookup(:GET, "/api/books", "") }
+        ok {pr}.raise?(K8::HttpException)
+        ex = pr.exception
+        ok {ex.status_code} == 301
+        ok {ex.response_headers} == {"Location"=>"/api/books/"}
+      end
+
+      spec "[!kbff3] raises 301 when urlpath not found but found without tailing '/'." do
+        |app|
+        pr = proc { app.lookup(:GET, "/api/books/123/", "") }
+        ok {pr}.raise?(K8::HttpException)
+        ex = pr.exception
+        ok {ex.status_code} == 301
+        ok {ex.response_headers} == {"Location"=>"/api/books/123"}
+      end
+
+      spec "[!cgxx4] adds query string to 'Location' header when redirecting." do
+        |app|
+        pr = proc { app.lookup(:GET, "/api/books", "x=1&y=2") }
+        ok {pr}.raise?(K8::HttpException)
+        ex = pr.exception
+        ok {ex.status_code} == 301
+        ok {ex.response_headers} == {"Location"=>"/api/books/?x=1&y=2"}
+      end
+
+      spec "[!hdy1f] raises HTTP 404 when urlpath not found." do
+        |app|
+        pr = proc { app.lookup(:GET, "/api/book/comments", "") }
+        ok {pr}.raise?(K8::HttpException)
+        ex = pr.exception
+        ok {ex.status_code} == 404
+      end
+
+      spec "[!0znwr] uses 'GET' method to find action when request method is 'HEAD'." do
+        |app|
+        tuple = app.lookup(:HEAD, "/api/books/123")
+        ok {tuple} == [BooksAction, :do_show, [123]]
+      end
+
+      spec "[!bfpav] raises HTTP 405 when urlpath found but request method not allowed." do
+        |app|
+        pr = proc { app.lookup(:POST, "/api/books/123", "") }
+        ok {pr}.raise?(K8::HttpException)
+        ex = pr.exception
+        ok {ex.status_code} == 405
       end
 
     end
@@ -2456,7 +2894,7 @@ Oktest.scope do
         status, headers, body = app.call(env)
         ok {status} == 301
         ok {headers['Location']} == "/api/books/"
-        ok {body} == []
+        ok {body} == ["<div>\n<h2>301 Moved Permanently</h2>\n<p></p>\n</div>\n"]
       end
 
       spec "[!02dow] returns 301 when urlpath not found but found without tailing '/'." do
@@ -2465,20 +2903,7 @@ Oktest.scope do
         status, headers, body = app.call(env)
         ok {status} == 301
         ok {headers['Location']} == "/api/books/123"
-        ok {body} == []
-      end
-
-      spec "[!2a9c9] adds query string to 'Location' header." do
-        |app|
-        env = new_env("GET", "/api/books", query: 'x=1&y=2')
-        status, headers, body = app.call(env)
-        ok {status} == 301
-        ok {headers['Location']} == "/api/books/?x=1&y=2"
-        #
-        env = new_env("GET", "/api/books/123/", query: 'x=3&y=4')
-        status, headers, body = app.call(env)
-        ok {status} == 301
-        ok {headers['Location']} == "/api/books/123?x=3&y=4"
+        ok {body} == ["<div>\n<h2>301 Moved Permanently</h2>\n<p></p>\n</div>\n"]
       end
 
       spec "[!vz07j] redirects only when request method is GET or HEAD." do
@@ -2494,106 +2919,113 @@ Oktest.scope do
         ok {headers['Location']} == nil
       end
 
-    end
-
-
-    topic '#handle_request()' do
-
-      spec "[!0fgbd] finds action class and invokes action method with urlpath params." do
-        |app|
-        env = new_env("GET", "/api/books/123")
-        app.instance_exec(self) do |_|
-          tuple = handle_request(K8::Request.new(env), K8::Response.new)
-          _.ok {tuple}.is_a?(Array)
-          status, headers, body = tuple
-          _.ok {status}  == 200
-          _.ok {body}    == ["<show:123(Fixnum)>"]
-          _.ok {headers} == {
-            "Content-Length" => "18",
-            "Content-Type"   => "text/html; charset=utf-8",
-          }
-        end
-      end
-
       spec "[!l6kmc] uses 'GET' method to find action when request method is 'HEAD'." do
         |app|
         env = new_env("HEAD", "/api/books/123")
-        app.instance_exec(self) do |_|
-          tuple = handle_request(K8::Request.new(env), K8::Response.new)
-          status, headers, body = tuple
-          _.ok {status}  == 200
-          _.ok {body}    == [""]
-          _.ok {headers} == {
-            "Content-Length" => "18",
-            "Content-Type"   => "text/html; charset=utf-8",
-          }
-        end
+        status, headers, body = app.call(env)
+        ok {status}  == 200
+        ok {body}    == [""]
+        ok {headers} == {
+          "Content-Length" => "18",
+          "Content-Type"   => "text/html; charset=utf-8",
+        }
       end
 
       spec "[!4vmd3] uses '_method' value of query string as request method when 'POST' method." do
         |app|
         env = new_env("POST", "/api/books/123", query: {"_method"=>"DELETE"})
-        app.instance_exec(self) do |_|
-          tuple = handle_request(K8::Request.new(env), K8::Response.new)
-          status, headers, body = tuple
-          _.ok {status}  == 200
-          _.ok {body}    == ["<delete:123(Fixnum)>"]  # do_delete() caled
-        end
+        status, headers, body = app.call(env)
+        ok {status}  == 200
+        ok {body}    == ["<delete:123(Fixnum)>"]  # do_delete() caled
       end
 
       spec "[!vdllr] clears request and response if possible." do
         |app|
-        req  = K8::Request.new(new_env("GET", "/"))
-        resp = K8::Response.new()
-        req_clear = false
-        (class << req; self; end).__send__(:define_method, :clear) { req_clear = true }
-        resp_clear = false
-        (class << resp; self; end).__send__(:define_method, :clear) { resp_clear = true }
+        reqclass  = K8::RackApplication::REQUEST_CLASS
+        respclass = K8::RackApplication::RESPONSE_CLASS
+        K8::RackApplication.module_eval do
+          remove_const :REQUEST_CLASS
+          remove_const :RESPONSE_CLASS
+        end
+        $req_clear = $resp_clear = false
+        K8::RackApplication::REQUEST_CLASS = Class.new(reqclass) do
+          def clear; $req_clear = true; end
+        end
+        K8::RackApplication::RESPONSE_CLASS = Class.new(respclass) do
+          def clear; $resp_clear = true; end
+        end
+        at_end do
+          K8::RackApplication.REQUEST_CLASS = reqclass
+          K8::RackApplication.RESPONSE_CLASS = respclass
+          $req_clear  = nil
+          $resp_clear = nil
+        end
         #
-        app.instance_exec(self) do |_|
-          tuple = handle_request(req, resp)
-          _.ok {req_clear}  == true
-          _.ok {resp_clear} == true
+        env = new_env("GET", "/")
+        ok {$req_clear}  == false
+        ok {$resp_clear} == false
+        app.call(env)
+        _ = self
+        K8::RackApplication::REQUEST_CLASS.class_eval do
+          _.ok {$req_clear} == true
         end
-      end
-
-      spec "[!9wp9z] returns empty body when request method is HEAD." do
-        |app|
-        env = new_env("HEAD", "/api/books/123")
-        app.instance_exec(self) do |_|
-          tuple = handle_request(K8::Request.new(env), K8::Response.new)
-          status, headers, body = tuple
-          _.ok {body} == [""]
+        K8::RackApplication::RESPONSE_CLASS.class_eval do
+          _.ok {$resp_clear} == true
         end
       end
 
       spec "[!rz13i] returns HTTP 404 when urlpath not found." do
         |app|
         env = new_env("GET", "/api/book/comments")
+        status, headers, body = app.call(env)
+        ok {status} == 404
+        ok {headers} == {
+          "Content-Length" => "44",
+          "Content-Type"   => "text/html;charset=utf-8",
+        }
+        ok {body} == ["<div>\n<h2>404 Not Found</h2>\n<p></p>\n</div>\n"]
+      end
+
+      spec "[!rv3cf] returns HTTP 405 when urlpath found but request method not allowed." do
+        |app|
+        env = new_env("POST", "/api/books/123")
+        status, headers, body = app.call(env)
+        ok {status} == 405
+        ok {headers} == {
+          "Content-Length" => "53",
+          "Content-Type"   => "text/html;charset=utf-8",
+        }
+        ok {body} == ["<div>\n<h2>405 Method Not Allowed</h2>\n<p></p>\n</div>\n"]
+      end
+
+    end
+
+
+    topic '#handle_request()' do
+
+      spec "[!0fgbd] finds action class and invokes action method with urlpath params." do
+        |app|
+        env = new_env("GET", "/api/books/123")
         app.instance_exec(self) do |_|
-          tuple = handle_request(K8::Request.new(env), K8::Response.new)
+          tuple = handle_request(K8::RackRequest.new(env), K8::RackResponse.new)
+          _.ok {tuple}.is_a?(Array)
           status, headers, body = tuple
-          _.ok {status}  == 404
-          _.ok {body}    == ["<div>\n<h2>404 Not Found</h2>\n<p></p>\n</div>\n"]
+          _.ok {status}  == 200
+          _.ok {body}    == ["<show:123(Fixnum)>"]
           _.ok {headers} == {
-            "Content-Length" => "44",
-            "Content-Type"   => "text/html;charset=utf-8",
+            "Content-Length" => "18",
+            "Content-Type"   => "text/html; charset=utf-8",
           }
         end
       end
 
-      spec "[!rv3cf] returns HTTP 405 when urlpath found but request method not allowed." do
+      spec "[!9wp9z] returns empty body when request method is HEAD." do
         |app|
-        env = new_env("POST", "/api/books/123")
+        env = new_env("HEAD", "/api/books/123")
         app.instance_exec(self) do |_|
-          tuple = handle_request(K8::Request.new(env), K8::Response.new)
+          tuple = handle_request(K8::RackRequest.new(env), K8::RackResponse.new)
           status, headers, body = tuple
-          _.ok {status}  == 405
-          _.ok {body}    == ["<div>\n<h2>405 Method Not Allowed</h2>\n<p></p>\n</div>\n"]
-          _.ok {headers} == {
-            "Content-Length" => "53",
-            "Content-Type"   => "text/html;charset=utf-8",
-          }
+          _.ok {body}    == [""]
         end
       end
 
@@ -2652,364 +3084,6 @@ Oktest.scope do
   end
 
 
-  topic K8::SecretValue do
-
-
-    topic '#initialize()' do
-
-      spec "[!fbwnh] takes environment variable name." do
-        obj = K8::SecretValue.new('DB_PASS')
-        ok {obj.name} == 'DB_PASS'
-      end
-
-    end
-
-
-    topic '#value()' do
-
-      spec "[!gg06v] returns environment variable value." do
-        obj = K8::SecretValue.new('TEST_HOMHOM')
-        ok {obj.value} == nil
-        ENV['TEST_HOMHOM'] = 'homhom'
-        ok {obj.value} == 'homhom'
-      end
-
-    end
-
-
-    topic '#to_s()' do
-
-      spec "[!7ymqq] returns '<SECRET>' string when name not eixst." do
-        ok {K8::SecretValue.new.to_s} == "<SECRET>"
-      end
-
-      spec "[!x6edf] returns 'ENV[<name>]' string when name exists." do
-        ok {K8::SecretValue.new('DB_PASS').to_s} == "ENV['DB_PASS']"
-      end
-
-    end
-
-
-    topic '#inspect()' do
-
-      spec "[!j27ji] 'inspect()' is alias of 'to_s()'." do
-        ok {K8::SecretValue.new('DB_PASS').inspect} == "ENV['DB_PASS']"
-      end
-
-    end
-
-
-    topic '#[](name)' do
-
-      spec "[!jjqmn] creates new instance object with name." do
-        obj = K8::SecretValue.new['DB_PASSWORD']
-        ok {obj}.is_a?(K8::SecretValue)
-        ok {obj.name} == 'DB_PASSWORD'
-      end
-
-    end
-
-
-  end
-
-
-  topic K8::BaseConfig do
-
-
-    topic '#initialize()' do
-
-      spec "[!vvd1n] copies key and values from class object." do
-        class C01 < K8::BaseConfig
-          add :haruhi  , 'C'   , "Suzumiya"
-          add :mikuru  , 'E'   , "Asahina"
-          add :yuki    , 'A'   , "Nagato"
-        end
-        c = C01.new
-        c.instance_exec(self) do |_|
-          _.ok {@haruhi} == 'C'
-          _.ok {@mikuru} == 'E'
-          _.ok {@yuki}   == 'A'
-        end
-      end
-
-      spec "[!6dilv] freezes self and class object if 'freeze:' is true." do
-        class C02 < K8::BaseConfig
-          add :haruhi  , 'C'   , "Suzumiya"
-          add :mikuru  , 'E'   , "Asahina"
-          add :yuki    , 'A'   , "Nagato"
-        end
-        ## when freeze: false
-        c = C02.new(freeze: false)
-        pr = proc { c.instance_variable_set('@yuki', 'B') }
-        ok {pr}.NOT.raise?(Exception)
-        pr = proc { C02.class_eval { put :yuki, 'B' } }
-        ok {pr}.NOT.raise?(Exception)
-        ## when freeze: true
-        c = C02.new
-        pr = proc { c.instance_variable_set('@yuki', 'B') }
-        ok {pr}.raise?(RuntimeError, "can't modify frozen C02")
-        pr = proc { C02.class_eval { put :yuki, 'B' } }
-        ok {pr}.raise?(RuntimeError, "can't modify frozen class")
-      end
-
-      case_when "[!xok12] when value is SECRET..." do
-
-        spec "[!a4a4p] raises error when key not specified." do
-          class C03 < K8::BaseConfig
-            add :db_pass    , SECRET,   "db password"
-          end
-          pr = proc { C03.new }
-          ok {pr}.raise?(K8::ConfigError, "config 'db_pass' should be set, but not.")
-        end
-
-        spec "[!w4yl7] raises error when ENV value not specified." do
-          class C04 < K8::BaseConfig
-            add :db_pass1    , SECRET['DB_PASS1'],   "db password"
-          end
-          ok {ENV['DB_PASS1']} == nil
-          pr = proc { C04.new }
-          ok {pr}.raise?(K8::ConfigError, )
-        end
-
-        spec "[!he20d] get value from ENV." do
-          class C05 < K8::BaseConfig
-            add :db_pass1    , SECRET['DB_PASS1'],   "db password"
-          end
-          begin
-            ENV['DB_PASS1'] = 'homhom'
-            pr = proc { C05.new }
-            ok {pr}.NOT.raise?(Exception)
-            ok {C05.new.db_pass1} == 'homhom'
-          ensure
-            ENV['DB_PASS1'] = nil
-          end
-        end
-
-      end
-
-    end
-
-
-    topic '.has?()' do
-
-      spec "[!dv87n] returns true iff key is set." do
-        class C11 < K8::BaseConfig
-          @result1 = has? :foo
-          put :foo, 1
-          @result2 = has? :foo
-        end
-        ok {C11.instance_variable_get('@result1')} == false
-        ok {C11.instance_variable_get('@result2')} == true
-      end
-
-    end
-
-
-    topic '.put()' do
-
-      spec "[!h9b47] defines getter method." do
-        class C21 < K8::BaseConfig
-          put :hom, 123, "HomHom"
-        end
-        ok {C21.instance_methods}.include?(:hom)
-        ok {C21.new.hom} == 123
-      end
-
-      spec "[!ncwzt] stores key with value, description and secret flag." do
-        class C22 < K8::BaseConfig
-          put :hom,  123,    "HomHom"
-          put :hom2, SECRET, "Secret HomHom"
-        end
-        ok {C22.instance_variable_get('@__all')} == {
-          :hom  => [123, "HomHom", false],
-          :hom2 => [K8::BaseConfig::SECRET, "Secret HomHom", true],
-        }
-      end
-
-      spec "[!mun1v] keeps secret flag." do
-        class C23 < K8::BaseConfig
-          put :haruhi  , 'C'   , "Suzumiya"
-          put :mikuru  , SECRET, "Asahina"
-          put :yuki    , SECRET, "Nagato"
-        end
-        class C23
-          put :mikuru  , 'F'
-        end
-        ok {C23.instance_variable_get('@__all')} == {
-          :haruhi => ['C', "Suzumiya", false],
-          :mikuru => ['F', "Asahina", true],
-          :yuki   => [K8::BaseConfig::SECRET, "Nagato", true],
-        }
-      end
-
-    end
-
-
-    topic '.add()' do
-
-      spec "[!envke] raises error when already added." do
-        class C31 < K8::BaseConfig
-          add :hom, 123, "HomHom"
-          @ex = nil
-          begin
-            add :hom, 456, "HomHom"
-          rescue => ex
-            @ex = ex
-          end
-        end
-        ex = C31.instance_variable_get('@ex')
-        ok {ex} != nil
-        ok {ex}.is_a?(K8::ConfigError)
-        ok {ex.message} == "add(:hom, 456): cannot add because already added; use set() or put() instead."
-      end
-
-      spec "[!6cmb4] adds new key, value and desc." do
-        class C32 < K8::BaseConfig
-          add :hom, 123, "HomHom"
-          add :hom2, 'HOM'
-        end
-        all = C32.instance_variable_get('@__all')
-        ok {all} == {:hom=>[123, "HomHom", false], :hom2=>['HOM', nil, false]}
-      end
-
-    end
-
-
-    topic '.set()' do
-
-      spec "[!2yis0] raises error when not added yet." do
-        class C41 < K8::BaseConfig
-          @ex = nil
-          begin
-            set :hom, 123, "HomHom"
-          rescue => ex
-            @ex = ex
-          end
-        end
-        ex = C41.instance_variable_get('@ex')
-        ok {ex} != nil
-        ok {ex}.is_a?(K8::ConfigError)
-        ok {ex.message} == "set(:hom, 123): cannot set because not added yet; use add() or put() instead."
-      end
-
-      spec "[!3060g] sets key, value and desc." do
-        class C42 < K8::BaseConfig
-          add :hom, 123, "HomHom"
-        end
-        class C42
-          set :hom, 456
-        end
-        all = C42.instance_variable_get('@__all')
-        ok {all} == {:hom=>[456, "HomHom", false]}
-      end
-
-    end
-
-
-    topic '.each()' do
-
-      spec "[!iu88i] yields with key, value, desc and secret flag." do
-        class C51 < K8::BaseConfig
-          add :haruhi  , 'C'   , "Suzumiya"
-          add :mikuru  , SECRET, "Asahina"
-          add :yuki    , 'A'   , "Nagato"
-        end
-        class C51
-          set :mikuru  , 'F'
-          add :sasaki  , 'B'
-        end
-        #
-        arr = []
-        C51.each {|*args| arr << args }
-        ok {arr} == [
-          [:haruhi, 'C', "Suzumiya", false],
-          [:mikuru, 'F', "Asahina", true],
-          [:yuki,   'A', "Nagato", false],
-          [:sasaki, 'B', nil, false],
-        ]
-      end
-
-    end
-
-
-    topic '.get()' do
-
-      spec "[!zlhnp] returns value corresponding to key." do
-        class C61 < K8::BaseConfig
-          add :haruhi  , 'C'   , "Suzumiya"
-          add :mikuru  , 'E'   , "Asahina"
-          add :yuki    , 'A'   , "Nagato"
-        end
-        class C61
-          set :mikuru  , 'F'
-          add :sasaki  , 'B'
-        end
-        ok {C61.get(:haruhi)} == 'C'
-        ok {C61.get(:mikuru)} == 'F'
-        ok {C61.get(:yuki)}   == 'A'
-        ok {C61.get(:sasaki)} == 'B'
-      end
-
-      spec "[!o0k05] returns default value (=nil) when key is not added." do
-        class C62 < K8::BaseConfig
-          add :haruhi  , 'C'   , "Suzumiya"
-          add :mikuru  , 'E'   , "Asahina"
-          add :yuki    , 'A'   , "Nagato"
-        end
-        ok {C62.get(:sasaki)}     == nil
-        ok {C62.get(:sasaki, "")} == ""
-      end
-
-    end
-
-
-    topic '[](key)' do
-
-      spec "[!jn9l5] returns value corresponding to key." do
-        class C71 < K8::BaseConfig
-          add :haruhi  , 'C'   , "Suzumiya"
-          add :mikuru  , 'E'   , "Asahina"
-          add :yuki    , 'A'   , "Nagato"
-        end
-        class C71
-          set :mikuru  , 'F'
-          add :sasaki  , 'B'
-        end
-        c = C71.new
-        ok {c[:haruhi]} == 'C'
-        ok {c[:mikuru]} == 'F'
-        ok {c[:yuki]}   == 'A'
-        ok {c[:sasaki]} == 'B'
-      end
-
-    end
-
-
-    topic '#get_all()' do
-
-      spec "[!4ik3c] returns all keys and values which keys start with prefix as hash object." do
-        class C81 < K8::BaseConfig
-          add :session_cookie_name     , 'rack.sess'
-          add :session_cookie_expires  , 30*60*60
-          add :session_cookie_secure   , true
-          add :name    , 'Homhom'
-          add :secure  , false
-        end
-        #
-        c = C81.new
-        ok {c.get_all(:session_cookie_)} == {
-          :name     => 'rack.sess',
-          :expires  => 30*60*60,
-          :secure   => true,
-        }
-      end
-
-    end
-
-
-  end
-
-
 end