celluloid 0.16.0 → 0.17.3

data/spec/celluloid/actor_system_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::ActorSystem do
-  class TestActor
-    include Celluloid
-  end
-
-  it "supports non-global ActorSystem" do
-    subject.within do
-      Celluloid.actor_system.should == subject
-    end
-  end
-
-  it "starts default actors" do
-    subject.start
-
-    subject.registered.should == [:notifications_fanout, :default_incident_reporter]
-  end
-
-  it "support getting threads" do
-    queue = Queue.new
-    thread = subject.get_thread do
-      Celluloid.actor_system.should == subject
-      queue << nil
-    end
-    queue.pop
-  end
-
-  it "allows a stack dump" do
-    subject.stack_dump.should be_a(Celluloid::StackDump)
-  end
-
-  it "returns named actors" do
-    subject.registered.should be_empty
-
-    subject.within do
-      TestActor.supervise_as :test
-    end
-
-    subject.registered.should == [:test]
-  end
-
-  it "returns running actors" do
-    subject.running.should be_empty
-
-    first = subject.within do
-      TestActor.new
-    end
-
-    second = subject.within do
-      TestActor.new
-    end
-
-    subject.running.should == [first, second]
-  end
-
-  it "shuts down" do
-    subject.shutdown
-
-    lambda { subject.get_thread }.
-      should raise_error("Thread pool is not running")
-  end
-
-  it "warns nicely when no actor system is started" do
-    lambda { TestActor.new }.
-      should raise_error("Celluloid is not yet started; use Celluloid.boot")
-  end
-
-end

