polyphony 0.43.8

data/test/test_kernel.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class KernelTest < MiniTest::Test
+  def test_system_method
+    fn = '/tmp/test_system_method'
+    FileUtils.rm(fn) rescue nil
+
+    counter = 0
+    timer = spin { throttled_loop(200) { counter += 1 } }
+
+    system('sleep 0.01')
+    assert(counter >= 2)
+
+    system('echo "hello" > ' + fn)
+    assert_equal "hello\n", IO.read(fn)
+  ensure
+    timer&.stop
+  end
+
+  def patch_open3
+    class << Open3
+      alias_method :orig_popen2, :popen2
+      def popen2(*args)
+        raise SystemCallError, 'foo'
+      end
+    end
+  end
+
+  def unpatch_open3
+    class << Open3
+      alias_method :popen2, :orig_popen2
+    end
+  end
+
+  def test_system_method_with_system_call_error
+    patch_open3
+    result = system('foo')
+    assert_nil result
+  ensure
+    unpatch_open3
+  end
+
+  def test_backtick_method
+    counter = 0
+    timer = spin { throttled_loop(200) { counter += 1 } }
+
+    `sleep 0.01`
+    assert(counter >= 2)
+
+    result = `echo "hello"`
+    assert_equal "hello\n", result
+  ensure
+    timer&.stop
+  end
+end

data/test/test_process_supervision.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class ProcessSupervisionTest < MiniTest::Test
+  def test_process_supervisor_with_block
+    i, o = IO.pipe
+
+    f = spin do
+      Polyphony.watch_process do
+        i.close
+        sleep 5
+      ensure
+        o << 'foo'
+        o.close
+      end
+      supervise(on_error: :restart)
+    end
+
+    sleep 0.05
+    f.terminate
+    f.await
+
+    o.close
+    msg = i.read
+    i.close
+    assert_equal 'foo', msg
+  end
+
+  def test_process_supervisor_with_cmd
+    fn = '/tmp/test_process_supervisor_with_cmd'
+    FileUtils.rm(fn) rescue nil
+
+    f = spin do
+      Polyphony.watch_process("echo foo >> #{fn}")
+      supervise(on_error: :restart)
+    end
+
+    sleep 0.05
+    f.terminate
+    f.await
+
+    assert_equal "foo\n", IO.read(fn)
+
+  end
+end

data/test/test_queue.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class QueueTest < MiniTest::Test
+  def setup
+    super
+    @queue = Polyphony::Queue.new
+  end
+
+  def test_push_shift
+    spin {
+      @queue << 42
+    }
+    v = @queue.shift
+    assert_equal 42, v
+
+    (1..4).each { |i| @queue << i }
+    buf = []
+    4.times { buf << @queue.shift }
+    assert_equal [1, 2, 3, 4], buf
+  end
+
+  def test_unshift
+    @queue.push 1
+    @queue.push 2
+    @queue.push 3
+    @queue.unshift 4
+
+    buf = []
+    buf << @queue.shift while !@queue.empty?
+
+    assert_equal [4, 1, 2, 3], buf
+  end
+
+  def test_multiple_waiters
+    a = spin { @queue.shift }
+    b = spin { @queue.shift }
+
+    @queue << :foo
+    @queue << :bar
+
+    assert_equal [:foo, :bar], Fiber.await(a, b)
+  end
+
+  def test_multi_thread_usage
+    t = Thread.new { @queue.push :foo }
+    assert_equal :foo, @queue.shift
+  end
+
+  def test_shift_each
+    (1..4).each { |i| @queue << i }
+    buf = []
+    @queue.shift_each { |i| buf << i }
+    assert_equal [1, 2, 3, 4], buf
+
+    buf = []
+    @queue.shift_each { |i| buf << i }
+    assert_equal [], buf
+  end
+
+  def test_shift_all
+    (1..4).each { |i| @queue << i }
+    buf = @queue.shift_all
+    assert_equal [1, 2, 3, 4], buf
+
+    buf = @queue.shift_all
+    assert_equal [], buf
+  end
+
+  def test_empty?
+    assert @queue.empty?
+    
+    @queue << :foo
+    assert !@queue.empty?
+
+    assert_equal :foo, @queue.shift
+    assert @queue.empty?
+  end
+
+  def test_fiber_removal_from_queue
+    f1 = spin { @queue.shift }
+    f2 = spin { @queue.shift }
+    f3 = spin { @queue.shift }
+    
+    # let fibers run
+    snooze
+
+    f2.stop
+    snooze
+
+    @queue << :foo
+    @queue << :bar
+
+    assert_equal :foo, f1.await
+    assert_nil f2.await
+    assert_equal :bar, f3.await
+  end
+
+  def test_fiber_removal_from_queue_simple
+    f1 = spin { @queue.shift }
+    
+    # let fibers run
+    snooze
+
+    f1.stop
+    snooze
+
+    @queue << :foo
+    assert_nil f1.await
+  end
+end

