plum 0.1.3 → 0.2.0

data/test/plum/client/test_client.rb

@@ -0,0 +1,152 @@
+require "test_helper"
+
+using Plum::BinaryString
+class ClientTest < Minitest::Test
+  def test_request_sync
+    server_thread = start_tls_server
+    client = Client.start("127.0.0.1", LISTEN_PORT, https: true, verify_mode: OpenSSL::SSL::VERIFY_NONE)
+    res1 = client.put!("/", "aaa", headers: { "header" => "ccc" })
+    assert_equal("PUTcccaaa", res1.body)
+    client.close
+  ensure
+    server_thread.join if server_thread
+  end
+
+  def test_request_async
+    res2 = nil
+    client = nil
+    server_thread = start_tls_server
+    Client.start("127.0.0.1", LISTEN_PORT, https: true, verify_mode: OpenSSL::SSL::VERIFY_NONE) { |c|
+      client = c
+      res1 = client.request({ ":path" => "/", ":method" => "GET", ":scheme" => "https", "header" => "ccc" }, nil) { |res1|
+        assert(res1.headers)
+      }
+      assert_nil(res1.headers)
+
+      res2 = client.get("/", headers: { "header" => "ccc" })
+      assert_nil(res2.headers)
+    }
+    assert(res2.headers)
+    assert_equal("GETccc", res2.body)
+  ensure
+    server_thread.join if server_thread
+  end
+
+  def test_verify
+    client = nil
+    server_thread = start_tls_server
+    assert_raises(OpenSSL::SSL::SSLError) {
+      client = Client.start("127.0.0.1", LISTEN_PORT, https: true, verify_mode: OpenSSL::SSL::VERIFY_PEER)
+    }
+  ensure
+    server_thread.join if server_thread
+  end
+
+  def test_raise_error_sync
+    client = nil
+    server_thread = start_tls_server
+    Client.start("127.0.0.1", LISTEN_PORT, https: true, verify_mode: OpenSSL::SSL::VERIFY_NONE) { |c|
+      client = c
+      assert_raises(LocalConnectionError) {
+        client.get!("/connection_error")
+      }
+    }
+  ensure
+    server_thread.join if server_thread
+  end
+
+  def test_raise_error_async_seq_resume
+    server_thread = start_tls_server
+    client = Client.start("127.0.0.1", LISTEN_PORT, https: true, verify_mode: OpenSSL::SSL::VERIFY_NONE)
+    res = client.get("/error_in_data")
+    assert_raises(LocalConnectionError) {
+      client.resume(res)
+    }
+    client.close
+  ensure
+    server_thread.join if server_thread
+  end
+
+  def test_raise_error_async_block
+    client = nil
+    server_thread = start_tls_server
+    assert_raises(LocalConnectionError) {
+      Client.start("127.0.0.1", LISTEN_PORT, https: true, verify_mode: OpenSSL::SSL::VERIFY_NONE) { |c|
+        client = c
+        client.get("/connection_error") { |res| flunk "success??" }
+      } # resume
+    }
+  ensure
+    server_thread.join if server_thread
+  end
+
+  def test_session_socket_http2_https
+    sock = StringSocket.new
+    client = Client.start(sock, nil, http2: true, scheme: "https")
+    assert(client.session.class == ClientSession)
+  end
+
+  def test_session_socket_http2_http
+    sock = StringSocket.new("HTTP/1.1 100\r\n\r\n")
+    client = Client.start(sock, nil, http2: true, scheme: "http")
+    assert(client.session.class == UpgradeClientSession)
+  end
+
+  def test_session_socket_http1
+    sock = StringSocket.new
+    client = Client.start(sock, nil, http2: false)
+    assert(client.session.class == LegacyClientSession)
+  end
+
+  private
+  def start_tls_server(&block)
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.alpn_select_cb = -> protocols { "h2" }
+    ctx.cert = TLS_CERT
+    ctx.key = TLS_KEY
+    tcp_server = TCPServer.new("127.0.0.1", LISTEN_PORT)
+    ssl_server = OpenSSL::SSL::SSLServer.new(tcp_server, ctx)
+
+    server_thread = Thread.new {
+      plum = nil
+      begin
+        Timeout.timeout(1) {
+          sock = ssl_server.accept
+          plum = HTTPSServerConnection.new(sock)
+
+          plum.on(:stream) { |stream|
+            headers = data = nil
+            stream.on(:headers) { |h|
+              headers = h.to_h }
+            stream.on(:data) { |d|
+              data = d }
+            stream.on(:end_stream) {
+              case headers[":path"]
+              when "/connection_error"
+                plum.goaway(:protocol_error)
+              when "/error_in_data"
+                stream.send_headers({ ":status" => 200 }, end_stream: false)
+                stream.send_data("a", end_stream: false)
+                raise ExampleError, "example error"
+              else
+                stream.send_headers({ ":status" => 200 }, end_stream: false)
+                stream.send_data(headers.to_h[":method"] + headers.to_h["header"].to_s + data.to_s, end_stream: true)
+              end } }
+
+          yield plum if block_given?
+
+          while !sock.closed? && !sock.eof?
+            plum << sock.readpartial(1024)
+          end
+        }
+      rescue OpenSSL::SSL::SSLError
+      rescue Timeout::Error
+        flunk "server timeout"
+      rescue ExampleError => e
+        plum.goaway(:internal_error) if plum
+      ensure
+        tcp_server.close
+      end
+    }
+  end
+end

