celluloid 0.17.2 → 0.18.0

data/spec/celluloid/mailbox/evented_spec.rb

@@ -2,26 +2,28 @@ 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 = Specs::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)
+  it "recovers from timeout exceeded to process mailbox message" do
+    timeout_interval = Specs::TIMER_QUANTUM + 0.1
+    started_at = Time.now
+    expect do
+      ::Timeout.timeout(timeout_interval) do
+        subject.receive { false }
+      end
+    end.to raise_exception(Timeout::Error)
 
-      expect(Time.now - started_at).to be_within(Specs::TIMER_QUANTUM).of timeout_interval
+    expect(Time.now - started_at).to be_within(Specs::TIMER_QUANTUM).of timeout_interval
+  end
+
+  it "discard messages when reactor wakeup fails" do
+    expect(Celluloid::Internals::Logger).to receive(:crash).with("reactor crashed", RuntimeError)
+    expect(Celluloid.logger).to receive(:debug).with("Discarded message (mailbox is dead): first")
+
+    bad_reactor = Class.new do
+      def wakeup
+        raise
+      end
     end
+    mailbox = Celluloid::Mailbox::Evented.new(bad_reactor)
+    mailbox << :first
   end
 end

data/spec/celluloid/misc/leak_spec.rb

@@ -13,11 +13,10 @@ RSpec.describe "Leaks", actor_system: :global, leaktest: true,
       []
     end
 
-    def terminate
-    end
+    def terminate; end
   end
 
-  def wait_for_release(weak, _what, count=1000)
+  def wait_for_release(weak, _what, count = 1000)
     trash = []
     count.times do |step|
       GC.start
@@ -43,7 +42,7 @@ RSpec.describe "Leaks", actor_system: :global, leaktest: true,
   end
 
   context "celluloid actor" do
-    it "is properly destroyed upon termination" do
+    xit "is properly destroyed upon termination" do
       actor_life("actor") do |actor|
         WeakRef.new actor
       end

data/spec/celluloid/notifications_spec.rb

