celluloid 0.15.2 → 0.16.0.pre3

data/spec/celluloid/probe_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+class DummyActor; include Celluloid; end
+
+class TestProbeClient
+  include Celluloid
+  include Celluloid::Notifications
+
+  attr_reader :buffer
+
+  def initialize()
+    @condition = Condition.new
+    subscribe(/celluloid\.events\..+/, :event_received)
+    @buffer = []
+  end
+
+  def wait
+    @condition.wait
+  end
+
+  def wait_event(topic, expected_actor1 = nil, expected_actor2 = nil)
+    loop do
+      wait
+      while ev = @buffer.shift()
+        if (ev[0] == topic) && (ev[1].mailbox.address == expected_actor1.mailbox.address) &&
+          (expected_actor2.nil? || (ev[2].mailbox.address == expected_actor2.mailbox.address) )
+          return ev
+        end
+      end
+    end
+  end
+
+  def event_received(topic, args)
+    @buffer << [topic, args[0], args[1]]
+    @condition.signal
+  end
+end
+
+describe "Probe", actor_system: :global do
+  describe 'on boot' do
+    it 'should capture system actor spawn' do
+      client = TestProbeClient.new
+      Celluloid::Probe.run
+      create_events = []
+      received_named_events = {
+        :default_incident_reporter => nil,
+        :notifications_fanout      => nil
+      }
+      # wait for the events we seek
+      Timeout.timeout(5) do
+        loop do
+          client.wait
+          while ev = client.buffer.shift
+            if ev[0] == 'celluloid.events.actor_created'
+              create_events << ev
+            elsif ev[0] == 'celluloid.events.actor_named'
+              if received_named_events.keys.include?(ev[1].name)
+                received_named_events[ev[1].name] = ev[1].mailbox.address
+              end
+            end
+          end
+          if received_named_events.all?{|_, v| v != nil }
+            break
+          end
+        end
+      end
+      received_named_events.all?{|_, v| v != nil }.should == true
+      # now check we got the create events for every actors
+      received_named_events.each do |_, mailbox_address|
+        found = create_events.detect{|_, aa| aa.mailbox.address == mailbox_address }
+        found.should_not == nil
+      end
+    end
+  end
+
+  describe 'after boot' do
+    it 'should send a notification when an actor is spawned' do
+      client = TestProbeClient.new
+      Celluloid::Probe.run
+      a = DummyActor.new
+      event = Timeout.timeout(5) do
+        client.wait_event('celluloid.events.actor_created', a)
+      end
+      event.should_not == nil
+    end
+
+    it 'should send a notification when an actor is named' do
+      client = TestProbeClient.new
+      Celluloid::Probe.run
+      a = DummyActor.new
+      Celluloid::Actor['a name'] = a
+      event = Timeout.timeout(5) do
+        client.wait_event('celluloid.events.actor_named', a)
+      end
+      event.should_not == nil
+    end
+
+    it 'should send a notification when actor dies' do
+      client = TestProbeClient.new
+      Celluloid::Probe.run
+      a = DummyActor.new
+      a.terminate
+      event = Timeout.timeout(5) do
+        client.wait_event('celluloid.events.actor_died', a)
+      end
+      event.should_not == nil
+    end
+
+    it 'should send a notification when actors are linked' do
+      client = TestProbeClient.new
+      Celluloid::Probe.run
+      a = DummyActor.new
+      b = DummyActor.new
+      a.link(b)
+      event = Timeout.timeout(5) do
+        client.wait_event('celluloid.events.actors_linked', a, b)
+      end
+      event.should_not == nil
+    end
+  end
+end

data/spec/celluloid/registry_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Celluloid::Registry do
+describe Celluloid::Registry, actor_system: :global do
   class Marilyn
     include Celluloid
 
@@ -27,21 +27,21 @@ describe Celluloid::Registry do
 
   it "knows its name once registered" do
     Celluloid::Actor[:marilyn] = Marilyn.new
-    Celluloid::Actor[:marilyn].name.should == :marilyn
+    Celluloid::Actor[:marilyn].registered_name.should == :marilyn
   end
 
   describe :delete do
     before do
       Celluloid::Actor[:marilyn] ||= Marilyn.new
     end
-    
+
     it "removes reference to actors' name from the registry" do
