celluloid 0.16.0 → 0.17.3

data/spec/shared/group_examples.rb

@@ -0,0 +1,121 @@
+RSpec.shared_examples "a Celluloid Group" do
+  let!(:queue) { Queue.new }
+  let!(:busy_queue) { Queue.new }
+
+  let(:logger) { Specs::FakeLogger.current }
+
+  def wait_until_busy(busy_queue = nil)
+    return busy_queue.pop if busy_queue
+    Specs.sleep_and_wait_until { subject.busy? }
+  end
+
+  def wait_until_idle
+    Specs.sleep_and_wait_until { subject.idle? }
+  end
+
+  before { subject }
+
+  after do
+    subject.shutdown
+  end
+
+  it "gets threads" do
+    expect(subject.get { queue.pop }).to be_a Thread
+    queue << nil
+    wait_until_idle
+  end
+
+  [::StandardError, ::Exception].each do |exception_class|
+    context "with an #{exception_class} in the thread" do
+      before do
+        @wait_queue = Queue.new # doesn't work if in a let()
+
+        allow(logger).to receive(:crash)
+
+        subject.get do
+          busy_queue << nil
+          @wait_queue.pop
+          fail exception_class, "Error"
+        end
+
+        wait_until_busy(busy_queue)
+      end
+
+      it "logs the crash" do
+        expect(logger).to receive(:crash).with("thread crashed", exception_class)
+        @wait_queue << nil # let the thread fail
+        wait_until_idle
+      end
+
+      it "puts error'd threads back" do
+        @wait_queue << nil # let the thread fail
+        wait_until_idle
+        expect(subject.idle?).to be_truthy
+      end
+    end
+  end
+
+  context "when a thread has local variables" do
+    before do
+      @thread = subject.get do
+        Thread.current[:foo] = :bar
+        queue.pop
+      end
+
+      wait_until_busy
+
+      queue << nil # let the thread finish
+      if Celluloid.group_class == Celluloid::Group::Pool
+        # Wait until we get the same thread for a different proc
+        Specs.sleep_and_wait_until { subject.get { sleep 0.1 } == @thread }
+      else
+        wait_until_idle
+      end
+    end
+
+    # Cleaning not necessary for Spawner
+    unless Celluloid.group_class == Celluloid::Group::Spawner
+      it "cleans thread locals from old threads" do
+        expect(@thread[:foo]).to be_nil
+      end
+    end
+  end
+
+  it "shuts down" do
+    subject
+    thread = Queue.new
+
+    expect(
+      subject.get do
+        thread << Thread.current
+        sleep
+      end,
+    ).to be_a(Celluloid::Thread)
+
+    thread.pop # wait for 3rd-party thread to get strated
+
+    expect(subject.active?).to eq true
+    subject.shutdown
+    expect(subject.active?).to eq false
+    expect(subject.group.length).to eq 0
+  end
+
+  context "with a dead thread" do
+    before do
+      if Celluloid.group_class == Celluloid::Group::Pool
+        subject.max_idle = 0 # Instruct the pool to immediately shut down the thread.
+      end
+
+      subject.get { queue.pop }
+      wait_until_busy
+      queue << nil
+      wait_until_idle
+
+      subject.shutdown if Celluloid.group_class == Celluloid::Group::Spawner
+    end
+
+    it "doesn't leak dead threads" do
+      expect(subject.to_a.size).to eq(0)
+    end
+  end
+end

data/spec/shared/mailbox_examples.rb

@@ -0,0 +1,87 @@
+RSpec.shared_examples "a Celluloid Mailbox" do
+  after do
+    allow(Celluloid.logger).to receive(:debug)
+    subject.shutdown if subject.alive?
+  end
+
+  it "receives messages" do
+    message = :ohai
+
+    subject << message
+    expect(subject.receive).to eq(message)
+  end
+
+  it "prioritizes system events over other messages" do
+    subject << :dummy1
+    subject << :dummy2
+
+    subject << Celluloid::SystemEvent.new
+    expect(subject.receive).to be_a(Celluloid::SystemEvent)
+  end
+
+  it "selectively receives messages with a block" do
+    class Foo; end
+    class Bar; end
+    class Baz; end
+
+    foo = Foo.new
+    bar = Bar.new
+    baz = Baz.new
+
+    subject << baz
+    subject << foo
+    subject << bar
+
+    expect(subject.receive { |msg| msg.is_a? Foo }).to eq(foo)
+    expect(subject.receive { |msg| msg.is_a? Bar }).to eq(bar)
+    expect(subject.receive).to eq(baz)
+  end
+
+  it "waits for a given timeout interval" do
+    interval = 0.1
+    started_at = Time.now
+
+    expect do
+      subject.receive(interval) { false }
+    end.to raise_exception(Celluloid::TaskTimeout)
+
+    # Just check to make sure it didn't return earlier
+    expect(Time.now - started_at).to be >= interval
+  end
+
+  it "has a size" do
+    expect(subject).to respond_to(:size)
+    expect(subject.size).to be_zero
+    subject << :foo
+    subject << :foo
+    expect(subject.entries.size).to eq(2)
+  end
+
+  it "discards messages received when when full" do
+    subject.max_size = 2
+    subject << :first
+    subject << :second
+    subject << :third
+    expect(subject.to_a).to match_array([:first, :second])
+  end
+
+  it "logs discarded messages" do
+    expect(Celluloid.logger).to receive(:debug).with("Discarded message (mailbox is dead): third")
+
+    subject.max_size = 2
+    subject << :first
+    subject << :second
+    subject << :third
+  end
+
+  it "discard messages when dead" do
+    expect(Celluloid.logger).to receive(:debug).with("Discarded message (mailbox is dead): first")
+    expect(Celluloid.logger).to receive(:debug).with("Discarded message (mailbox is dead): second")
+    expect(Celluloid.logger).to receive(:debug).with("Discarded message (mailbox is dead): third")
+
+    subject << :first
+    subject << :second
+    subject.shutdown
+    subject << :third
+  end
+end

