celluloid 0.14.1 → 0.15.0.pre

data/spec/celluloid/future_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Celluloid::Future do
+  it "creates future objects that can be retrieved later" do
+    future = Celluloid::Future.new { 40 + 2 }
+    future.value.should == 42
+  end
+
+  it "passes arguments to future blocks" do
+    future = Celluloid::Future.new(40) { |n| n + 2 }
+    future.value.should == 42
+  end
+
+  it "reraises exceptions that occur when the value is retrieved" do
+    class ExampleError < StandardError; end
+
+    future = Celluloid::Future.new { raise ExampleError, "oh noes crash!" }
+    expect { future.value }.to raise_exception(ExampleError)
+  end
+
+  it "knows if it's got a value yet" do
+    future = Celluloid::Future.new { sleep Celluloid::TIMER_QUANTUM * 5 }
+    future.should_not be_ready
+    sleep Celluloid::TIMER_QUANTUM * 6
+    future.should be_ready
+  end
+
+  it "raises TimeoutError when the future times out" do
+    future = Celluloid::Future.new { sleep 2 }
+    expect { future.value(1) }.to raise_exception(Celluloid::TimeoutError)
+  end
+end

data/spec/celluloid/internal_pool_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Celluloid::InternalPool do
+  it "gets threads from the pool" do
+    subject.get { sleep 1 }.should be_a Thread
+  end
+
+  it "puts threads back into the pool" do
+    subject.idle_size.should be_zero
+    subject.busy_size.should be_zero
+
+    queue = Queue.new
+    subject.get { queue.pop }
+
+    subject.idle_size.should be_zero
+    subject.busy_size.should eq 1
+
+    queue << nil
+    sleep 0.01 # hax
+
+    subject.idle_size.should eq 1
+    subject.busy_size.should eq 0
+  end
+
+  it "cleans thread locals from old threads" do
+    thread = subject.get { Thread.current[:foo] = :bar }
+
+    sleep 0.01 #hax
+    thread[:foo].should be_nil
+  end
+
+  it "doesn't fail if a third-party thread is spawned" do
+    subject.idle_size.should be_zero
+    subject.busy_size.should be_zero
+
+    subject.get { ::Thread.new { sleep 0.5 } }.should be_a(Celluloid::Thread)
+
+    sleep 0.01 # hax
+
+    subject.idle_size.should eq 1
+    subject.busy_size.should eq 0
+  end
+
+  it "doesn't leak dead threads" do
+    subject.max_idle = 0 # Instruct the pool to immediately shut down the thread.
+    subject.get { true }.should be_a(Celluloid::Thread)
+
+    sleep 0.01 # hax
+
+    subject.to_a.should have(0).items
+  end
+end

data/spec/celluloid/links_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Celluloid::Links do
+  subject { Celluloid::Links.new }
+
+  let(:mailbox_mock) do
+    Class.new(Array) do
+      attr_reader :address
+      def initialize address
+        @address = address
+      end
+    end
+  end
+
+  let(:first_actor) do
+    Struct.new(:mailbox).new(mailbox_mock.new('foo123'))
+  end
+
+  let(:second_actor) do
+    Struct.new(:mailbox).new(mailbox_mock.new('bar456'))
+  end
+
+  it 'is Enumerable' do
+    subject.should be_an(Enumerable)
+  end
+
+  it 'adds actors by their mailbox address' do
+    subject.include?(first_actor).should be_false
+    subject << first_actor
+    subject.include?(first_actor).should be_true
+  end
+
+  it 'removes actors by their mailbox address' do
+    subject << first_actor
+    subject.include?(first_actor).should be_true
+    subject.delete first_actor
+    subject.include?(first_actor).should be_false
+  end
+
+  it 'iterates over all actors' do
+    subject << first_actor
+    subject << second_actor
+    subject.inject([]) { |all, a| all << a }.should == [first_actor, second_actor]
+  end
+end

data/spec/celluloid/logging/ring_buffer_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Celluloid::RingBuffer do
+  subject { Celluloid::RingBuffer.new(2) }
+
+  it { should be_empty }
+  it { should_not be_full }
+
+  it 'should push and shift' do
+    subject.push('foo')
+    subject.push('foo2')
+    subject.shift.should eq('foo')
+    subject.shift.should eq('foo2')
+  end
+
+  it 'should push past the end' do
+    subject.push('foo')
+    subject.push('foo2')
+    subject.push('foo3')
+    subject.should be_full
+  end
+
+  it 'should shift the most recent' do
+    (1..5).each { |i| subject.push(i) }
+    subject.shift.should be 4
+    subject.shift.should be 5
+    subject.shift.should be_nil
+  end
+
+  it 'should return nil when shifting empty' do
+    subject.should be_empty
+    subject.shift.should be_nil
+  end
+
+  it 'should be thread-safe' do
+    #TODO how to test?
+  end
+end

