celluloid 0.16.0 → 0.17.3

data/spec/celluloid/calls_spec.rb

@@ -1,42 +1,47 @@
-require 'spec_helper'
+RSpec.describe Celluloid::Call::Sync, actor_system: :global do
+  # TODO: these should be Call::Sync unit tests (without working on actual actors)
 
-describe Celluloid::SyncCall, actor_system: :global do
-  class CallExampleActor
-    include Celluloid
-
-    def initialize(next_actor = nil)
-      @next = next_actor
+  let(:actor) { CallExampleActor.new }
+  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)
+
+        expect do
+          actor.the_method_that_wasnt_there
+        end.to raise_exception(NoMethodError)
+      end
     end
 
-    def actual_method; end
+    context "when obj raises during inspect" do
+      it "should emulate obj.inspect" do
+        allow(logger).to receive(:crash).with("Actor crashed!", NoMethodError)
 
-    def chained_call_ids
-      [call_chain_id, @next.call_chain_id]
+        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
 
-  let(:actor) { CallExampleActor.new }
-
-  it "aborts with NoMethodError when a nonexistent method is called" do
-    expect do
-      actor.the_method_that_wasnt_there
-    end.to raise_exception(NoMethodError)
-
-    actor.should be_alive
-  end
-
   it "aborts with ArgumentError when a method is called with too many arguments" do
+    allow(logger).to receive(:crash).with("Actor crashed!", ArgumentError)
+
     expect do
       actor.actual_method("with too many arguments")
     end.to raise_exception(ArgumentError)
-
-    actor.should be_alive
   end
 
   it "preserves call chains across synchronous calls" do
     actor2 = CallExampleActor.new(actor)
 
     uuid, next_actor_uuid = actor2.chained_call_ids
-    uuid.should eq next_actor_uuid
+    expect(uuid).to eq next_actor_uuid
   end
 end

data/spec/celluloid/condition_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+RSpec.describe Celluloid::Condition, actor_system: :global do
+  let(:logger) { Specs::FakeLogger.current }
 
-describe Celluloid::Condition, actor_system: :global do
   class ConditionExample
     include Celluloid
 
@@ -9,7 +9,7 @@ describe Celluloid::Condition, actor_system: :global do
     def initialize
       @condition = Condition.new
 
-      @waiting  = false
+      @waiting = false
       @signaled_times = 0
     end
 
@@ -29,7 +29,9 @@ describe Celluloid::Condition, actor_system: :global do
       value
     end
 
-    def waiting?; @waiting end
+    def waiting?
+      @waiting
+    end
   end
 
   let(:actor) { ConditionExample.new }
@@ -37,40 +39,47 @@ describe Celluloid::Condition, actor_system: :global do
 
   it "sends signals" do
     3.times { actor.async.wait_for_condition }
-    actor.signaled_times.should be_zero
+    expect(actor.signaled_times).to be_zero
 
     actor.condition.signal
-    actor.signaled_times.should be(1)
+    expect(actor.signaled_times).to be(1)
   end
 
   it "broadcasts signals" do
     3.times { actor.async.wait_for_condition }
-    actor.signaled_times.should be_zero
+    expect(actor.signaled_times).to be_zero
 
     actor.condition.broadcast
-    actor.signaled_times.should be(3)
+    expect(actor.signaled_times).to be(3)
   end
 
   it "sends values along with signals" do
     future = actor.future(:wait_for_condition)
     actor.condition.signal(:example_value)
-    future.value.should be(:example_value)
+    expect(future.value).to be(:example_value)
+  end
+
+  it "supports running blocks with value once obtained" do
+    condition = Celluloid::Condition.new
+    actor.async.signal_condition condition, :value
+    expect(condition.wait { |value| "#{value} post-handled" }).to eq("value post-handled")
   end
 
   it "supports waiting outside actors" do
     condition = Celluloid::Condition.new
     actor.async.signal_condition condition, :value
-    condition.wait.should eq(:value)
+    expect(condition.wait).to eq(:value)
   end
 
   it "times out inside normal Threads" do
     condition = Celluloid::Condition.new
-    lambda { condition.wait(1) }.
-      should raise_error(Celluloid::ConditionError)
+    expect { condition.wait(1) }
+      .to raise_error(Celluloid::ConditionError)
   end
 
   it "times out inside Tasks" do
-    lambda { actor.wait_for_condition(1) }.
-      should raise_error(Celluloid::ConditionError)
+    allow(logger).to receive(:crash).with("Actor crashed!", Celluloid::ConditionError)
+    expect { actor.wait_for_condition(1) }
+      .to raise_error(Celluloid::ConditionError)
   end
 end

