celluloid 0.18.0.pre → 0.18.0.pre2

data/spec/celluloid/supervision/configuration_spec.rb

@@ -0,0 +1,181 @@
+RSpec.describe Celluloid::Supervision::Configuration, actor_system: :global do
+  class TestActor
+    include Celluloid
+    def identity
+      :testing
+    end
+  end
+
+  let(:succeeding) do
+    {
+      as: :testing,
+      type: TestActor
+    }
+  end
+
+  let(:failing) do
+    {
+      as: :testing,
+      type: TestActor,
+      args: [:fail]
+    }
+  end
+
+  after(:each) do
+    Celluloid::Supervision::Configuration.resync_parameters
+    subject.resync_accessors
+  end
+
+  context("remains reusable without being mutated") do
+    it("properly") do
+      expect(Celluloid.actor_system.root_configuration.export).to eq(Celluloid::Actor::System::ROOT_SERVICES)
+    end
+  end
+
+  context("metaprogramming") do
+    context("Celluloid.services accessor") do
+      it("is dynamically added, and available") do
+        expect(Celluloid.services.respond_to?(:supervise)).to be_truthy
+      end
+      it("allows supervision") do
+        Celluloid.services.supervise(type: TestActor, as: :test_actor)
+        expect(Celluloid.services.test_actor.identity).to eq(:testing)
+      end
+    end
+
+    context("supervised actors can create accessors") do
+      it("which are dynamically added, and available as Celluloid.accessor") do
+        TestActor.supervise(as: :test_actor, accessors: [:test_actor])
+        expect(Celluloid.test_actor.identity).to eq(:testing)
+      end
+    end
+  end
+
+  context("parameters") do
+    context("can be added to") do
+      context("can be given new :mandatory parameters") do
+        before(:each) do
+          Celluloid::Supervision::Configuration.parameter! :mandatory, :special_requirement
+          subject.resync_accessors
+        end
+
+        it("programmatically") do
+          expect(Celluloid::Supervision::Configuration.parameters(:mandatory)).to include(:special_requirement)
+        end
+
+        it("and respond appropriately") do
+          subject.resync_accessors
+          expect(subject.methods).to include(:special_requirement)
+          expect(subject.respond_to?(:special_requirement!)).to be_truthy
+          expect(subject.respond_to?(:special_requirement?)).to be_truthy
+          expect(subject.respond_to?(:special_requirement=)).to be_truthy
+          expect(subject.respond_to?(:special_requirement)).to be_truthy
+        end
+
+        it("and instances will respond appropriately") do
+          subject.instances.first.resync_accessors
+          subject.define(type: TestActor, special_requirement: :valid)
+          expect(subject.respond_to?(:special_requirement)).to be_truthy
+        end
+
+        it("and be reset to defaults") do
+          Celluloid::Supervision::Configuration.resync_parameters
+          expect(Celluloid::Supervision::Configuration.parameters(:mandatory)).not_to include(:special_requirement)
+        end
+      end
+
+      context("can be aliased") do
+        before(:each) do
+          Celluloid::Supervision::Configuration.resync_parameters
+          Celluloid::Supervision::Configuration.alias! :nick, :as
+          subject.resync_accessors
+        end
+
+        it("programmatically") do
+          expect(Celluloid::Supervision::Configuration.aliases.keys).to include(:nick)
+        end
+
+        it("and respond appropriately by method") do
+          subject.define(type: TestActor, as: :test_name)
+          expect(subject.respond_to?(:nick!)).to be_truthy
+          expect(subject.respond_to?(:nick?)).to be_truthy
+          expect(subject.respond_to?(:nick=)).to be_truthy
+          expect(subject.respond_to?(:nick)).to be_truthy
+          expect(subject.nick).to eq(:test_name)
+        end
+
+        xit("and respond properly by current_instance, by method") do
+          # subject.current_instance[:aliased] gets subject.current_instance[:original]
+        end
+
+        it("and instances will respond properly by method") do
+          subject.define(as: :test_name, type: TestActor)
+          expect(subject.instances.first.respond_to?(:nick!)).to be_truthy
+          expect(subject.instances.first.respond_to?(:nick?)).to be_truthy
+          expect(subject.instances.first.respond_to?(:nick=)).to be_truthy
+          expect(subject.instances.first.respond_to?(:nick)).to be_truthy
+          expect(subject.instances.first.nick).to eq(:test_name)
+        end
+
+        xit("and respond appropriately by key") do
+          # subject[:aliased] gets subject[:original]
+        end
+
+        xit("and instances respond properly by current_instance, by key") do
+          # subject.instances.first[:aliased] gets subject.instances.first[:original]
+        end
+
+        xit("and instances respond properly by key") do
+          # subject.instances.first[:aliased] gets subject.instances.first[:original]
+        end
+      end
+    end
+  end
+
+  context("Configuration.define class method") do
+    xit("can take individual instance configuration") do
+    end
+
+    xit("can take array of instance configurations") do
+    end
+  end
+
+  context("Configuration#define instance method") do
+    xit("can take individual instance configuration") do
+    end
+
+    xit("can take array of instance configurations") do
+    end
+  end
+
+  context("Configuration.deploy class method") do
+    xit("can take individual instance configuration") do
+    end
+
+    xit("can take array of instance configurations") do
+    end
+  end
+
+  context("Configuration#deploy instance method") do
+    xit("can take individual instance configuration") do
+    end
+
+    xit("can take array of instance configurations") do
+    end
+  end
+
+  context("accessing information") do
+    before(:each) { subject.define(succeeding) }
+    it("can get values out of current level of configuration by [:key]") do
+      expect(subject[:as]).to eq(:testing)
+    end
+
+    it("can get values out of current level of configuration by #key") do
+      expect(subject.as).to eq(:testing)
+    end
+  end
+
+  it("verifies arity of intended actor's initialize method") do
+    expect { subject.define(failing) }.to raise_exception(ArgumentError)
+  end
+end

