celluloid 0.14.1 → 0.15.0.pre

data/spec/celluloid/stack_dump_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Celluloid::StackDump do
+  class BlockingActor
+    include Celluloid
+
+    def blocking
+      Kernel.sleep
+    end
+  end
+
+  before(:each) do
+    [Celluloid::TaskFiber, Celluloid::TaskThread].each do |task_klass|
+      actor_klass = Class.new(BlockingActor) do
+        task_class task_klass
+      end
+      actor = actor_klass.new
+      actor.async.blocking
+    end
+
+    Celluloid.internal_pool.get do
+      Thread.current.role = :testing
+      sleep
+    end
+  end
+
+  it 'should include all actors' do
+    subject.actors.size.should == Celluloid::Actor.all.size
+  end
+
+  it 'should include threads that are not actors' do
+    pending "bugs"
+    subject.threads.size.should == 2
+  end
+end

data/spec/celluloid/supervision_group_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Celluloid::SupervisionGroup do
+  before :all do
+    class MyActor
+      include Celluloid
+
+      def running?; :yep; end
+    end
+
+    class MyGroup < Celluloid::SupervisionGroup
+      supervise MyActor, :as => :example
+    end
+  end
+
+  it "runs applications" do
+    MyGroup.run!
+    sleep 0.01 # startup time hax
+
+    Celluloid::Actor[:example].should be_running
+  end
+
+  it "accepts a private actor registry" do
+    my_registry = Celluloid::Registry.new
+    MyGroup.run!(my_registry)
+    sleep 0.01
+
+    my_registry[:example].should be_running
+  end
+
+  context "pool" do
+    before :all do
+      class MyActor
+        attr_reader :args
+        def initialize *args
+          @args = *args
+        end
+      end
+      class MyGroup
+        pool MyActor, :as => :example_pool, :args => 'foo', :size => 3
+      end
+    end
+
+    it "runs applications and passes pool options and actor args" do
+      MyGroup.run!
+      sleep 0.001 # startup time hax
+
+      Celluloid::Actor[:example_pool].should be_running
+      Celluloid::Actor[:example_pool].args.should eq ['foo']
+      Celluloid::Actor[:example_pool].size.should be 3
+    end
+  end
+end

data/spec/celluloid/supervisor_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Celluloid::Supervisor do
+  class SubordinateDead < StandardError; end
+
+  class Subordinate
+    include Celluloid
+    attr_reader :state
+
+    def initialize(state)
+      @state = state
+    end
+
+    def crack_the_whip
+      case @state
+      when :idle
+        @state = :working
+      else raise SubordinateDead, "the spec purposely crashed me :("
+      end
+    end
+  end
+
+  it "restarts actors when they die" do
+    supervisor = Celluloid::Supervisor.supervise(Subordinate, :idle)
+    subordinate = supervisor.actors.first
+    subordinate.state.should be(:idle)
+
+    subordinate.crack_the_whip
+    subordinate.state.should be(:working)
+
+    expect do
+      subordinate.crack_the_whip
+    end.to raise_exception(SubordinateDead)
+    sleep 0.1 # hax to prevent race :(
+    subordinate.should_not be_alive
+
+    new_subordinate = supervisor.actors.first
+    new_subordinate.should_not eq subordinate
+    new_subordinate.state.should eq :idle
+  end
+
+  it "registers actors and reregisters them when they die" do
+    Celluloid::Supervisor.supervise_as(:subordinate, Subordinate, :idle)
+    subordinate = Celluloid::Actor[:subordinate]
+    subordinate.state.should be(:idle)
+
+    subordinate.crack_the_whip
+    subordinate.state.should be(:working)
+
+    expect do
+      subordinate.crack_the_whip
+    end.to raise_exception(SubordinateDead)
+    sleep 0.1 # hax to prevent race :(
+    subordinate.should_not be_alive
+
+    new_subordinate = Celluloid::Actor[:subordinate]
+    new_subordinate.should_not eq subordinate
+    new_subordinate.state.should eq :idle
+  end
+
+  it "creates supervisors via Actor.supervise" do
+    supervisor = Subordinate.supervise(:working)
+    subordinate = supervisor.actors.first
+    subordinate.state.should be(:working)
+
+    expect do
+      subordinate.crack_the_whip
+    end.to raise_exception(SubordinateDead)
+    sleep 0.1 # hax to prevent race :(
+    subordinate.should_not be_alive
+
+    new_subordinate = supervisor.actors.first
+    new_subordinate.should_not eq subordinate
+    new_subordinate.state.should eq :working
+  end
+
+  it "creates supervisors and registers actors via Actor.supervise_as" do
+    supervisor = Subordinate.supervise_as(:subordinate, :working)
+    subordinate = Celluloid::Actor[:subordinate]
+    subordinate.state.should be(:working)
+
+    expect do
+      subordinate.crack_the_whip
+    end.to raise_exception(SubordinateDead)
+    sleep 0.1 # hax to prevent race :(
+    subordinate.should_not be_alive
+
+    new_subordinate = supervisor.actors.first
+    new_subordinate.should_not eq subordinate
+    new_subordinate.state.should be(:working)
+  end
+end