-      Celluloid::Registry.root.delete(:marilyn)
+      Celluloid::Actor.delete(:marilyn)
       Celluloid::Actor.registered.should_not include :marilyn
     end
-    
+
     it "returns actor removed from the registry" do
-      rval = Celluloid::Registry.root.delete(:marilyn)
+      rval = Celluloid::Actor.delete(:marilyn)
       rval.should be_kind_of(Marilyn)
     end
   end

data/spec/celluloid/stack_dump_spec.rb

@@ -1,6 +1,14 @@
 require 'spec_helper'
 
 describe Celluloid::StackDump do
+  let(:actor_system) do
+    Celluloid::ActorSystem.new
+  end
+
+  subject do
+    actor_system.stack_dump
+  end
+
   class BlockingActor
     include Celluloid
 
@@ -14,22 +22,43 @@ describe Celluloid::StackDump do
       actor_klass = Class.new(BlockingActor) do
         task_class task_klass
       end
-      actor = actor_klass.new
+      actor = actor_system.within do
+        actor_klass.new
+      end
       actor.async.blocking
     end
 
-    Celluloid.internal_pool.get do
-      Thread.current.role = :testing
+    @active_thread = actor_system.get_thread do
       sleep
     end
+    @active_thread.role = :other_thing
+    @idle_thread = actor_system.get_thread do
+    end
+
+    sleep 0.01
   end
 
-  it 'should include all actors' do
-    subject.actors.size.should == Celluloid::Actor.all.size
+  describe '#actors' do
+    it 'should include all actors' do
+      subject.actors.size.should == actor_system.running.size
+    end
   end
 
-  it 'should include threads that are not actors' do
-    pending "bugs"
-    subject.threads.size.should == 2
+  describe '#threads' do
+    it 'should include threads that are not actors', pending: 'flaky' do
+      expect(subject.threads.size).to eq(3)
+    end
+
+    it 'should include idle threads' do
+      subject.threads.map(&:thread_id).should include(@idle_thread.object_id)
+    end
+
+    it 'should include threads checked out of the pool for roles other than :actor' do
+      subject.threads.map(&:thread_id).should include(@active_thread.object_id)
+    end
+
+    it 'should have the correct roles', pending: 'flaky' do
+      expect(subject.threads.map(&:role)).to include(nil, :other_thing, :task)
+    end
   end
 end

data/spec/celluloid/supervision_group_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Celluloid::SupervisionGroup do
+describe Celluloid::SupervisionGroup, actor_system: :global do
   before :all do
     class MyActor
       include Celluloid
@@ -55,5 +55,11 @@ describe Celluloid::SupervisionGroup do
       Celluloid::Actor[:example_pool].args.should eq ['foo']
       Celluloid::Actor[:example_pool].size.should be 3
     end
+
+    it "allows external access to the internal registry" do
+      supervisor = MyGroup.run!
+
+      supervisor[:example].should be_a MyActor
+    end
   end
 end

data/spec/celluloid/supervisor_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Celluloid::Supervisor do
+describe Celluloid::Supervisor, actor_system: :global do
   class SubordinateDead < StandardError; end
 
   class Subordinate
@@ -89,4 +89,15 @@ describe Celluloid::Supervisor do
     new_subordinate.should_not eq subordinate
     new_subordinate.state.should be(:working)
   end
+
+  it "removes an actor if it terminates cleanly" do
+    supervisor = Subordinate.supervise(:working)
+    subordinate = supervisor.actors.first
+
+    supervisor.actors.should == [subordinate]
+
+    subordinate.terminate
+
+    supervisor.actors.should be_empty
+  end
 end

data/spec/celluloid/tasks/task_fiber_spec.rb

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

data/spec/celluloid/tasks/task_thread_spec.rb

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

data/spec/celluloid/thread_handle_spec.rb

@@ -1,9 +1,13 @@
 require 'spec_helper'
 
 describe Celluloid::ThreadHandle do
+  let(:actor_system) do
+    Celluloid::ActorSystem.new
+  end
+
   it "knows thread liveliness" do
     queue = Queue.new
-    handle = Celluloid::ThreadHandle.new { queue.pop }
+    handle = Celluloid::ThreadHandle.new(actor_system) { queue.pop }
     handle.should be_alive
 
     queue << :die