data/test/test_resource_pool.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class ResourcePoolTest < MiniTest::Test
+  def test_resource_pool_limit
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 2) { resources.shift }
+
+    assert_equal 2, pool.limit
+    assert_equal 0, pool.available
+    assert_equal 0, pool.size
+
+    results = []
+    4.times {
+      spin {
+        snooze
+        pool.acquire { |resource|
+          results << resource
+          snooze
+        }
+      }
+    }
+    2.times { snooze }
+    assert_equal 2, pool.limit
+    assert_equal 0, pool.available
+    assert_equal 2, pool.size
+
+    2.times { snooze }
+
+    assert_equal ['a', 'b', 'a', 'b'], results
+
+    2.times { snooze }
+
+    assert_equal 2, pool.limit
+    assert_equal 2, pool.available
+    assert_equal 2, pool.size
+  end
+
+  def test_discard
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 2) { resources.shift }
+
+    results = []
+    4.times {
+      spin {
+        snooze
+        pool.acquire { |resource|
+          results << resource
+          resource.__discard__ if resource == 'b'
+          snooze
+        }
+      }
+    }
+    6.times { snooze }
+
+    assert_equal ['a', 'b', 'a', 'a'], results
+    assert_equal 1, pool.size
+  end
+
+  def test_add
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 2) { resources.shift }
+
+    pool << +'c'
+
+    results = []
+    4.times {
+      spin {
+        snooze
+        pool.acquire { |resource|
+          results << resource
+          resource.__discard__ if resource == 'b'
+          snooze
+        }
+      }
+    }
+    6.times { snooze }
+
+    assert_equal ['c', 'a', 'c', 'a'], results
+  end
+
+  def test_single_resource_limit
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 1) { resources.shift }
+
+    results = []
+    10.times {
+      spin {
+        snooze
+        pool.acquire { |resource|
+          results << resource
+          snooze
+        }
+      }
+    }
+    20.times { snooze }
+
+    assert_equal ['a'] * 10, results
+  end
+
+  def test_failing_allocator
+    pool = Polyphony::ResourcePool.new(limit: 4) { raise }
+
+    assert_raises { pool.acquire { } }
+  end
+
+  def test_method_delegation
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 2) { resources.shift }
+
+    assert_respond_to pool, :upcase
+    assert_equal 'A', pool.upcase
+  end
+
+  def test_preheat
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 2) { resources.shift }
+
+    assert_equal 2, pool.limit
+    assert_equal 0, pool.size
+
+    pool.preheat!
+    assert_equal 2, pool.size
+  end
+
+  def test_reentrant_resource_pool
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 1) { resources.shift }
+
+    pool.acquire do |r|
+      assert_equal 'a', r
+      pool.acquire do |r|
+        assert_equal 'a', r
+      end
+    end
+  end
+end

data/test/test_signal.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class SignalTrapTest < Minitest::Test
+  def test_signal_exception_handling
+    i, o = IO.pipe
+    pid = Polyphony.fork do
+      i.close
+      spin do
+        spin do
+          sleep 5
+        rescue ::Interrupt => e
+          # the signal should be raised only in the main fiber
+          o.puts "1-interrupt"
+        end.await
+      end.await
+    rescue ::Interrupt => e
+      o.puts "3-interrupt"
+    ensure
+      o.close
+    end
+    sleep 0.01
+    o.close
+    Process.kill('INT', pid)
+    Thread.current.agent.waitpid(pid)
+    buffer = i.read
+    assert_equal "3-interrupt\n", buffer
+  end
+
+  def test_signal_exception_with_cleanup
+    i, o = IO.pipe
+    pid = Polyphony.fork do
+      i.close
+      spin do
+        spin do
+          sleep
+        rescue Polyphony::Terminate
+          o.puts "1 - terminated"
+        end.await
+      rescue Polyphony::Terminate
+        o.puts "2 - terminated"
+      end.await
+    rescue Interrupt
+      o.puts "3 - interrupted"
+      Fiber.current.terminate_all_children
+      Fiber.current.await_all_children
+    ensure
+      o.close
+    end
+    sleep 0.02
+    o.close
+    Process.kill('INT', pid)
+    Thread.current.agent.waitpid(pid)
+    buffer = i.read
+    assert_equal "3 - interrupted\n2 - terminated\n1 - terminated\n", buffer
+  end
+
+  def test_signal_exception_possible_race_condition
+    i, o = IO.pipe
+    pid = Polyphony.fork do
+      i.close
+      f1 = nil
+      f2 = spin do
+        # this fiber will try to create a race condition by
+        # - being scheduled before f1 is scheduled with the Interrupt exception
+        # - scheduling f1 without an exception
+        suspend
+        f1.schedule
+      rescue ::Interrupt => e
+        o.puts '2-interrupt'
+        raise e
+      end
+      f1 = spin do
+        # this fiber is the one that will be current when the
+        # signal is trapped
+        sleep 1
+        o << 'boom'
+      rescue ::Interrupt => e
+        o.puts '1-interrupt'
+        raise e
+      end
+      old_trap = trap('INT') do
+        f2.schedule
+        old_trap.()
+      end
+      Fiber.current.await_all_children
+    rescue ::Interrupt => e
+      o.puts '3-interrupt'
+    ensure
+      o.close
+    end
+    o.close
+    sleep 0.1
+    Process.kill('INT', pid)
+    Thread.current.agent.waitpid(pid)
+    buffer = i.read
+    assert_equal "3-interrupt\n", buffer
+  end
+end