data/spec/celluloid/supervision/container_spec.rb

@@ -0,0 +1,72 @@
+RSpec.describe Celluloid::Supervision::Container, actor_system: :global do
+  let(:queue_count) { 1 }
+
+  before do
+    SupervisionContainerHelper.reset!
+    subject # init for easier debugging
+    queue_count.times { SupervisionContainerHelper.pop! }
+  end
+
+  after do
+    # TODO: hangs without condition on JRuby?
+    subject.terminate if subject.alive?
+  end
+
+  context "when supervising a single actor" do
+    subject do
+      Class.new(Celluloid::Supervision::Container) do
+        supervise type: MyContainerActor, as: :example
+      end.run!(*registry)
+    end
+
+    let(:registry) { [] }
+
+    it "runs applications" do
+      expect(Celluloid::Actor[:example]).to be_running
+    end
+
+    context "with a private registry" do
+      let(:registry) { Celluloid::Internals::Registry.new }
+
+      it "accepts a private actor registry" do
+        expect(registry[:example]).to be_running
+      end
+    end
+
+    it "removes actors from the registry when terminating" do
+      subject.terminate
+      expect(Celluloid::Actor[:example]).to be_nil
+    end
+
+    it "allows external access to the internal registry" do
+      expect(subject[:example]).to be_a MyContainerActor
+    end
+  end
+
+  context "with multiple args" do
+    subject do
+      Class.new(Celluloid::Supervision::Container) do
+        supervise type: MyContainerActor, as: :example, args: %i[foo bar]
+      end.run!
+    end
+
+    it "passes them" do
+      expect(Celluloid::Actor[:example].args).to eq(%i[foo bar])
+    end
+  end
+
+  context "with lazy evaluation" do
+    subject do
+      Class.new(Celluloid::Supervision::Container) do
+        supervise type: MyContainerActor, as: :example, args: -> { :lazy }
+      end.run!
+    end
+
+    it "evaluates correctly" do
+      expect(Celluloid::Actor[:example].args).to eq([:lazy])
+    end
+  end
+
+  xit("can remove members") do
+  end
+end

data/spec/celluloid/supervision/instance_spec.rb

