syntropy 0.29.0 → 0.31.0

data/lib/syntropy/test.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'syntropy'
+require 'syntropy/request/mock_adapter'
+require 'minitest'
+
+module Syntropy
+  class TestHarness
+    def initialize(app)
+      @app = app
+      @app.test_mode = true
+    end
+
+    def request(headers, body = nil)
+      req = mock_req(headers, body)
+      @app.call(req)
+      req
+    end
+
+    private
+
+    def mock_req(headers, body = nil)
+      Syntropy::MockAdapter.mock(headers, body)
+    end
+  end
+
+  class Request
+    def response_headers
+      adapter.response_headers
+    end
+
+    def response_status
+      adapter.status
+    end
+
+    def response_body
+      adapter.response_body
+    end
+
+    def response_json
+      raise if response_content_type != 'application/json'
+      JSON.parse(response_body)
+    end
+
+    def response_content_type
+      ct = response_headers['Content-Type']
+      return nil if !ct
+
+      m = ct.match(/^([^;]+)/)
+      return nil if !m
+
+      m[1]
+    end
+
+    def response_cookie(name)
+      sc = response_headers['Set-Cookie']
+      return nil if !sc
+
+      m = sc.match(/#{name}=([^\s]+)$/)
+      return nil if !m
+
+      m[1]
+    end
+  end
+end

data/lib/syntropy/utils.rb

@@ -20,7 +20,7 @@ module Syntropy
       #
       lambda { |req|
         site = sites[req.host]
-        site ? site.call(req) : req.respond(nil, ':status' => Status::BAD_REQUEST)
+        site ? site.call(req) : req.respond(nil, ':status' => HTTP::BAD_REQUEST)
       }
     end
 

data/lib/syntropy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Syntropy
-  VERSION = '0.29.0'
+  VERSION = '0.31.0'
 end

data/lib/syntropy.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
-require 'qeweney'
 require 'uringmachine'
 require 'papercraft'
 
+require 'syntropy/request'
 require 'syntropy/logger'
-require 'syntropy/connection'
-require 'syntropy/server'
+require 'syntropy/http'
+require 'syntropy/mime_types'
 require 'syntropy/app'
 require 'syntropy/connection_pool'
 require 'syntropy/errors'
 require 'syntropy/markdown'
 require 'syntropy/module'
-require 'syntropy/request_extensions'
 require 'syntropy/papercraft_extensions'
 require 'syntropy/routing_tree'
 require 'syntropy/json_api'
@@ -21,8 +20,6 @@ require 'syntropy/utils'
 require 'syntropy/version'
 
 module Syntropy
-  Status = Qeweney::Status
-
   extend Utilities
 
   class << self
@@ -35,25 +32,6 @@ module Syntropy
     end
   end
 
-  def colorize(color_code)
-    "\e[#{color_code}m#{self}\e[0m"
-  end
-
-  GREEN = "\e[32m"
-  CLEAR = "\e[0m"
-  YELLOW = "\e[33m"
-
-  BANNER =
-    "\n"\
-    "  #{GREEN}\n"\
-    "  #{GREEN} ooo\n"\
-    "  #{GREEN}ooooo\n"\
-    "  #{GREEN} ooo vvv       #{CLEAR}Syntropy - a web framework for Ruby\n"\
-    "  #{GREEN}  o vvvvv     #{CLEAR}--------------------------------------\n"\
-    "  #{GREEN}  #{YELLOW}|#{GREEN}  vvv o    #{CLEAR}https://github.com/digital-fabric/syntropy\n"\
-    "  #{GREEN} :#{YELLOW}|#{GREEN}:::#{YELLOW}|#{GREEN}::#{YELLOW}|#{GREEN}:\n"\
-    "#{YELLOW}+++++++++++++++++++++++++++++++++++++++++++++++++++++++++\e[0m\n\n"
-
   class << self
     def run(env = {}, &app)
       if @in_run
@@ -66,11 +44,10 @@ module Syntropy
       begin
         @in_run = true
         machine = env[:machine] || UM.new
-        machine.puts(env[:banner]) if env[:banner]
 
         env[:logger]&.info(message: "Running Syntropy #{Syntropy::VERSION}, UringMachine #{UM::VERSION}, Ruby #{RUBY_VERSION}")
 
-        server = Server.new(machine, env, &app)
+        server = HTTP::Server.new(machine, env, &app)
 
         setup_signal_handling(machine, Fiber.current)
         server.run

data/syntropy.gemspec

@@ -23,10 +23,8 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'extralite',     '~>2.14'
   s.add_dependency 'papercraft',    '~>3.2.0'
-  s.add_dependency 'qeweney',       '~>0.24'
-  s.add_dependency 'uringmachine',  '~>1.0.0'
-
-  s.add_dependency 'listen',        '~>3.9.0'
+  s.add_dependency 'uringmachine',  '~>1.0.2'
+  s.add_dependency 'escape_utils',  '1.3.0'
 
   s.add_dependency 'json'
   s.add_dependency 'logger'

data/test/app/.well-known/foo.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  req.respond('foo')
+}

