polyphony 0.19 → 0.20

data/test/test_core.rb

@@ -1,13 +1,9 @@
-require 'minitest/autorun'
-require 'bundler/setup'
-require 'polyphony'
+# frozen_string_literal: true
 
-class SpawnTest < MiniTest::Test
-  def setup
-    EV.rerun
-  end
+require_relative 'helper'
 
-  def test_that_spawn_returns_a_coprocess
+class SpinTest < MiniTest::Test
+  def test_that_spin_returns_a_coprocess
     result = nil
     coprocess = spin { result = 42 }
 
@@ -17,17 +13,17 @@ class SpawnTest < MiniTest::Test
     assert_equal(42, result)
   end
 
-  def test_that_spawn_accepts_coprocess_argument
+  def test_that_spin_accepts_coprocess_argument
     result = nil
     coprocess = Polyphony::Coprocess.new { result = 42 }
-    spin coprocess
+    coprocess.run
 
     assert_nil(result)
     suspend
     assert_equal(42, result)
   end
 
-  def test_that_spawned_coprocess_saves_result
+  def test_that_spined_coprocess_saves_result
     coprocess = spin { 42 }
 
     assert_kind_of(Polyphony::Coprocess, coprocess)
@@ -36,20 +32,18 @@ class SpawnTest < MiniTest::Test
     assert_equal(42, coprocess.result)
   end
 
-  def test_that_spawned_coprocess_can_be_interrupted
-    result = nil
-    coprocess = spin { sleep(1); 42 }
-    EV.next_tick { coprocess.interrupt }
+  def test_that_spined_coprocess_can_be_interrupted
+    coprocess = spin do
+      sleep(1)
+      42
+    end
+    defer { coprocess.interrupt }
     suspend
     assert_nil(coprocess.result)
   end
 end
 
 class CancelScopeTest < Minitest::Test
-  def setup
-    EV.rerun
-  end
-
   def sleep_with_cancel(ctx, mode = nil)
     Polyphony::CancelScope.new(mode: mode).call do |c|
       ctx[:cancel_scope] = c
@@ -60,7 +54,7 @@ class CancelScopeTest < Minitest::Test
   def test_that_cancel_scope_cancels_coprocess
     ctx = {}
     spin do
-      EV::Timer.new(0.005, 0).start { ctx[:cancel_scope]&.cancel! }
+      Gyro::Timer.new(0.005, 0).start { ctx[:cancel_scope]&.cancel! }
       sleep_with_cancel(ctx, :cancel)
     rescue Exception => e
       ctx[:result] = e
@@ -68,7 +62,7 @@ class CancelScopeTest < Minitest::Test
     assert_nil(ctx[:result])
     # async operation will only begin on next iteration of event loop
     assert_nil(ctx[:cancel_scope])
-    
+
     suspend
     assert_kind_of(Polyphony::CancelScope, ctx[:cancel_scope])
     assert_kind_of(Polyphony::Cancel, ctx[:result])
@@ -77,10 +71,10 @@ class CancelScopeTest < Minitest::Test
   # def test_that_cancel_scope_cancels_async_op_with_stop
   #   ctx = {}
   #   spin do
-  #     EV::Timer.new(0, 0).start { ctx[:cancel_scope].cancel! }
+  #     Gyro::Timer.new(0, 0).start { ctx[:cancel_scope].cancel! }
   #     sleep_with_cancel(ctx, :stop)
   #   end
-    
+
   #   suspend
   #   assert(ctx[:cancel_scope])
   #   assert_nil(ctx[:result])
@@ -100,45 +94,41 @@ class CancelScopeTest < Minitest::Test
     assert_equal(:cancelled, result)
   end
 
-  def test_that_cancel_scopes_can_be_nested
-    inner_result = nil
-    outer_result = nil
-    spin do
-      move_on_after(0.01) do
-        move_on_after(0.02) do
-          sleep(1000)
-        end
-        inner_result = 42
-      end
-      outer_result = 42
-    end
-    suspend
-    assert_nil(inner_result)
-    assert_equal(42, outer_result)
+  # def test_that_cancel_scopes_can_be_nested
+  #   inner_result = nil
+  #   outer_result = nil
+  #   spin do
+  #     Polyphony::CancelScope.new(timeout: 0.01) do
+  #       Polyphony::CancelScope.new(timeout: 0.02) do
+  #         sleep(1000)
+  #       end
+  #       inner_result = 42
+  #     end
+  #     outer_result = 42
+  #   end
+  #   suspend
+  #   assert_nil(inner_result)
+  #   assert_equal(42, outer_result)
 