@@ -0,0 +1,13 @@
+# RSpec.describe Celluloid::Supervision::Configuration do
+#   xit("can be instantiated without a name") {
+#   }
+#
+#   xit("can be instantiated with a name") {
+#   }
+#
+#   context("can be terminated") {
+#     xit("cleanly") {
+#     }
+#   }
+# end
+# =

data/spec/celluloid/supervision/root_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Celluloid::Supervision::Service::Root, actor_system: :global do
+  class RootTestingActor
+    include Celluloid
+    def identity
+      :testing
+    end
+  end
+
+  before(:all) do
+    Celluloid::Supervision::Configuration.resync_parameters
+  end
+
+  context("deploys root services") do
+    it("properly") do
+      expect(Celluloid.actor_system.registered).to eq(Celluloid::Actor::System::ROOT_SERVICES.map { |r| r[:as] })
+    end
+  end
+
+  context("makes public services available") do
+    it("properly") do
+      expect(Celluloid.services.respond_to?(:supervise)).to be_truthy
+    end
+    it("and accepts one-off actor supervision") do
+      RootTestingActor.supervise as: :tester
+      expect(Celluloid[:tester].identity).to eq(:testing)
+    end
+  end
+end

data/spec/celluloid/supervision/supervisor_spec.rb

@@ -0,0 +1,93 @@
+RSpec.describe "Celluloid supervisor", actor_system: :global do
+  let(:logger) { Specs::FakeLogger.current }
+
+  it "restarts actors when they die" do
+    supervisor = Celluloid.supervise(type: Subordinate, args: [:idle])
+    subordinate = supervisor.actors.first
+    expect(subordinate.state).to be(:idle)
+
+    subordinate.crack_the_whip
+    expect(subordinate.state).to be(:working)
+
+    allow(logger).to receive(:crash).with("Actor crashed!", SubordinateDead)
+
+    expect do
+      subordinate.crack_the_whip
+    end.to raise_exception(SubordinateDead)
+    sleep 0.1 # hax to prevent race :(
+    expect(subordinate).not_to be_alive
+
+    new_subordinate = supervisor.actors.first
+    expect(new_subordinate).not_to eq subordinate
+    expect(new_subordinate.state).to eq :idle
+  end
+
+  it "registers actors and reregisters them when they die" do
+    Celluloid.supervise(as: :subordinate, type: Subordinate, args: [:idle])
+    subordinate = Celluloid::Actor[:subordinate]
+    expect(subordinate.state).to be(:idle)
+
+    subordinate.crack_the_whip
+    expect(subordinate.state).to be(:working)
+
+    allow(logger).to receive(:crash).with("Actor crashed!", SubordinateDead)
+
+    expect do
+      subordinate.crack_the_whip
+    end.to raise_exception(SubordinateDead)
+    sleep 0.1 # hax to prevent race :(
+    expect(subordinate).not_to be_alive
+
+    new_subordinate = Celluloid::Actor[:subordinate]
+    expect(new_subordinate).not_to eq subordinate
+    expect(new_subordinate.state).to eq :idle
+  end
+
+  it "creates supervisors via Actor.supervise" do
+    supervisor = Subordinate.supervise(args: [:working])
+    subordinate = supervisor.actors.first
+    expect(subordinate.state).to be(:working)
+
+    allow(logger).to receive(:crash).with("Actor crashed!", SubordinateDead)
+
+    expect do
+      subordinate.crack_the_whip
+    end.to raise_exception(SubordinateDead, "the spec purposely crashed me :(")
+
+    sleep 0.1 # hax to prevent race :(
+    expect(subordinate).not_to be_alive
+
+    new_subordinate = supervisor.actors.first
+    expect(new_subordinate).not_to eq subordinate
+    expect(new_subordinate.state).to eq :working
+  end
+
+  it "creates supervisors and registers actors via Actor.supervise as:" do
+    supervisor = Subordinate.supervise(as: :subordinate, args: [:working])
+    subordinate = Celluloid::Actor[:subordinate]
+    expect(subordinate.state).to be(:working)
+
+    allow(logger).to receive(:crash).with("Actor crashed!", SubordinateDead)
+
+    expect do
+      subordinate.crack_the_whip
+    end.to raise_exception(SubordinateDead)
+    sleep 0.1 # hax to prevent race :(
+    expect(subordinate).not_to be_alive
+
+    new_subordinate = supervisor.actors.first
+    expect(new_subordinate).not_to eq subordinate
+    expect(new_subordinate.state).to be(:working)
+  end
+
+  it "removes an actor if it terminates cleanly" do
+    supervisor = Subordinate.supervise(args: [:working])
+    subordinate = supervisor.actors.first
+
+    expect(supervisor.actors).to eq([subordinate])
+
+    subordinate.terminate
+
+    expect(supervisor.actors).to be_empty
+  end
+end