data/spec/celluloid/evented_mailbox_spec.rb

@@ -1,34 +1,4 @@
-require 'spec_helper'
-
-class TestEventedMailbox < Celluloid::EventedMailbox
-  class Reactor
-    def initialize
-      @condition = ConditionVariable.new
-      @mutex = Mutex.new
-    end
-
-    def wakeup
-      @mutex.synchronize do
-        @condition.signal
-      end
-    end
-
-    def run_once(timeout)
-      @mutex.synchronize do
-        @condition.wait(@mutex, timeout)
-      end
-    end
-
-    def shutdown
-    end
-  end
-
-  def initialize
-    super(Reactor)
-  end
-end
-
-describe Celluloid::EventedMailbox do
+RSpec.describe Celluloid::Mailbox::Evented do
   subject { TestEventedMailbox.new }
   it_behaves_like "a Celluloid Mailbox"
 end

data/spec/celluloid/future_spec.rb

@@ -1,32 +1,35 @@
-require 'spec_helper'
-
-describe Celluloid::Future, actor_system: :global do
+RSpec.describe Celluloid::Future, actor_system: :global do
   it "creates future objects that can be retrieved later" do
     future = Celluloid::Future.new { 40 + 2 }
-    future.value.should == 42
+    expect(future.value).to eq(42)
   end
 
   it "passes arguments to future blocks" do
     future = Celluloid::Future.new(40) { |n| n + 2 }
-    future.value.should == 42
+    expect(future.value).to eq(42)
   end
 
   it "reraises exceptions that occur when the value is retrieved" do
     class ExampleError < StandardError; end
 
-    future = Celluloid::Future.new { raise ExampleError, "oh noes crash!" }
+    future = Celluloid::Future.new { fail ExampleError, "oh noes crash!" }
     expect { future.value }.to raise_exception(ExampleError)
   end
 
   it "knows if it's got a value yet" do
-    future = Celluloid::Future.new { sleep Celluloid::TIMER_QUANTUM * 5 }
-    future.should_not be_ready
-    sleep Celluloid::TIMER_QUANTUM * 6
-    future.should be_ready
+    queue = Queue.new
+    future = Celluloid::Future.new { queue.pop }
+
+    expect(future).not_to be_ready
+    queue << nil # let it continue
+
+    Specs.sleep_and_wait_until { future.ready? }
+
+    expect(future).to be_ready
   end
 
-  it "raises TimeoutError when the future times out" do
+  it "raises TaskTimeout when the future times out" do
     future = Celluloid::Future.new { sleep 2 }
-    expect { future.value(1) }.to raise_exception(Celluloid::TimeoutError)
+    expect { future.value(1) }.to raise_exception(Celluloid::TaskTimeout)
   end
 end

data/spec/celluloid/group/pool_spec.rb

@@ -0,0 +1,8 @@
+# set logger early on
+require "celluloid/internals/logger"
+
+if Celluloid.group_class == Celluloid::Group::Pool
+  RSpec.describe Celluloid::Group::Pool do
+    it_behaves_like "a Celluloid Group"
+  end
+end

data/spec/celluloid/group/spawner_spec.rb

@@ -0,0 +1,17 @@
+# set logger early on
+require "celluloid/internals/logger"
+
+if Celluloid.group_class == Celluloid::Group::Spawner
+  RSpec.describe Celluloid::Group::Spawner do
+    it_behaves_like "a Celluloid Group"
+
+    it "does not leak finished threads" do
+      queue = Queue.new
+      th = subject.get { queue.pop }
+      expect do
+        queue << nil
+        th.join
+      end.to change { subject.group.length }.by(-1)
+    end
+  end
+end

data/spec/celluloid/mailbox/evented_spec.rb

@@ -0,0 +1,40 @@
+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)
+
+      expect(Time.now - started_at).to be_within(Specs::TIMER_QUANTUM).of timeout_interval
+    end
+  end
+
+  it "discard messages when reactor wakeup fails" do
+    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
+      end
+    end
+    mailbox = Celluloid::Mailbox::Evented.new(bad_reactor)
+    mailbox << :first
+  end
+end

data/spec/celluloid/mailbox_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
-describe Celluloid::Mailbox do
+RSpec.describe Celluloid::Mailbox do
   it_behaves_like "a Celluloid Mailbox"
 end

data/spec/celluloid/misc/leak_spec.rb

