celluloid 0.12.0 → 0.13.0

data/spec/support/actor_examples.rb

@@ -30,11 +30,27 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.greet.should == "Hi, I'm Troy McClure"
   end
 
+  it "supports synchronous calls with blocks" do
+    actor = actor_class.new "Blocky Ralboa"
+
+    block_executed = false
+    actor.run { block_executed = true }
+    block_executed.should be_true
+  end
+
   it "supports synchronous calls via #method" do
     method = actor_class.new("Troy McClure").method(:greet)
     method.call.should == "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 = actor_class.new("Troy McClure").method(:change_name)
+    method.arity.should == 1
+  end
+
   it "supports future(:method) syntax for synchronous future calls" do
     actor = actor_class.new "Troy McClure"
     future = actor.future :greet
@@ -77,75 +93,11 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.respond_to?(:zomg_private, true).should be_true
   end
 
-  it "raises NoMethodError when a nonexistent method is called" do
-    actor = actor_class.new "Billy Bob Thornton"
-
-    expect do
-      actor.the_method_that_wasnt_there
-    end.to raise_exception(NoMethodError)
-  end
-
-  it "reraises exceptions which occur during synchronous calls in the caller" do
-    actor = actor_class.new "James Dean" # is this in bad taste?
-
-    expect do
-      actor.crash
-    end.to raise_exception(ExampleCrash)
-  end
-
-  describe "when #abort is called" do
-    it "raises exceptions in the caller but keeps running" do
-      actor = actor_class.new "Al Pacino"
-
-      e = nil
-      line_no = nil
-
-      expect do
-        begin
-          line_no = __LINE__; actor.crash_with_abort "You die motherfucker!", :bar
-        rescue => ex
-          e = ex
-          raise
-        end
-      end.to raise_exception(ExampleCrash, "You die motherfucker!")
-
-      e.backtrace.any? { |line| line.include?([__FILE__, line_no].join(':')) }.should be_true # Check the backtrace is appropriate to the caller
-      e.foo.should be == :bar # Check the exception maintains instance variables
-
-      actor.should be_alive
-    end
-
-    it "converts strings to runtime errors" do
-      actor = actor_class.new "Al Pacino"
-      expect do
-        actor.crash_with_abort_raw "foo"
-      end.to raise_exception(RuntimeError, "foo")
-    end
-
-    it "crashes the caller if we pass neither String nor Exception" do
-      actor = actor_class.new "Al Pacino"
-      expect do
-        actor.crash_with_abort_raw 10
-      end.to raise_exception(TypeError, "Exception object/String expected, but Fixnum received")
-
-      actor.greet rescue nil # Ensure our actor has died.
-      actor.should_not be_alive
-    end
-  end
-
-  it "raises DeadActorError if methods are synchronously called on a dead actor" do
-    actor = actor_class.new "James Dean"
-    actor.crash rescue nil
-
-    expect do
-      actor.greet
-    end.to raise_exception(Celluloid::DeadActorError)
-  end
-
-  it "supports method! syntax for asynchronous calls" do
-    actor = actor_class.new "Troy McClure"
-    actor.change_name! "Charlie Sheen"
-    actor.greet.should == "Hi, I'm Charlie Sheen"
+  it "calls the user defined finalizer" do
+    actor = actor_class.new "Mr. Bean"
+    actor.wrapped_object.should_receive(:my_finalizer)
+    actor.terminate
+    Celluloid::Actor.join(actor)
   end
 
   it "supports async(:method) syntax for asynchronous calls" do
@@ -160,19 +112,13 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.greet.should == "Hi, I'm Charlie Sheen"
   end
 
-  it "supports method! syntax for asynchronous calls to itself" do
-    actor = actor_class.new "Troy McClure"
-    actor.change_name_with_a_bang "Charlie Sheen"
-    actor.greet.should == "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"
   end
 
-  it "allows an actor to call private methods asynchronously with a bang" do
+  it "allows an actor to call private methods asynchronously" do
     actor = actor_class.new "Troy McClure"
     actor.call_private
     actor.private_called.should be_true
@@ -184,11 +130,12 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.run do
       Celluloid.actor?
     end.should be_true
+    actor.should be_actor
   end
 
   it "inspects properly" do
     actor = actor_class.new "Troy McClure"