data/test/plum/client/test_connection.rb

@@ -0,0 +1,11 @@
+require "test_helper"
+
+using Plum::BinaryString
+class ClientConnectionTest < Minitest::Test
+  def test_open_stream
+    con = open_client_connection
+    stream = con.open_stream
+    assert(stream.id % 2 == 1, "Stream ID is not odd")
+    assert_equal(:idle, stream.state)
+  end
+end

data/test/plum/client/test_legacy_client_session.rb

@@ -0,0 +1,90 @@
+require "test_helper"
+
+using Plum::BinaryString
+class LegacyClientSessionTest < Minitest::Test
+  def test_empty?
+    io = StringIO.new
+    session = LegacyClientSession.new(io, Client::DEFAULT_CONFIG)
+    assert(session.empty?)
+    res = session.request({}, "aa", {})
+    assert(!session.empty?)
+    io.string << "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"
+    session.succ
+    assert(res.finished?)
+    assert(session.empty?)
+  end
+
+  def test_close_fails_req
+    session = LegacyClientSession.new(StringIO.new, Client::DEFAULT_CONFIG)
+    res = session.request({}, nil, {})
+    assert(!res.failed?)
+    session.close
+    assert(res.failed?)
+  end
+
+  def test_fail
+    io = StringIO.new
+    session = LegacyClientSession.new(io, Client::DEFAULT_CONFIG)
+    res = session.request({}, "aa", {})
+    assert_raises {
+      session.succ
+    }
+    assert(!res.finished?)
+    assert(res.failed?)
+  end
+
+  def test_request
+    io = StringIO.new
+    session = LegacyClientSession.new(io, Client::DEFAULT_CONFIG.merge(hostname: "aa"))
+    res = session.request({ ":method" => "GET", ":path" => "/aa" }, "aa", {})
+    assert_equal("GET /aa HTTP/1.1\r\nhost: aa\r\ntransfer-encoding: chunked\r\n\r\n2\r\naa\r\n", io.string)
+    io.string << "HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\naaa"
+    session.succ until res.finished?
+    assert(res.finished?)
+    assert_equal("aaa", res.body)
+    assert_equal({ ":status" => "200", "content-length" => "3" }, res.headers)
+  end
+
+  def test_chunked_chunked_string
+    io = StringIO.new
+    session = LegacyClientSession.new(io, Client::DEFAULT_CONFIG.merge(hostname: "hostname"))
+    res = session.request({ ":method" => "GET", ":path" => "/aa" }, "a" * 1025, {})
+    assert_equal(<<-EOR, io.string)
+GET /aa HTTP/1.1\r
+host: hostname\r
+transfer-encoding: chunked\r
+\r
+401\r
+#{"a"*1025}\r
+    EOR
+  end
+
+  def test_chunked_chunked_io
+    io = StringIO.new
+    session = LegacyClientSession.new(io, Client::DEFAULT_CONFIG.merge(hostname: "hostname"))
+    res = session.request({ ":method" => "GET", ":path" => "/aa" }, StringIO.new("a" * 1025), {})
+    assert_equal(<<-EOR, io.string)
+GET /aa HTTP/1.1\r
+host: hostname\r
+transfer-encoding: chunked\r
+\r
+400\r
+#{"a"*1024}\r
+1\r
+a\r
+    EOR
+  end
+
+  def test_chunked_sized
+    io = StringIO.new
+    session = LegacyClientSession.new(io, Client::DEFAULT_CONFIG.merge(hostname: "hostname"))
+    res = session.request({ ":method" => "GET", ":path" => "/aa", "content-length" => 1025 }, StringIO.new("a" * 1025), {})
+    assert_equal((<<-EOR).chomp, io.string)
+GET /aa HTTP/1.1\r
+content-length: 1025\r
+host: hostname\r
+\r
+#{"a"*1025}
+    EOR
+  end
+end

data/test/plum/client/test_response.rb

