scoot 0.0.4

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/spec/celluloid/condition_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Celluloid::Condition, actor_system: :global do
+  class ConditionExample
+    include Celluloid
+
+    attr_reader :condition, :signaled_times
+
+    def initialize
+      @condition = Condition.new
+
+      @waiting  = false
+      @signaled_times = 0
+    end
+
+    def signal_condition(condition, value)
+      condition.signal value
+    end
+
+    def wait_for_condition(timeout = nil)
+      @waiting = true
+      begin
+        value = @condition.wait(timeout)
+        @signaled_times += 1
+      ensure
+        @waiting = false
+      end
+
+      value
+    end
+
+    def waiting?; @waiting end
+  end
+
+  let(:actor) { ConditionExample.new }
+  after { actor.terminate rescue nil }
+
+  it "sends signals" do
+    3.times { actor.async.wait_for_condition }
+    actor.signaled_times.should be_zero
+
+    actor.condition.signal
+    actor.signaled_times.should be(1)
+  end
+
+  it "broadcasts signals" do
+    3.times { actor.async.wait_for_condition }
+    actor.signaled_times.should be_zero
+
+    actor.condition.broadcast
+    actor.signaled_times.should be(3)
+  end
+
+  it "sends values along with signals" do
+    future = actor.future(:wait_for_condition)
+    actor.condition.signal(:example_value)
+    future.value.should be(:example_value)
+  end
+
+  it "supports waiting outside actors" do
+    condition = Celluloid::Condition.new
+    actor.async.signal_condition condition, :value
+    condition.wait.should eq(:value)
+  end
+
+  it "times out inside normal Threads" do
+    condition = Celluloid::Condition.new
+    lambda { condition.wait(1) }.
+      should raise_error(Celluloid::ConditionError)
+  end
+
+  it "times out inside Tasks" do
+    lambda { actor.wait_for_condition(1) }.
+      should raise_error(Celluloid::ConditionError)
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/spec/celluloid/cpu_counter_spec.rb

@@ -0,0 +1,82 @@
+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/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/spec/celluloid/evented_mailbox_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+class TestEventedMailbox < Celluloid::EventedMailbox
+  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
+
+describe Celluloid::EventedMailbox do
+  subject { TestEventedMailbox.new }
+  it_behaves_like "a Celluloid Mailbox"
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/spec/celluloid/fsm_spec.rb

@@ -0,0 +1,107 @@
+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/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/spec/celluloid/future_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Celluloid::Future, actor_system: :global do
+  it "creates future objects that can be retrieved later" do
+    future = Celluloid::Future.new { 40 + 2 }
+    future.value.should == 42
+  end
+
+  it "passes arguments to future blocks" do
+    future = Celluloid::Future.new(40) { |n| n + 2 }
+    future.value.should == 42
+  end
+
+  it "reraises exceptions that occur when the value is retrieved" do
+    class ExampleError < StandardError; end
+
+    future = Celluloid::Future.new { raise ExampleError, "oh noes crash!" }
+    expect { future.value }.to raise_exception(ExampleError)
+  end
+
+  it "knows if it's got a value yet" do
+    future = Celluloid::Future.new { sleep Celluloid::TIMER_QUANTUM * 5 }
+    future.should_not be_ready
+    sleep Celluloid::TIMER_QUANTUM * 6
+    future.should be_ready
+  end
+
+  it "raises TimeoutError when the future times out" do
+    future = Celluloid::Future.new { sleep 2 }
+    expect { future.value(1) }.to raise_exception(Celluloid::TimeoutError)
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/spec/celluloid/internal_pool_spec.rb

@@ -0,0 +1,52 @@
+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/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/spec/celluloid/links_spec.rb

@@ -0,0 +1,45 @@
+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/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/spec/celluloid/logging/ring_buffer_spec.rb

@@ -0,0 +1,38 @@
+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/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/spec/celluloid/mailbox_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Celluloid::Mailbox do
+  it_behaves_like "a Celluloid Mailbox"
+end

data/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/spec/celluloid/notifications_spec.rb

@@ -0,0 +1,120 @@
+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/.bundle/gems/ruby/2.2.0/gems/celluloid-0.16.0/spec/celluloid/pool_spec.rb

@@ -0,0 +1,92 @@
+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