syntropy 0.29.0 → 0.30.0

data/test/test_app.rb

@@ -3,7 +3,7 @@
 require_relative 'helper'
 
 class AppTest < Minitest::Test
-  Status = Qeweney::Status
+  HTTP = Syntropy::HTTP
 
   APP_ROOT = File.join(__dir__, 'app')
 
@@ -29,27 +29,27 @@ class AppTest < Minitest::Test
 
   def test_app_rendering
     req = make_request(':method' => 'GET', ':path' => '/')
-    assert_equal Status::NOT_FOUND, req.response_status
+    assert_equal HTTP::NOT_FOUND, req.response_status
     assert_equal 'Not found', req.response_body
 
     req = make_request(':method' => 'HEAD', ':path' => '/')
-    assert_equal Status::NOT_FOUND, req.response_status
+    assert_equal HTTP::NOT_FOUND, req.response_status
     assert_nil req.response_body
 
     req = make_request(':method' => 'POST', ':path' => '/')
     assert_equal 'Not found', req.response_body
-    assert_equal Status::NOT_FOUND, req.response_status
+    assert_equal HTTP::NOT_FOUND, req.response_status
 
     req = make_request(':method' => 'GET', ':path' => '/test')
-    assert_equal Status::OK, req.response_status
+    assert_equal HTTP::OK, req.response_status
     assert_equal '<h1>Hello, world!</h1>', req.response_body
 
     req = make_request(':method' => 'HEAD', ':path' => '/test')
-    assert_equal Status::OK, req.response_status
+    assert_equal HTTP::OK, req.response_status
     assert_nil req.response_body
 
     req = make_request(':method' => 'POST', ':path' => '/test')
-    assert_equal Status::METHOD_NOT_ALLOWED, req.response_status
+    assert_equal HTTP::METHOD_NOT_ALLOWED, req.response_status
     assert_equal "Method not allowed", req.response_body
 
     req = make_request(':method' => 'GET', ':path' => '/test/assets/style.css')
@@ -57,13 +57,13 @@ class AppTest < Minitest::Test
     assert_equal 'text/css', req.response_headers['Content-Type']
 
     req = make_request(':method' => 'GET', ':path' => '/assets/style.css')
-    assert_equal Status::NOT_FOUND, req.response_status
+    assert_equal HTTP::NOT_FOUND, req.response_status
 
     req = make_request(':method' => 'GET', ':path' => '/test/api?q=get')
     assert_equal({ status: 'OK', response: 0 }, req.response_json)
 
     req = make_request(':method' => 'POST', ':path' => '/test/api?q=get')
-    assert_equal Status::METHOD_NOT_ALLOWED, req.response_status
+    assert_equal HTTP::METHOD_NOT_ALLOWED, req.response_status
     assert_equal({ status: 'Error', message: 'Method not allowed' }, req.response_json)
 
     req = make_request(':method' => 'GET', ':path' => '/test/api/foo?q=get')
@@ -73,32 +73,32 @@ class AppTest < Minitest::Test
     assert_equal({ status: 'OK', response: 1 }, req.response_json)
 
     req = make_request(':method' => 'GET', ':path' => '/test/api?q=incr')
-    assert_equal Status::METHOD_NOT_ALLOWED, req.response_status
+    assert_equal HTTP::METHOD_NOT_ALLOWED, req.response_status
     assert_equal({ status: 'Error', message: 'Method not allowed' }, req.response_json)
 
     req = make_request(':method' => 'POST', ':path' => '/test/api/foo?q=incr')
     assert_equal({ status: 'Error', message: 'Teapot' }, req.response_json)
-    assert_equal Status::TEAPOT, req.response_status
+    assert_equal HTTP::TEAPOT, req.response_status
 
     req = make_request(':method' => 'POST', ':path' => '/test/api/foo/bar?q=incr')
     assert_equal({ status: 'Error', message: 'Teapot' }, req.response_json)
-    assert_equal Status::TEAPOT, req.response_status
+    assert_equal HTTP::TEAPOT, req.response_status
 
     req = make_request(':method' => 'GET', ':path' => '/test/bar')
     assert_equal 'foobar', req.response_body
-    assert_equal Status::OK, req.response_status
+    assert_equal HTTP::OK, req.response_status
 
     req = make_request(':method' => 'POST', ':path' => '/test/bar')
     assert_equal 'foobar', req.response_body
-    assert_equal Status::OK, req.response_status
+    assert_equal HTTP::OK, req.response_status
 
     req = make_request(':method' => 'GET', ':path' => '/test/baz')
     assert_equal 'foobar', req.response_body
