itsi 0.1.0 → 0.1.2

data/gems/scheduler/test/test_file_io.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+
+class TestFileIO < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  # Test that a fiber waiting to read 5 bytes from a pipe is resumed
+  # when another fiber writes "hello" to the pipe.
+  def test_io_read_resume
+    reader, writer = IO.pipe
+    result = nil
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        result = reader.read(5)
+      end
+
+      Fiber.schedule do
+        sleep 0.05
+        writer.write("hello")
+      end
+    end
+
+    reader.close
+    writer.close
+
+    assert_equal "hello", result
+  end
+
+  # Test that IO.wait_readable times out correctly when no data arrives.
+  def test_io_wait_readable_timeout
+    reader, writer = IO.pipe
+
+    result = nil
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        # When no data is available, wait_readable should return nil after the timeout.
+        result = reader.wait_readable(0.05)
+        puts "Awoken"
+      end
+    end
+
+    reader.close
+    writer.close
+
+    assert_nil result, "Expected nil on timeout when no data is available"
+  end
+
+  # Test that two different pipes can be read concurrently.
+  def test_multiple_io_reads
+    reader1, writer1 = IO.pipe
+    reader2, writer2 = IO.pipe
+    results = {}
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        results[:first] = reader1.read(5)
+      end
+
+      Fiber.schedule do
+        results[:second] = reader2.read(6)
+      end
+
+      Fiber.schedule do
+        sleep 0.05
+        writer1.write("first")
+        writer2.write("second")
+      end
+    end
+
+    reader1.close
+    writer1.close
+    reader2.close
+    writer2.close
+
+    assert_equal "first", results[:first]
+    assert_equal "second", results[:second]
+  end
+
+  # Test an interleaved read/write operation.
+  # One fiber writes the data in chunks (with short sleeps in between),
+  # while another fiber reads in fixed-size chunks until EOF.
+  def test_io_interleaved_read_write
+    reader, writer = IO.pipe
+    data_read = "".dup
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        loop do
+          chunk = reader.read(3)
+          break if chunk.nil? || chunk.empty?
+
+          data_read << chunk
+        end
+      end
+
+      Fiber.schedule do
+        ["Hel", "lo ", "Wor", "ld"].each do |part|
+          writer.write(part)
+          sleep 0.02
+        end
+        writer.close # signal EOF to the reader
+      end
+    end
+
+    reader.close
+
+    assert_equal "Hello World", data_read
+  end
+
+  # Test that a fiber using nonblocking I/O correctly waits for data.
+  def test_io_read_with_nonblocking_mode
+    reader, writer = IO.pipe
+    # Ensure the IOs are in synchronous mode.
+    reader.sync = true
+    writer.sync = true
+    result = nil
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        # Use wait_readable to wait until data is available.
+        reader.wait_readable(0.2)
+        result = reader.read_nonblock(5)
+      end
+
+      Fiber.schedule do
+        sleep 0.05
+        writer.write("hello")
+      end
+    end
+
+    reader.close
+    writer.close
+
+    assert_equal "hello", result
+  end
+
+  # Test that writing to an IO (here a pipe) succeeds immediately
+  # when the pipe is ready for writing.
+  def test_io_write_immediate
+    reader, writer = IO.pipe
+    bytes_written = nil
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        # If the pipe is empty, write should not block.
+        bytes_written = writer.write("test")
+      end
+    end
+
+    reader.close
+    writer.close
+
+    assert_equal 4, bytes_written
+  end
+
+  # Test what happens when two fibers are waiting on the same IO.
+  # With the current scheduler design, only one fiber will be resumed
+  # when data becomes available, and the other will eventually time out.
+  def test_multiple_fibers_waiting_on_same_fd
+    reader, writer = IO.pipe
+    results = []
+    data = "data"
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        if res = reader.wait_readable(0.1)
+          reader.read(data.length)
+        end
+        results << (res ? "readable" : "timeout")
+      end
+
+      Fiber.schedule do
+        if res = reader.wait_readable(0.1)
+          reader.read(data.length)
+        end
+        results << (res ? "readable" : "timeout")
+      end
+
+      Fiber.schedule do
+        writer.write(data)
+      end
+    end
+
+    writer.close
+    reader.close
+
+    # One fiber should be resumed with "readable" while the other times out.
+    assert_equal 2, results.size
+    assert_includes results, "readable"
+    assert_includes results, "timeout"
+  end
+end

data/gems/scheduler/test/test_itsi_scheduler.rb

@@ -1,9 +1,32 @@
 # frozen_string_literal: true
 
-require "test_helper"
 
 class TestItsiScheduler < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
   def test_that_it_has_a_version_number
     refute_nil ::Itsi::Scheduler::VERSION
   end
