syntropy 0.29.0 → 0.31.0

data/test/test_errors.rb

@@ -3,7 +3,7 @@
 require_relative 'helper'
 
 class ErrorsTest < Minitest::Test
-  ISE = Qeweney::Status::INTERNAL_SERVER_ERROR
+  ISE = Syntropy::HTTP::INTERNAL_SERVER_ERROR
 
   def test_error_http_status_class_method
     e = RuntimeError.new
@@ -12,27 +12,27 @@ class ErrorsTest < Minitest::Test
     e = Syntropy::Error.new
     assert_equal ISE, Syntropy::Error.http_status(e)
 
-    e = Syntropy::Error.new("", Qeweney::Status::UNAUTHORIZED)
-    assert_equal Qeweney::Status::UNAUTHORIZED, Syntropy::Error.http_status(e)
+    e = Syntropy::Error.new("", Syntropy::HTTP::UNAUTHORIZED)
+    assert_equal Syntropy::HTTP::UNAUTHORIZED, Syntropy::Error.http_status(e)
   end
 
   def test_method_not_allowed_error
     e = Syntropy::Error.method_not_allowed('foo')
     assert_kind_of Syntropy::Error, e
-    assert_equal Qeweney::Status::METHOD_NOT_ALLOWED, e.http_status
+    assert_equal Syntropy::HTTP::METHOD_NOT_ALLOWED, e.http_status
     assert_equal 'foo', e.message
   end
 
   def test_not_found_error
     e = Syntropy::Error.not_found('bar')
     assert_kind_of Syntropy::Error, e
-    assert_equal Qeweney::Status::NOT_FOUND, e.http_status
+    assert_equal Syntropy::HTTP::NOT_FOUND, e.http_status
     assert_equal 'bar', e.message
   end
 
   def test_validation_error
     e = Syntropy::ValidationError.new('baz')
-    assert_equal Qeweney::Status::BAD_REQUEST, e.http_status
+    assert_equal Syntropy::HTTP::BAD_REQUEST, e.http_status
     assert_equal 'baz', e.message
   end
 end

data/test/test_http_client.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative './helper'
+require 'json'
+
+class HTTPClientTest < Minitest::Test
+  def setup
+    @machine = UM.new
+    @handler = ->(req) { req.respond_json(req.headers) }
+
+    @port = 10000 + rand(30000)
+    @env = { bind: "127.0.0.1:#{@port}" }
+    @server = Syntropy::HTTP::Server.new(@machine, @env) { @app&.call(it) }
+    @server_fiber = @machine.spin { @server.run }
+
+    # let server spin and listen to incoming connections
+    @machine.sleep(0.01)
+
+    @client = Syntropy::HTTP::Client.new(@machine)
+  end
+
+  def teardown
+    @machine.schedule(@server_fiber, UM::Terminate.new)
+    @machine.join(@server_fiber)
+  end
+
+  def test_get
+    @app = ->(req) { req.respond('foo') }
+    headers, body = @client.get("http://localhost:#{@port}")
+
+    assert_kind_of Hash, headers
+    assert_equal Syntropy::HTTP::OK, headers[':status']
+
+    assert_kind_of String, body
+    assert_equal 'foo', body
+  end
+
+  def test_get_with_block
+    @app = ->(req) { req.respond('foo') }
+    headers = body = nil
+    @client.get("http://localhost:#{@port}") { |h, c|
+      headers = h
+      body = c.get_response_body(headers)
+    }
+
+    assert_kind_of Hash, headers
+    assert_equal Syntropy::HTTP::OK, headers[':status']
+
+    assert_kind_of String, body
+    assert_equal 'foo', body
+  end
+end

