fiber_scheduler_spec 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75aebdfe9a1849f812c214b78eaa70a1d5ea759317e75ff1a895ae54eb9c6826
-  data.tar.gz: 5a1f24342b3191c79b0e09b346d46b046009475b795b3842c16bd613e96535ff
+  metadata.gz: c1e20ced7c55e6f9566d1a0e802f217e0981be4ab4d2ccbd5c27ac9604e43f7b
+  data.tar.gz: 5b2234c2a5dee08864e7cbbd27105c9e1b70e610c379afbd74b6c86ab38e2d88
 SHA512:
-  metadata.gz: 37f63683f1abc6822db5748059badef9a6799b18bac7a2e0eb1a35a12c295b1eca23f623eea81edca6246c731bcae6b12384ed01abd6a30ff526298edc06c863
-  data.tar.gz: 36b1726dcf43159c40c5fd311382442653a772b132956e6bdc9f70e797e0b28b60fa13787b3204b399cc6e701c573af3e4c22de1d190316c02e887bb8126a390
+  metadata.gz: a7baa25d93db508fb5dde06e91979c30df901b817e5dc878369873c9932af07a0c2be2e4587be3160c1c43e0672e0872470032dc600135585cf6fe9b97200405
+  data.tar.gz: 20471ba20badf88e691affb068309e7734a67d1f73e9d8d272d6de460040795b1b8e305fb09221908cdcdf9a281d6d066309d56d7f733c4cd126499669c33928

data/lib/fiber_scheduler_spec/address_resolve.rb

@@ -0,0 +1,47 @@
+require "rspec"
+require "socket"
+require_relative "context"
+
+module FiberSchedulerSpec
+  module AddressResolve
+  end
+end
+
+RSpec.shared_examples FiberSchedulerSpec::AddressResolve do
+  include_context FiberSchedulerSpec::Context
+
+  context "Addrinfo.getaddrinfo" do
+    let(:order) { [] }
+
+    def operations
+      Fiber.schedule do
+        order << 1
+        Addrinfo.getaddrinfo("example.com", 80, :AF_INET, :STREAM)
+        order << 5
+      end
+
+      order << 2
+
+      Fiber.schedule do
+        order << 3
+        Addrinfo.getaddrinfo("example.com", 80, :AF_INET, :STREAM)
+        order << 6
+      end
+      order << 4
+    end
+
+    it "calls #address_resolve" do
+      expect_any_instance_of(scheduler_class)
+        .to receive(:address_resolve).exactly(2).times
+        .and_call_original
+
+      setup
+    end
+
+    it "behaves async" do
+      setup
+
+      expect(order).to eq (1..6).to_a
+    end
+  end
+end

data/lib/fiber_scheduler_spec/block_unblock.rb

@@ -0,0 +1,53 @@
+require_relative "context"
+
+module FiberSchedulerSpec
+  module BlockUnblock
+  end
+end
+
+RSpec.shared_examples FiberSchedulerSpec::BlockUnblock do
+  include_context FiberSchedulerSpec::Context
+
+  context "Addrinfo.getaddrinfo" do
+    let(:order) { [] }
+    let(:queue) { Thread::Queue.new }
+    let(:item) { "item" }
+    let(:popped_items) { [] }
+
+    def operations
+      Fiber.schedule do
+        order << 1
+        popped_items << queue.pop
+        order << 6
+      end
+
+      order << 2
+
+      Fiber.schedule do
+        order << 3
+        queue.push(item)
+        order << 4
+      end
+
+      order << 5
+    end
+
+    it "calls #block and #unblock" do
+      expect_any_instance_of(scheduler_class)
+        .to receive(:block).once
+        .and_call_original
+      expect_any_instance_of(scheduler_class)
+        .to receive(:unblock).once
+        .and_call_original
+
+      setup
+    end
+
+    it "behaves async" do
+      setup
+
+      expect(popped_items).to contain_exactly(item)
+      expect(order).to eq (1..6).to_a
+    end
+  end
+end

data/lib/fiber_scheduler_spec/close.rb