@@ -0,0 +1,73 @@
+require "weakref"
+
+RSpec.describe "Leaks", actor_system: :global, leaktest: true,
+                        skip: !ENV["CELLULOID_LEAKTEST"] && "leak test disabled" do
+  class LeakActor
+    include Celluloid
+
+    def initialize(arg)
+      @arg = arg
+    end
+
+    def call(_arg)
+      []
+    end
+
+    def terminate
+    end
+  end
+
+  def wait_for_release(weak, _what, count=1000)
+    trash = []
+    count.times do |step|
+      GC.start
+      return true unless weak.weakref_alive?
+      trash << "*" * step
+    end
+
+    false
+  end
+
+  def do_actor(what)
+    actor = LeakActor.new what
+    weak = yield actor
+    actor.terminate
+    actor = nil
+    weak
+  end
+
+  def actor_life(what, &block)
+    GC.start
+    weak = do_actor what, &block
+    expect(wait_for_release(weak, what)).to be_truthy
+  end
+
+  context "celluloid actor" do
+    it "is properly destroyed upon termination" do
+      actor_life("actor") do |actor|
+        WeakRef.new actor
+      end
+    end
+  end
+
+  context "celluloid actor call" do
+    it "does not hold a reference its arguments on completion" do
+      actor_life("call-arg") do |actor|
+        arg = []
+        actor.call arg
+        weak = WeakRef.new arg
+        arg = nil
+        weak
+      end
+    end
+
+    it "does not hold a reference to the return value" do
+      actor_life("call-result") do |actor|
+        result = actor.call nil
+        weak = WeakRef.new result
+        result = nil
+        weak
+      end
+    end
+  end
+end

data/spec/celluloid/proxy_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe Celluloid::Proxy::Abstract do
+	around do |ex|
+		Celluloid.boot
+		ex.run
+		Celluloid.shutdown
+	end
+
+	let(:task_klass) { Celluloid.task_class }
+	let(:actor_class) { ExampleActorClass.create(CelluloidSpecs.included_module, task_klass) }
+	let(:actor) { actor_class.new "Troy McClure" }
+
+	let(:logger) { Specs::FakeLogger.current }
+	
+	it "should be eql? to self" do
+		expect(actor.eql? actor).to be_truthy
+	end
+	
+	it "should be eql? to self even if dead" do
+		actor.terminate
+		expect(actor.eql? actor).to be_truthy
+	end
+	
+	it "should not be eql? to other proxy objects" do
+		other_future = Celluloid::Proxy::Future.new(actor.mailbox, actor.__klass__)
+		
+		expect(actor.future.eql? other_future).to be_truthy
+	end
+	
+	it "should be possible to compare with non-proxy objects" do
+		expect(actor.eql? "string").to be_falsey
+		expect("string".eql? actor).to be_falsey
+	end
+end

data/spec/celluloid/task/fibered_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe Celluloid::Task::Fibered, actor_system: :within do
+  if Celluloid.task_class == Celluloid::Task::Fibered
+    it_behaves_like "a Celluloid Task"
+  end
+end

data/spec/celluloid/task/threaded_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe Celluloid::Task::Threaded, actor_system: :within do
+  if Celluloid.task_class == Celluloid::Task::Threaded
+    it_behaves_like "a Celluloid Task"
+  end
+end

data/spec/celluloid/timer_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 class EveryActor
   include Celluloid
 
@@ -7,39 +5,39 @@ class EveryActor
     @trace = []
     @times = []
     @start = Time.now
-    
+
     every(1) { log(1) }
     every(2) { log(2) }
     every(1) { log(11) }
     every(2) { log(22) }
   end
-  
+
   def log(t)
     @trace << t
-    
+
     offset = Time.now - @start
     @times << offset
-    
+
     # puts "log(#{t}) @ #{offset}"
   end
-  
-  attr :trace
-  attr :times
+
+  attr_reader :trace
+  attr_reader :times
 end
 
-describe Celluloid::Actor do
+RSpec.describe "Celluloid::Actor timers" do
   it "run every(t) task several times" do
     Celluloid.boot
-    
+
     every_actor = EveryActor.new
-    
+
     sleep 5.5
-    
-    times = every_actor.times
+
+    every_actor.times
     trace = every_actor.trace
-    
+
     Celluloid.shutdown
-    
+
     expect(trace.count(1)).to be == 5
     expect(trace.count(11)).to be == 5
     expect(trace.count(2)).to be == 2

data/spec/deprecate/actor_system_spec.rb