@@ -13,10 +17,10 @@ describe Celluloid::ThreadHandle do
   end
 
   it "joins to thread handles" do
-    Celluloid::ThreadHandle.new { sleep 0.01 }.join
+    Celluloid::ThreadHandle.new(actor_system) { sleep 0.01 }.join
   end
 
   it "supports passing a role" do
-    Celluloid::ThreadHandle.new(:useful) { Thread.current.role.should == :useful }.join
+    Celluloid::ThreadHandle.new(actor_system, :useful) { Thread.current.role.should == :useful }.join
   end
 end

data/spec/celluloid/timer_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+class EveryActor
+  include Celluloid
+
+  def initialize
+    @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
+end
+
+describe Celluloid::Actor do
+  it "run every(t) task several times" do
+    Celluloid.boot
+    
+    every_actor = EveryActor.new
+    
+    sleep 5.5
+    
+    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
+    expect(trace.count(22)).to be == 2
+  end
+end

data/spec/spec_helper.rb

@@ -4,11 +4,12 @@ Coveralls.wear!
 require 'rubygems'
 require 'bundler/setup'
 require 'celluloid/rspec'
+require 'celluloid/probe'
 
 logfile = File.open(File.expand_path("../../log/test.log", __FILE__), 'a')
 logfile.sync = true
 
-logger = Celluloid.logger = Logger.new(logfile)
+Celluloid.logger = Logger.new(logfile)
 
 Celluloid.shutdown_timeout = 1
 
@@ -18,14 +19,26 @@ RSpec.configure do |config|
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
 
-  config.before do
-    Celluloid.logger = logger
-    if Celluloid.running?
-      Celluloid.shutdown
-      sleep 0.01
-      Celluloid.internal_pool.assert_inactive
+  config.around do |ex|
+    Celluloid.actor_system = nil
+    Thread.list.each do |thread|
+      next if thread == Thread.current
+      thread.kill
     end
 
+    ex.run
+  end
+
+  config.around actor_system: :global do |ex|
     Celluloid.boot
+    ex.run
+    Celluloid.shutdown
+  end
+
+  config.around actor_system: :within do |ex|
+    Celluloid::ActorSystem.new.within do
+      ex.run
+    end
   end
+
 end

data/spec/support/actor_examples.rb

@@ -65,6 +65,19 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     method.arity.should be(1)
   end
 
+  it "supports #name calls via #method" do
+    method = actor_class.new("Troy McClure").method(:greet)
+    method.name.should == :greet
+  end
+
+  it "supports #parameters via #method" do
+    method = actor_class.new("Troy McClure").method(:greet)
+    method.parameters.should == []
+
+    method = actor_class.new("Troy McClure").method(:change_name)
+    method.parameters.should == [[:req, :new_name]]
+  end
+
   it "supports future(:method) syntax for synchronous future calls" do
     actor = actor_class.new "Troy McClure"
     future = actor.future :greet
@@ -148,7 +161,6 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
       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
@@ -175,7 +187,6 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
       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
@@ -221,7 +232,7 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
 
   it "inspects properly" do
     actor = actor_class.new "Troy McClure"
