celluloid 0.17.4 → 0.18.0

data/spec/celluloid/block_spec.rb

@@ -2,19 +2,20 @@ RSpec.describe "Blocks", actor_system: :global do
   class MyBlockActor
     include Celluloid
 
-    def initialize(name)
+    def initialize(name, data)
       @name = name
+      @data = data
     end
     attr_reader :name
 
     def ask_for_something(other)
       sender_actor = current_actor
-      $data << [:outside, @name, current_actor.name]
-      other.do_something_and_callback do |value|
-        $data << [:yielded, @name, current_actor.name]
-        $data << receive_result(:self)
-        $data << current_actor.receive_result(:current_actor)
-        $data << sender_actor.receive_result(:sender)
+      @data << [:outside, @name, current_actor.name]
+      other.do_something_and_callback do |_value|
+        @data << [:yielded, @name, current_actor.name]
+        @data << receive_result(:self)
+        @data << current_actor.receive_result(:current_actor)
+        @data << sender_actor.receive_result(:sender)
         :pete_the_polyglot_alien
       end
     end
@@ -34,20 +35,20 @@ RSpec.describe "Blocks", actor_system: :global do
     def defer_for_something(other, &_block)
       sender_actor = current_actor
       defer do
-        $data << [:outside, @name, current_actor.name]
-        other.do_something_and_callback do |value|
-          $data << [:yielded, @name, current_actor.name]
-          $data << receive_result(:self)
-          $data << current_actor.receive_result(:current_actor)
-          $data << sender_actor.receive_result(:sender)
+        @data << [:outside, @name, current_actor.name]
+        other.do_something_and_callback do |_value|
+          @data << [:yielded, @name, current_actor.name]
+          @data << receive_result(:self)
+          @data << current_actor.receive_result(:current_actor)
+          @data << sender_actor.receive_result(:sender)
           :pete_the_polyglot_alien
         end
       end
     end
 
     def do_something_and_callback
-      $data << [:something, @name, current_actor.name]
-      $data << yield(:foo)
+      @data << [:something, @name, current_actor.name]
+      @data << yield(:foo)
     end
 
     def receive_result(result)
@@ -56,10 +57,10 @@ RSpec.describe "Blocks", actor_system: :global do
   end
 
   it "work between actors" do
-    $data = []
+    data = []
 
-    a1 = MyBlockActor.new("one")
-    a2 = MyBlockActor.new("two")
+    a1 = MyBlockActor.new("one", data)
+    a2 = MyBlockActor.new("two", data)
 
     a1.ask_for_something a2
 
@@ -70,33 +71,29 @@ RSpec.describe "Blocks", actor_system: :global do
       [:self, "one", "one"],
       [:current_actor, "one", "one"],
       [:sender, "one", "one"],
-      :pete_the_polyglot_alien,
+      :pete_the_polyglot_alien
     ]
 
-    expect($data).to eq(expected)
+    expect(data).to eq(expected)
   end
 
   execute_deferred = proc do
-    a1 = MyBlockActor.new("one")
+    a1 = MyBlockActor.new("one", [])
     expect(a1.deferred_excecution(:pete_the_polyglot_alien) { |v| v })
-    .to eq(:pete_the_polyglot_alien)
+      .to eq(:pete_the_polyglot_alien)
   end
 
-  # unless RUBY_ENGINE == 'jruby'
   xit("can be deferred", &execute_deferred)
-  # else
-  #   it("can be deferred", &execute_deferred)
-  # end
 
   xit "can execute deferred blocks referencing current_actor" do
-    a1 = MyBlockActor.new("one")
+    a1 = MyBlockActor.new("one", [])
     expect(a1.deferred_current_actor { |v| v }).to be("one")
   end
 
   xit "can execute deferred blocks with another actor" do
-    $data = []
-    a1 = MyBlockActor.new("one")
-    a2 = MyBlockActor.new("two")
+    data = []
+    a1 = MyBlockActor.new("one", data)
+    a2 = MyBlockActor.new("two", data)
     a1.defer_for_something a2
     expected = [
       [:outside, "one", "one"],
@@ -105,9 +102,9 @@ RSpec.describe "Blocks", actor_system: :global do
       [:self, "one", "one"],
       [:current_actor, "one", "one"],
       [:sender, "one", "one"],
-      :pete_the_polyglot_alien,
+      :pete_the_polyglot_alien
     ]
 
-    expect($data).to eq(expected)
+    expect(data).to eq(expected)
   end
 end

data/spec/celluloid/calls_spec.rb

