syntropy 0.31.0 → 0.32.0

data/test/test_app.rb

@@ -114,12 +114,25 @@ class AppTest < Minitest::Test
     req = @test_harness.request(':method' => 'GET', ':path' => '/test/rss')
     assert_equal '<link>foo</link>', req.response_body
 
-    req = @test_harness.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
@@ -129,14 +142,14 @@ class AppTest < Minitest::Test
   end
 
   def test_app_file_watching
-    @machine.sleep 0.3
+    @machine.sleep 0.2
 
     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 = @test_harness.request(':method' => 'GET', ':path' => @tmp_path)
     assert_equal 'bar', req.response_body
@@ -309,3 +322,45 @@ class AppDependenciesTest < Minitest::Test
     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_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_protocol.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require_relative './helper'
+
+class HTTPProtocolTest < Minitest::Test
+  def setup
+    @machine = UM.new
+    @r, @w = UM.pipe
+    @io = @machine.io(@r)
+  end
+
+  def teardown
+    @machine.close(@r) rescue nil
+    @machine.close(@w) rescue nil
+    @io = nil
+    @machine = nil
+  end
+
+  def write(str)
+    @machine.write(@w, str)
+  end
+end
+
+class HTTPProtocolRequestTest < HTTPProtocolTest
+  def test_http_request_headers_basic
+    write("GET /foo HTTP/1.1\r\nHost: bar.baz\r\n\r\n")
+    h = @io.http_read_request_headers
+    assert_equal({
+      ':method'   => 'get',
+      ':path'     => '/foo',
+      'host'    => 'bar.baz'
+    }, h)
+  end
+
+  def test_http_request_headers_bad_http_method
+    write("foo /foo HTTP/1.1\r\n\r\n")
+    assert_raises(Syntropy::ProtocolError) { @io.http_read_request_headers }
+  end
+
+  def test_http_request_headers_bad_path
+    write("get HTTP/1.1\r\n\r\n")
+    assert_raises(Syntropy::ProtocolError) { @io.http_read_request_headers }
+  end
+
+  def test_http_request_headers_bad_protocol
+    write("get / HTTP/1.0\r\n\r\n")
+    assert_raises(Syntropy::ProtocolError) { @io.http_read_request_headers }
+  end
+
+  def test_http_request_headers_bad_header_missing_value
+    write("GET /foo HTTP/1.1\r\nHost: \r\n\r\n")
+    assert_raises(Syntropy::ProtocolError) { @io.http_read_request_headers }
+  end
+
+  def test_http_request_headers_bad_header
+    write("GET /foo HTTP/1.1\r\nHost\r\n\r\n")
+    assert_raises(Syntropy::ProtocolError) { @io.http_read_request_headers }
+  end
+
+  def test_http_request_with_body_cl
+    write("POST /foo HTTP/1.1\r\nContent-Length: 3\r\n\r\nabc")
+
+    h = @io.http_read_request_headers
+    assert_equal({
+      ':method'         => 'post',
+      ':path'           => '/foo',
+      'content-length'  => '3'
+    }, h)
+
+    b = @io.http_read_body(h)
+    assert_equal 'abc', b
+  end
+
+  def test_http_request_with_body_te
+    write("POST /foo HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n11\r\nabcdefghijKLMNOPQ\r\n3\r\nfoo\r\n0\r\n\r\n")
+
+    h = @io.http_read_request_headers
+    assert_equal({
+      ':method'           => 'post',
+      ':path'             => '/foo',
+      'transfer-encoding' => 'chunked'
+    }, h)
+
+    b = @io.http_read_body(h)
+    assert_equal 'abcdefghijKLMNOPQfoo', b
+  end
+
+  def test_http_request_pipelining
+    write(
+      "GET /a HTTP/1.1\r\n\r\n" +
+      "POST /b HTTP/1.1\r\nHost: foo.com\r\nContent-Length: 2\r\n\r\nab" +
+      "PATCH /c HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n3\r\nabc\r\n10\r\n#{'*' * 16}\r\n0\r\n\r\n" +
+      "GET /d HTTP/1.1\r\nFoo: bar\r\n\r\n"
+    )
+
+    reqs = 4.times.map {
+      h = @io.http_read_request_headers
+      b = @io.http_read_body(h)
+      [h, b]
+    }
+
+    assert_equal [
+      [
+        {
+          ':method'   => 'get',
+          ':path'     => '/a',
+        },
+        nil
+      ],
+      [
+        {
+          ':method'         => 'post',
+          ':path'           => '/b',
+          'host'            => 'foo.com',
+          'content-length'  => '2'
+        },
+        'ab'
+      ],
+      [
+        {
+          ':method'           => 'patch',
+          ':path'             => '/c',
+          'transfer-encoding' => 'chunked'
+        },
+        "abc#{'*' * 16}"
+      ],
+      [
+        {
+          ':method'   => 'get',
+          ':path'     => '/d',
+          'foo'       => 'bar'
+        },
+        nil
+      ],
+    ], reqs
+  end
+
+  def test_http_request_pipelining_skip_body
+    write(
+      "GET /a HTTP/1.1\r\n\r\n" +
+      "POST /b HTTP/1.1\r\nHost: foo.com\r\nContent-Length: 2\r\n\r\nab" +
+      "PATCH /c HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n3\r\nabc\r\n10\r\n#{'*' * 16}\r\n0\r\n\r\n" +
+      "GET /d HTTP/1.1\r\nFoo: bar\r\n\r\n"
+    )
+
+    reqs = 4.times.map {
+      h = @io.http_read_request_headers
+      @io.http_skip_body(h)
+      h
+    }
+
+    assert_equal [
+      {
+        ':method'   => 'get',
+        ':path'     => '/a'
+      },
+      {
+        ':method'         => 'post',
+        ':path'           => '/b',
+        'host'            => 'foo.com',
+        'content-length'  => '2'
+      },
+      {
+        ':method'           => 'patch',
+        ':path'             => '/c',
+        'transfer-encoding' => 'chunked'
+      },
+      {
+        ':method'   => 'get',
+        ':path'     => '/d',
+        'foo'       => 'bar'
+      }
+    ], reqs
+  end
+
+  def test_http_request_desync1
+    write(
+      "POST / HTTP/1.1\r\nHost: foo.com\r\nTransfer-Encoding: chunked\r\nContent-length: 35\r\n\r\n0\r\n\r\n" +
+      "GET /robots.txt HTTP/1.1\r\nX: y\r\n\r\n"
+    )
+
+    h = @io.http_read_request_headers
+    assert_equal({
+      ':method'           => 'post',
+      ':path'             => '/',
+      'host'              => 'foo.com',
+      'transfer-encoding' => 'chunked',
+      'content-length'    => '35'
+    }, h)
+
+    @io.http_skip_body(h)
+
+    assert_raises(Syntropy::ProtocolError) { @io.http_read_request_headers }
+  end
+end
+
+class HTTPProtocolReadChunkTest < HTTPProtocolTest
+  def test_http_read_body_chunk_no_body
+    write("GET /foo HTTP/1.1\r\Host: bar.baz\r\n\r\n")
+    h = @io.http_read_request_headers
+    assert_nil @io.http_read_body_chunk(h)
+  end
+
+  def test_http_read_body_chunk_cl
+    write("POST /foo HTTP/1.1\r\Host: bar.baz\r\nContent-Length: 5\r\n\r\nabcde")
+    h = @io.http_read_request_headers
+    assert_equal 'abcde', @io.http_read_body_chunk(h)
+  end
+
+  def test_http_read_body_chunk_te
+    write("POST /foo HTTP/1.1\r\Host: bar.baz\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nabcde\r\n0\r\n\r\n")
+    h = @io.http_read_request_headers
+    assert_equal 'abcde', @io.http_read_body_chunk(h)
+    assert_nil @io.http_read_body_chunk(h)
+  end
+
+  def test_http_read_body_chunk_te2
+    write("POST /foo HTTP/1.1\r\Host: bar.baz\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nabcde\r\n3\r\nfgh\r\n0\r\n\r\n")
+    h = @io.http_read_request_headers
+    assert_equal 'abcde', @io.http_read_body_chunk(h)
+    assert_equal 'fgh', @io.http_read_body_chunk(h)
+    assert_nil @io.http_read_body_chunk(h)
+  end
+end
+
+class HTTPProtocolResponseTest < HTTPProtocolTest
+  def test_http_response_headers_basic
+    write("HTTP/1.1 200 OK\r\nHost: bar.baz\r\n\r\n")
+    h = @io.http_read_response_headers
+    assert_equal({
+      ':status' => 200,
+      'host'    => 'bar.baz'
+    }, h)
+  end
+
+  def test_http_response_headers_invalid_status_line1
+    write("HTTP 200 OK\r\nHost: bar.baz\r\n\r\n")
+    assert_raises(Syntropy::ProtocolError) { @io.http_read_response_headers }
+  end
+
+  def test_http_response_headers_invalid_status_line2
+    write("HTTP/1.1\r\nHost: bar.baz\r\n\r\n")
+    assert_raises(Syntropy::ProtocolError) { @io.http_read_response_headers }
+  end
+
+  def test_http_response_headers_invalid_status_line3
+    write("HTTP/1.1 ok\r\nBlahblah\r\n\r\n")
+    assert_raises(Syntropy::ProtocolError) { @io.http_read_response_headers }
+  end
+end