@@ -0,0 +1,83 @@
+require "rspec"
+require_relative "context"
+
+module FiberSchedulerSpec
+  module Close
+  end
+end
+
+RSpec.shared_examples FiberSchedulerSpec::Close do
+  include_context FiberSchedulerSpec::Context
+
+  # TODO: should closing a scheduler also set Fiber.scheduler to nil?
+  context "without #run" do
+    let(:order) { [] }
+
+    def operations
+      Fiber.schedule do
+        order << 2
+      end
+      order << 1
+    end
+
+    # NOTE: this example does not use 'setup', #run should not be invoked
+    if method_defined?(:default_setup)
+      # skipping if user overrode setup
+      it "calls #close" do
+        expect(scheduler)
+          .to receive(:close).once
+          .and_call_original
+
+        Thread.new do
+          Fiber.set_scheduler(scheduler)
+
+          operations
+        end.join
+      end
+    end
+
+    it "behaves async" do
+      setup
+
+      expect(order).to contain_exactly(1, 2)
+    end
+  end
+
+  context "with #run" do
+    let(:order) { [] }
+
+    def operations
+      Fiber.schedule do
+        order << 2
+      end
+
+      order << 1
+      Fiber.scheduler.run
+      order << 3
+
+      Fiber.schedule do
+        order << 4
+      end
+
+      order << 5
+    end
+
+    it "calls #close" do
+      expect(scheduler)
+        .to receive(:close).once
+        .and_call_original
+
+      Thread.new do
+        Fiber.set_scheduler(scheduler)
+        operations
+        scheduler.run
+      end.join
+    end
+
+    it "behaves async" do
+      setup
+
+      expect(order).to contain_exactly(1, 2, 3, 4, 5)
+    end
+  end
+end

data/lib/fiber_scheduler_spec/context.rb

@@ -0,0 +1,30 @@
+require "rspec"
+
+module FiberSchedulerSpec
+  module Context
+  end
+end
+
+RSpec.shared_context FiberSchedulerSpec::Context do
+  unless method_defined?(:scheduler_class)
+    let(:scheduler_class) { described_class }
+  end
+  unless method_defined?(:scheduler)
+    subject(:scheduler) { scheduler_class.new }
+  end
+  def setup
+    ::Fiber.set_scheduler(scheduler)
+
+    operations
+
+    scheduler.run
+  end
+
+  around do |example|
+    result = Thread.new do
+      example.run
+    end.join(1)
+
+    expect(result).to be_a Thread # failure means spec timed out
+  end
+end

data/lib/fiber_scheduler_spec/fiber.rb

@@ -0,0 +1,48 @@
+require_relative "context"
+
+module FiberSchedulerSpec
+  module Fiber
+  end
+end
+
+RSpec.shared_examples FiberSchedulerSpec::Fiber do
+  include_context FiberSchedulerSpec::Context
+
+  context "Fiber.schedule" do
+    let(:fibers) { [] }
+    let(:fiber) { fibers.first }
+
+    def operations
+      fibers << Fiber.schedule {}
+    end
+
+    it "calls #fiber" do
+      expect_any_instance_of(scheduler_class)
+        .to receive(:fiber).once
+        .and_call_original
+
+      setup
+    end
+
+    it "creates a fiber" do
+      # Prevent GC running inbetween two ObjectSpace calls.
+      GC.disable
+
+      before = ObjectSpace.each_object(Fiber).count
+      setup
+      after = ObjectSpace.each_object(Fiber).count
+
+      # The after - before is > 1 with the built-in selector.
+      expect(after - before).to be >= 1
+    ensure
+      GC.enable
+    end
+
+    it "creates a non-blocking fiber" do
+      setup
+
+      expect(fiber).to be_a Fiber
+      expect(fiber).not_to be_blocking
+    end
+  end
+end

data/lib/fiber_scheduler_spec/io_wait.rb

@@ -0,0 +1,82 @@
+require_relative "context"
+
+module FiberSchedulerSpec
+  module IOWait
+  end
+end
+
+RSpec.shared_examples FiberSchedulerSpec::IOWait do
+  include_context FiberSchedulerSpec::Context
+
+  context "UNIXSocket#wait_readable" do
+    context "without a timeout" do
+      let(:order) { [] }
+      let(:pair) { UNIXSocket.pair }
+      let(:reader) { pair.first }
+      let(:writer) { pair.last }
+
+      def operations
+        Fiber.schedule do
+          order << 1
+          reader.wait_readable
+          reader.close
+          order << 6
+        end
+
+        order << 2
+
+        Fiber.schedule do
+          order << 3
+          writer.write(".")
+          writer.close
+          order << 4
+        end
+        order << 5
+      end
+
+      it "behaves async" do
+        setup
+
+        expect(order).to eq (1..6).to_a
+      end
+
+      it "calls #io_wait" do
+        expect_any_instance_of(scheduler_class)
+          .to receive(:io_wait).once
+          .and_call_original
+
+        setup
+      end
+    end
+
+    context "with a timeout" do
+      let(:order) { [] }
+      let(:pair) { UNIXSocket.pair }
+      let(:reader) { pair.first }
+      let(:writer) { pair.last }
+
+      def operations
+        Fiber.schedule do
+          order << 1
+          reader.wait_readable(0.001)
+          order << 3
+        end
+        order << 2
+      end
+
+      it "behaves async" do
+        setup
+
+        expect(order).to eq (1..3).to_a
+      end
+
+      it "calls #io_wait" do
+        expect_any_instance_of(scheduler_class)
+          .to receive(:io_wait).once
+          .and_call_original
+
+        setup
+      end
+    end
+  end
+end