-    actor.inspect.should match(/Celluloid::Actor\(/)
+    actor.inspect.should match(/Celluloid::ActorProxy\(/)
     actor.inspect.should match(/#{actor_class}/)
     actor.inspect.should include('@name="Troy McClure"')
     actor.inspect.should_not include("@celluloid")
@@ -207,22 +154,111 @@ shared_context "a Celluloid Actor" do |included_module|
     actor.wrapped_object.should be_a actor_class
   end
 
-  describe 'mocking methods' do
+  it "warns about leaked wrapped objects via #inspect" do
+    actor = actor_class.new "Troy McClure"
+
+    actor.inspect.should_not include Celluloid::BARE_OBJECT_WARNING_MESSAGE
+    actor.inspect_thunk.should_not include Celluloid::BARE_OBJECT_WARNING_MESSAGE
+    actor.wrapped_object.inspect.should include Celluloid::BARE_OBJECT_WARNING_MESSAGE
+  end
+
+  it "can override #send" do
+    actor = actor_class.new "Troy McClure"
+    actor.send('foo').should == 'oof'
+  end
+
+  context "mocking methods" do
     let(:actor) { actor_class.new "Troy McClure" }
 
     before do
       actor.wrapped_object.should_receive(:external_hello).once.and_return "World"
     end
 
-    it 'works externally via the proxy' do
+    it "works externally via the proxy" do
       actor.external_hello.should == "World"
     end
 
-    it 'works internally when called on self' do
+    it "works internally when called on self" do
       actor.internal_hello.should == "World"
     end
   end
 
+  context :exceptions do
+    it "reraises exceptions which occur during synchronous calls in the caller" do
+      actor = actor_class.new "James Dean" # is this in bad taste?
+
+      expect do
+        actor.crash
+      end.to raise_exception(ExampleCrash)
+    end
+
+    it "includes both caller and receiver in exception traces" do
+      ExampleReceiver = Class.new do
+        include included_module
+
+        def receiver_method
+          raise ExampleCrash, "the spec purposely crashed me :("
+        end
+      end
+
+      ExampleCaller = Class.new do
+        include included_module
+
+        def caller_method
+          ExampleReceiver.new.receiver_method
+        end
+      end
+
+      ex = nil
+      begin
+        ExampleCaller.new.caller_method
+      rescue => ex
+      end
+
+      ex.should be_a ExampleCrash
+      ex.backtrace.grep(/`caller_method'/).should be_true
+      ex.backtrace.grep(/`receiver_method'/).should be_true
+    end
+
+    it "raises DeadActorError if methods are synchronously called on a dead actor" do
+      actor = actor_class.new "James Dean"
+      actor.crash rescue nil
+
+      expect do
+        actor.greet
+      end.to raise_exception(Celluloid::DeadActorError)
+    end
+  end
+
+  context :abort do
+    it "raises exceptions in the caller but keeps running" do
+      actor = actor_class.new "Al Pacino"
+
+      expect do
+        actor.crash_with_abort "You die motherfucker!", :bar
+      end.to raise_exception(ExampleCrash, "You die motherfucker!")
+
+      actor.should be_alive
+    end
+
+    it "converts strings to runtime errors" do
+      actor = actor_class.new "Al Pacino"
+      expect do
+        actor.crash_with_abort_raw "foo"
+      end.to raise_exception(RuntimeError, "foo")
+    end
+
+    it "crashes the caller if we pass neither String nor Exception" do
+      actor = actor_class.new "Al Pacino"
+      expect do
+        actor.crash_with_abort_raw 10
+      end.to raise_exception(TypeError, "Exception object/String expected, but Fixnum received")
+
+      Celluloid::Actor.join(actor)
+      actor.should_not be_alive
+    end
+  end
+
   context :termination do
     it "terminates" do
       actor = actor_class.new "Arnold Schwarzenegger"
@@ -232,7 +268,7 @@ shared_context "a Celluloid Actor" do |included_module|
       actor.should_not be_alive
     end
 
-    it "kills" do
+    it "kills" do # THOU SHALT ALWAYS KILL
       actor = actor_class.new "Woody Harrelson"
       actor.should be_alive
       Celluloid::Actor.kill(actor)
@@ -262,7 +298,7 @@ shared_context "a Celluloid Actor" do |included_module|
   context :current_actor do
     it "knows the current actor" do
       actor = actor_class.new "Roger Daltrey"
-      actor.current_actor.should == actor
+      actor.current_actor.should eq actor
     end
 
     it "raises NotActorError if called outside an actor" do
@@ -278,6 +314,24 @@ shared_context "a Celluloid Actor" do |included_module|
       @charlie = actor_class.new "Charlie Sheen"
     end
 
+    let(:supervisor_class) do
+      Class.new do # like a boss
+        include included_module
+        trap_exit :lambaste_subordinate
+
+        def initialize(name)
+          @name = name
+          @subordinate_lambasted = false
+        end
+
+        def subordinate_lambasted?; @subordinate_lambasted; end
+
+        def lambaste_subordinate(actor, reason)
+          @subordinate_lambasted = true
+        end
+      end
+    end
+
     it "links to other actors" do
       @kevin.link @charlie
       @kevin.monitoring?(@charlie).should be_true
@@ -316,23 +370,20 @@ shared_context "a Celluloid Actor" do |included_module|
     end
 
     it "traps exit messages from other actors" do
-      boss = Class.new do # like a boss
-        include included_module
-        trap_exit :lambaste_subordinate
-
-        def initialize(name)
-          @name = name
-          @subordinate_lambasted = false
-        end
+      chuck = supervisor_class.new "Chuck Lorre"
+      chuck.link @charlie
 
-        def subordinate_lambasted?; @subordinate_lambasted; end
+      expect do
+        @charlie.crash
+      end.to raise_exception(ExampleCrash)
 
-        def lambaste_subordinate(actor, reason)
-          @subordinate_lambasted = true
-        end
-      end
+      sleep 0.1 # hax to prevent a race between exit handling and the next call
+      chuck.should be_subordinate_lambasted
+    end
 
-      chuck = boss.new "Chuck Lorre"
+    it "traps exit messages from other actors in subclasses" do
+      supervisor_subclass = Class.new(supervisor_class)
+      chuck = supervisor_subclass.new "Chuck Lorre"
       chuck.link @charlie
 
       expect do
@@ -342,6 +393,18 @@ shared_context "a Celluloid Actor" do |included_module|
       sleep 0.1 # hax to prevent a race between exit handling and the next call
       chuck.should be_subordinate_lambasted
     end
+
+    it "unlinks from a dead linked actor" do
+      chuck = supervisor_class.new "Chuck Lorre"
+      chuck.link @charlie
+
+      expect do
+        @charlie.crash
+      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
+    end
   end
 
   context :signaling do
@@ -385,7 +448,7 @@ shared_context "a Celluloid Actor" do |included_module|
       obj = @signaler.new
       obj.should_not be_signaled
 
-      obj.wait_for_signal!
+      obj.async.wait_for_signal
       obj.should_not be_signaled
 
       obj.send_signal :foobar
@@ -411,15 +474,65 @@ shared_context "a Celluloid Actor" do |included_module|
     subject do
       Class.new do
         include included_module
-        def exclusive_example
-          exclusive?
+
+        attr_reader :tasks
+
+        def initialize
+          @tasks = []
+        end
+
+        def log_task(task)
+          @tasks << task
+        end
+
+        def exclusive_with_block_log_task(task)
+          exclusive do
+            sleep Celluloid::TIMER_QUANTUM
+            log_task(task)
+          end
+        end
+
+        def exclusive_log_task(task)
+          sleep Celluloid::TIMER_QUANTUM
+          log_task(task)
+        end
+        exclusive :exclusive_log_task
+
+        def check_not_exclusive
+          Celluloid.exclusive?
+        end
+
+        def check_exclusive
+          exclusive { Celluloid.exclusive? }
+        end
+
+        def nested_exclusive_example
+          exclusive { exclusive { nil }; Celluloid.exclusive? }
         end
-        exclusive :exclusive_example
       end.new
     end
 
-    it "supports exclusive methods" do
-      subject.exclusive_example.should be_true
+    it "executes methods in the proper order with block form" do
+      subject.async.exclusive_with_block_log_task(:one)
+      subject.async.log_task(:two)
+      sleep Celluloid::TIMER_QUANTUM * 2
+      subject.tasks.should == [: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]
+    end
+
+    it "knows when it's in exclusive mode" do
+      subject.check_not_exclusive.should be_false
+      subject.check_exclusive.should be_true
+    end
+
+    it "remains in exclusive mode inside nested blocks" do
+      subject.nested_exclusive_example.should be_true
     end
   end
 
@@ -448,8 +561,8 @@ shared_context "a Celluloid Actor" do |included_module|
 
     it "executes two methods in an exclusive order" do
       actor = subject.new
-      actor.eat_donuts!
-      actor.drink_coffee!
+      actor.async.eat_donuts
+      actor.async.drink_coffee
       sleep Celluloid::TIMER_QUANTUM * 2
       actor.tasks.should == ['donuts', 'coffee']
     end
@@ -489,7 +602,6 @@ shared_context "a Celluloid Actor" do |included_module|
   end
 
   context :timers do
-
     before do
       @klass = Class.new do
         include included_module
@@ -579,6 +691,22 @@ shared_context "a Celluloid Actor" do |included_module|
       sleep(interval + Celluloid::TIMER_QUANTUM) # wonky! #/
       actor.should_not be_fired
     end
+
+    it "allows delays from outside the actor" do
+      actor = @klass.new
+
+      interval = Celluloid::TIMER_QUANTUM * 10
+      started_at = Time.now
+      fired = false
+
+      timer = actor.after(interval) do
+        fired = true
+      end
+      fired.should be_false
+
+      sleep(interval + Celluloid::TIMER_QUANTUM) # wonky! #/
+      fired.should be_true
+    end
   end
 
   context :tasks do
@@ -631,13 +759,13 @@ shared_context "a Celluloid Actor" do |included_module|
     end
   end
 
-  context :use_mailbox do
+  context :mailbox_class do
     class ExampleMailbox < Celluloid::Mailbox; end
 
     subject do
       Class.new do
         include included_module
-        use_mailbox ExampleMailbox
+        mailbox_class ExampleMailbox
       end
     end
 
@@ -651,23 +779,23 @@ shared_context "a Celluloid Actor" do |included_module|
     end
   end
 
-  context :mailbox_class do
-    class ExampleMailbox < Celluloid::Mailbox; end
+  context :proxy_class do
+    class ExampleProxy < Celluloid::ActorProxy; end
 
     subject do
       Class.new do
         include included_module
-        mailbox_class ExampleMailbox
+        proxy_class ExampleProxy
       end
     end
 
-    it "overrides the mailbox class" do
-      subject.new.mailbox.should be_a ExampleMailbox
+    it "uses user-specified proxy" do
+      subject.new.__class__.should == ExampleProxy
     end
 
-    it "retains custom mailboxes when subclassed" do
+    it "retains custom proxy when subclassed" do
       subclass = Class.new(subject)
-      subclass.new.mailbox.should be_a ExampleMailbox
+      subclass.new.__class__.should == ExampleProxy
     end
   end
 

data/spec/support/example_actor_class.rb

@@ -3,6 +3,7 @@ module ExampleActorClass
     Class.new do
       include included_module
       attr_reader :name
+      finalizer :my_finalizer
 
       def initialize(name)
         @name = name
@@ -13,10 +14,6 @@ module ExampleActorClass
         @name = new_name
       end
 
-      def change_name_with_a_bang(new_name)
-        change_name! new_name
-      end
-
       def change_name_async(new_name)
         async.change_name new_name
       end
@@ -25,6 +22,10 @@ module ExampleActorClass
         "Hi, I'm #{@name}"
       end
 
+      def actor?
+        Celluloid.actor?
+      end
+
       def run(*args)
         yield(*args)
       end
@@ -51,6 +52,14 @@ module ExampleActorClass
         "Hello"
       end
 
+      def inspect_thunk
+        inspect
+      end
+
+      def send(string)
+        string.reverse
+      end
+
       def method_missing(method_name, *args, &block)
         if delegates?(method_name)
           @delegate.send method_name, *args, &block
@@ -64,7 +73,7 @@ module ExampleActorClass
       end
 
       def call_private
-        zomg_private!
+        async.zomg_private
       end
 
       def zomg_private
@@ -73,6 +82,9 @@ module ExampleActorClass
       private :zomg_private
       attr_reader :private_called
 
+      def my_finalizer
+      end
+
       private
 
       def delegates?(method_name)

data/spec/support/task_examples.rb

@@ -14,11 +14,11 @@ shared_context "a Celluloid Task" do |task_class|
   subject { task_class.new(task_type) { Celluloid::Task.suspend(suspend_state) } }
 
   before :each do
-    Thread.current[:actor] = actor
+    Thread.current[:celluloid_actor] = actor
   end
 
   after :each do
-    Thread.current[:actor] = nil
+    Thread.current[:celluloid_actor] = nil
   end
 
   it "begins with status :new" do
@@ -33,4 +33,13 @@ shared_context "a Celluloid Task" do |task_class|
     subject.should_not be_running
   end
 
+  it "raises exceptions outside" do
+    task = task_class.new(task_type) do
+      raise "failure"
+    end
+    expect do
+      task.resume
+    end.to raise_exception("failure")
+  end
+
 end