data/test/test_http_client_connection.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative './helper'
+require 'json'
+
+class HTTPClientConectionTest < Minitest::Test
+  def setup
+    @client_fd, @server_fd = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
+    @machine = UM.new
+    @handler = ->(req) { req.respond_json(req.headers) }
+    @server_connection = Syntropy::HTTP::ServerConnection.new(
+      @machine, @server_fd, {}, &->(req) { @handler.(req) }
+    )
+    @server_fiber = @machine.spin { @server_connection.run }
+    @client_connection = Syntropy::HTTP::ClientConnection.new(
+      @machine, @client_fd
+    )
+  end
+
+  def teardown
+    @machine.schedule(@server_fiber, UM::Terminate.new)
+    @machine.join(@server_fiber)
+  end
+
+  def test_req_teapot
+    @handler = ->(req) { req.respond(nil, ':status' => Syntropy::HTTP::TEAPOT) }
+    headers = @client_connection.req(':method' => 'GET', ':path' => '/')
+
+    assert_kind_of Hash, headers
+    assert_equal Syntropy::HTTP::TEAPOT, headers[':status']
+  end
+
+  def test_req_with_response_body
+    @handler = ->(req) { req.respond('foo') }
+    headers = @client_connection.req(':method' => 'GET', ':path' => '/')
+
+    assert_kind_of Hash, headers
+    assert_equal Syntropy::HTTP::OK, headers[':status']
+
+    body = @client_connection.get_response_body(headers)
+    assert_equal 'foo', body
+  end
+end

data/test/{test_connection.rb → test_http_server_connection.rb}

@@ -3,7 +3,7 @@
 require_relative './helper'
 require 'securerandom'
 
-class ConnectionTest < Minitest::Test
+class HTTPServerConnectionTest < Minitest::Test
   def make_socket_pair
     port = SecureRandom.random_number(10000..40000)
     server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
@@ -29,7 +29,7 @@ class ConnectionTest < Minitest::Test
     @hook = nil
     @app = ->(req) { @reqs << req; @hook&.call(req) }
     @env = {}
-    @adapter = Syntropy::Connection.new(nil, @machine, @s_fd, @env, &@app)
+    @connection = Syntropy::HTTP::ServerConnection.new(@machine, @s_fd, @env, &@app)
   end
 
   def teardown
@@ -54,14 +54,14 @@ class ConnectionTest < Minitest::Test
 
   def test_http_unsupported_versions
     write_http_request "GET / HTTP/0.9\r\n\r\n"
-    @adapter.serve_request
+    @connection.serve_request
     response = read_client_side
     assert_equal "HTTP/1.1 505\r\nTransfer-Encoding: chunked\r\n\r\n1a\r\nHTTP version not supported\r\n0\r\n\r\n", response
 
     setup
 
     write_http_request "GET / HTTP/1.0\r\n\r\n"
-    @adapter.serve_request
+    @connection.serve_request
     response = read_client_side
     assert_equal "HTTP/1.1 505\r\nTransfer-Encoding: chunked\r\n\r\n1a\r\nHTTP version not supported\r\n0\r\n\r\n", response
 
@@ -69,7 +69,7 @@ class ConnectionTest < Minitest::Test
 
     @hook = ->(req) { req.respond('hi') }
     write_http_request "GET / HTTP/1.1\r\n\r\n"
-    @adapter.serve_request
+    @connection.serve_request
     @machine.close(@s_fd)
     response = read_client_side
     assert_equal "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\n2\r\nhi\r\n0\r\n\r\n", response
@@ -78,7 +78,7 @@ class ConnectionTest < Minitest::Test
   def test_basic_request_parsing
     write_http_request "GET / HTTP/1.1\r\n\r\n"
 
-    @adapter.serve_request
+    @connection.serve_request
     assert_equal 1, @reqs.size
     req = @reqs.shift
     headers = req.headers
@@ -101,7 +101,7 @@ class ConnectionTest < Minitest::Test
     HTTP
     write_http_request msg
 
-    @adapter.run
+    @connection.run
     assert_equal 2, @reqs.size
     req0 = @reqs.shift
     headers = req0.headers
@@ -137,7 +137,7 @@ class ConnectionTest < Minitest::Test
     @bodies = []
     @hook = ->(req) { @bodies << req.read }
 
-    @adapter.run
+    @connection.run
     assert_equal 2, @reqs.size
 
     req0 = @reqs.shift
