jubilee 2.1.0.Alpha1-java → 2.1.0.beta-java

data/test/apps/rack_input.ru

@@ -0,0 +1,5 @@
+app = lambda do |env|
+  data = env['rack.input'].read
+  [200, {}, [data]]
+end
+run app

data/test/apps/self_chunked.ru

@@ -0,0 +1,6 @@
+require_relative './persistent'
+body = ["5\r\nhello\r\n", "0\r\n\r\n"]
+headers= {"X-Header" => "Works", 'Transfer-Encoding' => "chunked"}
+
+run Persistent.new(body, headers)
+

data/test/apps/sha1.ru

@@ -1,3 +1,4 @@
+require 'digest'
 bs = 4096
 hdr = {'Content-Type' => 'text/plain', 'Content-Length' => '0'}
 sha1_app = lambda do |env|
@@ -31,6 +32,7 @@ sha1_app = lambda do |env|
   end
   resp[:size] = i
   resp[:expect_size] = expect_size
+  resp[:content_md5] = env['HTTP_X_CONTENT_MD5']
 
   [ 200, hdr.merge({'X-Resp' => resp.inspect}), [] ]
 end

data/test/apps/simple.ru

@@ -1 +1,10 @@
-run lambda { |env| [200, { "X-Header" => "Works" }, ["Hello"]] }
+require 'rack/request'
+require 'json'
+
+app = lambda do |env|
+  req = Rack::Request.new(env)
+  body = JSON.dump(req.params.merge({"QUERY_STRING" => env["QUERY_STRING"], "PATH_INFO" => env["PATH_INFO"]}))
+  [200, { "X-Header" => "Works" }, [body]]
+end
+
+run app

data/test/jubilee/test_cli.rb

@@ -11,7 +11,7 @@ class TestJubileeCLI < MiniTest::Unit::TestCase
   def test_chdir
     cli = Jubilee::CLI.new(["--dir", "test", "app.ru"])
     cli.parse_options
-    assert_equal "test", cli.options[:chdir]
+    assert_equal "test", cli.options[:root]
   end
 
   def test_eventbus_prefix

data/test/jubilee/test_configuration.rb

@@ -5,13 +5,11 @@ class TestConfig < MiniTest::Unit::TestCase
 
   def setup
     @tmp = Tempfile.new("jubilee_config")
-    @dir = Dir.getwd
   end
 
   def teardown
     @tmp.close
     @tmp.unlink
-    Dir.chdir(@dir)
   end
 
   def test_config_invalid
@@ -67,7 +65,7 @@ class TestConfig < MiniTest::Unit::TestCase
   def test_config_file_working_directory
     @tmp.syswrite(%q(working_directory "examples/chatapp"))
     options = Jubilee::Configuration.new(config_file: @tmp.path).options
-    assert_match(/chatapp/, options[:chdir])
+    assert_match(/chatapp/, options[:root])
   end
 
   def test_config_file_environment

data/test/jubilee/test_hijack.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+require 'socket'
+
+class TestJubileeServer < MiniTest::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+    @client.close
+    sleep 0.1
+    @server.stop
+  end
+
+  def test_hijack_supported
+    skip "not valid"
+    @valid_post = "POST / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\nContent-Length: 5\r\n\r\nhello"
+    @host, @port = "localhost", 8080
+
+    config = Jubilee::Configuration.new(rackup: File.expand_path("../../apps/hijack.ru", __FILE__), instances: 1)
+    @server = Jubilee::Server.new(config.options)
+    @server.start
+    @client = TCPSocket.new @host, @port
+
+    @client << @valid_post
+    assert @jijack
+  end
+end

data/test/jubilee/test_persistent.rb

@@ -0,0 +1,208 @@
+require 'test_helper'
+require 'timeout'
+require 'socket'
+class TestResponse < MiniTest::Unit::TestCase
+  def setup
+    @valid_request = "GET / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+    @close_request = "GET / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\nConnection: Close\r\n\r\n"
+    @http10_request = "GET / HTTP/1.0\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+    @keep_request = "GET / HTTP/1.0\r\nHost: test.com\r\nContent-Type: text/plain\r\nConnection: Keep-Alive\r\n\r\n"
+
+    @valid_post = "POST / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\nContent-Length: 5\r\n\r\nhello"
+    @valid_no_body = "GET / HTTP/1.1\r\nHost: test.com\r\nX-Status: 204\r\nContent-Type: text/plain\r\n\r\n"
+
+    @headers = { "X-Header" => "Works" }
+    @body = ["Hello"]
+    @sz = @body[0].size.to_s
+
+    @host = "127.0.0.1"
+    @port = 8080
+
+  end
+
+  def teardown
+    @client.close if @client
+    @server.stop if @server
+    sleep 0.1
+  end
+
+  def lines(count, s=@client)
+    str = ""
+    timeout(5) do
+      count.times { str << s.gets }
+    end
+    str
+  end
+
+  def valid_response(size = @sz, close = false)
+    conn = close ? "close" : "keep-alive"
+    %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\nServer: Jubilee\(\d\.\d\.\d\)\r\nContent-Length: #{size}\r\nConnection: #{conn}\r\nDate: (.*?)\r\n\r\n}
+  end
+
+  def test_one_with_content_length
+    start_server
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_two_back_to_back
+    start_server
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_post_then_get
+    start_server
+    @client << @valid_post
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_no_body_then_get
+    start_server
+    @client << @valid_no_body
+    assert_match %r{HTTP/1.1 204 No Content\r\nX-Header: Works\r\nConnection: keep-alive\r\n(.*?\r\n)*?\r\n}, lines(6)
+
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\nServer: Jubilee\(\d\.\d\.\d\)\r\nContent-Length: #{sz}\r\nConnection: keep-alive\r\n(.*?\r\n)*?\r\n}, lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_chunked
+    start_server("chunked")
+
+    @client << @valid_request
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\nServer: Jubilee\(\d\.\d\.\d\)\r\nConnection: keep-alive\r\nTransfer-Encoding: chunked\r\nDate(.*?)\r\n\r\n5\r\nHello\r\n7\r\nChunked\r\n0\r\n\r\n}, lines(13)
+  end
+
+  def test_no_chunked_in_http10
+    start_server("chunked")
+
+    @client << @http10_request
+
+    assert_match %r{HTTP/1.0 200 OK\r\nX-Header: Works\r\nServer: Jubilee\(\d\.\d\.\d\)\r\nConnection: close\r\nDate: (.*?)\r\n\r\n}, lines(6)
+    assert_equal "HelloChunked", @client.read
+  end
+
+  def test_hex
+    start_server("hex")
+    str = "This is longer and will be in hex"
+
+    @client << @valid_request
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\nServer: Jubilee(.*?)\r\nConnection: keep-alive\r\nTransfer-Encoding: chunked\r\nDate: (.*?)\r\n\r\n5\r\nHello\r\n#{str.size.to_s(16)}\r\n#{str}\r\n0\r\n\r\n}, lines(13)
+
+  end
+
+  def test_client11_close
+    start_server
+    @client << @close_request
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz, true), lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_app_sets_content_length
+    start_server("content_length")
+    @client << @valid_request
+
+    assert_match valid_response(11), lines(7)
+    assert_equal "hello world", @client.read(11)
+  end
+
+  def test_allow_app_to_chunk_itself
+    start_server("self_chunked")
+    @client << @valid_request
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\nServer: Jubilee(.*?)\r\nConnection: keep-alive\r\nTransfer-Encoding: chunked\r\nDate: (.*?)\r\n\r\n5\r\nhello\r\n0\r\n\r\n}, lines(11)
+  end
+
+
+  def test_two_requests_in_one_chunk
+    start_server
+    req = @valid_request.to_s
+    req << "GET /second HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+
+    @client << req
+
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_second_request_not_in_first_req_body
+    start_server
+
+    req = @valid_request.to_s
+    req << "GET /second HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+
+    @client << req
+
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+
+    #assert_kind_of Jubilee::IORackInput, @inputs[0]
+    #assert_kind_of Jubilee::IORackInput, @inputs[1]
+  end
+
+  def test_keepalive_doesnt_starve_clients
+    start_server
+    sz = @body[0].size.to_s
+
+    @client << @valid_request
+
+    c2 = TCPSocket.new @host, @port
+    c2 << @valid_request
+
+    out = IO.select([c2], nil, nil, 1)
+
+    assert out, "select returned nil"
+    assert_equal c2, out.first.first
+
+    assert_match valid_response(sz), lines(7, c2)
+    assert_equal "Hello", c2.read(5)
+  end
+
+  def start_server(ru='persistent')
+    config = Jubilee::Configuration.new(rackup: File.expand_path("../../apps/#{ru}.ru", __FILE__), instances: 1)
+    @server = Jubilee::Server.new(config.options)
+    q = Queue.new
+    @server.start{ q << 1 }
+    q.pop
+    sleep 0.1
+    @client = TCPSocket.new @host, @port
+  end
+end

data/test/jubilee/test_rack_server.rb

@@ -1,115 +1,76 @@
 require 'test_helper'
-require 'rack/lint'
-require 'rack/commonlogger'
+require 'json'
 
 class TestRackServer < MiniTest::Unit::TestCase
   include Helpers
 