data/lib/fiber_scheduler_spec/kernel_sleep.rb

@@ -0,0 +1,97 @@
+require_relative "context"
+
+module FiberSchedulerSpec
+  module KernelSleep
+  end
+end
+
+RSpec.shared_examples FiberSchedulerSpec::KernelSleep do
+  include_context FiberSchedulerSpec::Context
+
+  context "Kernel.sleep" do
+    let(:order) { [] }
+    let(:times) { [] }
+    let(:duration) { times[1] - times[0] }
+
+    context "multiple sleep operations" do
+      let(:interval) { 0.1 }
+
+      def operations
+        times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        Fiber.schedule do
+          order << 1
+          sleep interval
+          order << 5
+        end
+
+        order << 2
+
+        Fiber.schedule do
+          order << 3
+          sleep interval
+          order << 6
+        end
+
+        order << 4
+      end
+
+      it "calls #kernel_sleep" do
+        expect_any_instance_of(scheduler_class)
+          .to receive(:kernel_sleep).exactly(2).times
+          .and_call_original
+
+        setup
+      end
+
+      it "behaves async" do
+        setup
+
+        expect(order).to eq (1..6).to_a
+      end
+
+      it "runs operations in parallel" do
+        setup
+        times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        expect(duration).to be >= interval
+        expect(duration).to be < (interval * 1.2)
+      end
+    end
+
+    context "sleep 0" do
+      def operations
+        times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        Fiber.schedule do
+          order << 1
+          sleep 0
+          times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          order << 3
+        end
+        order << 2
+      end
+
+      it "calls #kernel_sleep" do
+        expect_any_instance_of(scheduler_class)
+          .to receive(:kernel_sleep).once
+          .and_call_original
+
+        setup
+      end
+
+      it "behaves async" do
+        setup
+
+        expect(order).to eq (1..3).to_a
+      end
+
+      it "runs the operation in no time" do
+        setup
+
+        # No sleeping was performed at all.
+        expect(duration).to be < 0.0005
+      end
+    end
+  end
+end

data/lib/fiber_scheduler_spec/process_wait.rb

@@ -0,0 +1,61 @@
+require_relative "context"
+
+module FiberSchedulerSpec
+  module ProcessWait
+  end
+end
+
+RSpec.shared_examples FiberSchedulerSpec::ProcessWait do
+  include_context FiberSchedulerSpec::Context
+
+  context "Process.wait" do
+    let(:interval_short) { 0.09 }
+    let(:interval) { 0.1 }
+    let(:order) { [] }
+    let(:times) { [] }
+    let(:duration) { times[1] - times[0] }
+    def operations
+      times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      Fiber.schedule do
+        order << 1
+        # This interval is shorter so we're certain it will finish before the
+        # other fiber.
+        Process.wait(spawn("sleep #{interval_short}"))
+        order << 5
+      end
+
+      order << 2
+
+      Fiber.schedule do
+        order << 3
+        Process.wait(spawn("sleep #{interval}"))
+        order << 6
+      end
+
+      order << 4
+    end
+
+    it "calls #process_wait" do
+      expect_any_instance_of(scheduler_class)
+        .to receive(:process_wait).exactly(2).times
+        .and_call_original
+
+      setup
+    end
+
+    it "behaves async" do
+      setup
+
+      expect(order).to eq (1..6).to_a
+    end
+
+    it "runs operations in parallel" do
+      setup
+      times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      expect(duration).to be >= interval
+      expect(duration).to be < (interval * 1.5)
+    end
+  end
+end

data/lib/fiber_scheduler_spec/socket_io.rb

@@ -0,0 +1,62 @@
+require_relative "context"
+
+module FiberSchedulerSpec
+  module SocketIO
+  end
+end
+
+RSpec.shared_examples FiberSchedulerSpec::SocketIO do
+  include_context FiberSchedulerSpec::Context
+
+  context "UNIXSocket.pair" do
+    let(:order) { [] }
+    let(:pair) { UNIXSocket.pair }
+    let(:reader) { pair.first }
+    let(:writer) { pair.last }
+    let(:messages) { [] }
+    let(:sent) { "ruby" }
+    let(:received) { messages.first }
+
+    def operations
+      Fiber.schedule do
+        order << 1
+        messages << reader.read(sent.size)
+        reader.close
+        order << 6
+      end
+
+      order << 2
+
+      Fiber.schedule do
+        order << 3
+        writer.write(sent)
+        writer.close
+        order << 4
+      end
+      order << 5
+    end
+
+    it "calls #io_read and #io_write" do
+      expect_any_instance_of(scheduler_class)
+        .to receive(:io_read).once
+        .and_call_original
+      expect_any_instance_of(scheduler_class)
+        .to receive(:io_write).once
+        .and_call_original
+
+      setup
+    end
+
+    it "writes and reads a message" do
+      setup
+
+      expect(received).to eq sent
+    end
+
+    it "behaves async" do
+      setup
+
+      expect(order).to eq (1..6).to_a
+    end
+  end
+end

