celluloid 0.18.0.pre → 0.18.0

data/spec/shared/stack_examples.rb

@@ -0,0 +1,87 @@
+RSpec.shared_examples "a Celluloid Stack" do
+  let(:actor_system) { Celluloid::Actor::System.new }
+  let(:threads) { Queue.new }
+
+  before(:each) do
+    items = 0
+
+    [Celluloid::Task::Fibered, Celluloid::Task::Threaded].each do |task_klass|
+      create_async_blocking_actor(task_klass)
+      items += 1
+    end
+
+    @active_thread = create_thread_with_role(threads, :other_thing)
+    items += 1
+
+    @idle_thread = create_thread_with_role(threads, :idle_thing)
+    items += 1
+
+    # StackWaiter for each thread to add itself to the queue
+    tmp = Queue.new
+    items.times do
+      th = Timeout.timeout(4) { threads.pop }
+      tmp << th
+    end
+
+    expect(threads).to be_empty
+
+    # put threads back into the queue for killing
+    threads << tmp.pop until tmp.empty?
+  end
+
+  after do
+    StackWaiter.no_longer
+    actor_system.shutdown
+  end
+
+  describe "#actors" do
+    it "should include all actors" do
+      expect(subject.actors.size).to eq(2)
+    end
+  end
+
+  describe "#threads" do
+    # TODO: this spec should use mocks because it's non-deterministict
+    it "should include threads that are not actors" do
+      # TODO: Assess need for bypassing StackWaiter.forever's QUEUE.pop after #670 & #678
+      # NOTE: Pool#each doesn't guarantee to contain the newly started thread
+      # because the actor's methods (which create and store the thread handle)
+      # are started asynchronously.
+      #
+      # The mutexes in InternalPool especially can cause additional delay -
+      # causing Pool#get to wait for IPool#each to free the mutex before the
+      # new thread can be stored.
+      #
+      # And, Internals::StackDump#threads is cached, so we have to reconstruct the
+      # Internals::StackDump until it matches reality.
+      #
+      # Also, the actual number of threads and how InternalPool juggles them is
+      # non deterministic to begin with:
+      #
+      # 2 actors
+      #   -> *0-1 task threads
+      #
+      # *1 idle thread
+      # *1 active thread
+      #
+      # Together: 3-4 threads
+
+      # Pool somehow doesn't create extra tasks
+      # 5 is on JRuby-head
+      expected = Celluloid.group_class == Celluloid::Group::Pool ? [3, 4] : [3, 4, 5, 6]
+      expect(expected).to include(subject.threads.size)
+    end
+
+    it "should include idle threads" do
+      expect(subject.threads.map(&:thread_id)).to include(@idle_thread.object_id)
+    end
+
+    it "should include threads checked out of the group for roles other than :actor" do
+      expect(subject.threads.map(&:thread_id)).to include(@active_thread.object_id)
+    end
+
+    it "should have the correct roles" do
+      expect(subject.threads.map(&:role)).to include(:idle_thing, :other_thing)
+    end
+  end
+end

data/spec/shared/task_examples.rb

@@ -5,8 +5,7 @@ class MockActor
     @tasks = []
   end
 
-  def setup_thread
-  end
+  def setup_thread; end
 end
 
 RSpec.shared_examples "a Celluloid Task" do
@@ -41,7 +40,7 @@ RSpec.shared_examples "a Celluloid Task" do
 
   it "raises exceptions outside" do
     task = Celluloid.task_class.new(task_type, {}) do
-      fail "failure"
+      raise "failure"
     end
     expect do
       task.resume

data/spec/spec_helper.rb

@@ -1,7 +1,5 @@
-require "rubygems"
-require "bundler/setup"
-
+require "rspec/retry"
 require "celluloid/rspec"
-require "celluloid/essentials"
+require "celluloid/supervision"
 
 Dir[*Specs::INCLUDE_PATHS].map { |f| require f }

data/spec/support/configure_rspec.rb

@@ -1,5 +1,4 @@
 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
@@ -19,7 +18,7 @@ RSpec.configure do |config|
   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    ")})"\
+      raise "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
@@ -42,7 +41,7 @@ RSpec.configure do |config|
         "\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}"
+      raise "Actor crashes occurred (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

data/spec/support/coverage.rb

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

data/spec/support/crash_checking.rb

@@ -19,7 +19,7 @@ module Specs
 
     def crash(*args)
       check
-      fail "Testing block has already ended!" if @details
+      raise "Testing block has already ended!" if @details
       @crashes << [args, caller.dup]
     end
 
@@ -59,7 +59,7 @@ module Specs
     def check
       return if self.class.allowed_logger.first == self
 
-      fail "Incorrect logger used:"\
+      raise "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?)"

data/spec/support/examples/actor_class.rb

@@ -45,7 +45,7 @@ module ExampleActorClass
       end
 
       def crash
-        fail ExampleCrash, "the spec purposely crashed me :("
+        raise ExampleCrash, "the spec purposely crashed me :("
       end
 
       def crash_with_abort(reason, foo = nil)
@@ -89,11 +89,7 @@ module ExampleActorClass
       end
 
       def respond_to?(method_name, include_private = false)
-        if delegates?(method_name)
-          delegates?(method_name)
-        else
-          super
-        end
+        delegates?(method_name) || super
       end
 
       def method(method_name)
@@ -114,8 +110,7 @@ module ExampleActorClass
       private :zomg_private
       attr_reader :private_called
 
-      def my_finalizer
-      end
+      def my_finalizer; end
 
       private
 

data/spec/support/examples/call_class.rb

@@ -8,7 +8,7 @@ class CallExampleActor
   def actual_method; end
 
   def inspect
