polyphony 0.43.8

data/test/test_socket.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class SocketTest < MiniTest::Test
+  def setup
+    super
+  end
+
+  def test_tcp
+    port = rand(1234..5678)
+    server = TCPServer.new('127.0.0.1', port)
+
+    server_fiber = spin do
+      while (socket = server.accept)
+        spin do
+          while (data = socket.gets(8192))
+            socket << data
+          end
+        end
+      end
+    end
+
+    snooze
+    client = TCPSocket.new('127.0.0.1', port)
+    client.write("1234\n")
+    assert_equal "1234\n", client.readpartial(8192)
+    client.close
+  ensure
+    server_fiber&.stop
+    server_fiber&.await
+    server&.close
+  end
+end

data/test/test_supervise.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class SuperviseTest < MiniTest::Test
+  def test_supervise
+    p = spin { supervise }
+    snooze
+    f1 = p.spin { receive }
+    f2 = p.spin { receive }
+
+    snooze
+    assert_equal p.state, :waiting
+    f1 << 'foo'
+    f1.await
+    snooze
+
+    assert_equal :waiting, p.state
+    assert_equal :waiting, f2.state
+
+    f2 << 'bar'
+    f2.await
+    snooze
+
+    assert_equal :waiting, p.state
+  end
+
+  def test_supervise_with_restart
+    watcher = spin { receive }
+    parent = spin { supervise(restart: true, watcher: watcher) }
+    snooze
+
+    buffer = []
+    f1 = parent.spin do
+      buffer << 'f1'
+    end
+
+    f1.await
+    assert_equal ['f1'], buffer
+    watcher.await
+    assert_equal ['f1', 'f1'], buffer
+  end
+
+  def test_supervise_with_restart_on_error
+    parent = spin { supervise(restart: true) }
+    snooze
+
+    buffer = []
+    f1 = parent.spin do
+      buffer << 'f1'
+      buffer << receive
+    end
+
+    snooze
+    assert_equal ['f1'], buffer
+
+    f1.raise 'foo'
+
+    3.times { snooze }
+
+    assert_equal ['f1', 'f1'], buffer
+    assert_equal :dead, f1.state
+
+    # f1 should have been restarted by supervisor
+    f1 = parent.children.first
+    assert_kind_of Fiber, f1
+
+    f1 << 'foo'
+    f1.await
+
+    assert_equal ['f1', 'f1', 'foo'], buffer
+  end
+
+  def test_supervisor_termination
+    f = nil
+    p = spin do
+      f = spin { sleep 1 }
+      supervise
+    end
+    sleep 0.01
+
+    p.terminate
+    p.await
+
+    assert :dead, f.state
+    assert :dead, p.state
+  end
+
+  def test_supervisor_termination_with_restart
+    f = nil
+    p = spin do
+      f = spin { sleep 1 }
+      supervise(restart: true)
+    end
+    sleep 0.01
+
+    p.terminate
+    p.await
+
+    assert :dead, f.state
+    assert :dead, p.state
+  end
+end

data/test/test_thread.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'polyphony/adapters/trace'
+
+class ThreadTest < MiniTest::Test
+  def test_thread_spin
+    buffer = []
+    f = spin { (1..3).each { |i| snooze; buffer << i } }
+    t = Thread.new do
+      sleep 0.01
+      s1 = spin { (11..13).each { |i| snooze; buffer << i } }
+      s2 = spin { (21..23).each { |i| snooze; buffer << i } }
+      sleep 0.02
+      Fiber.current.await_all_children
+    end
+    f.join
+    t.join
+    t = nil
+
+    assert_equal [1, 2, 3, 11, 12, 13, 21, 22, 23], buffer.sort
+  ensure
+    t&.kill
+    t&.join
+  end
+
+  def test_thread_join
+    buffer = []
+    spin { (1..3).each { |i| snooze; buffer << i } }
+    t = Thread.new { sleep 0.01; buffer << 4; :foo }
+
+    r = t.join
+    t = nil
+
+    assert_equal :foo, r
+    assert_equal [1, 2, 3, 4], buffer
+  ensure
+    t&.kill
+    t&.join
+  end
+
+  def test_thread_join_with_timeout
+    buffer = []
+    spin { (1..3).each { |i| snooze; buffer << i } }
+    t = Thread.new { sleep 1; buffer << 4 }
+    t0 = Time.now
+    r = t.join(0.01)
+    t = nil
+
+    assert Time.now - t0 < 0.2
+    assert_equal [1, 2, 3], buffer
+    assert_nil r
+  ensure
+    # killing the thread will prevent stopping the sleep timer, as well as the
+    # thread's event selector, leading to a memory leak.
+    t&.kill
+    t&.join
+  end
+
+  def test_thread_await_alias_method
+    buffer = []
+    spin { (1..3).each { |i| snooze; buffer << i } }
+    t = Thread.new { sleep 0.01; buffer << 4; :foo }
+    r = t.await
+    t = nil
+
+    assert_equal [1, 2, 3, 4], buffer
+    assert_equal :foo, r
+  ensure
+    t&.kill
+    t&.join
+  end
+
+  def test_join_race_condition_on_thread_spawning
+    buffer = []
+    t = Thread.new do
+      :foo
+    end
+    r = t.join
+    t = nil
+    assert_equal :foo, r
+  ensure
+    t&.kill
+    t&.join
+  end
+
+  def test_thread_uncaught_exception_propagation
+    ready = Polyphony::Event.new
+
+    t = Thread.new do
+      ready.signal
+      sleep 0.01
+      raise 'foo'
+    end
+    e = nil
+    begin
+      ready.await
+      r = t.await
+    rescue Exception => e
+    end
+    t = nil
+    assert_kind_of RuntimeError, e
+    assert_equal 'foo', e.message
+  ensure
+    t&.kill
+    t&.join
+  end
+
+  def test_thread_inspect
+    lineno = __LINE__ + 1
+    t = Thread.new { sleep 1 }
+    str = format(
+      "#<Thread:%d %s:%d",
+      t.object_id,
+      __FILE__,
+      lineno,
+    )
+    assert t.inspect =~ /#{str}/
+  rescue => e
+    p e
+    puts e.backtrace.join("\n")
+  ensure
+    t&.kill
+    t&.join
+  end
+
+  def test_that_suspend_returns_immediately_if_no_watchers
+    records = []
+    t = Polyphony::Trace.new(:fiber_all) do |r|
+      records << r if r[:event] =~ /^fiber_/
+    end
+    t.enable
+    Polyphony.trace(true)
+
+    suspend
+    t.disable
+    assert_equal [:fiber_switchpoint], records.map { |r| r[:event] }
+  ensure
+    t&.disable
+    Polyphony.trace(false)
+  end
+
+  def test_thread_child_fiber_termination
+    buffer = []
+    t = Thread.new do
+      spin do
+        sleep 61
+      ensure
+        buffer << :foo
+      end
+      spin do
+        sleep 62
+      ensure
+        buffer << :bar
+      end
+      assert 2, Fiber.current.children.size
+      sleep 1
+    end
+    sleep 0.05
+    assert_equal 2, t.main_fiber.children.size
+    t.kill
+    t.join
+    t = nil
+
+    assert_equal [:foo, :bar], buffer
+  ensure
+    t&.kill
+    t&.join
+  end
+end