data/lib/fiber_scheduler_spec/timeout_after.rb

@@ -0,0 +1,87 @@
+require "timeout"
+require_relative "context"
+
+module FiberSchedulerSpec
+  module TimeoutAfter
+  end
+end
+
+RSpec.shared_examples FiberSchedulerSpec::TimeoutAfter do
+  include_context FiberSchedulerSpec::Context
+
+  context "Timeout.timeout" do
+    let(:order) { [] }
+    let(:times) { [] }
+    let(:duration) { times[1] - times[0] }
+    let(:sleep_duration) { 0.01 }
+
+    def operations
+      times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      Fiber.schedule do
+        begin
+          order << 1
+          Timeout.timeout(timeout) do
+            order << 2
+            sleep sleep_duration
+            order << 4
+          end
+          order << 5
+        rescue Timeout::Error
+          order << 6
+        end
+        times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+      order << 3
+    end
+
+    context "when the operation times out" do
+      let(:timeout) { 0.001 }
+
+      it "calls #timeout_after" do
+        expect_any_instance_of(scheduler_class)
+          .to receive(:timeout_after)
+          .and_call_original
+
+        setup
+      end
+
+      it "behaves async" do
+        setup
+
+        expect(order).to eq [1, 2, 3, 6]
+      end
+
+      it "times out early" do
+        setup
+
+        expect(duration).to be >= timeout
+        expect(duration).to be < (timeout * 10)
+      end
+    end
+
+    context "when the operation doesn't time out" do
+      let(:timeout) { 0.1 }
+
+      it "calls #timeout_after" do
+        expect_any_instance_of(scheduler_class)
+          .to receive(:timeout_after)
+          .and_call_original
+
+        setup
+      end
+
+      it "behaves async" do
+        setup
+
+        expect(order).to eq (1..5).to_a
+      end
+
+      it "finishes the operation" do
+        setup
+
+        expect(duration).to be >= sleep_duration
+        expect(duration).to be < (sleep_duration * 1.5)
+      end
+    end
+  end
+end

data/lib/fiber_scheduler_spec/version.rb

@@ -1,3 +1,3 @@
 module FiberSchedulerSpec
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/fiber_scheduler_spec.rb

@@ -1,2 +1,21 @@
-module FiberSchedulerSpec
+require_relative "fiber_scheduler_spec/address_resolve"
+require_relative "fiber_scheduler_spec/block_unblock"
+require_relative "fiber_scheduler_spec/close"
+require_relative "fiber_scheduler_spec/fiber"
+require_relative "fiber_scheduler_spec/io_wait"
+require_relative "fiber_scheduler_spec/kernel_sleep"
+require_relative "fiber_scheduler_spec/process_wait"
+require_relative "fiber_scheduler_spec/socket_io"
+require_relative "fiber_scheduler_spec/timeout_after"
+
+RSpec.shared_examples FiberSchedulerSpec do
+  include_examples FiberSchedulerSpec::AddressResolve
+  include_examples FiberSchedulerSpec::BlockUnblock
+  include_examples FiberSchedulerSpec::Close
+  include_examples FiberSchedulerSpec::Fiber
+  include_examples FiberSchedulerSpec::IOWait
+  include_examples FiberSchedulerSpec::KernelSleep
+  include_examples FiberSchedulerSpec::ProcessWait
+  include_examples FiberSchedulerSpec::SocketIO
+  include_examples FiberSchedulerSpec::TimeoutAfter
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fiber_scheduler_spec
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Bruno Sutic
@@ -17,7 +17,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.11'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -45,6 +45,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/fiber_scheduler_spec.rb
+- lib/fiber_scheduler_spec/address_resolve.rb
+- lib/fiber_scheduler_spec/block_unblock.rb
+- lib/fiber_scheduler_spec/close.rb
+- lib/fiber_scheduler_spec/context.rb
+- lib/fiber_scheduler_spec/fiber.rb
+- lib/fiber_scheduler_spec/io_wait.rb
+- lib/fiber_scheduler_spec/kernel_sleep.rb
+- lib/fiber_scheduler_spec/process_wait.rb
+- lib/fiber_scheduler_spec/socket_io.rb
+- lib/fiber_scheduler_spec/timeout_after.rb
 - lib/fiber_scheduler_spec/version.rb
 homepage: https://github.com/bruno-/fiber_scheduler_spec
 licenses: