syntropy 0.30.0 → 0.32.0

data/test/helper.rb

@@ -4,7 +4,7 @@ require 'bundler/setup'
 require_relative './coverage' if ENV['COVERAGE']
 require 'uringmachine'
 require 'syntropy'
-require 'syntropy/request/mock_adapter'
+require 'syntropy/test'
 require 'minitest/autorun'
 require 'fileutils'
 
@@ -96,27 +96,3 @@ module Minitest::Assertions
     assert_equal exp_content_type, actual
   end
 end
-
-# Extensions to be used in conjunction with `Syntropy::TestAdapter`
-class Syntropy::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']
-  end
-end

data/test/schema/2026-01-02-foo.rb

@@ -0,0 +1,12 @@
+export ->(db) {
+  db.execute <<~SQL
+    create table posts (
+      id integer primary key autoincrement,
+      title text,
+      body text
+    );
+
+    insert into posts (title, body)
+    values ('foo', 'bar');
+  SQL
+}

data/test/schema/2026-05-30-bar.rb

@@ -0,0 +1,7 @@
+export ->(db) {
+  db.execute <<~SQL
+    update posts
+    set body = 'baz'
+    where title = 'foo';
+  SQL
+}

data/test/test_app.rb

@@ -19,149 +19,162 @@ 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' => '/')
+    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' => '/')
+    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 HTTP::NOT_FOUND, req.response_status
 
-    req = make_request(':method' => 'GET', ':path' => '/test')
+    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')
+    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')
+    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')
+    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')
+    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)
+    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')
+    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)
+    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)
+    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)
+    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 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 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 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 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')
+    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')
+    req = @test_harness.no_raise_internal_server_error {
+      @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
+
+    req = @test_harness.request(':method' => 'GET', ':path' => '/test/by_method')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'foo', req.response_body
+
+    req = @test_harness.request(':method' => 'POST', ':path' => '/test/by_method')
+    assert_equal HTTP::OK, req.response_status
+    assert_equal 'bar', req.response_body
+
+    req = @test_harness.request(':method' => 'DELETE', ':path' => '/test/by_method')
+    assert_equal HTTP::METHOD_NOT_ALLOWED, req.response_status
   end
 
   def test_automatic_redirect_on_trailing_slash
-    req = make_request(':method' => 'GET', ':path' => '/test/rss/')
+    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
+    @machine.sleep 0.2
 
-    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)
+    @machine.sleep(0.2)
 
-    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')
+    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')
+    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')
+    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')
+    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
@@ -179,16 +192,11 @@ 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 HTTP::TEAPOT, req.response_status
   end
@@ -206,23 +214,18 @@ 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 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
@@ -296,12 +299,6 @@ class AppDependenciesTest < Minitest::Test
 
   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 +315,52 @@ 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 HTTP::OK, req.response_status
   end
 end
+
+class AppDBSetupDBTest < Minitest::Test
+  HTTP = Syntropy::HTTP
+
+  APP_ROOT = File.join(__dir__, 'app_with_schema')
+
+  def test_app_setup_db
+    machine = UM.new
+
+    app = Syntropy::App.new(
+      root_dir: APP_ROOT,
+      mount_path: '/test',
+      machine: machine
+    )
+
+    assert_equal false, app.respond_to?(:connection_pool)
+    assert_equal false, app.respond_to?(:schema)
+
+    fn = "/tmp/#{rand(100000)}.db"
+
+    app.setup_db(
+      db_path:      fn,
+      schema_root:  '_schema'
+    )
+
+    assert_equal true, app.respond_to?(:connection_pool)
+    assert_equal fn, app.connection_pool.with_db { it.filename }
+
+    assert_equal true, app.respond_to?(:schema)
+    app.schema.apply(app.connection_pool)
+    assert_equal '2026-05-30-bar', app.schema.current_version(app.connection_pool)
+
+    assert_equal [
+      {
+        id: 1,
+        title: 'foo',
+        body: 'baz'
+      }
+    ], app.connection_pool.query('select id, title, body from posts')
+
+  end
+end

data/test/test_caching.rb

@@ -40,7 +40,7 @@ class CachingTest < Minitest::Test
     @app = Syntropy::App.new(**@env)
 
     @c_fd, @s_fd = make_socket_pair