-    assert_equal Status::OK, req.response_status
+    assert_equal HTTP::OK, req.response_status
 
     req = make_request(':method' => 'POST', ':path' => '/test/baz')
     assert_equal 'Method not allowed', req.response_body
-    assert_equal Status::METHOD_NOT_ALLOWED, req.response_status
+    assert_equal HTTP::METHOD_NOT_ALLOWED, req.response_status
 
     req = make_request(':method' => 'GET', ':path' => '/test/about')
     assert_equal 'About', req.response_body.chomp
@@ -110,7 +110,7 @@ class AppTest < Minitest::Test
     assert_nil req.response_body
 
     req = make_request(':method' => 'GET', ':path' => '/test/about/foo/bar')
-    assert_equal Status::NOT_FOUND, req.response_status
+    assert_equal HTTP::NOT_FOUND, req.response_status
 
     req = make_request(':method' => 'GET', ':path' => '/test/params/abc')
     assert_equal '/test/params/[foo]-abc', req.response_body.chomp
@@ -119,12 +119,12 @@ class AppTest < Minitest::Test
     assert_equal '<link>foo</link>', req.response_body
 
     req = make_request(':method' => 'GET', ':path' => '/test/bad_mod')
-    assert_equal Status::INTERNAL_SERVER_ERROR, req.response_status
+    assert_equal HTTP::INTERNAL_SERVER_ERROR, req.response_status
   end
 
   def test_automatic_redirect_on_trailing_slash
     req = make_request(':method' => 'GET', ':path' => '/test/rss/')
-    assert_equal Status::MOVED_PERMANENTLY, req.response_status
+    assert_equal HTTP::MOVED_PERMANENTLY, req.response_status
     assert_equal '/test/rss', req.response_headers['Location']
   end
 
@@ -146,29 +146,29 @@ class AppTest < Minitest::Test
 
   def test_middleware
     req = make_request(':method' => 'HEAD', ':path' => '/test?foo=42')
-    assert_equal Status::OK, req.response_status
+    assert_equal HTTP::OK, req.response_status
     assert_nil req.response_body
     assert_equal '42', req.ctx[:foo]
 
     req = make_request(':method' => 'HEAD', ':path' => '/test/about/raise?foo=43')
-    assert_equal Status::INTERNAL_SERVER_ERROR, req.response_status
+    assert_equal HTTP::INTERNAL_SERVER_ERROR, req.response_status
     assert_equal '<h1>Raised error</h1>', req.response_body
     assert_equal '43', req.ctx[:foo]
   end
 
   def test_middleware_invocation_on_404
     req = make_request(':method' => 'HEAD', ':path' => '/azerty?foo=bar')
-    assert_equal Status::NOT_FOUND, req.response_status
+    assert_equal HTTP::NOT_FOUND, req.response_status
     assert_nil req.ctx[:foo]
 
     req = make_request(':method' => 'HEAD', ':path' => '/test/azerty?foo=bar')
-    assert_equal Status::NOT_FOUND, req.response_status
+    assert_equal HTTP::NOT_FOUND, req.response_status
     assert_equal 'bar', req.ctx[:foo]
   end
 end
 
 class CustomAppTest < Minitest::Test
-  Status = Qeweney::Status
+  HTTP = Syntropy::HTTP
 
   APP_ROOT = File.join(__dir__, 'app_custom')
 
@@ -190,12 +190,12 @@ class CustomAppTest < Minitest::Test
   def test_app_with_site_rb_file
     req = make_request(':method' => 'GET', ':path' => '/foo/bar')
     assert_nil req.response_body
-    assert_equal Status::TEAPOT, req.response_status
+    assert_equal HTTP::TEAPOT, req.response_status
   end
 end
 
 class MultiSiteAppTest < Minitest::Test
-  Status = Qeweney::Status
+  HTTP = Syntropy::HTTP
 
   APP_ROOT = File.join(__dir__, 'app_multi_site')
 
@@ -217,7 +217,7 @@ class MultiSiteAppTest < Minitest::Test
   def test_route_by_host
     req = make_request(':method' => 'GET', ':path' => '/', 'host' => 'blah')
     assert_nil req.response_body
-    assert_equal Status::BAD_REQUEST, req.response_status
+    assert_equal HTTP::BAD_REQUEST, req.response_status
 
     req = make_request(':method' => 'GET', ':path' => '/', 'host' => 'foo.bar')
     assert_equal '<h1>foo.bar</h1>', req.response_body.chomp
@@ -228,7 +228,7 @@ class MultiSiteAppTest < Minitest::Test
 end
 
 class AppAPITest < Minitest::Test