data/test/test_http_server_connection.rb

@@ -84,8 +84,7 @@ class HTTPServerConnectionTest < Minitest::Test
     headers = req.headers
     assert_equal({
       ':method'   => 'get',
-      ':path'     => '/',
-      ':protocol' => 'http/1.1'
+      ':path'     => '/'
     }, headers)
   end
 
@@ -94,7 +93,7 @@ class HTTPServerConnectionTest < Minitest::Test
       GET /foo HTTP/1.1
       Server: foo.com
 
-      SCHMET /bar HTTP/1.1
+      GET /bar HTTP/1.1
 
 
 
@@ -108,16 +107,14 @@ class HTTPServerConnectionTest < Minitest::Test
     assert_equal({
       ':method'   => 'get',
       ':path'     => '/foo',
-      ':protocol' => 'http/1.1',
       'server'    => 'foo.com'
     }, headers)
 
     req1 = @reqs.shift
     headers = req1.headers
     assert_equal({
-      ':method'   => 'schmet',
-      ':path'     => '/bar',
-      ':protocol' => 'http/1.1'
+      ':method'   => 'get',
+      ':path'     => '/bar'
     }, headers)
   end
 
@@ -127,7 +124,7 @@ class HTTPServerConnectionTest < Minitest::Test
       Server: foo.com
       Content-Length: 3
 