+
+  def test_errors
+    results = []
+    start_at = Time.now
+    # Run the scheduler in a dedicated thread to avoid interference with the
+    # main thread’s scheduler state.
+    total = 0
+    out, err = capture_subprocess_io do
+      with_scheduler do |_scheduler|
+        9.times do |i|
+          Fiber.schedule do
+            sleep 0.05
+            raise i if i % 3 == 0
+            total += 1
+          end
+        end
+      end
+    end
+
+    assert_equal total, 6
+    assert_match /Failed to resume fiber /, out
+  end
 end

data/gems/scheduler/test/test_kernel_sleep.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+
+class TestKernelSleep < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  def test_that_it_has_a_version_number
+    refute_nil ::Itsi::Scheduler::VERSION
+  end
+
+  def test_it_can_sleep_concurrently
+    results = []
+    start_at = Time.now
+    # Run the scheduler in a dedicated thread to avoid interference with the
+    # main thread’s scheduler state.
+    with_scheduler do |_scheduler|
+      5.times do
+        Fiber.schedule do
+          sleep 0.05
+          results << "first"
+          sleep 0.05
+          results << "second"
+        end
+      end
+    end
+
+    ends_at = Time.now
+    # We expect 10 sleep completions overall (2 per fiber).
+    assert_equal 10, results.size
+    # Because all sleeps run concurrently, the total elapsed time should be about 1 second.
+    assert_in_delta 0.1, ends_at - start_at, 0.02, "Total elapsed time should be close to 0.1 second"
+  end
+
+  def test_sleep_zero_duration
+    with_scheduler do |_scheduler|
+      start = Time.now
+      result = sleep(0)
+      finish = Time.now
+      assert result, "sleep(0) should return a truthy value"
+      # Expect near-immediate return.
+      assert_operator finish - start, :<, 0.01, "sleep(0) should not delay execution"
+    end
+  end
+
+  def test_multiple_sleeps_in_single_fiber
+    order = []
+    with_scheduler do |_scheduler|
+      # Schedule one fiber that sleeps twice.
+      Fiber.schedule do
+        order << "start"
+        sleep 0.2
+        order << "after first sleep"
+        sleep 0.3
+        order << "after second sleep"
+      end
+    end
+
+    assert_equal ["start", "after first sleep", "after second sleep"], order
+  end
+
+  def test_fibers_wake_in_correct_order
+    order = []
+    with_scheduler do |_scheduler|
+      # Schedule three fibers with different sleep durations.
+      Fiber.schedule do
+        sleep 0.3
+        order << "fiber1"
+      end
+      Fiber.schedule do
+        sleep 0.1
+        order << "fiber2"
+      end
+      Fiber.schedule do
+        sleep 0.2
+        order << "fiber3"
+      end
+    end
+
+    # Since the fibers sleep for 0.1, 0.2, and 0.3 seconds respectively,
+    # we expect the wake-up order to be: fiber2, then fiber3, then fiber1.
+    assert_equal %w[fiber2 fiber3 fiber1], order
+  end
+
+  def test_invalid_sleep_value
+    with_scheduler do |_scheduler|
+      assert_raises(TypeError) do
+        sleep("not a number")
+      end
+    end
+  end
+end