data/spec/celluloid/tasks/task_fiber_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Celluloid::TaskFiber do
+  it_behaves_like "a Celluloid Task", Celluloid::TaskFiber
+end

data/spec/celluloid/tasks/task_thread_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Celluloid::TaskThread do
+  it_behaves_like "a Celluloid Task", Celluloid::TaskThread
+end

data/spec/celluloid/thread_handle_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Celluloid::ThreadHandle do
+  it "knows thread liveliness" do
+    queue = Queue.new
+    handle = Celluloid::ThreadHandle.new { queue.pop }
+    handle.should be_alive
+
+    queue << :die
+
+    sleep 0.01 # hax
+    handle.should_not be_alive
+  end
+
+  it "joins to thread handles" do
+    Celluloid::ThreadHandle.new { sleep 0.01 }.join
+  end
+
+  it "supports passing a role" do
+    Celluloid::ThreadHandle.new(:useful) { Thread.current.role.should == :useful }.join
+  end
+end

data/spec/celluloid/uuid_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Celluloid::UUID do
+  U = Celluloid::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 }
+    uuids.size.should == uuids.uniq.size
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'rubygems'
+require 'bundler/setup'
+require 'celluloid'
+require 'celluloid/rspec'
+
+logfile = File.open(File.expand_path("../../log/test.log", __FILE__), 'a')
+logfile.sync = true
+
+logger = Celluloid.logger = Logger.new(logfile)
+
+Celluloid.shutdown_timeout = 1
+
+Dir['./spec/support/*.rb'].map {|f| require f }
+
+RSpec.configure do |config|
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+
+  config.before do
+    Celluloid.logger = logger
+    Celluloid.shutdown
+    sleep 0.01
+
+    Celluloid.internal_pool.assert_inactive
+
+    Celluloid.boot
+  end
+end

data/spec/support/actor_examples.rb

@@ -34,6 +34,11 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     actor.object_id.should_not eq(Kernel.object_id)
   end
 
+  it "implements respond_to? correctly" do
+    actor = actor_class.new 'Troy McClure'
+    actor.should respond_to(:alive?)
+  end
+
   it "supports synchronous calls" do
     actor = actor_class.new "Troy McClure"
     actor.greet.should eq("Hi, I'm Troy McClure")
@@ -91,6 +96,36 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     ponycopter.greet_by_proxy(actor).should eq("Hi, I'm a ponycopter!")
   end
 
+  it "detects recursion" do
+    klass1 = Class.new do
+      include included_module
+      task_class task_klass
+
+      def recursion_test(recurse_through = nil)
+        if recurse_through
+          recurse_through.recursion_thunk(Celluloid::Actor.current)
+        else
+          Celluloid.detect_recursion
+        end
+      end
+    end
+
+    klass2 = Class.new do
+      include included_module
+      task_class task_klass
+
+      def recursion_thunk(other)
+        other.recursion_test
+      end
+    end
+
+    actor1 = klass1.new
+    actor2 = klass2.new
+
+    actor1.recursion_test.should be_false
+    actor1.recursion_test(actor2).should be_true
+  end
+
   it "properly handles method_missing" do
     actor = actor_class.new "Method Missing"
     actor.should respond_to(:first)
@@ -103,6 +138,24 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     actor.respond_to?(:zomg_private, true).should be_true
   end
 
+  it "warns about suspending the initialize" do
+    klass = Class.new do
+      include included_module
+      task_class task_klass
+
+      def initialize
+        sleep 0.1
+      end
+    end
+
+    Celluloid.logger = double.as_null_object
+    Celluloid.logger.should_receive(:warn).with(/Dangerously suspending task: type=:call, meta={:method_name=>:initialize}, status=:sleeping/)
+
+    actor = klass.new
+    actor.terminate
+    Celluloid::Actor.join(actor) unless defined?(JRUBY_VERSION)
+  end
+
   it "calls the user defined finalizer" do
     actor = actor_class.new "Mr. Bean"
     actor.wrapped_object.should_receive(:my_finalizer)
@@ -110,6 +163,26 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     Celluloid::Actor.join(actor)
   end
 
+  it "warns about suspending the finalizer" do
+    klass = Class.new do
+      include included_module
+      task_class task_klass
+
+      finalizer :cleanup
+
+      def cleanup
+        sleep 0.1
+      end
+    end
+
+    Celluloid.logger = double.as_null_object
+    Celluloid.logger.should_receive(:warn).with(/Dangerously suspending task: type=:finalizer, meta={:method_name=>:cleanup}, status=:sleeping/)
+
+    actor = klass.new
+    actor.terminate
+    Celluloid::Actor.join(actor)
+  end
+
   it "supports async(:method) syntax for asynchronous calls" do
     actor = actor_class.new "Troy McClure"
     actor.async :change_name, "Charlie Sheen"