@@ -5,27 +5,17 @@ RSpec.describe Celluloid::Call::Sync, actor_system: :global do
   let(:logger) { Specs::FakeLogger.current }
 
   context "when obj does not respond to a method" do
-    # bypass this until rubinius/rubinius#3373 is resolved
-    # under Rubinius, `method` calls `inspect` on an object when a method is not found
-    unless RUBY_ENGINE == "rbx"
-      it "raises a NoMethodError" do
-        allow(logger).to receive(:crash).with("Actor crashed!", NoMethodError)
+    it "raises a NoMethodError" do
+      allow(logger).to receive(:crash).with("Actor crashed!", NoMethodError)
 
-        expect do
-          actor.the_method_that_wasnt_there
-        end.to raise_exception(NoMethodError)
-      end
+      expect do
+        actor.the_method_that_was_not_there
+      end.to raise_exception(NoMethodError)
     end
 
     context "when obj raises during inspect" do
       it "should emulate obj.inspect" do
         allow(logger).to receive(:crash).with("Actor crashed!", NoMethodError)
-
-        if RUBY_ENGINE == "rbx"
-          expected = /undefined method `no_such_method' on an instance of CallExampleActor/
-        else
-          expected = /undefined method `no_such_method' for #\<CallExampleActor:0x[a-f0-9]+\>/
-        end
       end
     end
   end

data/spec/celluloid/future_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe Celluloid::Future, actor_system: :global do
   it "reraises exceptions that occur when the value is retrieved" do
     class ExampleError < StandardError; end
 
-    future = Celluloid::Future.new { fail ExampleError, "oh noes crash!" }
+    future = Celluloid::Future.new { raise ExampleError, "oh noes crash!" }
     expect { future.value }.to raise_exception(ExampleError)
   end
 
@@ -32,4 +32,10 @@ RSpec.describe Celluloid::Future, actor_system: :global do
     future = Celluloid::Future.new { sleep 2 }
     expect { future.value(1) }.to raise_exception(Celluloid::TaskTimeout)
   end
+
+  it "cancels future" do
+    future = Celluloid::Future.new { sleep 3600 }
+    future.cancel(StandardError.new("cancelled"))
+    expect { future.value }.to raise_exception(StandardError, "cancelled")
+  end
 end

data/spec/celluloid/internals/cpu_counter_spec.rb