-    EV.rerun
+  #   Polyphony.reset!
 
-    outer_result = nil
-    spin do
-      move_on_after(0.02) do
-        move_on_after(0.01) do
-          sleep(1000)
-        end
-        inner_result = 42
-      end
-      outer_result = 42
-    end
-    suspend
-    assert_equal(42, inner_result)
-    assert_equal(42, outer_result)
-  end
+  #   outer_result = nil
+  #   spin do
+  #     move_on_after(0.02) do
+  #       move_on_after(0.01) do
+  #         sleep(1000)
+  #       end
+  #       inner_result = 42
+  #     end
+  #     outer_result = 42
+  #   end
+  #   suspend
+  #   assert_equal(42, inner_result)
+  #   assert_equal(42, outer_result)
+  # end
 end
 
 class SupervisorTest < MiniTest::Test
-  def setup
-    EV.rerun
-  end
-
   def sleep_and_set(ctx, idx)
     proc do
       sleep(0.001 * idx)
@@ -151,7 +141,7 @@ class SupervisorTest < MiniTest::Test
       (1..3).each { |idx| s.spin sleep_and_set(ctx, idx) }
     end
   end
-  
+
   def test_that_supervisor_waits_for_all_nested_coprocesses_to_complete
     ctx = {}
     spin do
@@ -165,7 +155,7 @@ class SupervisorTest < MiniTest::Test
 
   def test_that_supervisor_can_add_coprocesses_after_having_started
     result = []
-    spin {
+    spin do
       supervisor = Polyphony::Supervisor.new
       3.times do |i|
         spin do
@@ -177,8 +167,52 @@ class SupervisorTest < MiniTest::Test
         end
       end
       supervisor.await
-    }.await
+    end.await
 
     assert_equal([0, 1, 2], result)
   end
-end
+end
+
+class ExceptionTest < MiniTest::Test
+  def test_cross_fiber_backtrace
+    error = nil
+    frames = []
+    spin do
+      spin do
+        spin do
+          raise 'foo'
+        end
+        suspend
+      rescue Exception => e
+        frames << 2
+        raise e
+      end
+      suspend
+    rescue Exception => e
+      frames << 3
+      raise e
+    end
+    4.times { snooze }
+  rescue Exception => e
+    error = e
+  ensure
+    assert_kind_of RuntimeError, error
+    assert_equal [2, 3], frames
+  end
+
+  def test_cross_fiber_backtrace_with_dead_calling_fiber
+    error = nil
+    spin do
+      spin do
+        spin do
+          raise 'foo'
+        end
+      end
+    end
+    4.times { snooze }
+  rescue Exception => e
+    error = e
+  ensure
+    assert_kind_of RuntimeError, error
+  end
+end

data/test/test_gyro.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class RunTest < Minitest::Test
+  def test_that_run_loop_returns_immediately_if_no_watchers
+    t0 = Time.now
+    suspend
+    t1 = Time.now
+    assert((t1 - t0) < 0.01)
+  end
+end
+
+class IdleTest < MiniTest::Test
+  def test_defer
+    values = []
+    defer { values << 1 }
+    defer { values << 2 }
+    defer { values << 3 }
+    suspend
+
+    assert_equal [1, 2, 3], values
+  end
+
+  def test_schedule
+    values = []
+    f = Fiber.new do
+      values << :foo
+      # We *have* to suspend the fiber in order to yield to the reactor,
+      # otherwise control will transfer back to root fiber.
+      suspend
+    end
+    assert_equal [], values
+    f.schedule
+    suspend
+
+    assert_equal [:foo], values
+  end
+
+  def test_suspend
+    values = []
+    Fiber.new do
+      values << :foo
+      suspend
+    end.schedule
+    suspend
+
+    assert_equal [:foo], values
+  end
+
+  def test_schedule_and_suspend
+    values = []
+    3.times.map do |i|
+      Fiber.new do
+        values << i
+        suspend
+      end.schedule
+    end
+    suspend
+
+    assert_equal [0, 1, 2], values
+  end
+
+  def test_snooze
+    values = []
+    3.times.map do |i|
+      Fiber.new do
+        3.times do
+          snooze
+          values << i
+        end
+        suspend
+      end.schedule
+    end
+    suspend
+
+    assert_equal [0, 1, 2, 0, 1, 2, 0, 1, 2], values
+  end
+
+  def test_break
+    values = []
+    Fiber.new do
+      values << :foo
+      snooze
+      # here will never be reached
+      values << :bar
+      suspend
+    end.schedule
+
+    Fiber.new do
+      Gyro.break
+    end.schedule
+
+    suspend
+
+    assert_equal [:foo], values
+  end
+
+  def test_start
+    values = []
+    f1 = Fiber.new do
+      values << :foo
+      snooze
+      values << :bar
+      suspend
+    end.schedule
+
+    f2 = Fiber.new do
+      Gyro.break
+      values << :restarted
+      snooze
+      values << :baz
+    end.schedule
+
+    suspend
+
+    Gyro.start
+    f2.schedule
+    f1.schedule
+    suspend
+
+    assert_equal %i[foo restarted bar baz], values
+  end
+
+  def test_restart
+    values = []
+    Fiber.new do
+      values << :foo
+      snooze
+      # this part will not be reached, as f
+      values << :bar
+      suspend
+    end.schedule
+
+    Fiber.new do
+      Gyro.restart
+
+      # control is transfer to the fiber that called Gyro.restart
+      values << :restarted
+      snooze
+      values << :baz
+    end.schedule
+
+    suspend
+
+    assert_equal %i[foo restarted baz], values
+  end
+end