-    fail "Don't call!"
+    raise "Don't call!"
   end
 
   def chained_call_ids
@@ -28,7 +28,7 @@ class DeprecatedCallExampleActor
   def actual_method; end
 
   def inspect
-    fail "Please don't call me! I'm not ready yet!"
+    raise "Please don't call me! I'm not ready yet!"
   end
 
   def chained_call_ids

data/spec/support/examples/container_class.rb

@@ -0,0 +1,35 @@
+class SupervisionContainerHelper
+  @queue = nil
+  class << self
+    def reset!
+      @queue = Queue.new
+    end
+
+    def done!
+      @queue << :done
+    end
+
+    def pop!
+      @queue.pop
+    end
+  end
+end
+
+class MyContainerActor
+  include Celluloid
+
+  attr_reader :args
+
+  def initialize(*args)
+    @args = args
+    ready
+  end
+
+  def running?
+    :yep
+  end
+
+  def ready
+    SupervisionContainerHelper.done!
+  end
+end

data/spec/support/examples/evented_mailbox_class.rb

@@ -17,8 +17,7 @@ class TestEventedMailbox < Celluloid::Mailbox::Evented
       end
     end
 
-    def shutdown
-    end
+    def shutdown; end
   end
 
   def initialize

data/spec/support/examples/stack_classes.rb

@@ -0,0 +1,58 @@
+class StackWaiter
+  QUEUE = Queue.new
+  WAITERS = Queue.new
+  ACTORS = Queue.new
+
+  class << self
+    def forever
+      WAITERS << Thread.current
+      # de QUEUE.pop
+      sleep
+    end
+
+    def no_longer
+      StackWaiter::ACTORS.pop.terminate until StackWaiter::ACTORS.empty?
+
+      loop do
+        break if WAITERS.empty?
+        QUEUE << nil
+        nicely_end_thread(WAITERS.pop)
+      end
+    end
+
+    def nicely_end_thread(th)
+      return if jruby_fiber?(th)
+
+      status = th.status
+      case status
+      when nil, false, "dead"
+      when "aborting"
+        th.join(2) || STDERR.puts("Thread join timed out...")
+      when "sleep", "run"
+        th.kill
+        th.join(2) || STDERR.puts("Thread join timed out...")
+      else
+        STDERR.puts "unknown status: #{th.status.inspect}"
+      end
+    end
+
+    def jruby_fiber?(th)
+      return false unless RUBY_PLATFORM == "java" && (java_th = th.to_java.getNativeThread)
+      /Fiber/ =~ java_th.get_name
+    end
+  end
+end
+
+class StackBlocker
+  include Celluloid
+
+  def initialize(threads)
+    @threads = threads
+  end
+
+  def blocking
+    StackWaiter::ACTORS << Thread.current
+    @threads << Thread.current
+    StackWaiter.forever
+  end
+end

data/spec/support/examples/stack_methods.rb

@@ -0,0 +1,23 @@
+def create_async_blocking_actor(task_klass)
+  actor_klass = Class.new(StackBlocker) do
+    task_class task_klass
+  end
+
+  actor = actor_system.within do
+    actor_klass.new(threads)
+  end
+
+  actor.async.blocking
+end
+
+def create_thread_with_role(threads, role)
+  resume = Queue.new
+  thread = actor_system.get_thread do
+    resume.pop # to avoid race for 'thread' variable
+    thread.role = role
+    threads << thread
+    StackWaiter.forever
+  end
+  resume << nil # to avoid race for 'thread' variable
+  thread
+end

data/spec/support/examples/subordinate_class.rb

@@ -0,0 +1,19 @@
+class SubordinateDead < Celluloid::Error; 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

data/spec/support/logging.rb

@@ -1,21 +1,7 @@
 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 }
+      @logger ||= default_logger.tap { |log| log.level = Logger::WARN }
     end
 
     attr_writer :logger
@@ -23,15 +9,7 @@ module Specs
     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
+      Logger.new(STDERR)
     end
 
     def open_logfile(rel_path, sync)
@@ -42,15 +20,5 @@ module Specs
       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

data/spec/support/loose_threads.rb

@@ -13,20 +13,7 @@ module Specs
           backtrace = thread.backtrace # avoid race maybe
           next unless backtrace
           next if backtrace.empty? # possibly a timer thread
-        end
-
-        if RUBY_ENGINE == "rbx"
-          # Avoid disrupting Rubinious thread
-          next if thread.backtrace.first =~ %r{rubysl/timeout/timeout\.rb}
-
-          if Specs::ALLOW_SLOW_MAILBOXES
-            if thread.backtrace.first =~ /wait/
-              next if thread.backtrace[1] =~ /mailbox\.rb/ && thread.backtrace[1] =~ /check/
-            end
-          end
-        end
-
-        if RUBY_ENGINE == "ruby"
+        else
           # Sometimes stays
           next if thread.backtrace.nil?
           next unless thread.backtrace.is_a?(Array)
@@ -39,7 +26,7 @@ module Specs
     end
 
     def thread_name(thread)
-      (RUBY_PLATFORM == "java") ? thread.to_java.getNativeThread.get_name : ""
+      RUBY_PLATFORM == "java" ? thread.to_java.getNativeThread.get_name : ""
     end
 
     def assert_no_loose_threads!(location)
@@ -61,7 +48,7 @@ module Specs
         sleep
       end
 
-      fail Celluloid::ThreadLeak, "Aborted due to runaway threads (#{location})\n"\
+      raise Celluloid::ThreadLeak, "Aborted due to runaway threads (#{location})\n"\
         "List: (#{loose.map(&:inspect)})\n:#{backtraces.join("\n")}"
     end
   end