celluloid 0.13.0 → 0.14.1

data/spec/support/actor_examples.rb

@@ -1,13 +1,22 @@
-shared_context "a Celluloid Actor" do |included_module|
+shared_examples "a Celluloid Actor" do |included_module|
+  describe "using Fibers" do
+    include_examples "Celluloid::Actor examples", included_module, Celluloid::TaskFiber
+  end
+  describe "using Threads" do
+    include_examples "Celluloid::Actor examples", included_module, Celluloid::TaskThread
+  end
+end
+
+shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
   class ExampleCrash < StandardError
     attr_accessor :foo
   end
 
-  let(:actor_class) { ExampleActorClass.create(included_module) }
+  let(:actor_class) { ExampleActorClass.create(included_module, task_klass) }
 
   it "returns the actor's class, not the proxy's" do
     actor = actor_class.new "Troy McClure"
-    actor.class.should == actor_class
+    actor.class.should eq(actor_class)
   end
 
   it "compares with the actor's class in a case statement" do
@@ -21,13 +30,13 @@ shared_context "a Celluloid Actor" do |included_module|
 
   it "can be stored in hashes" do
     actor = actor_class.new "Troy McClure"
-    actor.hash.should_not == Kernel.hash
-    actor.object_id.should_not == Kernel.object_id
+    actor.hash.should_not eq(Kernel.hash)
+    actor.object_id.should_not eq(Kernel.object_id)
   end
 
   it "supports synchronous calls" do
     actor = actor_class.new "Troy McClure"
-    actor.greet.should == "Hi, I'm Troy McClure"
+    actor.greet.should eq("Hi, I'm Troy McClure")
   end
 
   it "supports synchronous calls with blocks" do
@@ -40,32 +49,33 @@ shared_context "a Celluloid Actor" do |included_module|
 
   it "supports synchronous calls via #method" do
     method = actor_class.new("Troy McClure").method(:greet)
-    method.call.should == "Hi, I'm Troy McClure"
+    method.call.should eq("Hi, I'm Troy McClure")
   end
 
   it "supports #arity calls via #method" do
     method = actor_class.new("Troy McClure").method(:greet)
-    method.arity.should == 0
+    method.arity.should be(0)
 
     method = actor_class.new("Troy McClure").method(:change_name)
-    method.arity.should == 1
+    method.arity.should be(1)
   end
 
   it "supports future(:method) syntax for synchronous future calls" do
     actor = actor_class.new "Troy McClure"
     future = actor.future :greet
-    future.value.should == "Hi, I'm Troy McClure"
+    future.value.should eq("Hi, I'm Troy McClure")
   end
 
   it "supports future.method syntax for synchronous future calls" do
     actor = actor_class.new "Troy McClure"
     future = actor.future.greet
-    future.value.should == "Hi, I'm Troy McClure"
+    future.value.should eq("Hi, I'm Troy McClure")
   end
 
   it "handles circular synchronous calls" do
     klass = Class.new do
       include included_module
+      task_class task_klass
 
       def greet_by_proxy(actor)
         actor.greet
@@ -78,13 +88,13 @@ shared_context "a Celluloid Actor" do |included_module|
 
     ponycopter = klass.new
     actor = actor_class.new ponycopter
-    ponycopter.greet_by_proxy(actor).should == "Hi, I'm a ponycopter!"
+    ponycopter.greet_by_proxy(actor).should eq("Hi, I'm a ponycopter!")
   end
 
   it "properly handles method_missing" do
     actor = actor_class.new "Method Missing"
     actor.should respond_to(:first)
-    actor.first.should be == :bar
+    actor.first.should be :bar
   end
 
   it "properly handles respond_to with include_private" do
@@ -103,19 +113,19 @@ shared_context "a Celluloid Actor" do |included_module|
   it "supports async(:method) syntax for asynchronous calls" do
     actor = actor_class.new "Troy McClure"
     actor.async :change_name, "Charlie Sheen"