data/{lib/celluloid/rspec → spec/shared}/task_examples.rb

@@ -9,12 +9,12 @@ class MockActor
   end
 end
 
-shared_context "a Celluloid Task" do |task_class|
+RSpec.shared_examples "a Celluloid Task" do
   let(:task_type)     { :foobar }
   let(:suspend_state) { :doing_something }
   let(:actor)         { MockActor.new }
 
-  subject { task_class.new(task_type, {}) { Celluloid::Task.suspend(suspend_state) } }
+  subject { Celluloid.task_class.new(task_type, {}) { Celluloid::Task.suspend(suspend_state) } }
 
   before :each do
     Thread.current[:celluloid_actor_system] = Celluloid.actor_system
@@ -22,25 +22,26 @@ shared_context "a Celluloid Task" do |task_class|
   end
 
   after :each do
+    Thread.current[:celluloid_actor_system].shutdown
     Thread.current[:celluloid_actor] = nil
     Thread.current[:celluloid_actor_system] = nil
   end
 
   it "begins with status :new" do
-    subject.status.should be :new
+    expect(subject.status).to be :new
   end
 
   it "resumes" do
-    subject.should be_running
+    expect(subject).to be_running
     subject.resume
-    subject.status.should eq(suspend_state)
+    expect(subject.status).to eq(suspend_state)
     subject.resume
-    subject.should_not be_running
+    expect(subject).not_to be_running
   end
 
   it "raises exceptions outside" do
-    task = task_class.new(task_type, {}) do
-      raise "failure"
+    task = Celluloid.task_class.new(task_type, {}) do
+      fail "failure"
     end
     expect do
       task.resume

data/spec/spec_helper.rb

@@ -1,44 +1,7 @@
-require 'coveralls'
-Coveralls.wear!
+require "rubygems"
+require "bundler/setup"
 
-require 'rubygems'
-require 'bundler/setup'
-require 'celluloid/rspec'
-require 'celluloid/probe'
+require "celluloid/rspec"
+require "celluloid/essentials"
 
-logfile = File.open(File.expand_path("../../log/test.log", __FILE__), 'a')
-logfile.sync = true
-
-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.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
+Dir[*Specs::INCLUDE_PATHS].map { |f| require f }

data/spec/support/configure_rspec.rb