-  Status = Qeweney::Status
+  HTTP = Syntropy::HTTP
 
   APP_ROOT = File.join(__dir__, 'app')
 
@@ -292,7 +292,7 @@ class AppAPITest < Minitest::Test
 end
 
 class AppDependenciesTest < Minitest::Test
-  Status = Qeweney::Status
+  HTTP = Syntropy::HTTP
 
   APP_ROOT = File.join(__dir__, 'app')
 
@@ -321,6 +321,6 @@ class AppDependenciesTest < Minitest::Test
 
     req = make_request(':method' => 'GET', ':path' => '/test/bar')
     assert_equal 'foobar', req.response_body
-    assert_equal Status::OK, req.response_status
+    assert_equal HTTP::OK, req.response_status
   end
 end

data/test/test_caching.rb

@@ -4,7 +4,7 @@ require_relative 'helper'
 require 'digest/sha1'
 
 class CachingTest < Minitest::Test
-  Status = Qeweney::Status
+  HTTP = Syntropy::HTTP
 
   APP_ROOT = File.join(__dir__, 'app')
 
@@ -40,7 +40,7 @@ class CachingTest < Minitest::Test
     @app = Syntropy::App.new(**@env)
 
     @c_fd, @s_fd = make_socket_pair
-    @adapter = Syntropy::Connection.new(nil, @machine, @s_fd, @env) { @app.(it) }
+    @adapter = Syntropy::HTTP::Connection.new(nil, @machine, @s_fd, @env) { @app.(it) }
   end
 
   def teardown

data/test/test_connection.rb

@@ -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)
+    @adapter = Syntropy::HTTP::Connection.new(nil, @machine, @s_fd, @env, &@app)
   end
 
   def teardown
@@ -614,7 +614,7 @@ class ConnectionTest < Minitest::Test
     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
@@ -628,7 +628,7 @@ class ConnectionTest < Minitest::Test
     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
@@ -644,6 +644,6 @@ class ConnectionTest < Minitest::Test
     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_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_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 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 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 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 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

data/test/test_request_info.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class RequestInfoTest < Minitest::Test
+  def test_uri
+    r = Syntropy::MockAdapter.mock(':path' => '/test/path')
+    assert_equal '/test/path', r.path
+    assert_equal({}, r.query)
+
+    r = Syntropy::MockAdapter.mock(':path' => '/test/path?a=1&b=2&c=3%2f4')
+    assert_equal '/test/path', r.path
+    assert_equal({ a: '1', b: '2', c: '3/4' }, r.query)
+  end
+
+  def test_query
+    r = Syntropy::MockAdapter.mock(':path' => '/GponForm/diag_Form?images/')
+    assert_equal '/GponForm/diag_Form', r.path
+    assert_equal({:'images/' => true}, r.query)
+
+    r = Syntropy::MockAdapter.mock(':path' => '/?a=1&b=2')
+    assert_equal '/', r.path
+    assert_equal({a: '1', b: '2'}, r.query)
+
+    r = Syntropy::MockAdapter.mock(':path' => '/?l=a&t=&x=42')
+    assert_equal({l: 'a', t: '', x: '42'}, r.query)
+  end
+
+  def test_host
+    r = Syntropy::MockAdapter.mock(':path' => '/')
+    assert_nil r.host
+    assert_nil r.authority
+
+    r = Syntropy::MockAdapter.mock('host' => 'my.example.com')
+    assert_equal 'my.example.com', r.host
+    assert_equal 'my.example.com', r.authority
+
+    r = Syntropy::MockAdapter.mock(':authority' => 'my.foo.com')
+    assert_equal 'my.foo.com', r.host
+    assert_equal 'my.foo.com', r.authority
+  end
+
+  def test_full_uri
+    r = Syntropy::MockAdapter.mock(
+      ':scheme' => 'https',
+      'host' => 'foo.bar',
+      ':path' => '/hey?a=b&c=d'
+    )
+
+    assert_equal 'https://foo.bar/hey?a=b&c=d', r.full_uri
+  end
+
+  def test_cookies
+    r = Syntropy::MockAdapter.mock
+
+    assert_equal({}, r.cookies)
+
+    r = Syntropy::MockAdapter.mock(
+      'cookie' => 'uaid=a%2Fb; lastLocus=settings; signin_ref=/'
+    )
+
+    assert_equal({
+      'uaid' => 'a/b',
+      'lastLocus' => 'settings',
+      'signin_ref' => '/'
+    }, r.cookies)
+  end
+
+  def test_rewrite!
+    r = Syntropy::MockAdapter.mock(
+      ':scheme' => 'https',
+      'host' => 'foo.bar',
+      ':path' => '/hey/ho?a=b&c=d'
+    )
+
+    assert_equal '/hey/ho', r.path
+    assert_equal URI.parse('/hey/ho?a=b&c=d'), r.uri
+    assert_equal 'https://foo.bar/hey/ho?a=b&c=d', r.full_uri
+
+    r.rewrite!('/hhh', '/')
+    assert_equal '/hey/ho', r.path
+    assert_equal URI.parse('/hey/ho?a=b&c=d'), r.uri
+    assert_equal 'https://foo.bar/hey/ho?a=b&c=d', r.full_uri
+
+    r.rewrite!('/hey', '/')
+    assert_equal '/ho', r.path
+    assert_equal URI.parse('/ho?a=b&c=d'), r.uri
+    assert_equal 'https://foo.bar/ho?a=b&c=d', r.full_uri
+  end
+end