@@ -0,0 +1,74 @@
+require "test_helper"
+
+using Plum::BinaryString
+class ResponseTest < Minitest::Test
+  def test_finished
+    resp = Response.new
+    assert_equal(false, resp.finished?)
+    resp._finish
+    assert_equal(true, resp.finished?)
+  end
+
+  def test_fail
+    resp = Response.new
+    resp._fail
+    assert(true, resp.failed?)
+  end
+
+  def test_status
+    resp = Response.new
+    resp._headers([
+      [":status", "200"]
+    ])
+    assert_equal("200", resp.status)
+  end
+
+  def test_headers
+    resp = Response.new
+    resp._headers([
+      [":status", "200"],
+      ["header", "abc"]
+    ])
+    assert_equal("abc", resp[:HEADER])
+  end
+
+  def test_body
+    resp = Response.new
+    resp._chunk("a")
+    resp._chunk("b")
+    resp._finish
+    assert_equal("ab", resp.body)
+  end
+
+  def test_body_not_finished
+    resp = Response.new
+    resp._chunk("a")
+    resp._chunk("b")
+    assert_raises { # TODO
+      resp.body
+    }
+  end
+
+  def test_on_chunk
+    resp = Response.new
+    res = []
+    resp._chunk("a")
+    resp._chunk("b")
+    resp._finish
+    resp.on_chunk { |chunk| res << chunk }
+    assert_equal(["a", "b"], res)
+    resp._chunk("c")
+    assert_equal(["a", "b", "c"], res)
+  end
+
+  def test_on_finish
+    resp = Response.new
+    ran = false
+    resp.on_finish { ran = true }
+    resp._finish
+    assert(ran)
+    ran = false
+    resp.on_finish { ran = true }
+    assert(ran)
+  end
+end

data/test/plum/client/test_upgrade_client_session.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+using Plum::BinaryString
+class UpgradeClientSessionTest < Minitest::Test
+  def test_empty?
+    sock = StringSocket.new("HTTP/1.1 101\r\n\r\n")
+    session = UpgradeClientSession.new(sock, Client::DEFAULT_CONFIG)
+    assert(sock.wio.string.start_with?("OPTIONS * HTTP/1.1\r\n"), "sends options request")
+    assert(session.empty?)
+  end
+
+  def test_close
+    sock = StringSocket.new("HTTP/1.1 101\r\n\r\n")
+    session = UpgradeClientSession.new(sock, Client::DEFAULT_CONFIG)
+    res = session.request({}, nil, {})
+    assert(!res.failed?)
+    session.close
+    assert(res.failed?)
+  end
+
+  def test_request
+    sock = StringSocket.new("HTTP/1.1 101\r\n\r\n")
+    session = UpgradeClientSession.new(sock, Client::DEFAULT_CONFIG)
+    sock.rio.string << Frame.settings().assemble
+    sock.rio.string << Frame.settings(:ack).assemble
+    res = session.request({ ":method" => "GET", ":path" => "/aa" }, "aa", {})
+    sock.rio.string << Frame.headers(3, HPACK::Encoder.new(3).encode(":status" => "200", "content-length" => "3"), :end_headers).assemble
+    sock.rio.string << Frame.data(3, "aaa", :end_stream).assemble
+    session.succ until res.finished?
+    assert(res.finished?)
+    assert_equal("aaa", res.body)
+    assert_equal({ ":status" => "200", "content-length" => "3" }, res.headers)
+  end
+
+  def test_request_legacy
+    sock = StringSocket.new("HTTP/1.1 200\r\nContent-Length: 0\r\n\r\n")
+    session = UpgradeClientSession.new(sock, Client::DEFAULT_CONFIG)
+    res = session.request({ ":method" => "GET", ":path" => "/aa" }, "aa", {})
+    sock.rio.string << "HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\naaaHTTP/1.1 400\r\nnext-response"
+    session.succ until res.finished?
+    assert(res.finished?)
+    assert_equal("aaa", res.body)
+    assert_equal({ ":status" => "200", "content-length" => "3" }, res.headers)
+  end
+end

data/test/plum/connection/test_handle_frame.rb

@@ -62,7 +62,10 @@ class ServerConnectionHandleFrameTest < Minitest::Test
   def test_server_handle_goaway_reply
     open_server_connection {|con|
       assert_no_error {
-        con << Frame.goaway(1234, :stream_closed).assemble
+        begin
+          con << Frame.goaway(1, :stream_closed).assemble
+        rescue LocalHTTPError
+        end
       }
       assert_equal(:goaway, sent_frames.last.type)
     }

data/test/plum/{test_http_connection.rb → server/test_http_connection.rb}

@@ -5,7 +5,7 @@ using Plum::BinaryString
 class HTTPConnectionNegotiationTest < Minitest::Test
   ## with Prior Knowledge (same as over TLS)
   def test_server_must_raise_cprotocol_error_non_settings_after_magic