data/test/test_thread_pool.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class ThreadPoolTest < MiniTest::Test
+  def setup
+    super
+    @pool = Polyphony::ThreadPool.new
+  end
+
+  def test_process
+    current_thread = Thread.current
+
+    processing_thread = nil
+    result = @pool.process do
+      processing_thread = Thread.current
+      +'foo' + 'bar'
+    end
+    assert_equal 'foobar', result
+    assert processing_thread != current_thread
+  end
+
+  def test_multi_process
+    current_thread = Thread.current
+    threads = []
+    results = []
+
+    15.times do |i|
+      spin do
+        results << @pool.process do
+          threads << Thread.current
+          sleep 0.01
+          i * 10
+        end
+      end
+    end
+
+    suspend
+
+    assert_equal @pool.size, threads.uniq.size
+    assert_equal (0..14).map { |i| i * 10}, results.sort
+  end
+
+  def test_process_with_exception
+    result = nil
+    begin
+      result = @pool.process { raise 'foo' }
+    rescue => result
+    end
+
+    assert_kind_of RuntimeError, result
+    assert_equal 'foo', result.message
+  end
+
+  def test_cast
+    t0 = Time.now
+    threads = []
+    buffer = []
+    10.times do |i|
+      @pool.cast do
+        sleep 0.01
+        threads << Thread.current
+        buffer << i
+      end
+    end
+    elapsed = Time.now - t0
+
+    assert elapsed < 0.007
+    assert buffer.size < 2
+    
+    sleep 0.1 # allow time for threads to spawn
+    assert_equal @pool.size, threads.uniq.size
+    assert_equal (0..9).to_a, buffer.sort
+  end
+
+  def test_busy?
+    assert_equal false, @pool.busy?
+
+    f = spin do
+      @pool.process { sleep 0.001 }
+    end
+
+    snooze
+    assert_equal true, @pool.busy?
+    f.await
+
+    assert_equal false, @pool.busy?
+  end
+
+  def test_default_thread_pool_process
+    current_thread = Thread.current
+
+    processing_thread = nil
+    result = Polyphony::ThreadPool.process do
+      processing_thread = Thread.current
+      +'foo' + 'bar'
+    end
+    assert_equal 'foobar', result
+    assert processing_thread != current_thread
+  end
+end

data/test/test_throttler.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class ThrottlerTest < MiniTest::Test
+  def test_throttler_with_rate
+    t = Polyphony::Throttler.new(10)
+    buffer = []
+    t0 = Time.now
+    f = spin { loop { t.process { buffer << 1 } } }
+    sleep 0.2
+    f.stop
+    elapsed = Time.now - t0
+    expected = (elapsed * 10).to_i
+    assert buffer.size >= expected - 1 && buffer.size <= expected + 1
+  ensure
+    t.stop
+  end
+
+  def test_throttler_with_hash_of_rate
+    t = Polyphony::Throttler.new(rate: 20)
+    buffer = []
+    f = spin do
+      loop { t.process { buffer << 1 } }
+    end
+    sleep 0.25
+    f.stop
+    assert (2..6).include?(buffer.size)
+  ensure
+    t.stop
+  end
+
+  def test_throttler_with_hash_of_interval
+    t = Polyphony::Throttler.new(interval: 0.01)
+    buffer = []
+    f = spin { loop { t.process { buffer << 1 } } }
+    sleep 0.02
+    f.stop
+    assert buffer.size >= 2
+    assert buffer.size <= 3
+  ensure
+    t.stop
+  end
+
+  def test_throttler_with_invalid_argument
+    assert_raises RuntimeError do
+      Polyphony::Throttler.new(:foobar)
+    end
+  end
+end