@@ -162,6 +235,27 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     actor.inspect.should include('dead')
   end
 
+  it "supports recursive inspect with other actors" do
+    klass = Class.new do
+      include included_module
+      task_class task_klass
+
+      attr_accessor :other
+
+      def initialize(other = nil)
+        @other = other
+      end
+    end
+
+    itchy = klass.new
+    scratchy = klass.new(itchy)
+    itchy.other = scratchy
+
+    inspection = itchy.inspect
+    inspection.should match(/Celluloid::ActorProxy\(/)
+    inspection.should include("...")
+  end
+
   it "allows access to the wrapped object" do
     actor = actor_class.new "Troy McClure"
     actor.wrapped_object.should be_a actor_class
@@ -239,6 +333,8 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
       actor = actor_class.new "James Dean"
       actor.crash rescue nil
 
+      sleep 0.1 # hax to prevent a race between exit handling and the next call
+
       expect do
         actor.greet
       end.to raise_exception(Celluloid::DeadActorError)
@@ -283,6 +379,14 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
       actor.should_not be_alive
     end
 
+    it "can be terminated by a SyncCall" do
+      actor = actor_class.new "Arnold Schwarzenegger"
+      actor.should be_alive
+      actor.shutdown
+      Celluloid::Actor.join(actor)
+      actor.should_not be_alive
+    end
+
     it "kills" do # THOU SHALT ALWAYS KILL
       actor = actor_class.new "Woody Harrelson"
       actor.should be_alive
@@ -308,6 +412,17 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
         actor.terminate!
       end.to raise_exception(Celluloid::DeadActorError, "actor already terminated")
     end
+
+    it "logs a warning when terminating tasks" do
+      Celluloid.logger = double.as_null_object
+      Celluloid.logger.should_receive(:warn).with("Terminating task: type=:call, meta={:method_name=>:sleepy}, status=:sleeping")
+
+      actor = actor_class.new "Arnold Schwarzenegger"
+      actor.async.sleepy 10
+      actor.greet # make sure the actor has started sleeping
+
+      actor.terminate
+    end
   end
 
   context :current_actor do
@@ -438,8 +553,6 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
           raise "already signaled" if @signaled
 
           @waiting = true
-          signal :future
-
           value = wait :ponycopter
 
           @waiting = false
@@ -447,11 +560,6 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
           value
         end
 
-        def wait_for_future
-          return true if @waiting
-          wait :future
-        end
-
         def send_signal(value)
           signal :ponycopter, value
         end
@@ -467,9 +575,11 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
 
       obj.async.wait_for_signal
       obj.should_not be_signaled
+      obj.should be_waiting
 
       obj.send_signal :foobar
       obj.should be_signaled
+      obj.should_not be_waiting
     end
 
     it "sends values along with signals" do
@@ -478,7 +588,6 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
 
       future = obj.future(:wait_for_signal)
 
-      obj.wait_for_future
       obj.should be_waiting
       obj.should_not be_signaled
 
@@ -799,12 +908,12 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     end
   end
 
-  context :mailbox_limit do
+  context :mailbox_size do
     subject do
       Class.new do
         include included_module
         task_class task_klass
-        mailbox.max_size = 100
+        mailbox_size 100
       end
     end
 
@@ -857,4 +966,46 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
       subclass.new.tasks.first.should be_a ExampleTask
     end
   end
+
+  context :timeouts do
+    let :actor_class do
+      Class.new do
+        include included_module
+
+        def name
+          sleep 0.5
+          :foo
+        end
+
+        def ask_name_with_timeout(other, duration)
+          timeout(duration) { other.name }
+        end
+      end
+    end
+
+    it "allows timing out tasks, raising Celluloid::Task::TimeoutError" do
+      a1 = actor_class.new
+      a2 = actor_class.new
+
+      expect { a1.ask_name_with_timeout a2, 0.3 }.to raise_error(Celluloid::Task::TimeoutError)
+    end
+
+    it "does not raise when it completes in time" do
+      a1 = actor_class.new
+      a2 = actor_class.new
+
+      a1.ask_name_with_timeout(a2, 0.6).should == :foo
+    end
+  end
+
+  context "raw message sends" do
+    it "logs on unhandled messages" do
+      Celluloid.logger = double.as_null_object
+      Celluloid.logger.should_receive(:debug).with("Discarded message (unhandled): first")
+
+      actor = actor_class.new "Irma Gladden"
+      actor.mailbox << :first
+      sleep Celluloid::TIMER_QUANTUM
+    end
+  end
 end