data/spec/celluloid/task/fibered_spec.rb

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

data/spec/celluloid/task/threaded_spec.rb

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

data/spec/shared/actor_examples.rb

@@ -2,7 +2,7 @@ RSpec.shared_examples "a Celluloid Actor" do
   around do |ex|
     Celluloid.boot
     ex.run
-    Celluloid.shutdown
+    Celluloid.shutdown if Celluloid.running?
   end
 
   let(:task_klass) { Celluloid.task_class }
@@ -11,6 +11,12 @@ RSpec.shared_examples "a Celluloid Actor" do
 
   let(:logger) { Specs::FakeLogger.current }
 
+  it "doesn't raise an error when rebooting" do
+    Celluloid.shutdown
+
+    expect { Celluloid.boot }.to change { Celluloid.running? }.from(false).to(true)
+  end
+
   it "returns the actor's class, not the proxy's" do
     expect(actor.class).to eq(actor_class)
   end
@@ -22,24 +28,24 @@ RSpec.shared_examples "a Celluloid Actor" do
         true
       else
         false
-      end,
+      end
     ).to be_truthy
   end
 
   it "can be stored in hashes" do
     expect(actor.hash).not_to eq(Kernel.hash)
     expect(actor.object_id).not_to eq(Kernel.object_id)
-    expect(actor.eql? actor).to be_truthy
+    expect(actor.eql?(actor)).to be_truthy
   end
 
   it "can be stored in hashes even when dead" do
     actor.terminate
-    
+
     expect(actor.dead?).to be_truthy
-    
+
     expect(actor.hash).not_to eq(Kernel.hash)
     expect(actor.object_id).not_to eq(Kernel.object_id)
-    expect(actor.eql? actor).to be_truthy
+    expect(actor.eql?(actor)).to be_truthy
   end
 
   it "implements respond_to? correctly" do
@@ -201,7 +207,9 @@ RSpec.shared_examples "a Celluloid Actor" do
     end
 
     it "warns about suspending the initialize" do
+      # rubocop:disable Metrics/LineLength
       expect(logger).to receive(:warn).with(/Dangerously suspending task: type=:call, meta={:dangerous_suspend=>true, :method_name=>:initialize}, status=:sleeping/)
+      # rubocop:enable Metrics/LineLength
 
       actor.terminate
       Specs.sleep_and_wait_until { !actor.alive? }
@@ -232,7 +240,9 @@ RSpec.shared_examples "a Celluloid Actor" do
     it "warns about suspending the finalizer" do
       allow(logger).to receive(:warn)
       allow(logger).to receive(:crash).with(/finalizer crashed!/, Celluloid::TaskTerminated)
+      # rubocop:disable Metrics/LineLength
       expect(logger).to receive(:warn).with(/Dangerously suspending task: type=:finalizer, meta={:dangerous_suspend=>true, :method_name=>:cleanup}, status=:sleeping/)
+      # rubocop:enable Metrics/LineLength
       actor.terminate
       Specs.sleep_and_wait_until { !actor.alive? }
     end
@@ -418,7 +428,7 @@ RSpec.shared_examples "a Celluloid Actor" do
           include CelluloidSpecs.included_module
 
           define_method(:receiver_method) do