-    actor.greet.should == "Hi, I'm Charlie Sheen"
+    actor.greet.should eq("Hi, I'm Charlie Sheen")
   end
 
   it "supports async.method syntax for asynchronous calls" do
     actor = actor_class.new "Troy McClure"
     actor.async.change_name "Charlie Sheen"
-    actor.greet.should == "Hi, I'm Charlie Sheen"
+    actor.greet.should eq("Hi, I'm Charlie Sheen")
   end
 
   it "supports async.method syntax for asynchronous calls to itself" do
     actor = actor_class.new "Troy McClure"
     actor.change_name_async "Charlie Sheen"
-    actor.greet.should == "Hi, I'm Charlie Sheen"
+    actor.greet.should eq("Hi, I'm Charlie Sheen")
   end
 
   it "allows an actor to call private methods asynchronously" do
@@ -129,6 +139,9 @@ shared_context "a Celluloid Actor" do |included_module|
     actor = actor_class.new "Troy McClure"
     actor.run do
       Celluloid.actor?
+    end.should be_false
+    actor.run_on_receiver do
+      Celluloid.actor?
     end.should be_true
     actor.should be_actor
   end
@@ -144,7 +157,7 @@ shared_context "a Celluloid Actor" do |included_module|
   it "inspects properly when dead" do
     actor = actor_class.new "Troy McClure"
     actor.terminate
