rack-test_app 1.0.0

data/rack-test_app.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rack/test_app'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rack-test_app"
+  spec.version       = Rack::TestApp::VERSION
+  spec.authors       = ["makoto kuwata"]
+  spec.email         = ["kwa@kuwata-lab.com"]
+  spec.summary       = "more intuitive testing helper library for Rack app"
+  spec.description   = <<END
+Rack::TestApp is another testing helper library for Rack application.
+IMO it is more intuitive than Rack::Test.
+END
+  spec.homepage      = "https://github.com/kwatch/rack-test_app"
+  spec.license       = "MIT-LICENCE"
+  spec.files         = Dir[*%w[
+                         README.md MIT-LICENSE.txt Rakefile rack-test_app.gemspec
+                         lib/rack/test_app.rb
+			 test/test_helper.rb
+			 test/rack/**/*_test.rb
+			 test/rack/test_app/data/**/*.*
+                       ]]
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = '>= 2.0'
+  spec.add_runtime_dependency 'rack'
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

data/test/rack/test_app/MultipartBuilder_test.rb

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+
+###
+### $Release: 1.0.0 $
+### $Copyright: copyright(c) 2015 kuwata-lab.com all rights reserved $
+### $License: MIT License $
+###
+
+
+require_relative '../../test_helper'
+
+require 'tempfile'
+require 'rack/multipart'
+require 'rack/mock'
+require 'rack/request'
+
+
+describe Rack::TestApp::MultipartBuilder do
+
+
+  describe '#initialize()' do
+
+    it "[!ajfgl] sets random string as boundary when boundary is nil." do
+      arr = []
+      1000.times do
+        mp = Rack::TestApp::MultipartBuilder.new(nil)
+        refute_nil mp.boundary
+        assert_kind_of String, mp.boundary
+        arr << mp.boundary
+      end
+      assert_equal 1000, arr.sort.uniq.length
+    end
+
+  end
+
+
+  describe '#add()' do
+
+    it "[!tp4bk] detects content type from filename when filename is not nil." do
+      mp = Rack::TestApp::MultipartBuilder.new
+      mp.add("name1", "value1")
+      mp.add("name2", "value2", "foo.csv")
+      mp.add("name3", "value3", "bar.csv", "text/plain")
+      expected = [
+        ["name1", "value1", nil, nil],
+        #["name2", "value2", "foo.csv", "text/comma-separated-values"],
+        ["name2", "value2", "foo.csv", "text/csv"],
+        ["name3", "value3", "bar.csv", "text/plain"],
+      ]
+      assert_equal expected, mp.instance_variable_get('@params')
+    end
+
+  end
+
+
+  describe '#add_file()' do
+
+    data_dir = File.join(File.dirname(__FILE__), 'data')
+    filename1 = File.join(data_dir, 'example1.png')
+    filename2 = File.join(data_dir, 'example1.jpg')
+    datafile  = File.join(data_dir, 'multipart.form')
+    multipart_data = File.open(datafile, 'rb') {|f| f.read }
+
+    it "[!uafqa] detects content type from filename when content type is not provided." do
+      file1 = File.open(filename1)
+      file2 = File.open(filename2)
+      begin
+        mp = Rack::TestApp::MultipartBuilder.new
+        mp.add_file('image1', file1)
+        mp.add_file('image2', file2)
+        params = mp.instance_variable_get('@params')
+        assert_equal "example1.png" , params[0][2]
+        assert_equal "image/png"    , params[0][3]
+        assert_equal "example1.jpg" , params[1][2]
+        assert_equal "image/jpeg"   , params[1][3]
+      ensure
+        [file1, file2].each {|f| f.close() unless f.closed? }
+      end
+    end
+
+    it "[!b5811] reads file content and adds it as param value." do
+      file1 = File.open(filename1)
+      file2 = File.open(filename2)
+      begin
+        boundary = '---------------------------68927884511827559971471404947'
+        mp = Rack::TestApp::MultipartBuilder.new(boundary)
+        mp.add('text1', "test1")
+        mp.add('text2', "日本語\r\nあいうえお\r\n")
+        mp.add_file('file1', file1)
+        mp.add_file('file2', file2)
+        expected = multipart_data
+        assert expected, mp.to_s
+      ensure
+        [file1, file2].each {|f| f.close() unless f.closed? }
+      end
+    end
+
+    it "[!36bsu] closes opened file automatically." do
+      file1 = File.open(filename1)
+      file2 = File.open(filename2)
+      begin
+        assert_equal false, file1.closed?
+        assert_equal false, file2.closed?
+        mp = Rack::TestApp::MultipartBuilder.new()
+        mp.add_file('file1', file1)
+        mp.add_file('file2', file2)
+        assert_equal true, file1.closed?
+        assert_equal true, file2.closed?
+      ensure
+        [file1, file2].each {|f| f.close() unless f.closed? }
+      end
+    end
+
+  end
+
+
+  describe '#to_s()' do
+
+    it "[!61gc4] returns multipart form string." do
+      mp = Rack::TestApp::MultipartBuilder.new("abc123")
+      mp.add("name1", "value1")
+      mp.add("name2", "value2", "foo.txt", "text/plain")
+      s = mp.to_s
+      expected = [
+        "--abc123\r\n",
+        "Content-Disposition: form-data; name=\"name1\"\r\n",
+        "\r\n",
+        "value1\r\n",
+        "--abc123\r\n",
+        "Content-Disposition: form-data; name=\"name2\"; filename=\"foo.txt\"\r\n",
+        "Content-Type: text/plain\r\n",
+        "\r\n",
+        "value2\r\n",
+        "--abc123--\r\n",
+      ].join()
+      s = mp.to_s
+      assert_equal expected, s
+      #
+      opts = {
+        :method => "POST",
+        :input  => s,
+        "CONTENT_TYPE"   => "multipart/form-data; boundary=abc123",
+        "CONTENT_LENGTH" => s.bytesize,
+      }
+      env = Rack::MockRequest.env_for('http://localhost/form', opts)
+      req = Rack::Request.new(env)
+      params = req.POST
+      assert_equal "value1",     params["name1"]
+      assert_equal "name2",      params["name2"][:name]
+      assert_equal "foo.txt",    params["name2"][:filename]
+      assert_equal "text/plain", params["name2"][:type]
+      assert_kind_of Tempfile,   params["name2"][:tempfile]
+    end
+
+  end
+
+
+end

data/test/rack/test_app/Result_test.rb

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+
+###
+### $Release: 1.0.0 $
+### $Copyright: copyright(c) 2015 kuwata-lab.com all rights reserved $
+### $License: MIT License $
+###
+
+
+require_relative '../../test_helper'
+
+
+describe Rack::TestApp::Result do
+
+
+  describe '#initialize()' do
+
+    it "[!3lcsj] accepts response status, headers and body." do
+      r = Rack::TestApp::Result.new(200, {"Content-Type"=>"text/plain"}, ["Hello"])
+      assert 200, r.status
+      assert({"Content-Type"=>"text/plain"}, r.headers)
+      assert ["Hello"], r.body
+    end
+
+    it "[!n086q] parses 'Set-Cookie' header." do
+      headers = {
+        "Content-Type"=>"text/plain",
+        "Set-Cookie"=>("key1=value1; Path=/; Domain=example.com; HttpOnly; Secure\n" +
+                       "key2=value2"),
+      }
+      expected = {
+        'key1' => {
+          :name     => 'key1',
+          :value    => 'value1',
+          :path     => '/',
+          :domain   => 'example.com',
+          :httponly => true,
+          :secure   => true,
+        },
+        'key2' => {
+          :name     => 'key2',
+          :value    => 'value2',
+        },
+      }
+      r = Rack::TestApp::Result.new(200, headers, ["Hello"])
+      assert_equal expected, r.cookies
+    end
+
+  end
+
+
+  describe '#body_binary' do
+
+    it "[!mb0i4] returns body as binary string." do
+      r = Rack::TestApp::Result.new(200, {}, ["Hello"])
+      assert_equal "Hello", r.body_binary
+    end
+
+  end
+
+
+  describe '#body_text' do
+
+    it "[!vkj9h] returns body as text string, according to 'charset' in 'Content-Type'." do
+      headers = {'Content-Type' => 'text/plain; charset=utf-8'}
+      r = Rack::TestApp::Result.new(200, headers, ["Hello"])
+      assert_equal "Hello", r.body_text
+    end
+
+    it "[!rr18d] error when 'Content-Type' header is missing." do
+      headers = {}
+      r = Rack::TestApp::Result.new(200, headers, ["Hello"])
+      ex = assert_raises(TypeError) { r.body_text }
+      assert_equal "body_text(): missing 'Content-Type' header.", ex.message
+    end
+
+    it "[!dou1n] converts body text according to 'charset' in 'Content-Type' header." do
+      headers = {'Content-Type' => 'text/plain; charset=utf-8'}
+      binary = "\u3042\u3044\u3046\u3048\u304A"
+      assert_equal binary, "あいうえお".encode('utf-8')
+      r = Rack::TestApp::Result.new(200, headers, [binary])
+      assert_equal "あいうえお", r.body_text
+      assert_equal 'UTF-8', r.body_text.encoding.name
+    end
+
+    it "[!cxje7] assumes charset as 'utf-8' when 'Content-Type' is json." do
+      headers = {'Content-Type' => 'application/json'}
+      binary = %Q`{"msg":"\u3042\u3044\u3046\u3048\u304A"}`
+      assert_equal binary, %Q`{"msg":"あいうえお"}`.encode('utf-8')
+      r = Rack::TestApp::Result.new(200, headers, [binary])
+      assert_equal %Q`{"msg":"あいうえお"}`, r.body_text
+      assert_equal 'UTF-8', r.body_text.encoding.name
+    end
+
+    it "[!n4c71] error when non-json 'Content-Type' header has no 'charset'." do
+      headers = {'Content-Type' => 'text/plain'}
+      binary = "\u3042\u3044\u3046\u3048\u304A"
+      assert_equal binary, "あいうえお".encode('utf-8')
+      r = Rack::TestApp::Result.new(200, headers, [binary])
+      ex = assert_raises(TypeError) { r.body_text }
+      assert_equal "body_text(): missing 'charset' in 'Content-Type' header.", ex.message
+    end
+
+  end
+
+
+  describe '#body_json' do
+
+    it "[!qnic1] returns Hash object representing JSON string." do
+      headers = {'Content-Type' => 'application/json'}
+      binary = %Q`{"msg":"\u3042\u3044\u3046\u3048\u304A"}`
+      assert_equal binary, %Q`{"msg":"あいうえお"}`.encode('utf-8')
+      r = Rack::TestApp::Result.new(200, headers, [binary])
+      assert_equal({"msg"=>"あいうえお"}, r.body_json)
+    end
+
+  end
+
+
+  describe '#content_type' do
+
+    it "[!40hcz] returns 'Content-Type' header value." do
+      headers = {'Content-Type' => 'application/json'}
+      r = Rack::TestApp::Result.new(200, headers, [])
+      assert_equal "application/json", r.content_type
+      #
+      headers = {'content-type' => 'application/json'}
+      r = Rack::TestApp::Result.new(200, headers, [])
+      assert_equal "application/json", r.content_type
+    end
+
+  end
+
+
+  describe '' do
+
+    it "[!5lb19] returns 'Content-Length' header value as integer." do
+      headers = {'Content-Length' => '123'}
+      r = Rack::TestApp::Result.new(200, headers, [])
+      assert_equal 123, r.content_length
+      #
+      headers = {'content-length' => '123'}
+      r = Rack::TestApp::Result.new(200, headers, [])
+      assert_equal 123, r.content_length
+    end
+
+    it "[!qjktz] returns nil when 'Content-Length' is not set." do
+      headers = {'Content-Type' => 'text/plain'}
+      r = Rack::TestApp::Result.new(200, headers, ["Hello"])
+      assert_nil r.content_length
+    end
+
+  end
+
+
+  describe '#location' do
+
+    it "[!8y8lg] returns 'Location' header value." do
+      headers = {'Location' => '/foo'}
+      r = Rack::TestApp::Result.new(302, headers, [])
+      assert_equal '/foo', r.location
+    end
+
+  end
+
+
+  describe '#cookie_value' do
+
+    it "[!neaf8] returns cookie value if exists." do
+      headers = {'Set-Cookie' => 'name1=value1'}
+      r = Rack::TestApp::Result.new(200, headers, [])
+      assert_equal 'value1', r.cookie_value('name1')
+    end
+
+    it "[!oapns] returns nil if cookie not exists." do
+      headers = {'Set-Cookie' => 'name1=value1'}
+      r = Rack::TestApp::Result.new(200, headers, [])
+      assert_equal nil, r.cookie_value('name2')
+    end
+
+  end
+
+
+end

data/test/rack/test_app/TestApp_test.rb

@@ -0,0 +1,238 @@
+# -*- coding: utf-8 -*-
+
+###
+### $Release: 1.0.0 $
+### $Copyright: copyright(c) 2015 kuwata-lab.com all rights reserved $
+### $License: MIT License $
+###
+
+
+require_relative '../../test_helper'
+
+
+describe Rack::TestApp do
+
+  class << self
+    alias context describe       # minitest doesn't provide 'context' method
+  end
+
+
+  describe '::VERSION' do
+
+    it "represents release version number." do
+      expected = '$Release: 1.0.0 $'.split()[1]
+      assert_equal expected, Rack::TestApp::VERSION
+    end
+
+  end
+
+
+  describe '.new_env()' do
+
+    it "[!b3ts8] returns environ hash object." do
+      env = Rack::TestApp.new_env()
+      assert_kind_of Hash, env
+      assert_equal 'GET', env['REQUEST_METHOD']
+      assert_equal '/',   env['PATH_INFO']
+    end
+
+    it "[!j879z] sets 'HTTPS' with 'on' when 'rack.url_scheme' is 'https'." do
+      env = Rack::TestApp.new_env(env: {'rack.url_scheme'=>'https'})
+      assert_equal 'on', env['HTTPS']
+      assert_equal 'https', env['rack.url_scheme']
+    end
+
+    it "[!vpwvu] sets 'HTTPS' with 'on' when 'HTTPS' is 'on'." do
+      env = Rack::TestApp.new_env(env: {'HTTPS'=>'on'})
+      assert_equal 'on', env['HTTPS']
+      assert_equal 'https', env['rack.url_scheme']
+    end
+
+    it "[!2uvyb] raises ArgumentError when both query string and 'query' kwarg specified." do
+      ex = assert_raises(ArgumentError) do
+        Rack::TestApp.new_env(:GET, '/path?x=1', query: {'y'=>2})
+      end
+      assert_equal "new_env(): not allowed both query string and 'query' kwarg at a time.", ex.message
+    end
+
+    it "[!8tq3m] accepts query string in path string." do
+      env = Rack::TestApp.new_env(:GET, '/path?x=1')
+      assert_equal 'x=1', env['QUERY_STRING']
+    end
+
+    context "[!d1c83] when 'form' kwarg specified..." do
+
+      it "[!c779l] raises ArgumentError when both 'form' and 'json' are specified." do
+        ex = assert_raises(ArgumentError) do
+          Rack::TestApp.new_env(form: {}, json: {})
+        end
+        assert_equal "new_env(): not allowed both 'form' and 'json' at a time.", ex.message
+      end
+
+      it "[!5iv35] sets content type with 'application/x-www-form-urlencoded'." do
+        env = Rack::TestApp.new_env(form: {'x'=>1})
+        assert_equal 'application/x-www-form-urlencoded', env['CONTENT_TYPE']
+      end
+
+    end
+
+    context "[!prv5z] when 'json' kwarg specified..." do
+
+      it "[!2o0ph] raises ArgumentError when both 'json' and 'multipart' are specified." do
+        ex = assert_raises(ArgumentError) do
+          Rack::TestApp.new_env(json: {}, multipart: {})
+        end
+        assert_equal "new_env(): not allowed both 'json' and 'multipart' at a time.", ex.message
+      end
+
+      it "[!ta24a] sets content type with 'application/json'." do
+        env = Rack::TestApp.new_env(json: {'x'=>1})
+        assert_equal 'application/json', env['CONTENT_TYPE']
+      end
+
+    end
+
+    context "[!dnvgj] when 'multipart' kwarg specified..." do
+
+      it "[!b1d1t] raises ArgumentError when both 'multipart' and 'form' are specified." do
+        ex = assert_raises(ArgumentError) do
+          Rack::TestApp.new_env(multipart: {}, form: {})
+        end
+        assert_equal "new_env(): not allowed both 'multipart' and 'form' at a time.", ex.message
+      end
+
+      it "[!dq33d] sets content type with 'multipart/form-data'." do
+        env = Rack::TestApp.new_env(multipart: {})
+        assert_match /\Amultipart\/form-data; boundary=\S+\z/, env['CONTENT_TYPE']
+      end
+
+      it "[!gko8g] 'multipart:' kwarg accepts Hash object (which is converted into multipart data)." do
+        fpath = File.join(File.dirname(__FILE__), "data", "example1.jpg")
+        file = File.open(fpath, 'rb')
+        env = Rack::TestApp.new_env(multipart: {
+          "value"  => 123,
+          "upload" => file,
+        })
+        assert_equal true, file.closed?
+        req = Rack::Request.new(env)
+        params = req.POST
+        assert_equal "123",           params['value']
+        assert_equal "upload",        params['upload'][:name]
+        assert_equal "example1.jpg",  params['upload'][:filename]
+        assert_equal "image/jpeg",    params['upload'][:type]
+        assert_kind_of Tempfile,      params['upload'][:tempfile]
+      end
+
+    end
+
+    it "[!iamrk] uses 'application/x-www-form-urlencoded' as default content type of input." do
+      env = Rack::TestApp.new_env(:POST, '/', input: 'x=1')
+      assert_equal 'application/x-www-form-urlencoded', env['CONTENT_TYPE']
+    end
+
+    it "[!7hfri] converts input string into binary." do
+      form = {"x"=>"あいうえお"}
+      env = Rack::TestApp.new_env(:POST, '/api/hello', form: form)
+      s = env['rack.input'].read()
+      assert_equal Encoding::ASCII_8BIT, s.encoding
+    end
+
+    it "[!r3soc] converts query string into binary." do
+      query = {"x"=>"あいうえお"}
+      env = Rack::TestApp.new_env(:POST, '/api/hello', query: query)
+      s = env['QUERY_STRING']
+      assert_equal Encoding::ASCII_8BIT, s.encoding
+    end
+
+    it "[!na9w6] builds environ hash object." do
+      env = Rack::TestApp.new_env(:POST, '/api/session?q=test')
+      #
+      assert_equal Rack::VERSION   , env['rack.version']
+      assert_kind_of Array         , env['rack.version']
+      assert_match /\A\[1, \d+\]\z/, env['rack.version'].inspect
+      assert_kind_of StringIO      , env['rack.input']
+      assert_kind_of StringIO      , env['rack.errors']
+      assert_equal true            , env['rack.multithread']
+      assert_equal true            , env['rack.multiprocess']
+      assert_equal false           , env['rack.run_once']
+      assert_equal 'http'          , env['rack.url_scheme']
+      #
+      assert_equal 'POST'          , env['REQUEST_METHOD']
+      assert_equal 'q=test'        , env['QUERY_STRING']
+      assert_equal 'localhost'     , env['SERVER_NAME']
+      assert_equal '80'            , env['SERVER_PORT']
+      assert_equal 'q=test'        , env['QUERY_STRING']
+      assert_equal '/api/session'  , env['PATH_INFO']
+      assert_equal 'off'           , env['HTTPS']
+      assert_equal ''              , env['SCRIPT_NAME']
+      assert_equal '0'             , env['CONTENT_LENGTH']
+      assert_equal nil             , env['CONTENT_TYPE']
+    end
+
+    it "[!ezvdn] unsets CONTENT_TYPE when not input." do
+      env = Rack::TestApp.new_env(:POST, '/api/session?q=test')
+      assert_nil env['CONTENT_TYPE']
+      assert_equal false, env.key?('CONTENT_TYPE')
+    end
+
+    it "[!r4jz8] copies 'headers' kwarg content into environ with 'HTTP_' prefix." do
+      headers = {
+        'If-Modified-Since'      => 'Mon, 02 Feb 2015 19:05:06 GMT',
+        'X-Requested-With'       => 'XMLHttpRequest'
+      }
+      env = Rack::TestApp.new_env(:PUT, '/', headers: headers)
+      assert_equal 'Mon, 02 Feb 2015 19:05:06 GMT', env['HTTP_IF_MODIFIED_SINCE']
+      assert_equal 'XMLHttpRequest', env['HTTP_X_REQUESTED_WITH']
+    end
+
+    it "[!ai9t3] don't add 'HTTP_' to Content-Length and Content-Type headers." do
+      headers = {
+        'Content-Type'           => 'application/json',
+        'Content-Length'         => '123',
+      }
+      env = Rack::TestApp.new_env(:PUT, '/', headers: headers)
+      assert_equal 'application/json', env['CONTENT_TYPE']
+      assert_equal '123',              env['CONTENT_LENGTH']
+      assert_equal false, env.key?('HTTP_CONTENT_TYPE')
+      assert_equal false, env.key?('HTTP_CONTENT_LENGTH')
+    end
+
+    it "[!a47n9] copies 'env' kwarg content into environ." do
+      environ = {
+        'rack.session' => {'k1'=>'v1'},
+      }
+      env = Rack::TestApp.new_env(:PUT, '/', env: environ)
+      expected = {'k1'=>'v1'}
+      assert_equal expected, env['rack.session']
+    end
+
+    it "[!pmefk] sets 'HTTP_COOKIE' when 'cookie' kwarg specified." do
+      env = Rack::TestApp.new_env(cookies: 'c1=v1')
+      assert_equal 'c1=v1', env['HTTP_COOKIE']
+      env = Rack::TestApp.new_env(cookies: {'c2'=>'v2'})
+      assert_equal 'c2=v2', env['HTTP_COOKIE']
+    end
+
+    it "[!qj7b8] cookie value can be {:name=>'name', :value=>'value'}." do
+      env = Rack::TestApp.new_env(cookies: {'c3'=>{name: 'c3', value: 'v3'}})
+      assert_equal 'c3=v3', env['HTTP_COOKIE']
+    end
+
+  end
+
+
+  describe '.wrap()' do
+
+    it "[!grqlf] creates new Wrapper object." do
+      app = proc {|env| [200, {}, []] }
+      env = {"HTTPS"=>"on"}
+      wrapper = Rack::TestApp.wrap(app, env)
+      assert_kind_of Rack::TestApp::Wrapper, wrapper
+      assert_equal app, wrapper.instance_variable_get('@app')
+      assert_equal env, wrapper.instance_variable_get('@env')
+    end
+
+  end
+
+
+end