-    @adapter = Syntropy::HTTP::Connection.new(nil, @machine, @s_fd, @env) { @app.(it) }
+    @adapter = Syntropy::HTTP::ServerConnection.new(@machine, @s_fd, @env) { @app.(it) }
   end
 
   def teardown

data/test/{test_connection_pool.rb → test_db_connection_pool.rb}

@@ -2,11 +2,11 @@
 
 require_relative 'helper'
 
-class ConnectionPoolTest < Minitest::Test
+class DBConnectionPoolTest < Minitest::Test
   def setup
     @machine = UM.new
     @fn = "/tmp/#{rand(100000)}.db"
-    @cp = Syntropy::ConnectionPool.new(@machine, @fn, 4)
+    @cp = Syntropy::DB::ConnectionPool.new(@machine, @fn, 4)
 
     FileUtils.rm(@fn) rescue nil
     @standalone_db = Extralite::Database.new(@fn)
@@ -14,6 +14,11 @@ class ConnectionPoolTest < Minitest::Test
     @standalone_db.execute("insert into foo values (1, 2, 3)")
   end
 
+  def teardown
+    @standalone_db.close
+    @cp.close
+  end
+
   def test_with_db
     assert_equal 0, @cp.count
 

data/test/test_db_schema.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class DBSchemaTest < Minitest::Test
+  def setup
+    @machine = UM.new
+    @fn = "/tmp/#{rand(100000)}.db"
+    FileUtils.rm(@fn) rescue nil
+    @cp = Syntropy::DB::ConnectionPool.new(@machine, @fn, 4)
+  end
+
+  def teardown
+    @cp.close
+  end
+
+  def test_db_schema_initial
+    schema = Syntropy::DB::Schema.new do
+      initial do |db|
+        db.execute <<~SQL
+          create table posts (
+            id integer primary key autoincrement,
+            title text,
+            body text
+          )
+        SQL
+      end
+    end
+
+    assert_nil schema.current_version(@cp)
+    schema.apply(@cp)
+    assert_equal '0000', schema.current_version(@cp)
+
+    assert_equal [], @cp.query('select id, title, body from posts')
+  end
+
+  def test_db_schema_version_blocks
+    schema = Syntropy::DB::Schema.new do
+      initial do |db|
+        db.execute <<~SQL
+          create table posts (
+            id integer primary key autoincrement,
+            title text,
+            body text
+          )
+        SQL
+      end
+
+      version('2026-05-30') do |db|
+        db.execute <<~SQL
+          insert into posts (title, body)
+          values ('foo', 'bar')
+        SQL
+      end
+
+      version('2026-05-31') do |db|
+        db.execute <<~SQL
+          update posts
+          set body = 'baz'
+          where title = 'foo'
+        SQL
+      end
+    end
+
+    assert_nil schema.current_version(@cp)
+    schema.apply(@cp)
+    assert_equal '2026-05-31', schema.current_version(@cp)
+
+    assert_equal [
+      {
+        id: 1,
+        title: 'foo',
+        body: 'baz'
+      }
+    ], @cp.query('select id, title, body from posts')
+  end
+
+  def test_schema_from_module_files
+    module_loader = Syntropy::ModuleLoader.new({
+      root_dir: File.join(__dir__, 'schema')
+    })
+    schema = Syntropy::DB::Schema.new(module_loader:, schema_root: '/')
+
+    assert_nil schema.current_version(@cp)
+    schema.apply(@cp)
+    assert_equal '2026-05-30-bar', schema.current_version(@cp)
+
+    assert_equal [
+      {
+        id: 1,
+        title: 'foo',
+        body: 'baz'
+      }
+    ], @cp.query('select id, title, body from posts')
+  end
+end

data/test/test_db_store.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class DBStoreTest < Minitest::Test
+  def setup
+    @machine = UM.new
+    @fn = "/tmp/#{rand(100000)}.db"
+    FileUtils.rm(@fn) rescue nil
+    @cp = Syntropy::DB::ConnectionPool.new(@machine, @fn, 4)
+  end
+
+  def teardown
+    @cp.close
+  end
+
+  def test_db_store
+    store = Syntropy::DB::Store.new(@cp)
+
+    assert_equal [{a: 42}], store.query("select ? as a", 42)
+    assert_equal({a: 42}, store.query_single_row("select ? as a", 42))
+    assert_equal 42, store.query_single_value("select ?", 42)
+  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