@@ -0,0 +1,129 @@
+RSpec.describe Celluloid::Internals::CPUCounter do
+  describe "#cores" do
+    subject { described_class.cores }
+
+    let(:num_cores) { 1024 }
+
+    before do
+      allow(described_class).to receive(:`) { raise "backtick stub called" }
+      allow(::IO).to receive(:open).and_raise("IO.open stub called!")
+      described_class.instance_variable_set(:@cores, nil)
+    end
+
+    after do
+      ENV["NUMBER_OF_PROCESSORS"] = nil
+      described_class.instance_variable_set(:@cores, nil)
+    end
+
+    context "with from_env" do
+      context "valid env value" do
+        before { ENV["NUMBER_OF_PROCESSORS"] = num_cores.to_s }
+        it { is_expected.to eq num_cores }
+      end
+
+      context "invalid env value" do
+        before { ENV["NUMBER_OF_PROCESSORS"] = "" }
+        subject { described_class.from_env }
+        it { is_expected.to be nil }
+      end
+    end
+
+    context "with from_sysdev" do
+      subject { described_class.from_sysdev }
+
+      context "when /sys/devices/system/cpu/present exists" do
+        before do
+          expect(::IO).to receive(:read).with("/sys/devices/system/cpu/present")
+                                        .and_return("dunno-whatever-#{num_cores - 1}")
+        end
+        it { is_expected.to eq num_cores }
+      end
+
+      context "when /sys/devices/system/cpu/present does NOT exist" do
+        before do
+          expect(::IO).to receive(:read).with("/sys/devices/system/cpu/present")
+                                        .and_raise(Errno::ENOENT)
+        end
+
+        context "when /sys/devices/system/cpu/cpu* files exist" do
+          before do
+            cpu_entries = (1..num_cores).map { |n| "cpu#{n}" }
+            cpu_entries << "non-cpu-entry-to-ignore"
+            expect(Dir).to receive(:[]).with("/sys/devices/system/cpu/cpu*")
+                                       .and_return(cpu_entries)
+          end
+          it { is_expected.to eq num_cores }
+        end
+      end
+
+      context "when /sys/devices/system/cpu/cpu* files DO NOT exist" do
+        before do
+          expect(Dir).to receive(:[]).with("/sys/devices/system/cpu/cpu*")
+                                     .and_return([])
+        end
+      end
+    end
+
+    context "with from_java" do
+      subject { described_class.from_java }
+
+      xit "not yet tested" do
+      end
+    end
+
+    context "with from_proc" do
+      subject { described_class.from_proc }
+
+      xit "not yet tested" do
+      end
+    end
+
+    context "with from_win32ole" do
+      subject { described_class.from_win32ole }
+
+      xit "not yet tested" do
+      end
+    end
+
+    context "with from_sysctl" do
+      subject { described_class.from_sysctl }
+
+      context "when sysctl blows up" do
+        before { allow(described_class).to receive(:`).and_raise(Errno::EINTR) }
+        it { is_expected.to be nil }
+      end
+
+      context "when sysctl fails" do
+        before { allow(described_class).to receive(:`).and_return(`false`) }
+        it { is_expected.to be nil }
+      end
+
+      context "when sysctl succeeds" do
+        before do
+          expect(described_class).to receive(:`).with("sysctl -n hw.ncpu 2>/dev/null")
+                                                .and_return(num_cores.to_s)
+          `true`
+        end
+        it { is_expected.to eq num_cores }
+      end
+    end
+
+    xit "when all guesses fail" do
+    end
+
+    context "with from_result" do
+      context "when passed a symbol" do
+        subject { described_class.from_result(:foo) }
+        it { is_expected.to be nil }
+      end
+      context "when passed 0" do
+        subject { described_class.from_result(:foo) }
+        it { is_expected.to be nil }
+      end
+      context "when passed valid integer" do
+        subject { described_class.from_result(num_cores) }
+        it { is_expected.to be num_cores }
+      end
+    end
+  end
+end

data/spec/celluloid/internals/links_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe Celluloid::Internals::Links do
+  subject { Celluloid::Internals::Links.new }
+
+  let(:mailbox_mock) do
+    Class.new(Array) do
+      attr_reader :address
+      def initialize(address)
+        @address = address
+      end
+    end
+  end
+
+  let(:first_actor) do
+    Struct.new(:mailbox).new(mailbox_mock.new("foo123"))
+  end
+
+  let(:second_actor) do
+    Struct.new(:mailbox).new(mailbox_mock.new("bar456"))
+  end
+
+  it "is Enumerable" do
+    expect(subject).to be_an(Enumerable)
+  end
+
+  it "adds actors by their mailbox address" do
+    expect(subject.include?(first_actor)).to be_falsey
+    subject << first_actor
+    expect(subject.include?(first_actor)).to be_truthy
+  end
+
+  it "removes actors by their mailbox address" do
+    subject << first_actor
+    expect(subject.include?(first_actor)).to be_truthy
+    subject.delete first_actor
+    expect(subject.include?(first_actor)).to be_falsey
+  end
+
+  it "iterates over all actors" do
+    subject << first_actor
+    subject << second_actor
+    expect(subject.inject([]) { |all, a| all << a }).to eq([first_actor, second_actor])
+  end
+end

data/spec/celluloid/internals/properties_spec.rb

@@ -0,0 +1,40 @@
+RSpec.describe Celluloid::Internals::Properties do
+  let(:default_value) { 42 }
+  let(:changed_value) { 43 }
+
+  let(:example_class) do
+    Class.new do
+      extend Celluloid::Internals::Properties
+      property :baz, default: 42
+    end
+  end
+
+  let(:example_subclass) do
+    Class.new(example_class)
+  end
+
+  let(:example_subclass_subclass) do
+    Class.new(example_subclass)
+  end
+
+  it "adds properties to classes" do
+    expect(example_class.baz).to eq default_value
+    example_class.baz changed_value
+    expect(example_class.baz).to eq changed_value
+  end
+
+  it "allows properties to be inherited" do
+    expect(example_subclass.baz).to eq default_value
+    example_subclass.baz changed_value
+    expect(example_subclass.baz).to eq changed_value
+    expect(example_class.baz).to eq default_value
+  end
+
+  it "allows properties to be deeply inherited" do
+    expect(example_subclass_subclass.baz).to eq default_value
+    example_subclass_subclass.baz changed_value
+    expect(example_subclass_subclass.baz).to eq changed_value
+    expect(example_subclass.baz).to eq default_value
+    expect(example_class.baz).to eq default_value
+  end
+end

data/spec/celluloid/internals/registry_spec.rb

@@ -0,0 +1,62 @@
+RSpec.describe Celluloid::Internals::Registry, actor_system: :global do
+  class Marilyn
+    include Celluloid
+
+    def sing_for(person)
+      "o/~ Happy birthday, #{person}"
+    end
+  end
+
+  it "registers Actors" do
+    Celluloid::Actor[:marilyn] = Marilyn.new
+    expect(Celluloid::Actor[:marilyn].sing_for("Mr. President")).to eq("o/~ Happy birthday, Mr. President")
+  end
+
+  it "refuses to register non-Actors" do
+    expect do
+      Celluloid::Actor[:impostor] = Object.new
+    end.to raise_error TypeError
+  end
+
+  it "lists all registered actors" do
+    Celluloid::Actor[:marilyn] = Marilyn.new
+    expect(Celluloid::Actor.registered).to include :marilyn
+  end
+
+  it "knows its name once registered" do
+    Celluloid::Actor[:marilyn] = Marilyn.new
+    expect(Celluloid::Actor[:marilyn].registered_name).to eq(:marilyn)
+  end
+
+  describe :delete do
+    before do
+      Celluloid::Actor[:marilyn] ||= Marilyn.new
+    end
+
+    it "removes reference to actors' name from the registry" do
+      Celluloid::Actor.delete(:marilyn)
+      expect(Celluloid::Actor.registered).not_to include :marilyn
+    end
+
+    it "returns actor removed from the registry" do
+      rval = Celluloid::Actor.delete(:marilyn)
+      expect(rval).to be_kind_of(Marilyn)
+    end
+  end
+
+  describe :clear do
+    it "should return a hash of registered actors and remove them from the registry" do
+      Celluloid::Actor[:marilyn] ||= Marilyn.new
+      rval = Celluloid::Actor.clear_registry
+      begin
+        expect(rval).to be_kind_of(Hash)
+        expect(rval).to have_key(:marilyn)
+        expect(rval[:marilyn].wrapped_object).to be_instance_of(Marilyn)
+        expect(Celluloid::Actor.registered).to be_empty
+      ensure
+        # Repopulate the registry once we're done
+        rval.each { |key, actor| Celluloid::Actor[key] = actor }
+      end
+    end
+  end
+end

data/spec/celluloid/internals/stack/dump_spec.rb

@@ -0,0 +1,4 @@
+RSpec.describe Celluloid::Internals::Stack::Dump do
+  subject { actor_system.stack_dump }
+  it_behaves_like "a Celluloid Stack"
+end

data/spec/celluloid/internals/stack/summary_spec.rb

@@ -0,0 +1,4 @@
+RSpec.describe Celluloid::Internals::Stack::Summary do
+  subject { actor_system.stack_summary }
+  it_behaves_like "a Celluloid Stack"
+end

data/spec/celluloid/internals/thread_handle_spec.rb

@@ -0,0 +1,60 @@
+RSpec.describe Celluloid::Internals::ThreadHandle do
+  let(:actor_system) { Celluloid::Actor::System.new }
+  after { actor_system.shutdown }
+
+  context "given a living thread" do
+    let(:args) { [actor_system] }
+
+    before do
+      @thread = nil
+      @thread_info_queue = Queue.new
+      @handle = Celluloid::Internals::ThreadHandle.new(*args) do
+        @thread_info_queue << Thread.current
+        sleep
+      end
+      @thread = Timeout.timeout(2) { @thread_info_queue.pop }
+    end
+
+    it "knows the thread is alive" do
+      alive = @handle.alive?
+      if @thread
+        @thread.kill
+        @thread.join
+      else
+        STDERR.puts "NOTE: something failed - thread missing"
+      end
+      expect(alive).to be(true)
+    end
+
+    context "when a role is provided" do
+      let(:args) { [actor_system, :useful] }
+
+      it "can be retrieved from thread directly" do
+        role = @thread.role
+        if @thread
+          @thread.kill
+          @thread.join
+        else
+          STDERR.puts "NOTE: something failed - thread missing"
+        end
+        expect(role).to eq(:useful)
+      end
+    end
+  end
+
+  context "given a finished thread" do
+    before do
+      thread_info_queue = Queue.new
+      @handle = Celluloid::Internals::ThreadHandle.new(actor_system) do
+        thread_info_queue << Thread.current
+      end
+      thread = thread_info_queue.pop
+      thread.kill
+      Specs.sleep_and_wait_until { !thread.alive? }
+    end
+
+    it "knows the thread is no longer alive" do
+      expect(@handle).not_to be_alive
+    end
+  end
+end

data/spec/celluloid/internals/uuid_spec.rb

@@ -0,0 +1,9 @@
+RSpec.describe Celluloid::Internals::UUID do
+  U = Celluloid::Internals::UUID
+
+  it "generates unique IDs across the BLOCK_SIZE boundary" do
+    upper_bound = U::BLOCK_SIZE * 2 + 10
+    uuids = (1..upper_bound).map { U.generate }
+    expect(uuids.size).to eq(uuids.uniq.size)
+  end
+end

data/spec/celluloid/logging/ring_buffer_spec.rb

@@ -0,0 +1,36 @@
+RSpec.describe Celluloid::RingBuffer do
+  subject { Celluloid::RingBuffer.new(2) }
+
+  it { is_expected.to be_empty }
+  it { is_expected.not_to be_full }
+
+  it "should push and shift" do
+    subject.push("foo")
+    subject.push("foo2")
+    expect(subject.shift).to eq("foo")
+    expect(subject.shift).to eq("foo2")
+  end
+
+  it "should push past the end" do
+    subject.push("foo")
+    subject.push("foo2")
+    subject.push("foo3")
+    expect(subject).to be_full
+  end
+
+  it "should shift the most recent" do
+    (1..5).each { |i| subject.push(i) }
+    expect(subject.shift).to be 4
+    expect(subject.shift).to be 5
+    expect(subject.shift).to be_nil
+  end
+
+  it "should return nil when shifting empty" do
+    expect(subject).to be_empty
+    expect(subject.shift).to be_nil
+  end
+
+  it "should be thread-safe" do
+    # TODO: how to test?
+  end
+end

data/spec/celluloid/mailbox/evented_spec.rb

@@ -2,36 +2,25 @@ RSpec.describe Celluloid::Mailbox::Evented do
   subject { TestEventedMailbox.new }
   it_behaves_like "a Celluloid Mailbox"
 
-  # NOTE: this example seems too exotic to "have to" succeed on RBX, though I
-  # don't know why it hangs on subject.receive and the timeout never occurs
-  #
-  # Other than
-  #
-  # Links:
-  #   https://github.com/celluloid/celluloid-io/pull/98
-  #   https://github.com/celluloid/celluloid-io/issues/56
-  #
-  unless RUBY_ENGINE == "rbx"
-    it "recovers from timeout exceeded to process mailbox message" do
-      timeout_interval = Specs::TIMER_QUANTUM + 0.1
-      started_at = Time.now
-      expect do
-        Kernel.send(:timeout, timeout_interval) do
-          subject.receive { false }
-        end
-      end.to raise_exception(Timeout::Error)
+  it "recovers from timeout exceeded to process mailbox message" do
+    timeout_interval = Specs::TIMER_QUANTUM + 0.1
+    started_at = Time.now
+    expect do
+      ::Timeout.timeout(timeout_interval) do
+        subject.receive { false }
+      end
+    end.to raise_exception(Timeout::Error)
 
-      expect(Time.now - started_at).to be_within(Specs::TIMER_QUANTUM).of timeout_interval
-    end
+    expect(Time.now - started_at).to be_within(Specs::TIMER_QUANTUM).of timeout_interval
   end
 
   it "discard messages when reactor wakeup fails" do
-    expect(Celluloid::Internals::Logger).to receive(:crash).with('reactor crashed', RuntimeError)
+    expect(Celluloid::Internals::Logger).to receive(:crash).with("reactor crashed", RuntimeError)
     expect(Celluloid.logger).to receive(:debug).with("Discarded message (mailbox is dead): first")
 
     bad_reactor = Class.new do
       def wakeup
-        fail
+        raise
       end
     end
     mailbox = Celluloid::Mailbox::Evented.new(bad_reactor)

data/spec/celluloid/misc/leak_spec.rb

@@ -13,11 +13,10 @@ RSpec.describe "Leaks", actor_system: :global, leaktest: true,
       []
     end
 
-    def terminate
-    end
+    def terminate; end
   end
 
-  def wait_for_release(weak, _what, count=1000)
+  def wait_for_release(weak, _what, count = 1000)
     trash = []
     count.times do |step|
       GC.start
@@ -43,7 +42,7 @@ RSpec.describe "Leaks", actor_system: :global, leaktest: true,
   end
 
   context "celluloid actor" do
-    it "is properly destroyed upon termination" do
+    xit "is properly destroyed upon termination" do
       actor_life("actor") do |actor|
         WeakRef.new actor
       end