-  def setup
-    @valid_request = "GET / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
-    @checker = "checker.ru"
-    @host = "localhost"
-    @port = 8080
-  end
-
   def teardown
-    @server.stop if @server
+    @server.stop
     sleep 0.1
   end
 
   def test_lint
-    @server = Jubilee::Server.new @checker
-
-    @server.start
+    start_server("checker")
+    resp = hit(['http://127.0.0.1:8080/test']).first
 
-    hit(['http://127.0.0.1:8080/test'])
-
-    if exc = @checker.exception
+    if exc = JSON.parse(resp.body)["exception"]
       raise exc
     end
   end
 
   def test_large_post_body
-    @checker = ErrorChecker.new ServerLint.new(@simple)
-    @server = Jubilee::Server.new @checker
-
-    @server.start
-    sleep 0.5
-
+    start_server("checker")
     big = "x" * (1024 * 16)
-
-    Net::HTTP.post_form URI.parse('http://127.0.0.1:8080/test'),
-                 { "big" => big }
-
-    if exc = @checker.exception
+    resp = POST('/test', { "big" => big })
+    if exc = JSON.parse(resp.body)["exception"]
       raise exc
     end
   end
 
   def test_path_info
-    input = nil
-    @server = Jubilee::Server.new(lambda { |env| input = env; @simple.call(env) })
-    @server.start
-
-    hit(['http://127.0.0.1:8080/test/a/b/c'])
-
-    assert_equal "/test/a/b/c", input['PATH_INFO']
+    start_server("simple")
+    resp = hit(['http://127.0.0.1:8080/test/a/b/c']).first
+    assert_equal "/test/a/b/c", JSON.parse(resp.body)['PATH_INFO']
   end
 
   def test_request_method
-    input = nil
-    @server = Jubilee::Server.new(Rack::MethodOverride.new(lambda { |env| input = env; @simple.call(env) }))
-    @server.start
-
-    POST('/test/a/b/c', {"_method" => "delete", "user" => 1})
-    assert_equal "DELETE", input['REQUEST_METHOD']
+    start_server("method_override")
+    resp = POST('/test/a/b/c', {"_method" => "delete", "user" => 1})
+    assert_equal "DELETE", resp.body
 
     # it should not memorize env
-    POST('/test/a/b/c', {"foo" => "bar"})
-    assert_equal "POST", input['REQUEST_METHOD']
-
+    resp = POST('/test/a/b/c', {"foo" => "bar"})
+    assert_equal "POST", resp.body
   end
 
   def test_query_string
-    input = nil
-    @server = Jubilee::Server.new(lambda { |env| input = env; @simple.call(env) })
-    @server.start
-    sleep 0.1
-
-    hit(['http://127.0.0.1:8080/test/a/b/c?foo=bar'])
-
-    assert_equal "foo=bar", input['QUERY_STRING']
+    start_server("simple")
+    resp = hit(['http://127.0.0.1:8080/test/a/b/c?foo=bar']).first
+    assert_equal "foo=bar", JSON.parse(resp.body)['QUERY_STRING']
   end
 
   def test_post_data
     require 'rack/request'
-    input = nil
-    @server = Jubilee::Server.new(lambda { |env| input = env; @simple.call(env) })
-    @server.start
-    sleep 0.1
-
+    start_server("simple")
     req = Net::HTTP::Post::Multipart.new("/", "foo" => "bar")
-    Net::HTTP.start('localhost', 8080) do |http|
+    resp = Net::HTTP.start('localhost', 8080) do |http|
       http.request req
     end
 
-    #Net::HTTP.post_form URI.parse('http://127.0.0.1:8080/test'), { "foo" => "bar" }
-
-    request = Rack::Request.new input
-    assert_equal "bar", request.params["foo"]
+    assert_equal "bar", JSON.parse(resp.body)["foo"]
   end
 
   def test_end_request_when_rack_crashes
-    @server = Jubilee::Server.new(RackCrasher.new(@simple))
-    @server.start
+    start_server("rack_crasher")
     res = hit(['http://127.0.0.1:8080/test'])
     assert_kind_of Net::HTTPServerError, res[0]
   end
 
-  # GH_9
-  def test_string_port_value
-    @server = Jubilee::Server.new(@simple, {Port: "3000"})
-    # assert_wont_raise_anything
-    @server.start
+  def start_server(ru)
+    config = Jubilee::Configuration.new(rackup: File.expand_path("../../apps/#{ru}.ru", __FILE__), instances: 1)
+    @server = Jubilee::Server.new(config.options)
+    q = Queue.new
+    @server.start{ q << 1 }
+    q.pop
   end
 end