syntropy 0.28.2 → 0.30.0

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

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+require_relative './helper'
+
+class ServerTest < Minitest::Test
+  def make_socket_pair
+    port = 10000 + rand(30000)
+    server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+    @machine.bind(server_fd, '127.0.0.1', port)
+    @machine.listen(server_fd, UM::SOMAXCONN)
+
+    client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.connect(client_conn_fd, '127.0.0.1', port)
+
+    server_conn_fd = @machine.accept(server_fd)
+
+    @machine.close(server_fd)
+    [client_conn_fd, server_conn_fd]
+  end
+
+  class STOP < StandardError
+  end
+
+  def setup(opts = {})
+    @machine = UM.new
+    @port = 10000 + rand(30000)
+    @env = { bind: "127.0.0.1:#{@port}" }.merge(opts)
+    @server = Syntropy::HTTP::Server.new(@machine, @env) { @app&.call(it) }
+    @f_server = @machine.spin { run_server }
+
+    # let server spin and listen to incoming connections
+    @machine.sleep(0.01)
+
+    @client_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.connect(@client_fd, '127.0.0.1', @port)
+  end
+
+  def run_server
+    @server.run
+  ensure
+    @server_done = true
+  end
+
+  def teardown
+    @machine.close(@client_fd) rescue nil
+    @server.stop!
+    @machine.snooze until @server_done
+  end
+
+  def write_http_request(msg)
+    @machine.send(@client_fd, msg, msg.bytesize, UM::MSG_WAITALL)
+  end
+
+  def write_client_side(msg)
+    @machine.send(@client_fd, msg, msg.bytesize, UM::MSG_WAITALL)
+  end
+
+  def read_client_side(len = 65536)
+    buf = +''
+    res = @machine.recv(@client_fd, buf, len, 0)
+    res == 0 ? nil : buf
+  end
+
+  def test_http_1_0_response
+    @app = ->(req) {
+      req.respond('Hello, world!', {})
+    }
+
+    write_http_request "GET / HTTP/1.0\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 505\r\nTransfer-Encoding: chunked\r\n\r\n1a\r\nHTTP version not supported\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_basic_app_response
+    @app = ->(req) {
+      req.respond('Hello, world!', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    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"
+    assert_equal(expected, response)
+  end
+
+  def test_pipelined_requests
+    @app = ->(req) {
+      req.respond("method: #{req.method}")
+    }
+
+    write_http_request "GET /foo HTTP/1.1\r\nServer: foo.com\r\n\r\nSCHmet /bar HTTP/1.1\r\n\r\n"
+
+    @machine.sleep(0.1)
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nb\r\nmethod: get\r\n0\r\n\r\n" +
+               "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\ne\r\nmethod: schmet\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_graceful_shutdown
+    @app = ->(req) do
+      @machine.sleep(1)
+      req.respond('Hello, world!', {})
+    rescue UM::Terminate
+      req.respond('Terminated!', {})
+      raise
+    end
+
+    write_http_request "GET /foo HTTP/1.1\r\nServer: foo.com\r\n\r\nSCHMET /bar HTTP/1.1\r\n\r\n"
+
+    @machine.sleep(0.01)
+    @server.stop!
+    @machine.snooze
+
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nb\r\nTerminated!\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_pipelined_requests_with_body
+    @bodies = []
+    @reqs = []
+    @app = ->(req) {
+      @reqs << req
+      @bodies << req.read
+      req.respond("method: #{req.method}")
+    }
+
+    msg = <<~HTTP.crlf_lines
+      POST /foo HTTP/1.1
+      Server: foo.com
+      Content-Length: 3
+
+      abcSCHMOST /bar HTTP/1.1
+      Server: bar.com
+      Content-Length: 6
+
+      defghi
+    HTTP
+    write_http_request msg
+
+    read_client_side
+    assert_equal 2, @bodies.size
+
+    req0 = @reqs.shift
+    headers = req0.headers
+    assert_equal({
+      ':method' => 'post',
+      ':path' => '/foo',
+      ':protocol' => 'http/1.1',
+      'server' => 'foo.com',
+      'content-length' => '3',
+      ':body-done-reading' => true,
+      ':tx' => 56,
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'abc', body
+
+    req1 = @reqs.shift
+    headers = req1.headers
+    assert_equal({
+      ':method' => 'schmost',
+      ':path' => '/bar',
+      ':protocol' => 'http/1.1',
+      'server' => 'bar.com',
+      'content-length' => '6',
+      ':body-done-reading' => true,
+      ':tx' => 59,
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'defghi', body
+  end
+
+  def test_pipelined_requests_with_body_chunked
+    @bodies = []
+    @reqs = []
+    @app = ->(req) do
+      @reqs << req
+      @bodies << (b = req.read)
+      req.respond("method: #{req.method}")
+    rescue => e
+      p e
+      p e.backtrace
+      exit!
+    end
+
+    msg = <<~HTTP.crlf_lines
+      POST /foo HTTP/1.1
+      Server: foo.com
+      Transfer-Encoding: chunked
+
+      3
+      abc
+      2
+      de
+      0
+
+      SCHMOST /bar HTTP/1.1
+      Server: bar.com
+      Transfer-Encoding: chunked
+
+      1f
+      123456789abcdefghijklmnopqrstuv
+      0
+
+
+
+    HTTP
+
+    write_http_request msg
+    read_client_side
+    read_client_side
+    assert_equal 2, @bodies.size
+
+    req0 = @reqs.shift
+    headers = req0.headers
+    assert_equal({
+      ':method'             => 'post',
+      ':path'               => '/foo',
+      ':protocol'           => 'http/1.1',
+      'server'              => 'foo.com',
+      'transfer-encoding'   => 'chunked',
+      ':body-done-reading'  => true,
+      ':tx'                 => 56
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'abcde', body
+
+    req1 = @reqs.shift
+    headers = req1.headers
+    assert_equal({
+      ':method'             => 'schmost',
+      ':path'               => '/bar',
+      ':protocol'           => 'http/1.1',
+      'server'              => 'bar.com',
+      'transfer-encoding'   => 'chunked',
+      ':body-done-reading'  => true,
+      ':tx'                 => 59
+    }, headers)
+    body = @bodies.shift
+    assert_equal '123456789abcdefghijklmnopqrstuv', body
+  end
+
+  class TestLogger
+    attr_reader :entries
+
+    def initialize
+      @entries = []
+    end
+
+    def info(o)
+      @entries << o.merge(level: :INFO)
+    end
+
+    def error(o)
+      @entries << o.merge(level: :ERROR)
+    end
+  end
+
+  def test_logging
+    skip
+    reqs = []
+    @env[:logger] = TestLogger.new
+    @app = ->(req) { reqs << req; req.respond('Hello, world!', {}) }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    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"
+    assert_equal(expected, response)
+
+    entries = @env[:logger].entries
+    assert_equal 1, entries.size
+    assert_equal 1, reqs.size
+
+    assert_equal reqs.first, entries.first[:request]
+  end
+
+  def test_server_headers
+    @env[:server_headers] = "Server: Tipi\r\n"
+
+    @app = ->(req) {
+      req.respond('Hello, world!', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: Tipi\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_server_headers_date
+    setup({ server_extensions: { date: true } })
+    @machine.sleep(0.1)
+    assert_kind_of Time, @env[:server_date]
+
+    @app = ->(req) {
+      req.respond('foo', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nDate: #{@env[:server_date].httpdate}\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_server_headers_date_and_server_name
+    setup({ server_extensions: { date: true, name: 'Foo' } })
+    @machine.sleep(0.1)
+    assert_kind_of Time, @env[:server_date]
+
+    @app = ->(req) {
+      req.respond('foo', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: Foo\r\nDate: #{@env[:server_date].httpdate}\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_server_headers_server_name
+    setup({ server_extensions: { name: 'Bar' } })
+    @machine.sleep(0.1)
+    assert_nil @env[:server_date]
+
+    @app = ->(req) {
+      req.respond('foo', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: Bar\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+end