@@ -195,7 +195,7 @@ class ConnectionTest < Minitest::Test
     @bodies = []
     @hook = ->(req) { @bodies << req.read }
 
-    @adapter.run
+    @connection.run
     assert_equal 2, @reqs.size
 
     req0 = @reqs.shift
@@ -247,7 +247,7 @@ class ConnectionTest < Minitest::Test
     chunks = []
     @hook = ->(req) { req.each_chunk { chunks << it } }
 
-    @adapter.serve_request
+    @connection.serve_request
     assert_equal 1, @reqs.size
 
     req0 = @reqs.shift
@@ -263,7 +263,7 @@ class ConnectionTest < Minitest::Test
     assert_equal ['abc', 'de'], chunks
 
     chunks.clear
-    @adapter.serve_request
+    @connection.serve_request
     assert_equal 1, @reqs.size
 
     req1 = @reqs.shift
@@ -285,7 +285,7 @@ class ConnectionTest < Minitest::Test
     }
 
     write_http_request "GET / HTTP/1.1\r\n\r\n"
-    @adapter.run
+    @connection.run
     response = read_client_side
 
     expected = <<~HTTP.crlf_lines
@@ -305,7 +305,7 @@ class ConnectionTest < Minitest::Test
 
     # using HTTP 1.0, server should close connection after responding
     write_http_request "GET / HTTP/1.1\r\n\r\n"
-    @adapter.run
+    @connection.run
 
     response = read_client_side
     expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n"
@@ -318,14 +318,14 @@ class ConnectionTest < Minitest::Test
     }
 
     write_http_request "GET / HTTP/1.1\r\nConnection: close\r\n\r\n", false
-    res = @adapter.serve_request
+    res = @connection.serve_request
     assert_equal false, res
 
     response = read_client_side
     assert_equal("HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\n2\r\nHi\r\n0\r\n\r\n", response)
 
     write_http_request "GET / HTTP/1.1\r\n\r\n", false
-    res = @adapter.serve_request
+    res = @connection.serve_request
     assert_equal true, res
 
     response = read_client_side
@@ -344,7 +344,7 @@ class ConnectionTest < Minitest::Test
     }
 
     write_http_request "GET / HTTP/1.1\r\n\r\nGET / HTTP/1.1\r\nFoo: bar\r\n\r\n"
-    @adapter.run
+    @connection.run
     response = read_client_side
 
     expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n" +
@@ -368,7 +368,7 @@ class ConnectionTest < Minitest::Test
 
     msg = "POST / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n6\r\nfoobar\r\n"
     write_http_request msg, false
-    @machine.spin { @adapter.serve_request rescue nil }
+    @machine.spin { @connection.serve_request rescue nil }
     @machine.sleep(0.01)
 
     assert request
@@ -417,7 +417,7 @@ class ConnectionTest < Minitest::Test
 
     msg = "GET / HTTP/1.1\r\nUpgrade: echo\r\nConnection: upgrade\r\n\r\n"
     write_http_request(msg, false)
-    @machine.spin { @adapter.serve_request rescue nil }
+    @machine.spin { @connection.serve_request rescue nil }
     @machine.sleep(0.01)
 
     response = read_client_side
@@ -462,7 +462,7 @@ class ConnectionTest < Minitest::Test
 
     write_client_side("GET / HTTP/1.1\r\n\r\n")
     @machine.spin do
-      @adapter.serve_request
+      @connection.serve_request
     rescue => e
       p e
       p e.backtrace
@@ -498,7 +498,7 @@ class ConnectionTest < Minitest::Test
 
     write_client_side("GET / HTTP/1.1\r\n\r\n")
     @machine.spin do
-      @adapter.serve_request
+      @connection.serve_request
     rescue => e
       p e
       p e.backtrace
@@ -531,7 +531,7 @@ class ConnectionTest < Minitest::Test
     count = 0
 
     write_client_side("GET / HTTP/1.1\r\n\r\n")
-    @machine.spin { @adapter.serve_request }
+    @machine.spin { @connection.serve_request }
 
     while (data = read_client_side(65536))
       response << data
