celluloid 0.16.0 → 0.17.0

data/spec/celluloid/future_spec.rb

@@ -1,28 +1,31 @@
-require 'spec_helper'
-
-describe Celluloid::Future, actor_system: :global do
+RSpec.describe Celluloid::Future, actor_system: :global do
   it "creates future objects that can be retrieved later" do
     future = Celluloid::Future.new { 40 + 2 }
-    future.value.should == 42
+    expect(future.value).to eq(42)
   end
 
   it "passes arguments to future blocks" do
     future = Celluloid::Future.new(40) { |n| n + 2 }
-    future.value.should == 42
+    expect(future.value).to eq(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!" }
+    future = Celluloid::Future.new { fail 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
+    queue = Queue.new
+    future = Celluloid::Future.new { queue.pop }
+
+    expect(future).not_to be_ready
+    queue << nil # let it continue
+
+    Specs.sleep_and_wait_until { future.ready? }
+
+    expect(future).to be_ready
   end
 
   it "raises TimeoutError when the future times out" do

data/spec/celluloid/group/pool_spec.rb

@@ -0,0 +1,8 @@
+# set logger early on
+require "celluloid/internals/logger"
+
+if Celluloid.group_class == Celluloid::Group::Pool
+  RSpec.describe Celluloid::Group::Pool do
+    it_behaves_like "a Celluloid Group"
+  end
+end

data/spec/celluloid/group/spawner_spec.rb

@@ -0,0 +1,8 @@
+# set logger early on
+require "celluloid/internals/logger"
+
+if Celluloid.group_class == Celluloid::Group::Spawner
+  RSpec.describe Celluloid::Group::Spawner do
+    it_behaves_like "a Celluloid Group"
+  end
+end

data/spec/celluloid/mailbox/evented_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe Celluloid::Mailbox::Evented do
+  subject { TestEventedMailbox.new }
+  it_behaves_like "a Celluloid Mailbox"
+
+  # NOTE: this example seems too exotic to "have to" succeed on RBX, though I
+  # don't know why it hangs on subject.receive and the timeout never occurs
+  #
+  # Other than
+  #
+  # Links:
+  #   https://github.com/celluloid/celluloid-io/pull/98
+  #   https://github.com/celluloid/celluloid-io/issues/56
+  #
+  unless RUBY_ENGINE == "rbx"
+    it "recovers from timeout exceeded to process mailbox message" do
+      timeout_interval = CelluloidSpecs::TIMER_QUANTUM + 0.1
+      started_at = Time.now
+      expect do
+        Kernel.send(:timeout, timeout_interval) do
+          subject.receive { false }
+        end
+      end.to raise_exception(Timeout::Error)
+
+      expect(Time.now - started_at).to be_within(CelluloidSpecs::TIMER_QUANTUM).of timeout_interval
+    end
+  end
+end

data/spec/celluloid/mailbox_spec.rb

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

data/spec/celluloid/misc/leak_spec.rb

@@ -0,0 +1,73 @@
+require "weakref"
+
+RSpec.describe "Leaks", actor_system: :global, leaktest: true,
+                        skip: !ENV["CELLULOID_LEAKTEST"] && "leak test disabled" do
+  class LeakActor
+    include Celluloid
+
+    def initialize(arg)
+      @arg = arg
+    end
+
+    def call(_arg)
+      []
+    end
+
+    def terminate
+    end
+  end
+
+  def wait_for_release(weak, _what, count=1000)
+    trash = []
+    count.times do |step|
+      GC.start
+      return true unless weak.weakref_alive?
+      trash << "*" * step
+    end
+
+    false
+  end
+
+  def do_actor(what)
+    actor = LeakActor.new what
+    weak = yield actor
+    actor.terminate
+    actor = nil
+    weak
+  end
+
+  def actor_life(what, &block)
+    GC.start
+    weak = do_actor what, &block
+    expect(wait_for_release(weak, what)).to be_truthy
+  end
+
+  context "celluloid actor" do
+    it "is properly destroyed upon termination" do
+      actor_life("actor") do |actor|
+        WeakRef.new actor
+      end
+    end
+  end
+
+  context "celluloid actor call" do
+    it "does not hold a reference its arguments on completion" do
+      actor_life("call-arg") do |actor|
+        arg = []
+        actor.call arg
+        weak = WeakRef.new arg
+        arg = nil
+        weak
+      end
+    end
+
+    it "does not hold a reference to the return value" do
+      actor_life("call-result") do |actor|
+        result = actor.call nil
+        weak = WeakRef.new result
+        result = nil
+        weak
+      end
+    end
+  end
+end

data/spec/celluloid/task/fibered_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe Celluloid::Task::Fibered, actor_system: :within do
+  if Celluloid.task_class == Celluloid::Task::Fibered
+    it_behaves_like "a Celluloid Task"
+  end
+end

data/spec/celluloid/task/threaded_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe Celluloid::Task::Threaded, actor_system: :within do
+  if Celluloid.task_class == Celluloid::Task::Threaded
+    it_behaves_like "a Celluloid Task"
+  end
+end

data/spec/celluloid/timer_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 class EveryActor
   include Celluloid
 
@@ -7,39 +5,39 @@ class EveryActor
     @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
+
+  attr_reader :trace
+  attr_reader :times
 end
 
-describe Celluloid::Actor do
+RSpec.describe "Celluloid::Actor timers" do
   it "run every(t) task several times" do
     Celluloid.boot
-    
+
     every_actor = EveryActor.new
-    
+
     sleep 5.5
-    
-    times = every_actor.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

data/spec/deprecate/actor_system_spec.rb

@@ -0,0 +1,72 @@
+RSpec.describe "Deprecated Celluloid::ActorSystem" do
+  subject { Celluloid::ActorSystem.new }
+
+  class DeprecatedTestActor
+    include Celluloid
+  end
+
+  it "supports non-global ActorSystem" do
+    subject.within do
+      expect(Celluloid.actor_system).to eq(subject)
+    end
+  end
+
+  it "starts default actors" do
+    subject.start
+    expect(subject.registered).to eq(Celluloid::ActorSystem::ROOT_SERVICES.map { |r| r[:as] })
+    subject.shutdown
+  end
+
+  it "support getting threads" do
+    subject.start
+    queue = Queue.new
+    thread = subject.get_thread do
+      expect(Celluloid.actor_system).to eq(subject)
+      queue << nil
+    end
+    queue.pop
+    subject.shutdown
+  end
+
+  it "allows a stack dump" do
+    expect(subject.stack_dump).to be_a(Celluloid::StackDump)
+  end
+
+  it "returns named actors" do
+    subject.start
+
+    subject.within do
+      DeprecatedTestActor.supervise_as :test
+    end
+
+    expect(subject.registered).to include(:test)
+    subject.shutdown
+  end
+
+  it "returns running actors" do
+    expect(subject.running).to be_empty
+
+    first = subject.within do
+      DeprecatedTestActor.new
+    end
+
+    second = subject.within do
+      DeprecatedTestActor.new
+    end
+
+    expect(subject.running).to eq([first, second])
+    subject.shutdown
+  end
+
+  it "shuts down" do
+    subject.shutdown
+
+    expect { subject.get_thread }
+      .to raise_error(Celluloid::Group::NotActive)
+  end
+
+  it "warns nicely when no actor system is started" do
+    expect { DeprecatedTestActor.new }
+      .to raise_error("Celluloid is not yet started; use Celluloid.boot")
+  end
+end unless $CELLULOID_BACKPORTED == false

data/spec/deprecate/block_spec.rb

@@ -0,0 +1,52 @@
+RSpec.describe "Deprecated Blocks", actor_system: :global do
+  class DeprecatedBlockActor
+    include Celluloid
+
+    def initialize(name)
+      @name = name
+    end
+    attr_reader :name
+
+    def ask_for_something(other)
+      sender_actor = current_actor
+      $data << [:outside, @name, current_actor.name]
+      other.do_something_and_callback do |value|
+        $data << [:yielded, @name, current_actor.name]
+        $data << receive_result(:self)
+        $data << current_actor.receive_result(:current_actor)
+        $data << sender_actor.receive_result(:sender)
+        "somevalue"
+      end
+    end
+
+    def do_something_and_callback
+      $data << [:something, @name, current_actor.name]
+      $data << yield(:foo)
+    end
+
+    def receive_result(result)
+      [result, @name, current_actor.name]
+    end
+  end
+
+  it "works" do
+    $data = []
+
+    a1 = DeprecatedBlockActor.new("one")
+    a2 = DeprecatedBlockActor.new("two")
+
+    a1.ask_for_something a2
+
+    expected = [
+      [:outside, "one", "one"],
+      [:something, "two", "two"],
+      [:yielded, "one", "one"],
+      [:self, "one", "one"],
+      [:current_actor, "one", "one"],
+      [:sender, "one", "one"],
+      "somevalue",
+    ]
+
+    expect($data).to eq(expected)
+  end
+end unless $CELLULOID_BACKPORTED == false

data/spec/deprecate/calls_spec.rb

@@ -0,0 +1,57 @@
+RSpec.describe "Deprecated Celluloid::SyncCall", actor_system: :global do
+  subject { Celluloid::SyncCall.new }
+
+  class DeprecatedCallExampleActor
+    include Celluloid
+
+    def initialize(next_actor = nil)
+      @next = next_actor
+    end
+
+    def actual_method; end
+
+    def inspect
+      fail "Please don't call me! I'm not ready yet!"
+    end
+
+    def chained_call_ids
+      [call_chain_id, @next.call_chain_id]
+    end
+  end
+
+  let(:actor) { DeprecatedCallExampleActor.new }
+
+  context "when obj does not respond to a method" do
+    it "raises a NoMethodError" do
+      expect do
+        actor.the_method_that_wasnt_there
+      end.to raise_exception(NoMethodError)
+      expect(actor).to be_alive
+    end
+
+    context "when obj raises during inspect" do
+      it "should emulate obj.inspect" do
+        expect(actor).to_not receive(:inspect)
+        expect { actor.no_such_method }.to raise_exception(
+          NoMethodError,
+          /undefined method `no_such_method' for #\<DeprecatedCallExampleActor:0x[a-f0-9]+>/,
+        )
+      end
+    end
+  end
+
+  it "aborts with ArgumentError when a method is called with too many arguments" do
+    expect do
+      actor.actual_method("with too many arguments")
+    end.to raise_exception(ArgumentError)
+
+    expect(actor).to be_alive
+  end
+
+  it "preserves call chains across synchronous calls" do
+    actor2 = DeprecatedCallExampleActor.new(actor)
+
+    uuid, next_actor_uuid = actor2.chained_call_ids
+    expect(uuid).to eq next_actor_uuid
+  end
+end unless $CELLULOID_BACKPORTED == false

data/spec/deprecate/evented_mailbox_spec.rb

@@ -0,0 +1,34 @@
+unless $CELLULOID_BACKPORTED == false
+  class DeprecatedTestEventedMailbox < Celluloid::Mailbox::Evented
+    class Reactor
+      def initialize
+        @condition = ConditionVariable.new
+        @mutex = Mutex.new
+      end
+
+      def wakeup
+        @mutex.synchronize do
+          @condition.signal
+        end
+      end
+
+      def run_once(timeout)
+        @mutex.synchronize do
+          @condition.wait(@mutex, timeout)
+        end
+      end
+
+      def shutdown
+      end
+    end
+
+    def initialize
+      super(Reactor)
+    end
+  end
+
+  RSpec.describe "Deprecated Celluloid::Mailbox::Evented" do
+    subject { DeprecatedTestEventedMailbox.new }
+    it_behaves_like "a Celluloid Mailbox"
+  end
+end