-    actor.inspect.should match(/Celluloid::Actor\(/)
+    actor.inspect.should match(/Celluloid::ActorProxy\(/)
     actor.inspect.should match(/#{actor_class}/)
     actor.inspect.should include('dead')
   end
@@ -164,7 +177,7 @@ shared_context "a Celluloid Actor" do |included_module|
 
   it "can override #send" do
     actor = actor_class.new "Troy McClure"
-    actor.send('foo').should == 'oof'
+    actor.send('foo').should eq('oof')
   end
 
   context "mocking methods" do
@@ -175,16 +188,16 @@ shared_context "a Celluloid Actor" do |included_module|
     end
 
     it "works externally via the proxy" do
-      actor.external_hello.should == "World"
+      actor.external_hello.should eq("World")
     end
 
     it "works internally when called on self" do
-      actor.internal_hello.should == "World"
+      actor.internal_hello.should eq("World")
     end
   end
 
   context :exceptions do
-    it "reraises exceptions which occur during synchronous calls in the caller" do
+    it "reraises exceptions which occur during synchronous calls in the sender" do
       actor = actor_class.new "James Dean" # is this in bad taste?
 
       expect do
@@ -192,9 +205,10 @@ shared_context "a Celluloid Actor" do |included_module|
       end.to raise_exception(ExampleCrash)
     end
 
-    it "includes both caller and receiver in exception traces" do
+    it "includes both sender and receiver in exception traces" do
       ExampleReceiver = Class.new do
         include included_module
+        task_class task_klass
 
         def receiver_method
           raise ExampleCrash, "the spec purposely crashed me :("
@@ -203,20 +217,21 @@ shared_context "a Celluloid Actor" do |included_module|
 
       ExampleCaller = Class.new do
         include included_module
+        task_class task_klass
 
-        def caller_method
+        def sender_method
           ExampleReceiver.new.receiver_method
         end
       end
 
       ex = nil
       begin
-        ExampleCaller.new.caller_method
+        ExampleCaller.new.sender_method
       rescue => ex
       end
 
       ex.should be_a ExampleCrash
-      ex.backtrace.grep(/`caller_method'/).should be_true
+      ex.backtrace.grep(/`sender_method'/).should be_true
       ex.backtrace.grep(/`receiver_method'/).should be_true
     end
 
@@ -231,7 +246,7 @@ shared_context "a Celluloid Actor" do |included_module|
   end
 
   context :abort do
-    it "raises exceptions in the caller but keeps running" do
+    it "raises exceptions in the sender but keeps running" do
       actor = actor_class.new "Al Pacino"
 
       expect do
@@ -248,7 +263,7 @@ shared_context "a Celluloid Actor" do |included_module|
       end.to raise_exception(RuntimeError, "foo")
     end
 
-    it "crashes the caller if we pass neither String nor Exception" do
+    it "crashes the sender if we pass neither String nor Exception" do
       actor = actor_class.new "Al Pacino"
       expect do
         actor.crash_with_abort_raw 10
@@ -317,6 +332,7 @@ shared_context "a Celluloid Actor" do |included_module|
     let(:supervisor_class) do
       Class.new do # like a boss
         include included_module
+        task_class task_klass
         trap_exit :lambaste_subordinate
 
         def initialize(name)
@@ -403,7 +419,7 @@ shared_context "a Celluloid Actor" do |included_module|
       end.to raise_exception(ExampleCrash)
 
       sleep 0.1 # hax to prevent a race between exit handling and the next call
-      chuck.links.count.should == 0
+      chuck.links.count.should be(0)
     end
   end
 
@@ -411,6 +427,7 @@ shared_context "a Celluloid Actor" do |included_module|
     before do
       @signaler = Class.new do
         include included_module
+        task_class task_klass
 
         def initialize
           @waiting  = false
@@ -466,7 +483,7 @@ shared_context "a Celluloid Actor" do |included_module|
       obj.should_not be_signaled
 
       obj.send_signal(:foobar).should be_true
-      future.value.should == :foobar
+      future.value.should be(:foobar)
     end
   end
 
@@ -474,6 +491,7 @@ shared_context "a Celluloid Actor" do |included_module|
     subject do
       Class.new do
         include included_module
+        task_class task_klass
 
         attr_reader :tasks
 
@@ -516,14 +534,14 @@ shared_context "a Celluloid Actor" do |included_module|
       subject.async.exclusive_with_block_log_task(:one)
       subject.async.log_task(:two)
       sleep Celluloid::TIMER_QUANTUM * 2
-      subject.tasks.should == [:one, :two]
+      subject.tasks.should eq([:one, :two])
     end
 
     it "executes methods in the proper order with a class-level annotation" do
       subject.async.exclusive_log_task :one
       subject.async.log_task :two
       sleep Celluloid::TIMER_QUANTUM * 2
-      subject.tasks.should == [:one, :two]
+      subject.tasks.should eq([:one, :two])
     end
 
     it "knows when it's in exclusive mode" do
@@ -540,6 +558,7 @@ shared_context "a Celluloid Actor" do |included_module|
     subject do
       Class.new do
         include included_module
+        task_class task_klass
         exclusive
 
         attr_reader :tasks
@@ -564,7 +583,7 @@ shared_context "a Celluloid Actor" do |included_module|
       actor.async.eat_donuts
       actor.async.drink_coffee
       sleep Celluloid::TIMER_QUANTUM * 2
-      actor.tasks.should == ['donuts', 'coffee']
+      actor.tasks.should eq(['donuts', 'coffee'])
     end
   end
 
@@ -572,6 +591,8 @@ shared_context "a Celluloid Actor" do |included_module|
     before do
       @receiver = Class.new do
         include included_module
+        task_class task_klass
+        execute_block_on_receiver :signal_myself
 
         def signal_myself(obj, &block)
           current_actor.mailbox << obj
@@ -584,12 +605,12 @@ shared_context "a Celluloid Actor" do |included_module|
     let(:message) { Object.new }
 
     it "allows unconditional receive" do
-      receiver.signal_myself(message).should == message
+      receiver.signal_myself(message).should eq(message)
     end
 
     it "allows arbitrary selective receive" do
       received_obj = receiver.signal_myself(message) { |o| o == message }
-      received_obj.should == message
+      received_obj.should eq(message)
     end
 
     it "times out after the given interval", :pending => ENV['CI'] do
@@ -605,6 +626,7 @@ shared_context "a Celluloid Actor" do |included_module|
     before do
       @klass = Class.new do
         include included_module
+        task_class task_klass
 
         def initialize
           @sleeping = false
@@ -653,9 +675,8 @@ shared_context "a Celluloid Actor" do |included_module|
       actor = @klass.new
 
       interval = Celluloid::TIMER_QUANTUM * 10
-      started_at = Time.now
 
-      timer = actor.fire_after(interval)
+      actor.fire_after(interval)
       actor.should_not be_fired
 
       sleep(interval + Celluloid::TIMER_QUANTUM) # wonky! #/
@@ -666,23 +687,21 @@ shared_context "a Celluloid Actor" do |included_module|
       actor = @klass.new
 
       interval = Celluloid::TIMER_QUANTUM * 10
-      started_at = Time.now
 
-      timer = actor.fire_every(interval)
-      actor.fired.should be == 0
+      actor.fire_every(interval)
+      actor.fired.should be_zero
 
       sleep(interval + Celluloid::TIMER_QUANTUM) # wonky! #/
-      actor.fired.should be == 1
+      actor.fired.should be 1
 
       2.times { sleep(interval + Celluloid::TIMER_QUANTUM) } # wonky! #/
-      actor.fired.should be == 3
+      actor.fired.should be 3
     end
 
     it "cancels timers before they fire" do
       actor = @klass.new
 
       interval = Celluloid::TIMER_QUANTUM * 10
-      started_at = Time.now
 
       timer = actor.fire_after(interval)
       actor.should_not be_fired
@@ -696,10 +715,9 @@ shared_context "a Celluloid Actor" do |included_module|
       actor = @klass.new
 
       interval = Celluloid::TIMER_QUANTUM * 10
-      started_at = Time.now
       fired = false
 
-      timer = actor.after(interval) do
+      actor.after(interval) do
         fired = true
       end
       fired.should be_false
@@ -713,6 +731,7 @@ shared_context "a Celluloid Actor" do |included_module|
     before do
       @klass = Class.new do
         include included_module
+        task_class task_klass
         attr_reader :blocker
 
         def initialize
@@ -741,21 +760,21 @@ shared_context "a Celluloid Actor" do |included_module|
       actor = @klass.new
 
       tasks = actor.tasks
-      tasks.size.should == 1
+      tasks.size.should be 1
 
-      future = actor.future(:blocking_call)
+      actor.future(:blocking_call)
       sleep 0.1 # hax! waiting for ^^^ call to actually start
 
       tasks = actor.tasks
-      tasks.size.should == 2
+      tasks.size.should be 2
 
       blocking_task = tasks.find { |t| t.status != :running }
-      blocking_task.should be_a Celluloid.task_class
-      blocking_task.status.should == :callwait
+      blocking_task.should be_a task_klass
+      blocking_task.status.should be :callwait
 
       actor.blocker.unblock
       sleep 0.1 # hax again :(
-      actor.tasks.size.should == 1
+      actor.tasks.size.should be 1
     end
   end
 
@@ -765,6 +784,7 @@ shared_context "a Celluloid Actor" do |included_module|
     subject do
       Class.new do
         include included_module
+        task_class task_klass
         mailbox_class ExampleMailbox
       end
     end
@@ -779,23 +799,42 @@ shared_context "a Celluloid Actor" do |included_module|
     end
   end
 
+  context :mailbox_limit do
+    subject do
+      Class.new do
+        include included_module
+        task_class task_klass
+        mailbox.max_size = 100
+      end
+    end
+
+    it "configures the mailbox limit" do
+      subject.new.mailbox.max_size.should == 100
+    end
+  end
+
   context :proxy_class do
-    class ExampleProxy < Celluloid::ActorProxy; end
+    class ExampleProxy < Celluloid::ActorProxy
+      def subclass_proxy?
+        true
+      end
+    end
 
     subject do
       Class.new do
         include included_module
+        task_class task_klass
         proxy_class ExampleProxy
       end
     end
 
     it "uses user-specified proxy" do
-      subject.new.__class__.should == ExampleProxy
+      subject.new.should be_subclass_proxy
     end
 
     it "retains custom proxy when subclassed" do
       subclass = Class.new(subject)
-      subclass.new.__class__.should == ExampleProxy
+      subclass.new.should be_subclass_proxy
     end
   end
 

data/spec/support/example_actor_class.rb

@@ -1,9 +1,11 @@
 module ExampleActorClass
-  def self.create(included_module)
+  def self.create(included_module, task_klass)
     Class.new do
       include included_module
+      task_class task_klass
       attr_reader :name
       finalizer :my_finalizer
+      execute_block_on_receiver :run_on_receiver
 
       def initialize(name)
         @name = name
@@ -30,6 +32,10 @@ module ExampleActorClass
         yield(*args)
       end
 
+      def run_on_receiver(*args)
+        yield(*args)
+      end
+
       def crash
         raise ExampleCrash, "the spec purposely crashed me :("
       end

data/spec/support/mailbox_examples.rb

@@ -25,9 +25,9 @@ shared_context "a Celluloid Mailbox" do
     subject << foo
     subject << bar
 
-    subject.receive { |msg| msg.is_a? Foo }.should == foo
-    subject.receive { |msg| msg.is_a? Bar }.should == bar
-    subject.receive.should == baz
+    subject.receive { |msg| msg.is_a? Foo }.should eq(foo)
+    subject.receive { |msg| msg.is_a? Bar }.should eq(bar)
+    subject.receive.should eq(baz)
   end
 
   it "waits for a given timeout interval" do
@@ -37,4 +37,30 @@ shared_context "a Celluloid Mailbox" do
     subject.receive(interval) { false }
     (Time.now - started_at).should be_within(Celluloid::TIMER_QUANTUM).of interval
   end
+
+  it "has a size" do
+    subject.should respond_to(:size)
+    subject.size.should be_zero
+    subject << :foo
+    subject << :foo
+    subject.size.should be 2
+  end
+
+  it "discards messages received when when full" do
+    subject.max_size = 2
+    subject << :first
+    subject << :second
+    subject << :third
+    subject.to_a.should =~ [:first, :second]
+  end
+
+  it "logs discarded messages" do
+    Celluloid.logger = mock.as_null_object
+    Celluloid.logger.should_receive(:debug).with("Discarded message: third")
+
+    subject.max_size = 2
+    subject << :first
+    subject << :second
+    subject << :third
+  end
 end

data/spec/support/task_examples.rb

@@ -1,12 +1,15 @@
-shared_context "a Celluloid Task" do |task_class|
-  class MockActor
-    attr_reader :tasks
+class MockActor
+  attr_reader :tasks
 
-    def initialize
-      @tasks = []
-    end
+  def initialize
+    @tasks = []
   end
 
+  def setup_thread
+  end
+end
+
+shared_context "a Celluloid Task" do |task_class|
   let(:task_type)     { :foobar }
   let(:suspend_state) { :doing_something }
   let(:actor)         { MockActor.new }
@@ -22,13 +25,13 @@ shared_context "a Celluloid Task" do |task_class|
   end
 
   it "begins with status :new" do
-    subject.status.should == :new
+    subject.status.should be :new
   end
 
   it "resumes" do
     subject.should be_running
     subject.resume
-    subject.status.should == suspend_state
+    subject.status.should eq(suspend_state)
     subject.resume
     subject.should_not be_running
   end
@@ -41,5 +44,4 @@ shared_context "a Celluloid Task" do |task_class|
       task.resume
     end.to raise_exception("failure")
   end
-
 end