data/test/test_http_server.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'polyphony/http'
+
+class String
+  def http_lines
+    gsub "\n", "\r\n"
+  end
+end
+
+class IO
+  # Creates two mockup sockets for simulating server-client communication
+  def self.server_client_mockup
+    server_in, client_out = IO.pipe
+    client_in, server_out = IO.pipe
+
+    server_connection = mockup_connection(server_in, server_out, client_out)
+    client_connection = mockup_connection(client_in, client_out, server_out)
+
+    [server_connection, client_connection]
+  end
+
+  def self.mockup_connection(input, output, output2)
+    eg(
+      :read        => ->(*args) { input.read(*args) },
+      :readpartial => ->(*args) { input.readpartial(*args) },
+      :<<          => ->(*args) { output.write(*args) },
+      :write       => ->(*args) { output.write(*args) },
+      :close       => -> { output.close },
+      :eof?        => -> { output2.closed? }
+    )
+  end
+end
+
+class HTTP1ServerTest < MiniTest::Test
+  def teardown
+    @server&.interrupt if @server&.alive?
+    snooze
+    super
+  end
+
+  def spin_server(opts = {}, &handler)
+    server_connection, client_connection = IO.server_client_mockup
+    coproc = spin do
+      Polyphony::HTTP::Server.client_loop(server_connection, opts, &handler)
+    end
+    [coproc, client_connection, server_connection]
+  end
+
+  def test_that_server_uses_content_length_in_http_1_0
+    @server, connection = spin_server do |req|
+      req.respond('Hello, world!', {})
+    end
+
+    # using HTTP 1.0, server should close connection after responding
+    connection << "GET / HTTP/1.0\r\n\r\n"
+
+    response = connection.readpartial(8192)
+    expected = <<~HTTP.chomp.http_lines
+      HTTP/1.0 200
+      Content-Length: 13
+
+      Hello, world!
+    HTTP
+    assert_equal(expected, response)
+  end
+
+  def test_that_server_uses_chunked_encoding_in_http_1_1
+    @server, connection = spin_server do |req|
+      req.respond('Hello, world!')
+    end
+
+    # using HTTP 1.0, server should close connection after responding
+    connection << "GET / HTTP/1.1\r\n\r\n"
+
+    response = connection.readpartial(8192)
+    expected = <<~HTTP.http_lines
+      HTTP/1.1 200
+      Transfer-Encoding: chunked
+
+      d
+      Hello, world!
+      0
+
+    HTTP
+    assert_equal(expected, response)
+  end
+
+  def test_that_server_maintains_connection_when_using_keep_alives
+    puts 'test_that_server_maintains_connection_when_using_keep_alives'
+    @server, connection = spin_server do |req|
+      req.respond('Hi', {})
+    end
+
+    connection << "GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n"
+    response = connection.readpartial(8192)
+    assert !connection.eof?
+    assert_equal("HTTP/1.0 200\r\nContent-Length: 2\r\n\r\nHi", response)
+
+    connection << "GET / HTTP/1.1\r\n\r\n"
+    response = connection.readpartial(8192)
+    assert !connection.eof?
+    expected = <<~HTTP.http_lines
+      HTTP/1.1 200
+      Transfer-Encoding: chunked
+
+      2
+      Hi
+      0
+
+    HTTP
+    assert_equal(expected, response)
+
+    connection << "GET / HTTP/1.0\r\n\r\n"
+    response = connection.readpartial(8192)
+    assert connection.eof?
+    assert_equal("HTTP/1.0 200\r\nContent-Length: 2\r\n\r\nHi", response)
+  end
+
+  def test_pipelining_client
+    @server, connection = spin_server do |req|
+      if req.headers['Foo'] == 'bar'
+        req.respond('Hello, foobar!', {})
+      else
+        req.respond('Hello, world!', {})
+      end
+    end
+
+    connection << "GET / HTTP/1.1\r\n\r\nGET / HTTP/1.1\r\nFoo: bar\r\n\r\n"
+    response = connection.readpartial(8192)
+
+    expected = <<~HTTP.http_lines
+      HTTP/1.1 200
+      Transfer-Encoding: chunked
+
+      d
+      Hello, world!
+      0
+
+      HTTP/1.1 200
+      Transfer-Encoding: chunked
+
+      e
+      Hello, foobar!
+      0
+
+    HTTP
+    assert_equal(expected, response)
+  end
+
+  def test_body_chunks
+    chunks = []
+    request = nil
+    @server, connection = spin_server do |req|
+      request = req
+      req.send_headers
+      req.each_chunk do |c|
+        chunks << c
+        req << c.upcase
+      end
+      req.finish
+    end
+
+    connection << <<~HTTP.http_lines
+      POST / HTTP/1.1
+      Transfer-Encoding: chunked
+
+      6
+      foobar
+    HTTP
+    2.times { snooze }
+    assert request
+    assert_equal %w[foobar], chunks
+    assert !request.complete?
+
+    connection << "6\r\nbazbud\r\n"
+    snooze
+    assert_equal %w[foobar bazbud], chunks
+    assert !request.complete?
+
+    connection << "0\r\n\r\n"
+    snooze
+    assert_equal %w[foobar bazbud], chunks
+    assert request.complete?
+
+    2.times { snooze }
+
+    response = connection.readpartial(8192)
+
+    expected = <<~HTTP.http_lines
+      HTTP/1.1 200
+      Transfer-Encoding: chunked
+
+      6
+      FOOBAR
+      6
+      BAZBUD
+      0
+
+    HTTP
+    assert_equal(expected, response)
+  end
+
+  def test_upgrade
+    done = nil
+
+    opts = {
+      upgrade: {
+        echo: lambda do |conn, _headers|
+          conn << <<~HTTP.http_lines
+            HTTP/1.1 101 Switching Protocols
+            Upgrade: echo
+            Connection: Upgrade
+
+          HTTP
+
+          while (data = conn.readpartial(8192))
+            conn << data
+            snooze
+          end
+          done = true
+        end
+      }
+    }
+
+    @server, connection = spin_server(opts) do |req|
+      req.respond('Hi')
+    end
+
+    connection << "GET / HTTP/1.1\r\n\r\n"
+    response = connection.readpartial(8192)
+    assert !connection.eof?
+    expected = <<~HTTP.http_lines
+      HTTP/1.1 200
+      Transfer-Encoding: chunked
+
+      2
+      Hi
+      0
+
+    HTTP
+    assert_equal(expected, response)
+
+    connection << <<~HTTP.http_lines
+      GET / HTTP/1.1
+      Upgrade: echo
+      Connection: upgrade
+
+    HTTP
+
+    snooze
+    response = connection.readpartial(8192)
+    assert !connection.eof?
+    expected = <<~HTTP.http_lines
+      HTTP/1.1 101 Switching Protocols
+      Upgrade: echo
+      Connection: Upgrade
+
+    HTTP
+    assert_equal(expected, response)
+
+    assert !done
+
+    connection << 'foo'
+    assert_equal 'foo', connection.readpartial(8192)
+
+    connection << 'bar'
+    assert_equal 'bar', connection.readpartial(8192)
+
+    connection.close
+    assert !done
+    snooze
+    assert done
+  end
+
+  def test_big_download
+    chunk_size = 100_000
+    chunk_count = 10
+    chunk = '*' * chunk_size
+    @server, connection = spin_server do |req|
+      req.send_headers
+      chunk_count.times do
+        req << chunk
+        snooze
+      end
+      req.finish
+      req.adapter.close
+    end
+
+    response = +''
+    count = 0
+
+    connection << "GET / HTTP/1.1\r\n\r\n"
+    while (data = connection.readpartial(chunk_size * 2))
+      response << data
+      count += 1
+      snooze
+    end
+
+    chunks = "#{chunk_size.to_s(16)}\n#{'*' * chunk_size}\n" * chunk_count
+    expected = <<~HTTP.http_lines
+      HTTP/1.1 200
+      Transfer-Encoding: chunked
+
+      #{chunks}0
+
+    HTTP
+
+    assert_equal expected, response
+    assert_equal chunk_count * 2 + 1, count
+  end
+end