ably 0.6.2 → 0.7.0

data/spec/unit/models/protocol_message_spec.rb

@@ -1,5 +1,6 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'support/model_helper'
+require 'shared/model_behaviour'
 
 describe Ably::Models::ProtocolMessage do
   include Ably::Modules::Conversions
@@ -16,7 +17,7 @@ describe Ably::Models::ProtocolMessage do
     let(:model_args) { [] }
   end
 
-  context 'initializer action coercion' do
+  context 'initializer action coercion', :api_private do
     it 'ignores actions that are Integers' do
       protocol_message = subject.new(action: 14)
       expect(protocol_message.hash[:action]).to eql(14)
@@ -38,9 +39,9 @@ describe Ably::Models::ProtocolMessage do
   end
 
   context 'attributes' do
-    let(:unique_value) { SecureRandom.hex }
+    let(:unique_value) { random_str }
 
-    context 'Java naming' do
+    context 'Java naming', :api_private do
       let(:protocol_message) { new_protocol_message(channelSerial: unique_value) }
 
       it 'converts the attribute to ruby symbol naming convention' do
@@ -48,7 +49,7 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
-    context '#action' do
+    context '#action', :api_private do
       let(:protocol_message) { new_protocol_message(action: 14) }
 
       it 'returns an Enum that behaves like a symbol' do
@@ -70,7 +71,7 @@ describe Ably::Models::ProtocolMessage do
 
     context '#timestamp' do
       let(:protocol_message) { new_protocol_message(timestamp: as_since_epoch(Time.now)) }
-      it 'retrieves attribute :timestamp' do
+      it 'retrieves attribute :timestamp as Time object' do
         expect(protocol_message.timestamp).to be_a(Time)
         expect(protocol_message.timestamp.to_i).to be_within(1).of(Time.now.to_i)
       end
@@ -133,6 +134,40 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
+    context '#flags' do
+      context 'when nil' do
+        let(:protocol_message) { new_protocol_message({}) }
+
+        it 'is zero' do
+          expect(protocol_message.flags).to eql(0)
+        end
+      end
+
+      context 'when numeric' do
+        let(:protocol_message) { new_protocol_message(flags: '25') }
+
+        it 'is an Integer' do
+          expect(protocol_message.flags).to eql(25)
+        end
+      end
+
+      context 'when has_presence' do
+        let(:protocol_message) { new_protocol_message(flags: 1) }
+
+        it '#has_presence_flag? is true' do
+          expect(protocol_message.has_presence_flag?).to be_truthy
+        end
+      end
+
+      context 'when has another future flag' do
+        let(:protocol_message) { new_protocol_message(flags: 2) }
+
+        it '#has_presence_flag? is false' do
+          expect(protocol_message.has_presence_flag?).to be_falsey
+        end
+      end
+    end
+
     context '#has_connection_serial?' do
       context 'without connection_serial' do
         let(:protocol_message) { new_protocol_message({}) }
@@ -231,7 +266,7 @@ describe Ably::Models::ProtocolMessage do
     end
   end
 
-  context '#to_json' do
+  context '#to_json', :api_private do
     let(:json_object) { JSON.parse(model.to_json) }
     let(:message) { { 'name' => 'event', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
     let(:attached_action) { Ably::Models::ProtocolMessage::ACTION.Attached }
@@ -266,7 +301,7 @@ describe Ably::Models::ProtocolMessage do
     end
   end
 
-  context '#to_msgpack' do
+  context '#to_msgpack', :api_private do
     let(:model)    { new_protocol_message({ :connectionSerial => 'unique', messages: [message] }) }
     let(:message)  { { 'name' => 'event', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
     let(:packed)   { model.to_msgpack }

data/spec/unit/modules/async_wrapper_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
-require 'securerandom'
 
-describe Ably::Modules::AsyncWrapper do
+describe Ably::Modules::AsyncWrapper, :api_private do
   include RSpec::EventMachine
 
   let(:class_with_module) do
@@ -18,7 +17,7 @@ describe Ably::Modules::AsyncWrapper do
     end
   end
   let(:subject)    { class_with_module.new }
-  let(:result)     { SecureRandom.hex }
+  let(:result)     { random_str }
   let(:sleep_time) { 0.1 }
 
   before do

data/spec/unit/modules/conversions_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Ably::Modules::Conversions do
+describe Ably::Modules::Conversions, :api_private do
   let(:class_with_module) { Class.new do; include Ably::Modules::Conversions; end }
   let(:subject) { class_with_module.new }
   before do

data/spec/unit/modules/enum_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
-require 'securerandom'
 
-describe Ably::Modules::Enum do
+describe Ably::Modules::Enum, :api_private do
   class ExampleClassWithEnum
     extend Ably::Modules::Enum
     ENUMEXAMPLE = ruby_enum('ENUMEXAMPLE', :value_zero, 'value_1', :value_snake_case_2, :SentenceCase)
@@ -92,7 +91,7 @@ describe Ably::Modules::Enum do
     end
 
     context '#[]' do
-      let(:argument) { SecureRandom.hex }
+      let(:argument) { random_str }
       before do
         expect(subject).to receive(:get).with(argument).once.and_return(true)
       end

data/spec/unit/modules/event_emitter_spec.rb

@@ -14,8 +14,8 @@ describe Ably::Modules::EventEmitter do
 
   subject { klass.new }
 
-  context 'event fan out' do
-    specify do
+  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
@@ -33,7 +33,7 @@ describe Ably::Modules::EventEmitter do
       subject.trigger 'valid', msg
     end
 
-    context 'with coercion' do
+    context 'with coercion', :api_private do
       let(:options) do
         { coerce_into: Proc.new { |event| String(event) } }
       end
@@ -46,7 +46,7 @@ describe Ably::Modules::EventEmitter do
       end
     end
 
-    context 'without coercion' do
+    context 'without coercion', :api_private do
       it 'only matches event names on type matches' do
         subject.on('valid') { |msg| obj.received_message msg }
 
@@ -55,7 +55,7 @@ describe Ably::Modules::EventEmitter do
       end
     end
 
-    context 'subscribe to multiple events' do
+    context '#on subscribe to multiple events' do
       it 'with the same block' do
         subject.on(:click, :hover) { |msg| obj.received_message msg }
 
@@ -65,6 +65,63 @@ describe Ably::Modules::EventEmitter do
         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

data/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