@@ -551,7 +551,7 @@ class ConnectionTest < Minitest::Test
     end
 
     write_client_side("GET / HTTP/1.1\r\n\r\n")
-    @adapter.serve_request
+    @connection.serve_request
     response = read_client_side(65536)
     expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: Syntropy\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
     assert_equal expected, response
@@ -559,7 +559,7 @@ class ConnectionTest < Minitest::Test
     @env[:server_headers] = "Server: TP3\r\n"
 
     write_client_side("GET / HTTP/1.1\r\n\r\n")
-    @adapter.serve_request
+    @connection.serve_request
     response = read_client_side(65536)
     expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: TP3\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
     assert_equal expected, response
@@ -572,7 +572,7 @@ class ConnectionTest < Minitest::Test
     }
 
     write_client_side("GET / HTTP/1.1\r\n\r\n")
-    @adapter.serve_request
+    @connection.serve_request
     response = read_client_side(65536)
     expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
     assert_equal expected, response
@@ -583,7 +583,7 @@ class ConnectionTest < Minitest::Test
     }
 
     write_client_side("GET / HTTP/1.1\r\n\r\n")
-    @adapter.serve_request
+    @connection.serve_request
     response = read_client_side(65536)
     expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar\r\nContent-Type: text/plain\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
     assert_equal expected, response
@@ -597,7 +597,7 @@ class ConnectionTest < Minitest::Test
     }
 
     write_client_side("GET / HTTP/1.1\r\n\r\n")
-    @adapter.serve_request
+    @connection.serve_request
     response = read_client_side(65536)
     expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar\r\nFoo: bar\r\nContent-Type: text/plain\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
     assert_equal expected, response
@@ -610,11 +610,11 @@ class ConnectionTest < Minitest::Test
     }
 
     write_client_side("GET / HTTP/1.1\r\n\r\n")
-    @adapter.serve_request
+    @connection.serve_request
     response = read_client_side(65536)
     expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar; HttpOnly\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
     assert_equal expected, response
-    
+
   end
 
   def test_set_cookie_multi1
@@ -624,11 +624,11 @@ class ConnectionTest < Minitest::Test
     }
 
     write_client_side("GET / HTTP/1.1\r\n\r\n")
-    @adapter.serve_request
+    @connection.serve_request
     response = read_client_side(65536)
     expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar; HttpOnly\r\nSet-Cookie: bar=baz\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
     assert_equal expected, response
-    
+
   end
 
   def test_set_cookie_multi2
@@ -640,10 +640,10 @@ class ConnectionTest < Minitest::Test
     }
 
     write_client_side("GET / HTTP/1.1\r\n\r\n")
-    @adapter.serve_request
+    @connection.serve_request
     response = read_client_side(65536)
     expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: a=1\r\nSet-Cookie: b=2\r\nSet-Cookie: c=3\r\nSet-Cookie: d=4\r\nSet-Cookie: e=5\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
     assert_equal expected, response
-    
+
   end
 end

data/test/test_json_api.rb

@@ -3,6 +3,8 @@
 require_relative 'helper'
 
 class JSONAPITest < Minitest::Test
+  HTTP = Syntropy::HTTP
+
   class TestAPI < Syntropy::JSONAPI
     def foo(req)
       @value
@@ -21,39 +23,39 @@ class JSONAPITest < Minitest::Test
   def test_json_api
     req = mock_req(':method' => 'GET', ':path' => '/')
     @app.call(req)
-    assert_equal Qeweney::Status::BAD_REQUEST, req.response_status
+    assert_equal HTTP::BAD_REQUEST, req.response_status
 
     req = mock_req(':method' => 'GET', ':path' => '/?q=foo')
     @app.call(req)
-    assert_equal Qeweney::Status::OK, req.response_status
-    assert_equal({ status: 'OK', response: nil }, req.response_json)
+    assert_equal HTTP::OK, req.response_status
+    assert_equal({ 'status' => 'OK', 'response' => nil }, req.response_json)
 
     req = mock_req(':method' => 'POST', ':path' => '/?q=foo')
     @app.call(req)