data/test/test_response.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class RedirectTest < Minitest::Test
+  def test_redirect
+    r = Syntropy::MockAdapter.mock
+    r.redirect('/foo')
+
+    assert_equal [
+      [:respond, r, nil, {":status"=>302, "Location"=>"/foo"}]
+    ], r.adapter.calls
+  end
+
+  def test_redirect_wirth_status
+    r = Syntropy::MockAdapter.mock
+    r.redirect('/bar', Syntropy::HTTP::MOVED_PERMANENTLY)
+
+    assert_equal [
+      [:respond, r, nil, {":status"=>301, "Location"=>"/bar"}]
+    ], r.adapter.calls
+  end
+end
+
+class StaticFileResponeTest < Minitest::Test
+  def setup
+    @path = File.join(__dir__, 'helper.rb')
+    @stat = File.stat(@path)
+
+    @etag = Syntropy::StaticFileCaching.file_stat_to_etag(@stat)
+    @last_modified = Syntropy::StaticFileCaching.file_stat_to_last_modified(@stat)
+    @content = IO.read(@path)
+  end
+
+  def test_serve_file_non_existent
+    r = Syntropy::MockAdapter.mock
+    r.serve_file('foo.rb', base_path: __dir__)
+    assert_equal [
+      [:respond, r, nil, { ':status' => Syntropy::HTTP::NOT_FOUND }]
+    ], r.adapter.calls
+  end
+end
+
+class UpgradeTest < Minitest::Test
+  def test_upgrade
+    r = Syntropy::MockAdapter.mock
+    r.upgrade('df')
+
+    assert_equal [
+      [
+        :respond,
+        r,
+        nil,
+        {
+          ':status' => 101,
+          'Upgrade' => 'df',
+          'Connection' => 'upgrade'
+        }
+      ],
+      [
+        :with_stream
+      ]
+    ], r.adapter.calls
+
+
+    r = Syntropy::MockAdapter.mock
+    r.upgrade('df', { 'foo' => 'bar' })
+
+    assert_equal [
+      [
+        :respond,
+        r,
+        nil,
+        {
+          ':status' => 101,
+          'Upgrade' => 'df',
+          'Connection' => 'upgrade',
+          'foo' => 'bar'
+        }
+      ],
+      [
+        :with_stream
+      ]
+    ], r.adapter.calls
+  end
+
+  def test_websocket_upgrade
+    r = Syntropy::MockAdapter.mock(
+      'connection' => 'upgrade',
+      'upgrade' => 'websocket',
+      'sec-websocket-version' => '23',
+      'sec-websocket-key' => 'abcdefghij'
+    )
+
+    assert_equal 'websocket', r.upgrade_protocol
+
+    r.upgrade_to_websocket('foo' => 'baz')
+    accept = Digest::SHA1.base64digest('abcdefghij258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+
+    assert_equal [
+      [:respond, r, nil, {
+        ':status' => 101,
+        'Upgrade' => 'websocket',
+        'Connection' => 'upgrade',
+        'foo' => 'baz',
+        'Sec-WebSocket-Accept' => accept
+      }],
+      [:with_stream],
+      [:websocket_connection, r]
+    ], r.adapter.calls
+  end
+end

data/test/test_server.rb

@@ -26,7 +26,7 @@ class ServerTest < Minitest::Test
     @machine = UM.new
     @port = 10000 + rand(30000)
     @env = { bind: "127.0.0.1:#{@port}" }.merge(opts)
-    @server = Syntropy::Server.new(@machine, @env) { @app&.call(it) }
+    @server = Syntropy::HTTP::Server.new(@machine, @env) { @app&.call(it) }
     @f_server = @machine.spin { run_server }
 
     # let server spin and listen to incoming connections