ably-rest 0.7.1 → 0.7.3

data/lib/submodules/ably-ruby/spec/unit/modules/event_emitter_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe Ably::Modules::EventEmitter do
+  let(:options) { {} }
+  let(:klass) do
+    callback_opts = options
+    Class.new do
+      include Ably::Modules::EventEmitter
+      configure_event_emitter callback_opts
+    end
+  end
+  let(:obj) { double('example') }
+  let(:msg) { double('message') }
+
+  subject { klass.new }
+
+  context '#trigger event fan out' do
+    it 'should emit an event for any number of subscribers' do
+      2.times do
+        subject.on(:message) { |msg| obj.received_message msg }
+      end
+
+      expect(obj).to receive(:received_message).with(msg).twice
+      subject.trigger :message, msg
+    end
+
+    it 'sends only messages to matching event names' do
+      subject.on(:valid) { |msg| obj.received_message msg }
+
+      expect(obj).to receive(:received_message).with(msg).once
+      subject.trigger :valid, msg
+      subject.trigger :ignored, msg
+      subject.trigger 'valid', msg
+    end
+
+    context 'with coercion', :api_private do
+      let(:options) do
+        { coerce_into: Proc.new { |event| String(event) } }
+      end
+
+      it 'calls the provided proc to coerce the event name' do
+        subject.on('valid') { |msg| obj.received_message msg }
+
+        expect(obj).to receive(:received_message).with(msg).once
+        subject.trigger :valid, msg
+      end
+    end
+
+    context 'without coercion', :api_private do
+      it 'only matches event names on type matches' do
+        subject.on('valid') { |msg| obj.received_message msg }
+
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.trigger :valid, msg
+      end
+    end
+
+    context '#on subscribe to multiple events' do
+      it 'with the same block' do
+        subject.on(:click, :hover) { |msg| obj.received_message msg }
+
+        expect(obj).to receive(:received_message).with(msg).twice
+
+        subject.trigger :click, msg
+        subject.trigger :hover, msg
+      end
+    end
+
+    context 'event callback changes within the callback block' do
+      context 'when new event callbacks are added' do
+        before do
+          2.times do
+            subject.on(:message) do |msg|
+              obj.received_message msg
+              subject.on(:message) do |msg|
+                obj.received_message_from_new_callbacks msg
+              end
+            end
+          end
+          allow(obj).to receive(:received_message)
+        end
+
+        it 'is unaffected and processes the prior event callbacks once' do
+          expect(obj).to receive(:received_message).with(msg).twice
+          expect(obj).to_not receive(:received_message_from_new_callbacks).with(msg)
+          subject.trigger :message, msg
+        end
+
+        it 'adds them for the next emitted event' do
+          expect(obj).to receive(:received_message_from_new_callbacks).with(msg).twice
+
+          # New callbacks are added in this trigger
+          subject.trigger :message, msg
+
+          # New callbacks are now called with second event emitted
+          subject.trigger :message, msg
+        end
+      end
+
+      context 'when callbacks are removed' do
+        before do
+          2.times do
+            subject.once(:message) do |msg|
+              obj.received_message msg
+              subject.off
+            end
+          end
+        end
+
+        it 'is unaffected and processes the prior event callbacks once' do
+          expect(obj).to receive(:received_message).with(msg).twice
+          subject.trigger :message, msg
+        end
+
+        it 'removes them for the next emitted event' do
+          expect(obj).to receive(:received_message).with(msg).twice
+
+          # Callbacks are removed in this trigger
+          subject.trigger :message, msg
+          # No callbacks should exist now
+          subject.trigger :message, msg
+        end
+      end
+    end
+  end
+
+  context '#once' do
+    it 'calls the block the first time an event is emitted only' do
+      block_called = 0
+      subject.once('event') { block_called += 1 }
+      3.times { subject.trigger 'event', 'data' }
+      expect(block_called).to eql(1)
+    end
+
+    it 'does not remove other blocks after it is called' do
+      block_called = 0
+      subject.once('event') { block_called += 1 }
+      subject.on('event')   { block_called += 1 }
+      3.times { subject.trigger 'event', 'data' }
+      expect(block_called).to eql(4)
+    end
+  end
+
+  context '#off' do
+    let(:callback) { Proc.new { |msg| obj.received_message msg } }
+
+    before do
+      subject.on(:message, &callback)
+    end
+
+    after do
+      subject.trigger :message, msg
+    end
+
+    context 'with event names as arguments' do
+      it 'deletes matching callbacks' do
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.off(:message, &callback)
+      end
+
+      it 'deletes all callbacks if not block given' do
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.off(:message)
+      end
+
+      it 'continues if the block does not exist' do
+        expect(obj).to receive(:received_message).with(msg)
+        subject.off(:message) { true }
+      end
+    end
+
+    context 'without any event names' do
+      it 'deletes all matching callbacks' do
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.off(&callback)
+      end
+
+      it 'deletes all callbacks if not block given' do
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.off
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/modules/state_emitter_spec.rb