data/test/app/about/_error.rb

@@ -1,4 +1,4 @@
-DEFAULT_STATUS = Qeweney::Status::INTERNAL_SERVER_ERROR
+DEFAULT_STATUS = HTTP::INTERNAL_SERVER_ERROR
 
 export ->(req, err) {
   status = err.respond_to?(:http_status) ? err.http_status : DEFAULT_STATUS

data/test/app/api+.rb

@@ -10,7 +10,7 @@ class API < Syntropy::JSONAPI
 
   def incr!(req)
     if req.path != '/test/api'
-        raise Syntropy::Error.new('Teapot', Qeweney::Status::TEAPOT)
+        raise Syntropy::Error.new('Teapot', HTTP::TEAPOT)
     end
 
     @count += 1

data/test/app_custom/_site.rb

@@ -1,3 +1,3 @@
 export ->(req) {
-  req.respond(nil, ':status' => Status::TEAPOT)
+  req.respond(nil, ':status' => HTTP::TEAPOT)
 }

data/test/bm_router_proc.rb

@@ -13,7 +13,7 @@ require 'roda'
 require 'benchmark/ips'
 require 'securerandom'
 require 'rack/mock_request'
-require 'qeweney/mock_adapter'
+require 'syntropy/request/mock_adapter'
 
 class BM
   def self.name(name)
@@ -100,7 +100,7 @@ p roda_app.(req)
 
 ################################################################################
 
-class Qeweney::Request
+class Syntropy::Request
   def response_headers
     adapter.headers
   end
@@ -157,7 +157,7 @@ proc = ->(req) { syntropy_app.(req) }
 
 module ::Kernel
   def mock_req(headers, body = nil)
-    Qeweney::MockAdapter.mock(headers, body).tap { it.setup_mock_request }
+    Syntropy::MockAdapter.mock(headers, body)
   end
 end
 

data/test/helper.rb

@@ -4,7 +4,7 @@ require 'bundler/setup'
 require_relative './coverage' if ENV['COVERAGE']
 require 'uringmachine'
 require 'syntropy'
-require 'qeweney/mock_adapter'
+require 'syntropy/test'
 require 'minitest/autorun'
 require 'fileutils'
 
@@ -19,7 +19,7 @@ end
 
 module ::Kernel
   def mock_req(headers, body = nil)
-    Qeweney::MockAdapter.mock(headers, body).tap { it.setup_mock_request }
+    Syntropy::MockAdapter.mock(headers, body)
   end
 
   def capture_exception
@@ -89,33 +89,10 @@ module Minitest::Assertions
     return unless exp_content_type
 
     if Symbol === exp_content_type
-      exp_content_type = Qeweney::MimeTypes[exp_content_type]
+      exp_content_type = Syntropy::MimeTypes[exp_content_type]
     end
     actual = req.response_content_type
-    assert_equal exp_content_type, actual
-  end
-end
-
-# Extensions to be used in conjunction with `Qeweney::TestAdapter`
-class Qeweney::Request
-  def response_headers
-    adapter.response_headers
-  end
-
-  def response_status
-    adapter.status
-  end
-
-  def response_body
-    adapter.response_body
-  end
 
-  def response_json
-    raise if response_content_type != 'application/json'
-    JSON.parse(response_body, symbolize_names: true)
-  end
-
-  def response_content_type
-    response_headers['Content-Type']
+    assert_equal exp_content_type, actual
   end
 end

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')
 
@@ -19,156 +19,156 @@ class AppTest < Minitest::Test
       watch_files: 0.05,
       machine: @machine
     )