data/spec/celluloid/mailbox_spec.rb

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

data/spec/celluloid/notifications_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe Celluloid::Notifications do
+  class Admirer
+    include Celluloid
+    include Celluloid::Notifications
+
+    attr_reader :mourning
+    attr_reader :mourning_count
+
+    def someone_died(topic, name)
+      @mourning = name
+      @mourning_count ||= 0
+      @mourning_count += 1
+    end
+  end
+
+  class President
+    include Celluloid
+    include Celluloid::Notifications
+
+    def die
+      publish("death", "Mr. President")
+    end
+  end
+
+  it 'notifies relevant subscribers' do
+    marilyn = Admirer.new
+    jackie = Admirer.new
+
+    marilyn.subscribe("death", :someone_died)
+    jackie.subscribe("alive", :someone_died)
+
+    president = President.new
+
+    president.die
+    marilyn.mourning.should eq("Mr. President")
+    jackie.mourning.should_not eq("Mr. President")
+  end
+
+  it 'allows multiple subscriptions from the same actor' do
+    marilyn = Admirer.new
+
+    marilyn.subscribe("death", :someone_died)
+    marilyn.subscribe("death", :someone_died)
+
+    president = President.new
+
+    president.die
+    marilyn.mourning_count.should be(2)
+  end
+
+
+  it 'notifies subscribers' do
+    marilyn = Admirer.new
+    jackie = Admirer.new
+
+    marilyn.subscribe("death", :someone_died)
+    jackie.subscribe("death", :someone_died)
+
+    president = President.new
+
+    president.die
+    marilyn.mourning.should eq("Mr. President")
+    jackie.mourning.should eq("Mr. President")
+  end
+
+  it 'publishes even if there are no subscribers' do
+    president = President.new
+    president.die
+  end
+
+  it 'allows regex subscriptions' do
+    marilyn = Admirer.new
+
+    marilyn.subscribe(/(death|assassination)/, :someone_died)
+
+    president = President.new
+    president.die
+    marilyn.mourning.should eq("Mr. President")
+  end
+
+  it 'allows unsubscribing' do
+    marilyn = Admirer.new
+
+    subscription = marilyn.subscribe("death", :someone_died)
+    marilyn.unsubscribe(subscription)
+
+    president = President.new
+    president.die
+    marilyn.mourning.should be_nil
+  end
+
+  it 'prunes dead subscriptions' do
+    marilyn = Admirer.new
+    jackie = Admirer.new
+
+    marilyn.subscribe("death", :someone_died)
+    jackie.subscribe("death", :someone_died)
+
+    listeners = Celluloid::Notifications.notifier.listeners_for("death").size
+    marilyn.terminate
+    after_listeners = Celluloid::Notifications.notifier.listeners_for("death").size
+
+    after_listeners.should == listeners - 1
+  end
+
+  it 'prunes multiple subscriptions from a dead actor' do
+    marilyn = Admirer.new
+
+    marilyn.subscribe("death", :someone_died)
+    marilyn.subscribe("death", :someone_died)
+
+    listeners = Celluloid::Notifications.notifier.listeners_for("death").size
+    marilyn.terminate
+    after_listeners = Celluloid::Notifications.notifier.listeners_for("death").size
+
+    after_listeners.should eq(listeners - 2)
+  end
+end

data/spec/celluloid/pool_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe "Celluloid.pool" do
+  class ExampleError < StandardError; end
+
+  class MyWorker
+    include Celluloid
+
+    def process(queue = nil)
+      if queue
+        queue << :done
+      else
+        :done
+      end
+    end
+
+    def crash
+      raise ExampleError, "zomgcrash"
+    end
+  end
+
+  subject { MyWorker.pool }
+
+  it "processes work units synchronously" do
+    subject.process.should be :done
+  end
+
+  it "processes work units asynchronously" do
+    queue = Queue.new
+    subject.async.process(queue)
+    queue.pop.should be :done
+  end
+
+  it "handles crashes" do
+    expect { subject.crash }.to raise_error(ExampleError)
+    subject.process.should be :done
+  end
+
+  it "uses a fixed-sized number of threads" do
+    subject # eagerly evaluate the pool to spawn it
+
+    actors = Celluloid::Actor.all
+    100.times.map { subject.future(:process) }.map(&:value)
+
+    new_actors = Celluloid::Actor.all - actors
+    new_actors.should eq []
+  end
+
+  it "terminates" do
+    expect { subject.terminate }.to_not raise_exception
+  end
+end

data/spec/celluloid/properties_spec.rb

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

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Celluloid::Registry 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].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.registered.should_not include :marilyn
+    end
+    
+    it "returns actor removed from the registry" do
+      rval = Celluloid::Registry.root.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