@@ -0,0 +1,72 @@
+RSpec.describe "Deprecated Celluloid::ActorSystem" do
+  subject { Celluloid::ActorSystem.new }
+
+  class DeprecatedTestActor
+    include Celluloid
+  end
+
+  it "supports non-global ActorSystem" do
+    subject.within do
+      expect(Celluloid.actor_system).to eq(subject)
+    end
+  end
+
+  it "starts default actors" do
+    subject.start
+    expect(subject.registered).to eq(Celluloid::ActorSystem::ROOT_SERVICES.map { |r| r[:as] })
+    subject.shutdown
+  end
+
+  it "support getting threads" do
+    subject.start
+    queue = Queue.new
+    thread = subject.get_thread do
+      expect(Celluloid.actor_system).to eq(subject)
+      queue << nil
+    end
+    queue.pop
+    subject.shutdown
+  end
+
+  it "allows a stack dump" do
+    expect(subject.stack_dump).to be_a(Celluloid::StackDump)
+  end
+
+  it "returns named actors" do
+    subject.start
+
+    subject.within do
+      DeprecatedTestActor.supervise_as :test
+    end
+
+    expect(subject.registered).to include(:test)
+    subject.shutdown
+  end
+
+  it "returns running actors" do
+    expect(subject.running).to be_empty
+
+    first = subject.within do
+      DeprecatedTestActor.new
+    end
+
+    second = subject.within do
+      DeprecatedTestActor.new
+    end
+
+    expect(subject.running).to eq([first, second])
+    subject.shutdown
+  end
+
+  it "shuts down" do
+    subject.shutdown
+
+    expect { subject.get_thread }
+      .to raise_error(Celluloid::NotActive)
+  end
+
+  it "warns nicely when no actor system is started" do
+    expect { DeprecatedTestActor.new }
+      .to raise_error("Celluloid is not yet started; use Celluloid.boot")
+  end
+end unless $CELLULOID_BACKPORTED == false

data/spec/deprecate/block_spec.rb

@@ -0,0 +1,52 @@
+RSpec.describe "Deprecated Blocks", actor_system: :global do
+  class DeprecatedBlockActor
+    include Celluloid
+
+    def initialize(name)
+      @name = name
+    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)
+        "somevalue"
+      end
+    end
+
+    def do_something_and_callback
+      $data << [:something, @name, current_actor.name]
+      $data << yield(:foo)
+    end
+
+    def receive_result(result)
+      [result, @name, current_actor.name]
+    end
+  end
+
+  it "works" do
+    $data = []
+
+    a1 = DeprecatedBlockActor.new("one")
+    a2 = DeprecatedBlockActor.new("two")
+
+    a1.ask_for_something a2
+
+    expected = [
+      [:outside, "one", "one"],
+      [:something, "two", "two"],
+      [:yielded, "one", "one"],
+      [:self, "one", "one"],
+      [:current_actor, "one", "one"],
+      [:sender, "one", "one"],
+      "somevalue",
+    ]
+
+    expect($data).to eq(expected)
+  end
+end unless $CELLULOID_BACKPORTED == false

data/spec/deprecate/calls_spec.rb

@@ -0,0 +1,39 @@
+RSpec.describe "Deprecated Celluloid::SyncCall", actor_system: :global do
+  subject { Celluloid::SyncCall.new }
+
+  let(:actor) { DeprecatedCallExampleActor.new }
+
+  context "when obj does not respond to a method" do
+    it "raises a NoMethodError" do
+      expect do
+        actor.the_method_that_wasnt_there
+      end.to raise_exception(NoMethodError)
+      expect(actor).to be_alive
+    end
+
+    context "when obj raises during inspect" do
+      it "should emulate obj.inspect" do
+        expect(actor).to_not receive(:inspect)
+        expect { actor.no_such_method }.to raise_exception(
+          NoMethodError,
+          /undefined method `no_such_method' for #\<DeprecatedCallExampleActor:0x[a-f0-9]+>/,
+        )
+      end
+    end
+  end
+
+  it "aborts with ArgumentError when a method is called with too many arguments" do
+    expect do
+      actor.actual_method("with too many arguments")
+    end.to raise_exception(ArgumentError)
+
+    expect(actor).to be_alive
+  end
+
+  it "preserves call chains across synchronous calls" do
+    actor2 = DeprecatedCallExampleActor.new(actor)
+
+    uuid, next_actor_uuid = actor2.chained_call_ids
+    expect(uuid).to eq next_actor_uuid
+  end
+end unless $CELLULOID_BACKPORTED == false