-  end
 
-  def make_request(*, **)
-    req = mock_req(*, **)
-    @app.call(req)
-    req
+    @test_harness = Syntropy::TestHarness.new(@app)
   end
 
   def test_app_rendering
-    req = make_request(':method' => 'GET', ':path' => '/')
-    assert_equal Status::NOT_FOUND, req.response_status
+    req = @test_harness.request(':method' => 'GET', ':path' => '/')
+    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
+    req = @test_harness.request(':method' => 'HEAD', ':path' => '/')
+    assert_equal HTTP::NOT_FOUND, req.response_status
     assert_nil req.response_body
 
-    req = make_request(':method' => 'POST', ':path' => '/')
+    req = @test_harness.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
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test')
+    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
+    req = @test_harness.request(':method' => 'HEAD', ':path' => '/test')
+    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
+    req = @test_harness.request(':method' => 'POST', ':path' => '/test')
+    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')
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test/assets/style.css')
     assert_equal '* { color: beige }', req.response_body
     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
+    req = @test_harness.request(':method' => 'GET', ':path' => '/assets/style.css')
+    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 = @test_harness.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({ status: 'Error', message: 'Method not allowed' }, req.response_json)
+    req = @test_harness.request(':method' => 'POST', ':path' => '/test/api?q=get')
+    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')
-    assert_equal({ status: 'OK', response: 0 }, req.response_json)
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test/api/foo?q=get')
+    assert_equal({ 'status' => 'OK', 'response' => 0 }, req.response_json)
 
-    req = make_request(':method' => 'POST', ':path' => '/test/api?q=incr')
-    assert_equal({ status: 'OK', response: 1 }, req.response_json)
+    req = @test_harness.request(':method' => 'POST', ':path' => '/test/api?q=incr')
+    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({ status: 'Error', message: 'Method not allowed' }, req.response_json)
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test/api?q=incr')
+    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
+    req = @test_harness.request(':method' => 'POST', ':path' => '/test/api/foo?q=incr')
+    assert_equal({ 'status' => 'Error', 'message' => 'Teapot' }, req.response_json)
+    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
+    req = @test_harness.request(':method' => 'POST', ':path' => '/test/api/foo/bar?q=incr')
+    assert_equal({ 'status' => 'Error', 'message' => 'Teapot' }, req.response_json)
+    assert_equal HTTP::TEAPOT, req.response_status
 
-    req = make_request(':method' => 'GET', ':path' => '/test/bar')
+    req = @test_harness.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')
+    req = @test_harness.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')
+    req = @test_harness.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')
+    req = @test_harness.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')
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test/about')
     assert_equal 'About', req.response_body.chomp
 
-    req = make_request(':method' => 'GET', ':path' => '/test/about/foo')
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test/about/foo')
     assert_equal '<!DOCTYPE html><html><head><title></title></head><body><p>Hello from Markdown</p></body></html>', req.response_body.gsub(/\n/, '')
 
-    req = make_request(':method' => 'HEAD', ':path' => '/test/about/foo')
+    req = @test_harness.request(':method' => 'HEAD', ':path' => '/test/about/foo')
     assert_nil req.response_body
 
-    req = make_request(':method' => 'GET', ':path' => '/test/about/foo/bar')
-    assert_equal Status::NOT_FOUND, req.response_status
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test/about/foo/bar')
+    assert_equal HTTP::NOT_FOUND, req.response_status
 
-    req = make_request(':method' => 'GET', ':path' => '/test/params/abc')
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test/params/abc')
     assert_equal '/test/params/[foo]-abc', req.response_body.chomp
 
-    req = make_request(':method' => 'GET', ':path' => '/test/rss')
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test/rss')
     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
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test/bad_mod')
+    assert_equal HTTP::INTERNAL_SERVER_ERROR, req.response_status
+
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test/.well-known/foo')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'foo', req.response_body
   end
 
   def test_automatic_redirect_on_trailing_slash