-            fail ExampleCrash, "the spec purposely crashed me :("
+            raise ExampleCrash, "the spec purposely crashed me :("
           end
         end.new
 
@@ -430,18 +440,16 @@ RSpec.shared_examples "a Celluloid Actor" do
           end
         end.new
 
-        ex = example_caller.sender_method rescue $ERROR_INFO
-        Specs.sleep_and_wait_until { !example_caller.alive? }
-        Specs.sleep_and_wait_until { !example_receiver.alive? }
-
-        expect(ex).to be_a ExampleCrash
-        expect(ex.backtrace.grep(/`sender_method'/)).to be_truthy
-        expect(ex.backtrace.grep(/`receiver_method'/)).to be_truthy
+        expect { example_caller.sender_method }.to raise_error ExampleCrash
       end
 
       it "raises DeadActorError if methods are synchronously called on a dead actor" do
         allow(logger).to receive(:crash).with("Actor crashed!", ExampleCrash)
-        actor.crash rescue ExampleCrash
+        begin
+          actor.crash
+        rescue
+          ExampleCrash
+        end
 
         # TODO: avoid this somehow
         sleep 0.1 # hax to prevent a race between exit handling and the next call
@@ -469,10 +477,11 @@ RSpec.shared_examples "a Celluloid Actor" do
     end
 
     it "crashes the sender if we pass neither String nor Exception" do
+      number = 10
       allow(logger).to receive(:crash).with("Actor crashed!", TypeError)
       expect do
-        actor.crash_with_abort_raw 10
-      end.to raise_exception(TypeError, "Exception object/String expected, but Fixnum received")
+        actor.crash_with_abort_raw number
+      end.to raise_exception(TypeError, "Exception object/String expected, but #{number.class} received")
 
       Specs.sleep_and_wait_until { !actor.alive? }
       expect(actor).not_to be_alive
@@ -550,7 +559,9 @@ RSpec.shared_examples "a Celluloid Actor" do
 
       context "when terminated" do
         it "logs a debug" do
+          # rubocop:disable Metrics/LineLength
           expect(logger).to receive(:debug).with(/^Terminating task: type=:call, meta={:dangerous_suspend=>false, :method_name=>:sleepy}, status=:sleeping/)
+          # rubocop:enable Metrics/LineLength
           actor.terminate
           Specs.sleep_and_wait_until { !actor.alive? }
         end
@@ -594,9 +605,9 @@ RSpec.shared_examples "a Celluloid Actor" do
           @subordinate_lambasted
         end
 
-        def lambaste_subordinate(_actor, _reason)
+        def lambaste_subordinate(_actor, reason)
           @subordinate_lambasted = true
-          @exception = _reason
+          @exception = reason
         end
       end
     end
@@ -704,7 +715,7 @@ RSpec.shared_examples "a Celluloid Actor" do
         end
 
         def wait_for_signal
-          fail "already signaled" if @signaled
+          raise "already signaled" if @signaled
 
           @waiting = true
           value = wait :ponycopter
@@ -801,14 +812,14 @@ RSpec.shared_examples "a Celluloid Actor" do
       subject.async.exclusive_with_block_log_task(:one)
       subject.async.log_task(:two)
       sleep Specs::TIMER_QUANTUM * 2
-      expect(subject.tasks).to eq([:one, :two])
+      expect(subject.tasks).to eq(%i[one two])
     end
 
     it "executes methods in the proper order with a class-level annotation" do
       subject.async.exclusive_log_task :one
       subject.async.log_task :two
       sleep Specs::TIMER_QUANTUM * 2
-      expect(subject.tasks).to eq([:one, :two])
+      expect(subject.tasks).to eq(%i[one two])
     end
 
     it "knows when it's in exclusive mode" do
@@ -854,7 +865,7 @@ RSpec.shared_examples "a Celluloid Actor" do
       end
 
       it "executes in an exclusive order" do
-        expect(actor.tasks).to eq(%w(donuts coffee))
+        expect(actor.tasks).to eq(%w[donuts coffee])
       end
     end
   end
@@ -949,7 +960,7 @@ RSpec.shared_examples "a Celluloid Actor" do
       expect(actor).to be_sleeping
 
       future.value
-      # I got 0.558 (in a slighly busy MRI) which is outside 0.05 of 0.5, so let's use (0.05 * 2)
+      # I got 0.558 (in a slightly busy MRI) which is outside 0.05 of 0.5, so let's use (0.05 * 2)
       expect(Time.now - started_at).to be_within(Specs::TIMER_QUANTUM * 2).of interval
     end
 
@@ -1102,7 +1113,7 @@ RSpec.shared_examples "a Celluloid Actor" do
 
           klass = Class.new(Celluloid::Proxy::Cell) do
             def dividing_3_by(number)
-              fail ArgumentError, "<facepalm>" if number.zero?
+              raise ArgumentError, "<facepalm>" if number.zero?
               super
             end
           end
@@ -1121,7 +1132,11 @@ RSpec.shared_examples "a Celluloid Actor" do
         end
 
         it "does not crash the actor" do
-          subject.dividing_3_by(0) rescue ArgumentError
+          begin
+            subject.dividing_3_by(0)
+          rescue
+            ArgumentError
+          end
           expect(subject.dividing_3_by(3)).to eq(1)
         end
       end
@@ -1130,7 +1145,7 @@ RSpec.shared_examples "a Celluloid Actor" do
     context "when it includes method checking" do
       module MethodChecking
         def method_missing(meth, *args)
-          return super if [:__send__, :respond_to?, :method, :class, :__class__].include? meth
+          return super if %i[__send__ respond_to? method class __class__].include? meth
 
           unmet_requirement = nil
 
@@ -1141,7 +1156,7 @@ RSpec.shared_examples "a Celluloid Actor" do
             mandatory_args = -arity - 1
             unmet_requirement = "#{mandatory_args}+" if args.size < mandatory_args
           end
-          fail ArgumentError, "wrong number of arguments (#{args.size} for #{unmet_requirement})" if unmet_requirement
+          raise ArgumentError, "wrong number of arguments (#{args.size} for #{unmet_requirement})" if unmet_requirement
 
           super
         end
@@ -1160,7 +1175,7 @@ RSpec.shared_examples "a Celluloid Actor" do
           end
 
           def this_is_not_madness(word1, word2, word3, *_args)
-            fail "This is madness!" unless [word1, word2, word3] == [:this, :is, :Sparta]
+            raise "This is madness!" unless [word1, word2, word3] == %i[this is Sparta]
           end
 
           proxy_class klass
@@ -1173,7 +1188,11 @@ RSpec.shared_examples "a Celluloid Actor" do
         end
 
         it "does not crash the actor" do
-          subject.method_to_madness rescue NoMethodError
+          begin
+            subject.method_to_madness
+          rescue
+            NoMethodError
+          end
           expect(subject.madness).to eq("This is madness!")
         end
       end
@@ -1181,18 +1200,24 @@ RSpec.shared_examples "a Celluloid Actor" do
       context "when invoking a existing method with incorrect args" do
         context "with too many arguments" do
           it "raises an ArgumentError" do
-            expect { subject.madness(:Sparta) }.to raise_error(ArgumentError, "wrong number of arguments (1 for 0)")
+            expect { subject.madness(:Sparta) }
+              .to raise_error(ArgumentError, "wrong number of arguments (1 for 0)")
           end
 
           it "does not crash the actor" do
-            subject.madness(:Sparta) rescue ArgumentError
+            begin
+              subject.madness(:Sparta)
+            rescue
+              ArgumentError
+            end
             expect(subject.madness).to eq("This is madness!")
           end
         end
 
         context "with not enough mandatory arguments" do
           it "raises an ArgumentError" do
-            expect { subject.this_is_not_madness(:this, :is) }.to raise_error(ArgumentError, "wrong number of arguments (2 for 3+)")
+            expect { subject.this_is_not_madness(:this, :is) }
+              .to raise_error(ArgumentError, "wrong number of arguments (2 for 3+)")
           end
         end
       end