celluloid 0.16.0 → 0.17.3

data/spec/celluloid/probe_spec.rb

@@ -1,121 +0,0 @@
-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/properties_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::Properties do
-  let(:default_value) { 42 }
-  let(:changed_value) { 43 }
-
-  let(:example_class) do
-    Class.new do
-      extend Celluloid::Properties
-      property :baz, :default => 42
-    end
-  end
-
-  let(:example_subclass) do
-    Class.new(example_class)
-  end
-
-  let(:example_subclass_subclass) do
-    Class.new(example_subclass)
-  end
-
-  it "adds properties to classes" do
-    example_class.baz.should eq default_value
-    example_class.baz changed_value
-    example_class.baz.should eq changed_value
-  end
-
-  it "allows properties to be inherited" do
-    example_subclass.baz.should eq default_value
-    example_subclass.baz changed_value
-    example_subclass.baz.should eq changed_value
-    example_class.baz.should eq default_value
-  end
-
-  it "allows properties to be deeply inherited" do
-    example_subclass_subclass.baz.should eq default_value
-    example_subclass_subclass.baz changed_value
-    example_subclass_subclass.baz.should eq changed_value
-    example_subclass.baz.should eq default_value
-    example_class.baz.should eq default_value
-  end
-end

data/spec/celluloid/registry_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::Registry, actor_system: :global do
-  class Marilyn
-    include Celluloid
-
-    def sing_for(person)
-      "o/~ Happy birthday, #{person}"
-    end
-  end
-
-  it "registers Actors" do
-    Celluloid::Actor[:marilyn] = Marilyn.new
-    Celluloid::Actor[:marilyn].sing_for("Mr. President").should == "o/~ Happy birthday, Mr. President"
-  end
-
-  it "refuses to register non-Actors" do
-    expect do
-      Celluloid::Actor[:impostor] = Object.new
-    end.to raise_error TypeError
-  end
-
-  it "lists all registered actors" do
-    Celluloid::Actor[:marilyn] = Marilyn.new
-    Celluloid::Actor.registered.should include :marilyn
-  end
-
-  it "knows its name once registered" do
-    Celluloid::Actor[:marilyn] = Marilyn.new
-    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::Actor.delete(:marilyn)
-      Celluloid::Actor.registered.should_not include :marilyn
-    end
-
-    it "returns actor removed from the registry" do
-      rval = Celluloid::Actor.delete(:marilyn)
-      rval.should be_kind_of(Marilyn)
-    end
-  end
-
-  describe :clear do
-    it "should return a hash of registered actors and remove them from the registry" do
-      Celluloid::Actor[:marilyn] ||= Marilyn.new
-      rval = Celluloid::Actor.clear_registry
-      begin
-        rval.should be_kind_of(Hash)
-        rval.should have_key(:marilyn)
-        rval[:marilyn].wrapped_object.should be_instance_of(Marilyn)
-        Celluloid::Actor.registered.should be_empty
-      ensure
-        # Repopulate the registry once we're done
-        rval.each { |key, actor| Celluloid::Actor[key] = actor }
-      end
-    end
-  end
-end

data/spec/celluloid/stack_dump_spec.rb

@@ -1,64 +0,0 @@
-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
-
-    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_system.within do
-        actor_klass.new
-      end
-      actor.async.blocking
-    end
-
-    @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
-
-  describe '#actors' do
-    it 'should include all actors' do
-      subject.actors.size.should == actor_system.running.size
-    end
-  end
-
-  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,65 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::SupervisionGroup, actor_system: :global 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
-
-  it "removes actors from the registry when terminating" do
-    group = MyGroup.run!
-    group.terminate
-    Celluloid::Actor[:example].should be_nil
-  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
-
-    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,103 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::Supervisor, actor_system: :global 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
-
-  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 +0,0 @@
-require 'spec_helper'
-
-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 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::TaskThread, actor_system: :within do
-  it_behaves_like "a Celluloid Task", Celluloid::TaskThread
-end

data/spec/celluloid/thread_handle_spec.rb

@@ -1,26 +0,0 @@
-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(actor_system) { 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(actor_system) { sleep 0.01 }.join
-  end
-
-  it "supports passing a role" do
-    Celluloid::ThreadHandle.new(actor_system, :useful) { Thread.current.role.should == :useful }.join
-  end
-end

data/spec/celluloid/uuid_spec.rb

@@ -1,11 +0,0 @@
-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