-    req = make_request(':method' => 'GET', ':path' => '/test/rss/')
-    assert_equal Status::MOVED_PERMANENTLY, req.response_status
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test/rss/')
+    assert_equal HTTP::MOVED_PERMANENTLY, req.response_status
     assert_equal '/test/rss', req.response_headers['Location']
   end
 
   def test_app_file_watching
     @machine.sleep 0.3
 
-    req = make_request(':method' => 'GET', ':path' => @tmp_path)
+    req = @test_harness.request(':method' => 'GET', ':path' => @tmp_path)
     assert_equal 'foo', req.response_body
 
     orig_body = IO.read(@tmp_fn)
     IO.write(@tmp_fn, orig_body.gsub('foo', 'bar'))
     @machine.sleep(0.3)
 
-    req = make_request(':method' => 'GET', ':path' => @tmp_path)
+    req = @test_harness.request(':method' => 'GET', ':path' => @tmp_path)
     assert_equal 'bar', req.response_body
   ensure
     IO.write(@tmp_fn, orig_body) if orig_body
   end
 
   def test_middleware
-    req = make_request(':method' => 'HEAD', ':path' => '/test?foo=42')
-    assert_equal Status::OK, req.response_status
+    req = @test_harness.request(':method' => 'HEAD', ':path' => '/test?foo=42')
+    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
+    req = @test_harness.request(':method' => 'HEAD', ':path' => '/test/about/raise?foo=43')
+    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
+    req = @test_harness.request(':method' => 'HEAD', ':path' => '/azerty?foo=bar')
+    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
+    req = @test_harness.request(':method' => 'HEAD', ':path' => '/test/azerty?foo=bar')
+    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')
 
@@ -179,23 +179,18 @@ class CustomAppTest < Minitest::Test
       root_dir: APP_ROOT,
       mount_path: '/'
     )
-  end
-
-  def make_request(*, **)
-    req = mock_req(*, **)
-    @app.call(req)
-    req
+    @test_harness = Syntropy::TestHarness.new(@app)
   end
 
   def test_app_with_site_rb_file
-    req = make_request(':method' => 'GET', ':path' => '/foo/bar')
+    req = @test_harness.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')
 
@@ -206,29 +201,24 @@ class MultiSiteAppTest < Minitest::Test
       root_dir: APP_ROOT,
       mount_path: '/'
     )
-  end
-
-  def make_request(*, **)
-    req = mock_req(*, **)
-    @app.call(req)
-    req
+    @test_harness = Syntropy::TestHarness.new(@app)
   end
 
   def test_route_by_host
-    req = make_request(':method' => 'GET', ':path' => '/', 'host' => 'blah')
+    req = @test_harness.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')
+    req = @test_harness.request(':method' => 'GET', ':path' => '/', 'host' => 'foo.bar')
     assert_equal '<h1>foo.bar</h1>', req.response_body.chomp
 
-    req = make_request(':method' => 'GET', ':path' => '/', 'host' => 'bar.baz')
+    req = @test_harness.request(':method' => 'GET', ':path' => '/', 'host' => 'bar.baz')
     assert_equal '<h1>bar.baz</h1>', req.response_body.chomp
   end
 end
 
 class AppAPITest < Minitest::Test
-  Status = Qeweney::Status
+  HTTP = Syntropy::HTTP
 
   APP_ROOT = File.join(__dir__, 'app')
 
@@ -292,16 +282,10 @@ class AppAPITest < Minitest::Test
 end
 
 class AppDependenciesTest < Minitest::Test
-  Status = Qeweney::Status
+  HTTP = Syntropy::HTTP
 
   APP_ROOT = File.join(__dir__, 'app')
 
-  def make_request(*, **)
-    req = mock_req(*, **)
-    @app.call(req)
-    req
-  end
-
   def test_app_dependencies
     foo = { foo: 'foo' }
     bar = { bar: 'bar' }
@@ -318,9 +302,10 @@ class AppDependenciesTest < Minitest::Test
       foo: foo,
       bar: bar
     )
+    @test_harness = Syntropy::TestHarness.new(@app)
 
-    req = make_request(':method' => 'GET', ':path' => '/test/bar')
+    req = @test_harness.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::ServerConnection.new(@machine, @s_fd, @env) { @app.(it) }
   end
 
   def teardown