data/spec/celluloid/cpu_counter_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::CPUCounter do
-  describe :cores do
-    subject { described_class.cores }
-
-    let(:num_cores) { 1024 }
-
-    before do
-      described_class.stub(:`) { fail 'backtick stub called' }
-      ::IO.stub(:open).and_raise('IO.open stub called!')
-      described_class.instance_variable_set('@cores', nil)
-    end
-
-    after { ENV['NUMBER_OF_PROCESSORS'] = nil }
-
-    context 'from valid env value' do
-      before { ENV['NUMBER_OF_PROCESSORS'] = num_cores.to_s }
-      it { should eq num_cores }
-    end
-
-    context 'from invalid env value' do
-      before { ENV['NUMBER_OF_PROCESSORS'] = '' }
-      specify { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'with no env value' do
-      before { ENV['NUMBER_OF_PROCESSORS'] = nil }
-
-      context 'when /sys/devices/system/cpu/present exists' do
-        before do
-          ::IO.should_receive(:read).with('/sys/devices/system/cpu/present')
-            .and_return("dunno-whatever-#{num_cores - 1}")
-        end
-        it { should eq num_cores }
-      end
-
-      context 'when /sys/devices/system/cpu/present does NOT exist' do
-        before do
-          ::IO.should_receive(:read).with('/sys/devices/system/cpu/present')
-            .and_raise(Errno::ENOENT)
-        end
-
-        context 'when /sys/devices/system/cpu/cpu* files exist' do
-          before do
-            cpu_entries = (1..num_cores).map { |n| "cpu#{n}" }
-            cpu_entries << 'non-cpu-entry-to-ignore'
-            Dir.should_receive(:[]).with('/sys/devices/system/cpu/cpu*')
-              .and_return(cpu_entries)
-          end
-          it { should eq num_cores }
-        end
-
-        context 'when /sys/devices/system/cpu/cpu* files DO NOT exist' do
-          before do
-            Dir.should_receive(:[]).with('/sys/devices/system/cpu/cpu*')
-              .and_return([])
-          end
-
-          context 'when sysctl blows up' do
-            before { described_class.stub(:`).and_raise(Errno::EINTR) }
-            specify { expect { subject }.to raise_error }
-          end
-
-          context 'when sysctl fails' do
-            before { described_class.stub(:`).and_return(`false`) }
-            it { should be nil }
-          end
-
-          context 'when sysctl succeeds' do
-            before do
-              described_class.should_receive(:`).with('sysctl -n hw.ncpu')
-                .and_return(num_cores.to_s)
-              `true`
-            end
-            it { should eq num_cores }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/celluloid/fsm_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::FSM, actor_system: :global do
-  before :all do
-    class TestMachine
-      include Celluloid::FSM
-
-      def initialize
-        super
-        @fired = false
-      end
-
-      state :callbacked do
-        @fired = true
-      end
-
-      state :pre_done, :to => :done
-      state :another, :done
-
-      def fired?; @fired end
-    end
-
-    class DummyActor
-      include Celluloid
-    end
-
-    class CustomDefaultMachine
-      include Celluloid::FSM
-
-      default_state :foobar
-    end
-  end
-
-  subject { TestMachine.new }
-
-  it "starts in the default state" do
-    subject.state.should eq(TestMachine.default_state)
-  end
-
-  it "transitions between states" do
-    subject.state.should_not be :done
-    subject.transition :done
-    subject.state.should be :done
-  end
-
-  it "fires callbacks for states" do
-    subject.should_not be_fired
-    subject.transition :callbacked
-    subject.should be_fired
-  end
-
-  it "allows custom default states" do
-    CustomDefaultMachine.new.state.should be :foobar
-  end
-
-  it "supports constraints on valid state transitions" do
-    subject.transition :pre_done
-    expect { subject.transition :another }.to raise_exception ArgumentError
-  end
-
-  it "transitions to states after a specified delay" do
-    interval = Celluloid::TIMER_QUANTUM * 10
-
-    subject.attach DummyActor.new
-    subject.transition :another
-    subject.transition :done, :delay => interval
-
-    subject.state.should be :another
-    sleep interval + Celluloid::TIMER_QUANTUM
-
-    subject.state.should be :done
-  end
-
-  it "cancels delayed state transitions if another transition is made" do
-    interval = Celluloid::TIMER_QUANTUM * 10
-
-    subject.attach DummyActor.new
-    subject.transition :another
-    subject.transition :done, :delay => interval
-
-    subject.state.should be :another
-    subject.transition :pre_done
-    sleep interval + Celluloid::TIMER_QUANTUM
-
-    subject.state.should be :pre_done
-  end
-
-  context "actor is not set" do
-    context "transition is delayed" do
-      it "raises an unattached error" do
-        expect { subject.transition :another, :delay => 100 } \
-          .to raise_error(Celluloid::FSM::UnattachedError)
-      end
-    end
-  end
-
-  context "transitioning to an invalid state" do
-    it "raises an argument error" do
-      expect { subject.transition :invalid_state }.to raise_error(ArgumentError)
-    end
-
-    it "should not call transition! if the state is :default" do
-      subject.should_not_receive :transition!
-      subject.transition :default
-    end
-  end
-end

data/spec/celluloid/internal_pool_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::InternalPool do
-  it "gets threads from the pool" do
-    subject.get { sleep 1 }.should be_a Thread
-  end
-
-  it "puts threads back into the pool" do
-    subject.idle_size.should be_zero
-    subject.busy_size.should be_zero
-
-    queue = Queue.new
-    subject.get { queue.pop }
-
-    subject.idle_size.should be_zero
-    subject.busy_size.should eq 1
-
-    queue << nil
-    sleep 0.01 # hax
-
-    subject.idle_size.should eq 1
-    subject.busy_size.should eq 0
-  end
-
-  it "cleans thread locals from old threads" do
-    thread = subject.get { Thread.current[:foo] = :bar }
-
-    sleep 0.01 #hax
-    thread[:foo].should be_nil
-  end
-
-  it "doesn't fail if a third-party thread is spawned" do
-    subject.idle_size.should be_zero
-    subject.busy_size.should be_zero
-
-    subject.get { ::Thread.new { sleep 0.5 } }.should be_a(Celluloid::Thread)
-
-    sleep 0.01 # hax
-
-    subject.idle_size.should eq 1
-    subject.busy_size.should eq 0
-  end
-
-  it "doesn't leak dead threads" do
-    subject.max_idle = 0 # Instruct the pool to immediately shut down the thread.
-    subject.get { true }.should be_a(Celluloid::Thread)
-
-    sleep 0.01 # hax
-
-    subject.to_a.should have(0).items
-  end
-end

data/spec/celluloid/links_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::Links do
-  subject { Celluloid::Links.new }
-
-  let(:mailbox_mock) do
-    Class.new(Array) do
-      attr_reader :address
-      def initialize address
-        @address = address
-      end
-    end
-  end
-
-  let(:first_actor) do
-    Struct.new(:mailbox).new(mailbox_mock.new('foo123'))
-  end
-
-  let(:second_actor) do
-    Struct.new(:mailbox).new(mailbox_mock.new('bar456'))
-  end
-
-  it 'is Enumerable' do
-    subject.should be_an(Enumerable)
-  end
-
-  it 'adds actors by their mailbox address' do
-    subject.include?(first_actor).should be_false
-    subject << first_actor
-    subject.include?(first_actor).should be_true
-  end
-
-  it 'removes actors by their mailbox address' do
-    subject << first_actor
-    subject.include?(first_actor).should be_true
-    subject.delete first_actor
-    subject.include?(first_actor).should be_false
-  end
-
-  it 'iterates over all actors' do
-    subject << first_actor
-    subject << second_actor
-    subject.inject([]) { |all, a| all << a }.should == [first_actor, second_actor]
-  end
-end

data/spec/celluloid/logging/ring_buffer_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::RingBuffer do
-  subject { Celluloid::RingBuffer.new(2) }
-
-  it { should be_empty }
-  it { should_not be_full }
-
-  it 'should push and shift' do
-    subject.push('foo')
-    subject.push('foo2')
-    subject.shift.should eq('foo')
-    subject.shift.should eq('foo2')
-  end
-
-  it 'should push past the end' do
-    subject.push('foo')
-    subject.push('foo2')
-    subject.push('foo3')
-    subject.should be_full
-  end
-
-  it 'should shift the most recent' do
-    (1..5).each { |i| subject.push(i) }
-    subject.shift.should be 4
-    subject.shift.should be 5
-    subject.shift.should be_nil
-  end
-
-  it 'should return nil when shifting empty' do
-    subject.should be_empty
-    subject.shift.should be_nil
-  end
-
-  it 'should be thread-safe' do
-    #TODO how to test?
-  end
-end

data/spec/celluloid/notifications_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-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
-      publish("death", "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
-    marilyn.mourning.should eq("Mr. President")
-    jackie.mourning.should_not 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
-    marilyn.mourning_count.should 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
-    marilyn.mourning.should eq("Mr. President")
-    jackie.mourning.should eq("Mr. President")
-  end
-
-  it 'publishes even if there are no subscribers' do
-    president = President.new
-    president.die
-  end
-
-  it 'allows regex subscriptions' do
-    marilyn = Admirer.new
-
-    marilyn.subscribe(/(death|assassination)/, :someone_died)
-
-    president = President.new
-    president.die
-    marilyn.mourning.should 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
-    marilyn.mourning.should 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
-
-    after_listeners.should == 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
-
-    after_listeners.should eq(listeners - 2)
-  end
-end

data/spec/celluloid/pool_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-describe "Celluloid.pool", actor_system: :global do
-  class ExampleError < StandardError; end
-
-  class MyWorker
-    include Celluloid
-
-    def process(queue = nil)
-      if queue
-        queue << :done
-      else
-        :done
-      end
-    end
-
-    def sleepy_work
-      t = Time.now.to_f
-      sleep 0.25
-      t
-    end
-
-    def crash
-      raise ExampleError, "zomgcrash"
-    end
-  end
-
-  def test_concurrency_of(pool)
-    baseline = Time.now.to_f
-    values = 10.times.map { pool.future.sleepy_work }.map(&:value)
-    values.select {|t| t - baseline < 0.1 }.length
-  end
-
-  subject { MyWorker.pool }
-
-  it "processes work units synchronously" do
-    subject.process.should be :done
-  end
-
-  it "processes work units asynchronously" do
-    queue = Queue.new
-    subject.async.process(queue)
-    queue.pop.should be :done
-  end
-
-  it "handles crashes" do
-    expect { subject.crash }.to raise_error(ExampleError)
-    subject.process.should be :done
-  end
-
-  it "uses a fixed-sized number of threads" do
-    subject # eagerly evaluate the pool to spawn it
-
-    actors = Celluloid::Actor.all
-    100.times.map { subject.future(:process) }.map(&:value)
-
-    new_actors = Celluloid::Actor.all - actors
-    new_actors.should eq []
-  end
-
-  it "terminates" do
-    expect { subject.terminate }.to_not raise_exception
-  end
-
-  it "handles many requests" do
-    futures = 10.times.map do
-      subject.future.process
-    end
-    futures.map(&:value)
-  end
-
-  context "#size=" do
-    subject { MyWorker.pool size: 4 }
-
-    it "should adjust the pool size up", pending: 'flaky' do
-      expect(test_concurrency_of(subject)).to eq(4)
-
-      subject.size = 6
-      subject.size.should == 6
-
-      test_concurrency_of(subject).should == 6
-    end
-
-    it "should adjust the pool size down" do
-      test_concurrency_of(subject).should == 4
-
-      subject.size = 2
-      subject.size.should == 2
-      test_concurrency_of(subject).should == 2
-    end
-  end
-end