-    con = HTTPConnection.new(StringIO.new)
+    con = HTTPServerConnection.new(StringIO.new)
     con << Connection::CLIENT_CONNECTION_PREFACE
     assert_connection_error(:protocol_error) {
       con << Frame.new(type: :window_update, stream_id: 0, payload: "".push_uint32(1)).assemble
@@ -14,7 +14,7 @@ class HTTPConnectionNegotiationTest < Minitest::Test
 
   def test_server_accept_fragmented_magic
     magic = Connection::CLIENT_CONNECTION_PREFACE
-    con = HTTPConnection.new(StringIO.new)
+    con = HTTPServerConnection.new(StringIO.new)
     assert_no_error {
       con << magic[0...5]
       con << magic[5..-1]
@@ -25,7 +25,7 @@ class HTTPConnectionNegotiationTest < Minitest::Test
   ## with HTTP/1.1 Upgrade
   def test_server_accept_upgrade
     io = StringIO.new
-    con = HTTPConnection.new(io)
+    con = HTTPServerConnection.new(io)
     heads = nil
     con.on(:headers) {|_, _h| heads = _h.to_h }
     req = "GET / HTTP/1.1\r\n" <<
@@ -47,7 +47,7 @@ class HTTPConnectionNegotiationTest < Minitest::Test
 
   def test_server_deny_non_upgrade
     io = StringIO.new
-    con = HTTPConnection.new(io)
+    con = HTTPServerConnection.new(io)
     req = "GET / HTTP/1.1\r\n" <<
           "Host: rhe.jp\r\n" <<
           "User-Agent: nya\r\n" <<

data/test/plum/{test_https_connection.rb → server/test_https_connection.rb}

@@ -4,21 +4,21 @@ using Plum::BinaryString
 
 class HTTPSConnectionNegotiationTest < Minitest::Test
   def test_server_must_raise_cprotocol_error_invalid_magic_short
-    con = HTTPSConnection.new(StringIO.new)
+    con = HTTPSServerConnection.new(StringIO.new)
     assert_connection_error(:protocol_error) {
       con << "HELLO"
     }
   end
 
   def test_server_must_raise_cprotocol_error_invalid_magic_long
-    con = HTTPSConnection.new(StringIO.new)
+    con = HTTPSServerConnection.new(StringIO.new)
     assert_connection_error(:protocol_error) {
       con << ("HELLO" * 100) # over 24
     }
   end
 
   def test_server_must_raise_cprotocol_error_non_settings_after_magic
-    con = HTTPSConnection.new(StringIO.new)
+    con = HTTPSServerConnection.new(StringIO.new)
     con << Connection::CLIENT_CONNECTION_PREFACE
     assert_connection_error(:protocol_error) {
       con << Frame.new(type: :window_update, stream_id: 0, payload: "".push_uint32(1)).assemble
@@ -27,7 +27,7 @@ class HTTPSConnectionNegotiationTest < Minitest::Test
 
   def test_server_accept_fragmented_magic
     magic = Connection::CLIENT_CONNECTION_PREFACE
-    con = HTTPSConnection.new(StringIO.new)
+    con = HTTPSServerConnection.new(StringIO.new)
     assert_no_error {
       con << magic[0...5]
       con << magic[5..-1]
@@ -40,8 +40,8 @@ class HTTPSConnectionNegotiationTest < Minitest::Test
 
     ctx = OpenSSL::SSL::SSLContext.new
     ctx.alpn_select_cb = -> protocols { "h2" }
-    ctx.cert = OpenSSL::X509::Certificate.new File.read(File.expand_path("../../server.crt", __FILE__))
-    ctx.key = OpenSSL::PKey::RSA.new File.read(File.expand_path("../../server.key", __FILE__))
+    ctx.cert = TLS_CERT
+    ctx.key = TLS_KEY
     tcp_server = TCPServer.new("127.0.0.1", LISTEN_PORT)
     ssl_server = OpenSSL::SSL::SSLServer.new(tcp_server, ctx)
 
@@ -49,14 +49,18 @@ class HTTPSConnectionNegotiationTest < Minitest::Test
       begin
         Timeout.timeout(3) {
           sock = ssl_server.accept
-          plum = HTTPSConnection.new(sock)
+          plum = HTTPSServerConnection.new(sock)
           assert_connection_error(:inadequate_security) {
             run = true
-            plum.run
+            while !sock.closed? && !sock.eof?
+              plum << sock.readpartial(1024)
+            end
           }
         }
       rescue Timeout::Error
         flunk "server timeout"
+      rescue => e
+        flunk e
       ensure
         tcp_server.close
       end
@@ -73,6 +77,8 @@ class HTTPSConnectionNegotiationTest < Minitest::Test
         ssl.write Connection::CLIENT_CONNECTION_PREFACE
         ssl.write Frame.settings.assemble
         sleep
+      rescue => e
+        flunk e
       ensure
         sock.close
       end