-    actor.inspect.should match(/Celluloid::ActorProxy\(/)
+    actor.inspect.should match(/Celluloid::CellProxy\(/)
     actor.inspect.should match(/#{actor_class}/)
     actor.inspect.should include('@name="Troy McClure"')
     actor.inspect.should_not include("@celluloid")
@@ -230,7 +241,7 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
   it "inspects properly when dead" do
     actor = actor_class.new "Troy McClure"
     actor.terminate
-    actor.inspect.should match(/Celluloid::ActorProxy\(/)
+    actor.inspect.should match(/Celluloid::CellProxy\(/)
     actor.inspect.should match(/#{actor_class}/)
     actor.inspect.should include('dead')
   end
@@ -252,7 +263,7 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     itchy.other = scratchy
 
     inspection = itchy.inspect
-    inspection.should match(/Celluloid::ActorProxy\(/)
+    inspection.should match(/Celluloid::CellProxy\(/)
     inspection.should include("...")
   end
 
@@ -274,6 +285,31 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     actor.send('foo').should eq('oof')
   end
 
+  context "when executing under JRuby" do
+    let(:klass) {
+      Class.new do
+        include included_module
+        task_class task_klass
+
+        def current_thread_name
+          java_thread.get_name
+        end
+
+        def java_thread
+          Thread.current.to_java.getNativeThread
+        end
+      end
+    }
+
+    it "sets execution info" do
+      klass.new.current_thread_name.should == "Class#current_thread_name"
+    end
+
+    it "unsets execution info after task completion" do
+      klass.new.java_thread.get_name.should == "<unused>"
+    end
+  end if RUBY_PLATFORM == "java"
+
   context "mocking methods" do
     let(:actor) { actor_class.new "Troy McClure" }
 
@@ -300,27 +336,27 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     end
 
     it "includes both sender and receiver in exception traces" do
-      ExampleReceiver = Class.new do
+      example_receiver = Class.new do
         include included_module
         task_class task_klass
 
-        def receiver_method
+        define_method(:receiver_method) do
           raise ExampleCrash, "the spec purposely crashed me :("
         end
       end
 
-      ExampleCaller = Class.new do
+      excample_caller = Class.new do
         include included_module
         task_class task_klass
 
-        def sender_method
-          ExampleReceiver.new.receiver_method
+        define_method(:sender_method) do
+          example_receiver.new.receiver_method
         end
       end
 
       ex = nil
       begin
-        ExampleCaller.new.sender_method
+        excample_caller.new.sender_method
       rescue => ex
       end
 
@@ -404,6 +440,15 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
       end.to raise_exception(Celluloid::DeadActorError)
     end
 
+    it "terminates cleanly on Celluloid shutdown" do
+      Celluloid::Actor.stub(:kill).and_call_original
+
+      actor = actor_class.new "Arnold Schwarzenegger"
+
+      Celluloid.shutdown
+      Celluloid::Actor.should_not have_received(:kill)
+    end
+
     it "raises the right DeadActorError if terminate! called after terminated" do
       actor = actor_class.new "Arnold Schwarzenegger"
       actor.terminate
@@ -414,8 +459,7 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     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")
+      Celluloid.logger.should_receive(:warn).with(/^Terminating task: type=:call, meta={:method_name=>:sleepy}, status=:sleeping\n/)
 
       actor = actor_class.new "Arnold Schwarzenegger"
       actor.async.sleepy 10
@@ -923,7 +967,7 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
   end
 
   context :proxy_class do
-    class ExampleProxy < Celluloid::ActorProxy
+    class ExampleProxy < Celluloid::CellProxy
       def subclass_proxy?
         true
       end
@@ -1000,7 +1044,6 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
 
   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"

data/spec/support/mailbox_examples.rb

@@ -1,4 +1,9 @@
 shared_context "a Celluloid Mailbox" do
+  after do
+    Celluloid.logger.stub(:debug)
+    subject.shutdown if subject.alive?
+  end
+
   it "receives messages" do
     message = :ohai
 
@@ -34,7 +39,10 @@ shared_context "a Celluloid Mailbox" do
     interval = 0.1
     started_at = Time.now
 
-    subject.receive(interval) { false }
+    expect do
+      subject.receive(interval) { false }
+    end.to raise_exception(Celluloid::TimeoutError)
+
     (Time.now - started_at).should be_within(Celluloid::TIMER_QUANTUM).of interval
   end
 
@@ -55,7 +63,6 @@ shared_context "a Celluloid Mailbox" do
   end
 
   it "logs discarded messages" do
-    Celluloid.logger = double.as_null_object
     Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): third")
 
     subject.max_size = 2
@@ -65,7 +72,6 @@ shared_context "a Celluloid Mailbox" do
   end
 
   it "discard messages when dead" do
-    Celluloid.logger = double.as_null_object
     Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): first")
     Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): second")
     Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): third")

data/spec/support/task_examples.rb

@@ -17,11 +17,13 @@ shared_context "a Celluloid Task" do |task_class|
   subject { task_class.new(task_type, {}) { Celluloid::Task.suspend(suspend_state) } }
 
   before :each do
+    Thread.current[:celluloid_actor_system] = Celluloid.actor_system
     Thread.current[:celluloid_actor] = actor
   end
 
   after :each do
     Thread.current[:celluloid_actor] = nil
+    Thread.current[:celluloid_actor_system] = nil
   end
 
   it "begins with status :new" do