@@ -0,0 +1,140 @@
+RSpec.describe Celluloid::Notifications, actor_system: :global 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(topic = "death")
+      publish(topic, "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
+    expect(marilyn.mourning).to eq("Mr. President")
+    expect(jackie.mourning).not_to 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
+    expect(marilyn.mourning_count).to 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
+    expect(marilyn.mourning).to eq("Mr. President")
+    expect(jackie.mourning).to eq("Mr. President")
+  end
+
+  it "publishes even if there are no subscribers" do
+    president = President.new
+    president.die
+  end
+
+  it "allows symbol subscriptions" do
+    marilyn = Admirer.new
+    jackie = Admirer.new
+
+    marilyn.subscribe(:death, :someone_died)
+    jackie.subscribe("death", :someone_died)
+
+    president = President.new
+    president.die(:death)
+    expect(marilyn.mourning).to eq("Mr. President")
+    expect(jackie.mourning).to eq("Mr. President")
+  end
+
+  it "allows regex subscriptions" do
+    marilyn = Admirer.new
+
+    marilyn.subscribe(/(death|assassination)/, :someone_died)
+
+    president = President.new
+    president.die
+    expect(marilyn.mourning).to eq("Mr. President")
+  end
+
+  it "matches symbols against regex subscriptions" do
+    marilyn = Admirer.new
+
+    marilyn.subscribe(/(death|assassination)/, :someone_died)
+
+    president = President.new
+    president.die(:assassination)
+    expect(marilyn.mourning).to 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
+    expect(marilyn.mourning).to 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
+
+    expect(after_listeners).to eq(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
+
+    expect(after_listeners).to eq(listeners - 2)
+  end
+end

data/spec/celluloid/probe_spec.rb

@@ -0,0 +1,102 @@
+require "celluloid/probe"
+
+class DummyActor; include Celluloid; end
+
+class TestProbeClient
+  include Celluloid
+  include Celluloid::Notifications
+
+  attr_reader :buffer
+  finalizer :do_unsubscribe
+
+  def initialize(queue)
+    @events = queue
+    subscribe(/celluloid\.events\..+/, :event_received)
+  end
+
+  def event_received(topic, args)
+    @events << [topic, args[0], args[1]]
+  end
+
+  def do_unsubscribe
+    # TODO: shouldn't be necessary
+    return unless Actor[:notifications_fanout]
+
+    unsubscribe
+  rescue Celluloid::DeadActorError
+    # Something is wrong with the shutdown seq. Whatever...
+  rescue => ex
+    STDERR.puts "Exception while finalizing TestProbeClient: #{ex.inspect}"
+    STDERR.puts "BACKTRACE: #{ex.backtrace * "\n (ex) "}"
+    sleep 5
+  end
+end
+
+RSpec.describe "Probe", actor_system: :global do
+  let(:logger) { Specs::FakeLogger.current }
+
+  def addr(actor)
+    return nil unless actor
+    return nil unless actor.mailbox
+    return nil unless actor.mailbox.address
+    actor.mailbox.address
+  rescue Celluloid::DeadActorError
+    "(dead actor)"
+  end
+
+  def wait_for_match(queue, topic, actor1 = nil, actor2 = nil)
+    started = Time.now.to_f
+    actors = [actor1, actor2]
+    expected = ([topic] + actors.map { |a| addr(a) }).dup
+
+    received = []
+    last_event_timestamp = nil
+
+    Timeout.timeout(5) do
+      loop do
+        event = queue.pop
+        actual = ([event[0]] + event[1..-1].map { |a| addr(a) }).dup
+        received << actual
+        last_event_timestamp = Time.now.to_f
+        return event if actual == expected
+      end
+    end
+  rescue Timeout::Error => e
+    q = Celluloid::Probe::EVENTS_BUFFER
+    unprocessed = []
+    loop do
+      break if q.empty?
+      name, args = q.pop
+      actual = ([name] + args.map { |a| addr(a) }).dup
+      unprocessed << actual
+    end
+
+    last_event_offset = if last_event_timestamp
+                          last_event_timestamp - started
+                        else
+                          "(no events ever received)"
+                        end
+
+    raise "wait_for_match: no matching event received for #{topic.inspect}! (#{e.inspect})\n"\
+      "Expected: #{expected.inspect}\n"\
+      "Events received: \n  #{received.map(&:inspect) * "\n  "}\n"\
+      "Current time offset: #{(Time.now.to_f - started).inspect}\n"\
+      "Last event offset: #{last_event_offset.inspect}\n"\
+      "Unprocessed probe events: #{unprocessed.map(&:inspect) * "\n  "}\n"\
+  end
+
+  def flush_probe_queue
+    # Probe doesn't process the queue periodically, so some events can get in
+    # while previous events are being processed.
+    #
+    # So, we generate another event, so Probe processed the queue (containing
+    # the previously unprocessed event).
+    Celluloid::Actor["an_extra_event"] = Class.new { include Celluloid }.new
+  end
+
+  let(:queue) { Queue.new }
+
+  describe ".run" do
+    pending "cannot unsupervise the Probe yet (#573)"
+  end
+end

data/spec/celluloid/proxy_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe Celluloid::Proxy::Abstract do
+  around do |ex|
+    Celluloid.boot
+    ex.run
+    Celluloid.shutdown
+  end
+
+  let(:task_klass) { Celluloid.task_class }
+  let(:actor_class) { ExampleActorClass.create(CelluloidSpecs.included_module, task_klass) }
+  let(:actor) { actor_class.new "Troy McClure" }
+
+  let(:logger) { Specs::FakeLogger.current }
+
+  it "should be eql? to self" do
+    expect(actor.eql?(actor)).to be_truthy
+  end
+
+  it "should be eql? to self even if dead" do
+    actor.terminate
+    expect(actor.eql?(actor)).to be_truthy
+  end
+
+  it "should not be eql? to other proxy objects" do
+    other_future = Celluloid::Proxy::Future.new(actor.mailbox, actor.__klass__)
+
+    expect(actor.future.eql?(other_future)).to be_truthy
+  end
+
+  it "should be possible to compare with non-proxy objects" do
+    expect(actor.eql?("string")).to be_falsey
+    expect("string".eql?(actor)).to be_falsey
+  end
+end

data/spec/celluloid/supervision/behavior_spec.rb

@@ -0,0 +1,74 @@
+RSpec.describe Celluloid::Supervision::Container::Behavior do
+  class WellBehaved
+    include Celluloid
+  end
+
+  let(:typeless) do
+    {
+      as: :testing_behaviors,
+      supervises: [
+        {
+          as: :testing_behaved_instances,
+          type: WellBehaved
+        }
+      ]
+    }
+  end
+
+  let(:normal) do
+    {
+      as: :testing_behaviors,
+      supervises: [
+        {
+          as: :testing_behaved_instances,
+          type: WellBehaved
+        }
+      ]
+    }
+  end
+
+  let(:mutant) do
+    {
+      as: :testing_behaviors,
+      supervise: [],
+      supervises: [
+        {
+          as: :testing_behaved_instances,
+          type: WellBehaved
+        }
+      ]
+    }
+  end
+
+  subject { Celluloid::Supervision::Configuration.new }
+
+  it("detects default type if not provided, and provides it") do
+  end
+
+  it("prejudicially rejects mutants") do
+    expect { subject.define(mutant) }.to raise_error(Celluloid::Supervision::Container::Behavior::Error::Mutant)
+  end
+
+  context("allows definition of new plugins") do
+    class TestPlugin
+      include Celluloid::Supervision::Container::Behavior
+      identifier! :identifying_parameter, :aliased_identifier
+    end
+
+    xit("and adds a plugin parameter") do
+      expect(Celluloid::Supervision::Configuration.parameters(:plugins)).to include(:identifying_parameter)
+    end
+
+    xit("and adds aliased parameters") do
+      expect(Celluloid::Supervision::Configuration.aliases.keys?).to include(:aliased_identifier)
+    end
+  end
+
+  context("allows inclusion by Module") do
+    xit("with automatic addition of injections") do
+    end
+
+    xit("with correct handling of injections made") do
+    end
+  end
+end

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