-      abcSCHMOST /bar HTTP/1.1
+      abcPOST /bar HTTP/1.1
       Server: bar.com
       Content-Length: 6
 
@@ -145,7 +142,6 @@ class HTTPServerConnectionTest < Minitest::Test
     assert_equal({
       ':method' => 'post',
       ':path' => '/foo',
-      ':protocol' => 'http/1.1',
       'server' => 'foo.com',
       'content-length' => '3',
       ':body-done-reading' => true
@@ -156,9 +152,8 @@ class HTTPServerConnectionTest < Minitest::Test
     req1 = @reqs.shift
     headers = req1.headers
     assert_equal({
-      ':method' => 'schmost',
+      ':method' => 'post',
       ':path' => '/bar',
-      ':protocol' => 'http/1.1',
       'server' => 'bar.com',
       'content-length' => '6',
       ':body-done-reading' => true
@@ -179,7 +174,7 @@ class HTTPServerConnectionTest < Minitest::Test
       de
       0
 
-      SCHMOST /bar HTTP/1.1
+      POST /bar HTTP/1.1
       Server: bar.com
       Transfer-Encoding: chunked
 
@@ -203,7 +198,6 @@ class HTTPServerConnectionTest < Minitest::Test
     assert_equal({
       ':method'             => 'post',
       ':path'               => '/foo',
-      ':protocol'           => 'http/1.1',
       'server'              => 'foo.com',
       'transfer-encoding'   => 'chunked',
       ':body-done-reading'  => true
@@ -214,9 +208,8 @@ class HTTPServerConnectionTest < Minitest::Test
     req1 = @reqs.shift
     headers = req1.headers
     assert_equal({
-      ':method'             => 'schmost',
+      ':method'             => 'post',
       ':path'               => '/bar',
-      ':protocol'           => 'http/1.1',
       'server'              => 'bar.com',
       'transfer-encoding'   => 'chunked',
       ':body-done-reading'  => true
@@ -237,7 +230,7 @@ class HTTPServerConnectionTest < Minitest::Test
       de
       0
 
-      SCHMOST /bar HTTP/1.1
+      POST /bar HTTP/1.1
       Server: bar.com
       Content-Length: 31
 
@@ -255,7 +248,6 @@ class HTTPServerConnectionTest < Minitest::Test
     assert_equal({
       ':method'             => 'post',
       ':path'               => '/foo',
-      ':protocol'           => 'http/1.1',
       'server'              => 'foo.com',
       'transfer-encoding'   => 'chunked',
       ':body-done-reading'  => true
@@ -269,9 +261,8 @@ class HTTPServerConnectionTest < Minitest::Test
     req1 = @reqs.shift
     headers = req1.headers
     assert_equal({
-      ':method'             => 'schmost',
+      ':method'             => 'post',
       ':path'               => '/bar',
-      ':protocol'           => 'http/1.1',
       'server'              => 'bar.com',
       'content-length'      => '31',
       ':body-done-reading'  => true

data/test/test_json_api.rb

@@ -11,7 +11,7 @@ class JSONAPITest < Minitest::Test
     end
 
     def bar!(req)
-      @value = req.query[:v]
+      @value = req.query['v']
       true
     end
   end

data/test/{test_module.rb → test_module_loader.rb}

@@ -79,4 +79,35 @@ class ModuleTest < Minitest::Test
     mod = @loader.load('mod/foo/index')
     assert_equal '/mod/foo', mod.env[:ref]
   end
+
+  def test_list
+    list = @loader.list('_layout')
+    assert_equal ['_layout/default'], list
+
+    list = @loader.list('_lib')
+    assert_equal [
+      '_lib/callable',
+      '_lib/dep',
+      '_lib/env',
+      '_lib/klass',
+      '_lib/missing-export',
+      '_lib/self',
+    ], list
+
+    list = @loader.list('about')
+    assert_equal [
+      'about/_error',
+      'about/index',
+      'about/raise'
+    ], list
+
+    list = @loader.list('assets')
+    assert_equal [], list
+
+    list = @loader.list('mod')
+    assert_equal [], list
+
+    list = @loader.list('mod/bar')
+    assert_equal ['mod/bar/index+'], list
+  end
 end

data/test/test_request.rb

@@ -10,20 +10,20 @@ class RequestInfoTest < Minitest::Test
 
     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)
+    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)
+    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)
+    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)
+    assert_equal({ 'l' => 'a', 't' => '', 'x' => '42'}, r.query)
   end
 
   def test_host
@@ -157,6 +157,9 @@ class ValidationTest < Minitest::Test
     assert_equal 'foo', @req.validate('foo', [String, nil])
     assert_nil          @req.validate(nil, [String, nil])
 
+    assert_equal 'foo', @req.validate('foo', String, /.+/)
+    assert_raises(VE) { @req.validate('', String, /.+/) }
+
     assert_equal 123,   @req.validate('123', Integer)
     assert_raises(VE) { @req.validate('a123', Integer) }
     assert_equal 123,   @req.validate('123', Integer, 120..125)