-    assert_equal Qeweney::Status::METHOD_NOT_ALLOWED, req.response_status
+    assert_equal HTTP::METHOD_NOT_ALLOWED, req.response_status
 
 
     req = mock_req(':method' => 'POST', ':path' => '/?q=bar&v=foo')
     @app.call(req)
-    assert_equal Qeweney::Status::OK, req.response_status
-    assert_equal({ status: 'OK', response: true }, req.response_json)
+    assert_equal HTTP::OK, req.response_status
+    assert_equal({ 'status' => 'OK', 'response' => true }, req.response_json)
 
     req = mock_req(':method' => 'GET', ':path' => '/?q=bar&v=foo')
     @app.call(req)
-    assert_equal Qeweney::Status::METHOD_NOT_ALLOWED, req.response_status
+    assert_equal HTTP::METHOD_NOT_ALLOWED, req.response_status
 
     req = mock_req(':method' => 'GET', ':path' => '/?q=foo')
     @app.call(req)
-    assert_equal Qeweney::Status::OK, req.response_status
-    assert_equal({ status: 'OK', response: 'foo' }, req.response_json)
+    assert_equal HTTP::OK, req.response_status
+    assert_equal({ 'status' => 'OK', 'response' => 'foo' }, req.response_json)
 
     req = mock_req(':method' => 'GET', ':path' => '/?q=foo')
     @app.call(req)
-    assert_equal Qeweney::Status::OK, req.response_status
-    assert_equal({ status: 'OK', response: 'foo' }, req.response_json)
+    assert_equal HTTP::OK, req.response_status
+    assert_equal({ 'status' => 'OK', 'response' => 'foo' }, req.response_json)
 
     req = mock_req(':method' => 'GET', ':path' => '/?q=xxx')
     @app.call(req)
-    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+    assert_equal HTTP::NOT_FOUND, req.response_status
   end
 end

data/test/test_mock_adapter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class MockAdapterTest < Minitest::Test
+  def test_mock_adapter
+    adapter = Syntropy::MockAdapter.new(nil)
+    req = Syntropy::Request.new({ ':path' => '/foo' }, adapter)
+    req.respond('bar', 'Content-Type' => 'baz')
+
+    assert_equal 'bar', adapter.response_body
+    assert_equal({'Content-Type' => 'baz'}, adapter.response_headers)
+  end
+
+  def test_mock_adapter_with_body
+    adapter = Syntropy::MockAdapter.new('barbaz')
+    req = Syntropy::Request.new({ ':path' => '/foo' }, adapter)
+    assert_equal false, req.complete?
+
+    body = req.read
+    assert_equal 'barbaz', body
+    assert_equal true, req.complete?
+  end
+
+  def test_mock_adapter_with_chunked_body
+    adapter = Syntropy::MockAdapter.new(['bar', 'baz'])
+    req = Syntropy::Request.new({ ':path' => '/foo' }, adapter)
+    assert_equal false, req.complete?
+
+    chunk = req.next_chunk
+    assert_equal 'bar', chunk
+    assert_equal false, req.complete?
+
+    chunk = req.next_chunk
+    assert_equal 'baz', chunk
+    assert_equal true, req.complete?
+  end
+
+  def test_mock_adapter_each_chunk
+    chunks = []
+    adapter = Syntropy::MockAdapter.new(['bar', 'baz'])
+    req = Syntropy::Request.new({ ':path' => '/foo' }, adapter)
+    assert_equal false, req.complete?
+
+    req.each_chunk { chunks << _1 }
+    assert_equal ['bar', 'baz'], chunks
+    assert_equal true, req.complete?
+  end
+
+  def test_set_response_headers
+    adapter = Syntropy::MockAdapter.new(nil)
+    req = Syntropy::Request.new({ ':path' => '/foo' }, adapter)
+    adapter.set_response_headers('Foo' => 'bar')
+    req.respond('hi', 'Bar' => 'baz')
+
+    assert_equal 'hi', adapter.response_body
+    assert_equal({'Foo' => 'bar', 'Bar' => 'baz'}, adapter.response_headers)
+  end
+end