data/gems/scheduler/test/test_nested_fibers.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+class TestNestedFibers < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  def each_pop(queue)
+    loop do
+      if item = queue.pop
+        sleep 0.001
+        yield item
+      else
+        break
+      end
+    end
+  end
+
+  def test_async_queue
+    results = []
+    queue = Queue.new
+
+    # In the thread running the scheduler, we use an enumerator, which
+    # uses a new Fiber per iteration
+    with_scheduler do
+      Fiber.schedule do
+        each_pop(queue) do |item|
+          results << item
+        end
+      end
+
+      # Non scheduler thread pushes to queue every 0.1 seconds
+      Thread.new do
+        1.times do |i|
+          queue.push(i)
+          sleep 0.1
+        end
+        queue.push(nil)
+      end.join
+    end
+
+    assert_equal [*0...1], results
+  end
+
+  def test_base_unowned_no_scheduler_transfer
+    results = []
+    scheduler = nil
+    outer = Fiber.new do
+      inner = Fiber.new do
+        results << 0
+        sleep 0.02
+        scheduler.transfer
+        results << 4
+      end
+
+      results << 1
+      inner.transfer
+      results << 2
+      inner.transfer
+    end
+
+    scheduler = Fiber.new do
+      outer.transfer while outer.alive?
+    end
+    scheduler.transfer
+
+    assert_equal [1, 0, 2, 4], results
+  end
+
+  def test_base_unowned_no_scheduler_yield
+    results = []
+
+    Fiber.new do
+      inner = Fiber.new do
+        results << 0
+        Fiber.yield
+        results << 4
+      end
+
+      results << 1
+      inner.resume
+      results << 2
+      inner.resume
+    end.resume
+
+    assert_equal [1, 0, 2, 4], results
+  end
+
+  def test_base_unowned_no_scheduler_combine_resume_and_transfer
+    results = []
+    scheduler = nil
+    inner = nil
+    outer = Fiber.new do
+      inner = Fiber.new do
+        results << 0
+        scheduler.transfer(inner)
+        results << 4
+      end
+      results << 1
+      inner.resume
+      results << 2
+    end
+    scheduler = Fiber.new do |fib|
+      fib = fib.transfer while fib
+    end
+    scheduler.transfer(outer)
+
+    assert_equal [1, 0, 4, 2], results
+  end
+
+  def test_base_unowned_no_scheduler_combine_resume_and_transfer_with_scheduler
+    results = []
+    with_scheduler do |scheduler|
+      results = []
+      inner = nil
+      outer = Fiber.new do
+        inner = Fiber.new do
+          results << 0
+          sleep 0.1
+          results << 4
+        end
+        results << 1
+        inner.resume
+        results << 2
+      end
+      outer.transfer
+    end
+
+    assert_equal [1, 0, 2, 4], results
+  end
+
+
+  def test_base_owned_with_scheduler
+    results = []
+    with_scheduler do |scheduler|
+      scheduler = nil
+
+      Fiber.schedule do
+        Fiber.schedule do
+          Fiber.schedule do
+            results << 0
+            sleep 0.01
+            results << 4
+          end
+
+          results << 1
+          sleep 0.03
+          results << 2
+          sleep 0.01
+        end
+      end
+    end
+    assert_equal [0, 1, 4, 2], results
+  end
+
+  def test_nested_owned_fibers
+    results = []
+    with_scheduler do |scheduler|
+      Fiber.schedule do
+        Fiber.schedule do
+          results << 0
+          sleep 0.02
+          results << 4
+        end
+
+        Fiber.schedule do
+          results << 1
+          sleep 0.2
+          Fiber.schedule do
+            results << 5
+            sleep 0.2
+            results << 7
+          end
+          results << 6
+        end
+        results << 2
+        sleep 0.01
+        results << 3
+      end
+    end
+    assert_equal [0, 1, 2, 3, 4, 5, 6, 7], results
+  end
+
+  def test_nested_unowned_fibers_with_scheduler
+    results = []
+    out, err = capture_subprocess_io do
+      begin
+        with_scheduler do |scheduler|
+          Fiber.new do
+            fib = Fiber.new do
+              results << 4
+              sleep 0.001
+              results << 5
+              sleep 0.001
+              results << 6
+            end
+
+            Fiber.new do
+              results << 0
+              sleep 0.001
+              Fiber.new do
+                results << 1
+                sleep 0.1
+                results << 8
+              end.transfer
+              results << 2
+            end.resume
+
+            results << 3
+
+            fib.resume
+            sleep 0.01
+            results << 7
+          end.transfer
+        end
+      rescue
+      end
+    end
+    # Transfered fibers are not resumed after yielding out.
+    assert_equal [0, 3, 4, 1, 5, 6], results
+    # assert_match /attempt to yield on a not resumed fiber/, out
+  end
+
+  def test_nested_unowned_fibers_no_scheduler
+    results = []
+    Fiber.new do
+      fib = Fiber.new do
+        results << 5
+        sleep 0.001
+        results << 6
+        sleep 0.001
+        results << 7
+      end
+
+      Fiber.new do
+        results << 0
+        sleep 0.001
+        Fiber.new do
+          results << 1
+          sleep 0.1
+          results << 2
+        end.resume
+        results << 3
+      end.resume
+
+      results << 4
+      fib.resume
+      sleep 0.01
+      results << 8
+    end.transfer
+
+    assert_equal [0, 1, 2, 3, 4, 5, 6, 7, 8], results
+  end
+
+  def test_nested_owned_fibers_resume
+    results = []
+    with_scheduler do |scheduler|
+      Fiber.schedule do
+        fib = Fiber.new do
+          results << 2
+          sleep 0.001
+          results << 5
+          sleep 0.001
+          results << 6
+        end
+
+        Fiber.schedule do
+          results << 0
+          sleep 0.001
+          Fiber.schedule do
+            results << 3
+            sleep 0.1
+            results << 8
+          end
+          results << 4
+        end
+
+        results << 1
+        fib.resume
+        sleep 0.01
+        results << 7
+      end
+    end
+    assert_equal [0, 1, 2, 3, 4, 5, 6, 7, 8], results
+  end
+end