@@ -0,0 +1,77 @@
+RSpec.configure do |config|
+  config.filter_run focus: true unless Nenv.ci?
+  config.run_all_when_everything_filtered = true
+  config.disable_monkey_patching!
+  config.profile_examples = 3
+  config.filter_gems_from_backtrace(*Specs::BACKTRACE_OMITTED)
+
+  config.verbose_retry = true
+  config.default_retry_count = Specs::ALLOW_RETRIES
+  config.display_try_failure_messages = true
+  config.default_sleep_interval = 1
+  config.exceptions_to_retry = [Timeout::Error, Celluloid::ThreadLeak]
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_doubled_constant_names = true
+    mocks.verify_partial_doubles = true
+  end
+
+  config.before(:suite) do
+    Specs.stub_out_class_method(Celluloid::Internals::Logger, :crash) do |*args|
+      _name, ex = *args
+      fail "Unstubbed Logger.crash() was called:\n  crash(\n    #{args.map(&:inspect).join(",\n    ")})"\
+        "\nException backtrace: \n  (#{ex.class}) #{ex.backtrace * "\n  (#{ex.class}) "}"
+    end
+  end
+
+  config.before(:each) do |example|
+    @fake_logger = Specs::FakeLogger.new(Celluloid.logger, example.description)
+    stub_const("Celluloid::Internals::Logger", @fake_logger)
+  end
+
+  config.around do |ex|
+    # Needed because some specs mock/stub/expect on the logger
+    Celluloid.logger = Specs.logger
+    Celluloid.actor_system = nil
+    Specs.reset_class_variables(ex.description) do
+      Timeout.timeout(Specs::MAX_EXECUTION) { ex.run }
+    end
+    if @fake_logger.crashes?
+      crashes = @fake_logger.crashes.map do |args, call_stack|
+        msg, ex = *args
+        "\n** Crash: #{msg.inspect}(#{ex.inspect})\n  Backtrace:\n    (crash) #{call_stack * "\n    (crash) "}"\
+          "\n  Exception Backtrace (#{ex.inspect}):\n    (ex) #{ex.backtrace * "\n    (ex) "}"
+      end.join("\n")
+      fail "Actor crashes occured (please stub/mock if these are expected): #{crashes}"
+    end
+    @fake_logger = nil
+    Specs.assert_no_loose_threads!("after example: #{ex.description}") if Specs::CHECK_LOOSE_THREADS
+  end
+
+  config.around :each, library: :IO do |ex|
+    Celluloid.init
+    FileUtils.rm("/tmp/cell_sock") if File.exist?("/tmp/cell_sock")
+    ex.run
+    Celluloid.shutdown
+  end
+
+  config.around :each, library: :ZMQ do |ex|
+    Celluloid::ZMQ.init(1) unless ex.metadata[:no_init]
+    Celluloid.boot
+    ex.run
+    Celluloid.shutdown
+    Celluloid::ZMQ.terminate
+  end
+
+  config.around :each, actor_system: :global do |ex|
+    Celluloid.boot
+    ex.run
+    Celluloid.shutdown
+  end
+
+  config.around :each, actor_system: :within do |ex|
+    Celluloid::Actor::System.new.within do
+      ex.run
+    end
+  end
+end

data/spec/support/coverage.rb

@@ -0,0 +1,4 @@
+if Nenv.ci?
+  require "coveralls"
+  Coveralls.wear!
+end

data/spec/support/crash_checking.rb

@@ -0,0 +1,68 @@
+module Specs
+  class FakeLogger
+    class << self
+      def current
+        allowed_logger.first
+      end
+
+      attr_accessor :allowed_logger
+    end
+
+    def initialize(real_logger, example)
+      @mutex = Mutex.new
+      @real_logger = real_logger
+      @crashes = Queue.new
+      @details = nil
+      @example = example
+      self.class.allowed_logger = [self, example]
+    end
+
+    def crash(*args)
+      check
+      fail "Testing block has already ended!" if @details
+      @crashes << [args, caller.dup]
+    end
+
+    def debug(*args)
+      check
+      @real_logger.debug(*args)
+    end
+
+    def warn(*args)
+      check
+      @real_logger.warn(*args)
+    end
+
+    def with_backtrace(_backtrace)
+      check
+      yield self
+    end
+
+    def crashes
+      check
+      @mutex.synchronize do
+        return @details if @details
+        @details = []
+        @details << @crashes.pop until @crashes.empty?
+        @crashes = nil
+        @details
+      end
+    end
+
+    def crashes?
+      check
+      !crashes.empty?
+    end
+
+    private
+
+    def check
+      return if self.class.allowed_logger.first == self
+
+      fail "Incorrect logger used:"\
+        " active/allowed: \n#{clas.allowed_logger.inspect},\n"\
+        " actual/self: \n#{[self, @example].inspect}\n"\
+        " (maybe an actor from another test is still running?)"
+    end
+  end
+end

data/spec/support/debugging.rb

@@ -0,0 +1,31 @@
+module Debugging
+  # Attempt to safely convert an object to a useful string (without side
+  # effects if possible)
+  #
+  # Feel free to add support for more objects/responses/etc.
+  def self.dump(obj)
+    case obj
+    when ::Symbol
+      obj.inspect
+    when ::String
+      obj
+    when ::Regexp
+      obj.inspect
+    when ::IO
+      obj.inspect
+    when ::Array
+      obj.map { |a| Debugging.dump(a) }.to_s
+    when ::Celluloid::Response::Success
+      "SuccessResponse(#{dump(obj.value)}) (#{dump(obj.call)})"
+    when ::Celluloid::Call
+      args = obj.arguments.map { |a| Debugging.dump(a) }
+      "Call: #{obj}-> #{obj.method.inspect}(#{args.join(', ')})"
+    else
+      begin
+        obj.__send__(:__class__).to_s
+      rescue NoMethodError
+        obj.__send__(:class).to_s
+      end
+    end
+  end
+end

data/spec/support/env.rb

@@ -0,0 +1,21 @@
+require "nenv"
+require "dotenv"
+
+# Default to `pwd`/.env-* ( whatever is in the current directory )
+# Otherwise take the `.env-*` from the gem itself.
+unless env = Nenv("celluloid").config_file
+  env = Nenv.ci? ? ".env-ci" : ".env-dev"
+  unless File.exist?(env)
+    env = File.expand_path("../../../#{env}", __FILE__)
+  end
+end
+
+Dotenv.load!(env) rescue nil # If for some reason no .env-* files are available at all, use defaults.
+
+module Specs
+  class << self
+    def env
+      @env ||= Nenv("celluloid_specs")
+    end
+  end
+end

data/{lib/celluloid/rspec/example_actor_class.rb → spec/support/examples/actor_class.rb}

@@ -1,3 +1,7 @@
+class ExampleCrash < Celluloid::Error
+  attr_accessor :foo
+end
+
 module ExampleActorClass
   def self.create(included_module, task_klass)
     Class.new do
@@ -41,7 +45,7 @@ module ExampleActorClass
       end
 
       def crash
-        raise ExampleCrash, "the spec purposely crashed me :("
+        fail ExampleCrash, "the spec purposely crashed me :("
       end
 
       def crash_with_abort(reason, foo = nil)
@@ -74,6 +78,8 @@ module ExampleActorClass
         terminate
       end
 
+      # Ideally, this class should implement "fake methods"
+      # consistently, including :methods, :public_methods, etc.
       def method_missing(method_name, *args, &block)
         if delegates?(method_name)
           @delegate.send method_name, *args, &block
@@ -83,7 +89,19 @@ module ExampleActorClass
       end
 
       def respond_to?(method_name, include_private = false)
-        super || delegates?(method_name)
+        if delegates?(method_name)
+          delegates?(method_name)
+        else
+          super
+        end
+      end
+
+      def method(method_name)
+        if delegates?(method_name)
+          @delegate.method(method_name)
+        else
+          super
+        end
       end
 
       def call_private
@@ -102,6 +120,7 @@ module ExampleActorClass
       private
 
       def delegates?(method_name)
+        return false unless @delegate ||= nil
         @delegate.respond_to?(method_name)
       end
     end

data/spec/support/examples/call_class.rb

@@ -0,0 +1,37 @@
+class CallExampleActor
+  include Celluloid
+
+  def initialize(next_actor = nil)
+    @next = next_actor
+  end
+
+  def actual_method; end
+
+  def inspect
+    fail "Don't call!"
+  end
+
+  def chained_call_ids
+    [call_chain_id, @next.call_chain_id]
+  end
+end
+
+# de DEPRECATE:
+
+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

data/spec/support/examples/evented_mailbox_class.rb

@@ -0,0 +1,27 @@
+class TestEventedMailbox < 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

data/spec/support/includer.rb

@@ -0,0 +1,6 @@
+module CelluloidSpecs
+  def self.included_module
+    # Celluloid::IO implements this with with 'Celluloid::IO'
+    (defined? INCLUDED_MODULE) ? INCLUDED_MODULE : Celluloid
+  end
+end

data/spec/support/logging.rb

@@ -0,0 +1,55 @@
+module Specs
+  class << self
+    def log
+      # Setup ENV variable handling with sane defaults
+      @log ||= Nenv("celluloid_specs_log") do |env|
+        env.create_method(:file) { |f| f || "log/default.log" }
+        env.create_method(:sync?) { |s| s || !Nenv.ci? }
+
+        env.create_method(:strategy) do |strategy|
+          strategy || default_strategy
+        end
+
+        env.create_method(:level) { |level| default_level_for(env, level) }
+      end
+    end
+
+    def logger
+      @logger ||= default_logger.tap { |logger| logger.level = log.level }
+    end
+
+    attr_writer :logger
+
+    private
+
+    def default_logger
+      case log.strategy
+      when "stderr"
+        Logger.new(STDERR)
+      when "single"
+        Logger.new(open_logfile(log.file, log.sync?))
+      else
+        fail "Unknown logger strategy: #{strategy.inspect}."\
+          " Expected 'single' or 'stderr'."
+      end
+    end
+
+    def open_logfile(rel_path, sync)
+      root = Pathname(__FILE__).dirname.dirname.dirname
+      log_path = root + rel_path
+      logfile = File.open(log_path.to_s, "a")
+      logfile.sync if sync
+      logfile
+    end
+
+    def default_strategy
+      (Nenv.ci? ? "stderr" : "single")
+    end
+
+    def default_level_for(env, level)
+      Integer(level)
+    rescue
+      env.strategy == "stderr" ? Logger::WARN : Logger::DEBUG
+    end
+  end
+end