@@ -0,0 +1,283 @@
+require 'spec_helper'
+
+describe Ably::Modules::StateEmitter do
+  class ExampleStateWithEventEmitter
+    include Ably::Modules::EventEmitter
+    extend  Ably::Modules::Enum
+
+    STATE = ruby_enum('STATE',
+      :initializing,
+      :connecting,
+      :connected,
+      :disconnected
+    )
+    include Ably::Modules::StateEmitter
+
+    def initialize
+      @state = :initializing
+    end
+  end
+
+  let(:initial_state) { :initializing }
+
+  subject { ExampleStateWithEventEmitter.new }
+
+  specify '#state returns current state' do
+    expect(subject.state).to eq(:initializing)
+  end
+
+  specify '#state= sets current state' do
+    expect { subject.state = :connecting }.to change { subject.state }.to(:connecting)
+  end
+
+  specify '#change_state sets current state' do
+    expect { subject.change_state :connecting }.to change { subject.state }.to(:connecting)
+  end
+
+  context '#change_state with arguments' do
+    let(:args) { [5,3,1] }
+    let(:callback_status) { { called: false } }
+
+    it 'passes the arguments through to the triggered callback' do
+      subject.on(:connecting) do |*callback_args|
+        expect(callback_args).to eql(args)
+        callback_status[:called] = true
+      end
+      expect { subject.change_state :connecting, *args }.to change { subject.state }.to(:connecting)
+      expect(callback_status).to eql(called: true)
+    end
+  end
+
+  context '#state?' do
+    it 'returns true if state matches' do
+      expect(subject.state?(initial_state)).to eql(true)
+    end
+
+    it 'returns false if state does not match' do
+      expect(subject.state?(:connecting)).to eql(false)
+    end
+
+    context 'and convenience predicates for states' do
+      it 'returns true for #initializing? if state matches' do
+        expect(subject.initializing?).to eql(true)
+      end
+
+      it 'returns false for #connecting? if state does not match' do
+        expect(subject.connecting?).to eql(false)
+      end
+    end
+  end
+
+  context '#state STATE coercion', :api_private do
+    it 'allows valid STATE values' do
+      expect { subject.state = :connected }.to_not raise_error
+    end
+
+    it 'prevents invalid STATE values' do
+      expect { subject.state = :invalid }.to raise_error KeyError
+    end
+  end
+
+  context '#once_or_if', :api_private do
+    context 'without :else option block' do
+      let(:block_calls) { [] }
+      let(:block) do
+        proc do
+          block_calls << Time.now
+        end
+      end
+
+      it 'calls the block if in the provided state' do
+        subject.once_or_if initial_state, &block
+        expect(block_calls.count).to eql(1)
+      end
+
+      it 'calls the block when the state is reached' do
+        subject.once_or_if :connected, &block
+        expect(block_calls.count).to eql(0)
+
+        subject.change_state :connected
+        expect(block_calls.count).to eql(1)
+      end
+
+      it 'calls the block only once' do
+        subject.once_or_if :connected, &block
+        3.times do
+          subject.change_state :connected
+          subject.change_state :connecting
+        end
+        expect(block_calls.count).to eql(1)
+      end
+    end
+
+    context 'with an array of targets' do
+      let(:block_calls) { [] }
+      let(:block) do
+        proc do
+          block_calls << Time.now
+        end
+      end
+
+      it 'calls the block if in the provided state' do
+        subject.once_or_if [initial_state, :connecting], &block
+        expect(block_calls.count).to eql(1)
+      end
+
+      it 'calls the block when one of the states is reached' do
+        subject.once_or_if [:connecting, :connected], &block
+        expect(block_calls.count).to eql(0)
+
+        subject.change_state :connected
+        expect(block_calls.count).to eql(1)
+      end
+
+      it 'calls the block only once' do
+        subject.once_or_if [:connecting, :connected], &block
+        expect(block_calls.count).to eql(0)
+
+        3.times do
+          subject.change_state :connected
+          subject.change_state :connecting
+        end
+        expect(block_calls.count).to eql(1)
+      end
+
+      it 'does not remove all blocks on success' do
+        allow(subject).to receive(:off) do |&block|
+          raise 'Should not receive a nil block' if block.nil?
+        end
+
+        subject.once_or_if(:connected) { }
+        subject.change_state :connected
+      end
+    end
+
+    context 'with :else option block', :api_private do
+      let(:success_calls) { [] }
+      let(:success_block) do
+        proc do
+          success_calls << Time.now
+        end
+      end
+
+      let(:failure_calls) { [] }
+      let(:failure_block) do
+        proc do |*args|
+          failure_calls << args
+        end
+      end
+
+      let(:target_state) { :connected }
+
+      before do
+        subject.once_or_if target_state, else: failure_block, &success_block
+      end
+
+      context 'blocks' do
+        specify 'are not called if the state does not change' do
+          subject.change_state initial_state
+          expect(success_calls.count).to eql(0)
+          expect(failure_calls.count).to eql(0)
+        end
+      end
+
+      context 'success block' do
+        it 'is called once target_state is reached' do
+          subject.change_state target_state
+          expect(success_calls.count).to eql(1)
+        end
+
+        it 'is never called again once target_state is reached' do
+          subject.change_state target_state
+          subject.change_state :connecting
+          subject.change_state target_state
+          expect(success_calls.count).to eql(1)
+        end
+
+        it 'is never called after failure block was called' do
+          subject.change_state :connecting
+          subject.change_state target_state
+          expect(success_calls.count).to eql(0)
+          expect(failure_calls.count).to eql(1)
+        end
+      end
+
+      context 'failure block' do
+        it 'is called once a state other than target_state is reached' do
+          subject.change_state :connecting
+          expect(failure_calls.count).to eql(1)
+        end
+
+        it 'is never called again once the block has been called previously' do
+          subject.change_state :connecting
+          subject.change_state target_state
+          subject.change_state :connecting
+          expect(failure_calls.count).to eql(1)
+        end
+
+        it 'is never called after success block was called' do
+          subject.change_state target_state
+          subject.change_state :connecting
+          expect(failure_calls.count).to eql(0)
+          expect(success_calls.count).to eql(1)
+        end
+
+        it 'has arguments from the error state' do
+          subject.change_state :disconnected, 1, 2
+          expect(failure_calls.count).to eql(1)
+          expect(failure_calls.first).to contain_exactly(1, 2)
+        end
+      end
+    end
+
+    context 'state change arguments' do
+      let(:arguments) { [1,2,3] }
+
+      specify 'are passed to success blocks' do
+        subject.once_or_if(:connected) do |*arguments|
+          expect(arguments).to eql(arguments)
+        end
+        subject.change_state :connected, *arguments
+      end
+
+      specify 'are passed to else blocks' do
+        else_block = proc { |arguments| expect(arguments).to eql(arguments) }
+        subject.once_or_if(:connected, else: else_block) do
+          raise 'Success should not be called'
+        end
+        subject.change_state :connecting, *arguments
+      end
+    end
+  end
+
+  context '#once_state_changed', :api_private do
+    let(:block_calls) { [] }
+    let(:block) do
+      proc do |*args|
+        block_calls << args
+      end
+    end
+
+    it 'is not called if the state does not change' do
+      subject.once_state_changed &block
+      subject.change_state initial_state
+      expect(block_calls.count).to eql(0)
+    end
+
+    it 'calls the block for any state change once' do
+      subject.once_state_changed &block
+      3.times do
+        subject.change_state :connected
+        subject.change_state :connecting
+      end
+      expect(block_calls.count).to eql(1)
+    end
+
+    it 'emits arguments to the block' do
+      subject.once_state_changed &block
+      subject.change_state :connected, 1, 2
+      expect(block_calls.count).to eql(1)
+      expect(block_calls.first).to contain_exactly(1, 2)
+    end
+  end
+end