ably 0.7.2 → 0.7.4

data/spec/unit/models/presence_message_spec.rb

@@ -28,7 +28,7 @@ describe Ably::Models::PresenceMessage do
       end
 
       context 'with a protocol message with a different connectionId' do
-        let(:model) { subject.new({ 'connectionId' => model_connection_id }, protocol_message) }
+        let(:model) { subject.new({ 'connectionId' => model_connection_id }, protocol_message: protocol_message) }
 
         it 'uses the model value' do
           expect(model.connection_id).to eql(model_connection_id)
@@ -46,7 +46,7 @@ describe Ably::Models::PresenceMessage do
       end
 
       context 'with a protocol message with a connectionId' do
-        let(:model) { subject.new({ }, protocol_message) }
+        let(:model) { subject.new({ }, protocol_message: protocol_message) }
 
         it 'uses the model value' do
           expect(model.connection_id).to eql(protocol_connection_id)
@@ -63,8 +63,8 @@ describe Ably::Models::PresenceMessage do
     end
 
     context 'with the same client id across multiple connections' do
-      let(:connection_1) { subject.new({ client_id: 'same', connection_id: 'unique' }, protocol_message) }
-      let(:connection_2) { subject.new({ client_id: 'same', connection_id: 'different' }, protocol_message) }
+      let(:connection_1) { subject.new({ client_id: 'same', connection_id: 'unique' }, protocol_message: protocol_message) }
+      let(:connection_2) { subject.new({ client_id: 'same', connection_id: 'different' }, protocol_message: protocol_message) }
 
       it 'is unique' do
         expect(connection_1.member_key).to_not eql(connection_2.member_key)
@@ -72,8 +72,8 @@ describe Ably::Models::PresenceMessage do
     end
 
     context 'with a single connection and different client_ids' do
-      let(:client_1) { subject.new({ client_id: 'unique', connection_id: 'same' }, protocol_message) }
-      let(:client_2) { subject.new({ client_id: 'different', connection_id: 'same' }, protocol_message) }
+      let(:client_1) { subject.new({ client_id: 'unique', connection_id: 'same' }, protocol_message: protocol_message) }
+      let(:client_2) { subject.new({ client_id: 'different', connection_id: 'same' }, protocol_message: protocol_message) }
 
       it 'is unique' do
         expect(client_1.member_key).to_not eql(client_2.member_key)
@@ -82,7 +82,7 @@ describe Ably::Models::PresenceMessage do
   end
 
   context '#timestamp' do
-    let(:model) { subject.new({}, protocol_message) }
+    let(:model) { subject.new({}, protocol_message: protocol_message) }
     it 'retrieves attribute :timestamp as a Time object from ProtocolMessage' do
       expect(model.timestamp).to be_a(Time)
       expect(model.timestamp.to_i).to be_within(1).of(Time.now.to_i)
@@ -90,7 +90,7 @@ describe Ably::Models::PresenceMessage do
   end
 
   context 'Java naming', :api_private do
-    let(:model) { subject.new({ clientId: 'joe' }, protocol_message) }
+    let(:model) { subject.new({ clientId: 'joe' }, protocol_message: protocol_message) }
 
     it 'converts the attribute to ruby symbol naming convention' do
       expect(model.client_id).to eql('joe')
@@ -99,7 +99,7 @@ describe Ably::Models::PresenceMessage do
 
   context 'with action', :api_private do
     context 'absent' do
-      let(:model) { subject.new({ action: 0 }, protocol_message) }
+      let(:model) { subject.new({ action: 0 }, protocol_message: protocol_message) }
 
       it 'provides action as an Enum' do
         expect(model.action).to eq(:absent)
@@ -107,7 +107,7 @@ describe Ably::Models::PresenceMessage do
     end
 
     context 'enter' do
-      let(:model) { subject.new({ action: 2 }, protocol_message) }
+      let(:model) { subject.new({ action: 2 }, protocol_message: protocol_message) }
 
       it 'provides action as an Enum' do
         expect(model.action).to eq(:enter)
@@ -116,7 +116,7 @@ describe Ably::Models::PresenceMessage do
   end
 
   context 'without action', :api_private do
-    let(:model) { subject.new({}, protocol_message) }
+    let(:model) { subject.new({}, protocol_message: protocol_message) }
 
     it 'raises an exception when accessed' do
       expect { model.action }.to raise_error KeyError
@@ -129,7 +129,7 @@ describe Ably::Models::PresenceMessage do
         let(:encoded_value)   { value.encode(encoding) }
         let(:value)           { random_str }
         let(:options)         { { attribute.to_sym => encoded_value } }
-        let(:model)           { subject.new(options, protocol_message) }
+        let(:model)           { subject.new(options, protocol_message: protocol_message) }
         let(:model_attribute) { model.public_send(attribute) }
 
         context 'as UTF_8 string' do
@@ -191,7 +191,7 @@ describe Ably::Models::PresenceMessage do
     let(:json_object) { JSON.parse(model.to_json) }
 
     context 'with valid data' do
-      let(:model) { subject.new({ action: 'enter', clientId: 'joe' }, protocol_message) }
+      let(:model) { subject.new({ action: 'enter', clientId: 'joe' }, protocol_message: protocol_message) }
 
       it 'converts the attribute back to Java mixedCase notation using string keys' do
         expect(json_object["clientId"]).to eql('joe')
@@ -199,7 +199,7 @@ describe Ably::Models::PresenceMessage do
     end
 
     context 'with invalid data' do
-      let(:model) { subject.new({ clientId: 'joe' }, protocol_message) }
+      let(:model) { subject.new({ clientId: 'joe' }, protocol_message: protocol_message) }
 
       it 'raises an exception' do
         expect { model.to_json }.to raise_error KeyError, /cannot generate a valid Hash/
@@ -208,7 +208,7 @@ describe Ably::Models::PresenceMessage do
 
     context 'with binary data' do
       let(:data) { MessagePack.pack(random_str(32)) }
-      let(:model) { subject.new({ action: 'enter', data: data }, protocol_message) }
+      let(:model) { subject.new({ action: 'enter', data: data }, protocol_message: protocol_message) }
 
       it 'encodes as Base64 so that it can be converted to UTF-8 automatically by JSON#dump' do
         expect(json_object["data"]).to eql(::Base64.encode64(data))
@@ -319,7 +319,7 @@ describe Ably::Models::PresenceMessage do
       end
 
       context 'with ProtocolMessage' do
-        subject { Ably::Models.PresenceMessage(json, protocol_message) }
+        subject { Ably::Models.PresenceMessage(json, protocol_message: protocol_message) }
 
         it 'returns a PresenceMessage object' do
           expect(subject).to be_a(Ably::Models::PresenceMessage)
@@ -363,7 +363,7 @@ describe Ably::Models::PresenceMessage do
       end
 
       context 'with ProtocolMessage' do
-        subject { Ably::Models.PresenceMessage(message, protocol_message) }
+        subject { Ably::Models.PresenceMessage(message, protocol_message: protocol_message) }
 
         it 'returns a PresenceMessage object' do
           expect(subject).to be_a(Ably::Models::PresenceMessage)

data/spec/unit/models/stat_spec.rb

@@ -64,22 +64,22 @@ describe Ably::Models::Stat do
 
     describe '#from_interval_id' do
       it 'converts a month interval_id 2014-02 into a Time object in UTC 0' do
-        expect(subject.from_interval_id('2014-02')).to eql(Time.new(2014, 2))
+        expect(subject.from_interval_id('2014-02')).to eql(Time.gm(2014, 2))
         expect(subject.from_interval_id('2014-02').utc_offset).to eql(0)
       end
 
       it 'converts a day interval_id 2014-02-03 into a Time object in UTC 0' do
-        expect(subject.from_interval_id('2014-02-03')).to eql(Time.new(2014, 2, 3))
+        expect(subject.from_interval_id('2014-02-03')).to eql(Time.gm(2014, 2, 3))
         expect(subject.from_interval_id('2014-02-03').utc_offset).to eql(0)
       end
 
       it 'converts an hour interval_id 2014-02-03:05 into a Time object in UTC 0' do
-        expect(subject.from_interval_id('2014-02-03:05')).to eql(Time.new(2014, 2, 3, 5))
+        expect(subject.from_interval_id('2014-02-03:05')).to eql(Time.gm(2014, 2, 3, 5))
         expect(subject.from_interval_id('2014-02-03:05').utc_offset).to eql(0)
       end
 
       it 'converts a minute interval_id 2014-02-03:05:06 into a Time object in UTC 0' do
-        expect(subject.from_interval_id('2014-02-03:05:06')).to eql(Time.new(2014, 2, 3, 5, 6))
+        expect(subject.from_interval_id('2014-02-03:05:06')).to eql(Time.gm(2014, 2, 3, 5, 6))
         expect(subject.from_interval_id('2014-02-03:05:06').utc_offset).to eql(0)
       end
 

data/spec/unit/modules/async_wrapper_spec.rb

@@ -14,6 +14,10 @@ describe Ably::Modules::AsyncWrapper, :api_private do
       def block=(block)
         @block = block
       end
+
+      def logger
+        true
+      end
     end
   end
   let(:subject)    { class_with_module.new }
@@ -33,7 +37,15 @@ describe Ably::Modules::AsyncWrapper, :api_private do
         end
       end
 
-      it 'calls the success_callback block with result when provided' do
+      it 'returns a SafeDeferrable that catches and logs exceptions in the provided callbacks' do
+        run_reactor do
+          deferrable = subject.operation
+          expect(deferrable).to be_a(Ably::Util::SafeDeferrable)
+          stop_reactor
+        end
+      end
+
+      it 'calls the provided block with result when provided' do
         run_reactor do
           subject.operation do |result|
             expect(result).to eql(result)
@@ -42,10 +54,20 @@ describe Ably::Modules::AsyncWrapper, :api_private do
         end
       end
 
-      it 'returns a deferrable that succeeds with result' do
+      it 'catches exceptions in the provided block and logs them to logger' do
+        run_reactor do
+          subject.operation do |result|
+            raise 'Intentional exception'
+          end
+          expect(subject.logger).to receive(:error).with(/Intentional exception/) do
+            stop_reactor
+          end
+        end
+      end
+
+      it 'returns a SafeDeferrable that calls the callback block' do
         run_reactor do
           deferrable = subject.operation
-          expect(deferrable).to be_a(EventMachine::Deferrable)
           deferrable.callback do |result|
             expect(result).to eql(result)
             stop_reactor
@@ -56,7 +78,6 @@ describe Ably::Modules::AsyncWrapper, :api_private do
       it 'does not call the errback' do
         run_reactor do
           deferrable = subject.operation
-          expect(deferrable).to be_a(EventMachine::Deferrable)
           deferrable.callback do |result|
             expect(result).to eql(result)
             EventMachine.add_timer(sleep_time * 2) { stop_reactor }
@@ -88,10 +109,9 @@ describe Ably::Modules::AsyncWrapper, :api_private do
         end
       end
 
-      it 'calls the errback block of the deferrable' do
+      it 'calls the errback block of the SafeDeferrable' do
         run_reactor do
           deferrable = subject.operation
-          expect(deferrable).to be_a(EventMachine::Deferrable)
           deferrable.errback do |error|
             expect(error).to be_a(RuntimeError)
             expect(error.message).to match(/Intentional/)
@@ -100,7 +120,7 @@ describe Ably::Modules::AsyncWrapper, :api_private do
         end
       end
 
-      it 'does not call the success_callback block' do
+      it 'does not call the provided block' do
         run_reactor do
           subject.operation do |result|
             raise 'Callback should not have been called'
@@ -109,10 +129,9 @@ describe Ably::Modules::AsyncWrapper, :api_private do
         end
       end
 
-      it 'does not call the callback block of the deferrable' do
+      it 'does not call the callback block of the SafeDeferrable' do
         run_reactor do
           deferrable = subject.operation
-          expect(deferrable).to be_a(EventMachine::Deferrable)
           deferrable.callback do |result|
             raise 'Callback should not have been called'
           end

data/spec/unit/modules/event_emitter_spec.rb

@@ -7,6 +7,7 @@ describe Ably::Modules::EventEmitter do
     Class.new do
       include Ably::Modules::EventEmitter
       configure_event_emitter callback_opts
+      def logger; end
     end
   end
   let(:obj) { double('example') }
@@ -124,6 +125,35 @@ describe Ably::Modules::EventEmitter do
     end
   end
 
+  context '#on' do
+    it 'calls the block every time an event is emitted only' do
+      block_called = 0
+      subject.on('event') { block_called += 1 }
+      3.times { subject.trigger 'event', 'data' }
+      expect(block_called).to eql(3)
+    end
+
+    it 'catches exceptions in the provided block, logs the error and continues' do
+      expect(subject.logger).to receive(:error).with(/Intentional exception/)
+      subject.on(:event) { raise 'Intentional exception' }
+      subject.trigger :event
+    end
+  end
+
+  context '#unsafe_on', api_private: true do
+    it 'calls the block every time an event is emitted only' do
+      block_called = 0
+      subject.unsafe_on('event') { block_called += 1 }
+      3.times { subject.trigger 'event', 'data' }
+      expect(block_called).to eql(3)
+    end
+
+    it 'does not catch exceptions in provided blocks' do
+      subject.unsafe_on(:event) { raise 'Intentional exception' }
+      expect { subject.trigger :event }.to raise_error(/Intentional exception/)
+    end
+  end
+
   context '#once' do
     it 'calls the block the first time an event is emitted only' do
       block_called = 0
@@ -139,6 +169,26 @@ describe Ably::Modules::EventEmitter do
       3.times { subject.trigger 'event', 'data' }
       expect(block_called).to eql(4)
     end
+
+    it 'catches exceptions in the provided block, logs the error and continues' do
+      expect(subject.logger).to receive(:error).with(/Intentional exception/)
+      subject.once(:event) { raise 'Intentional exception' }
+      subject.trigger :event
+    end
+  end
+
+  context '#unsafe_once' do
+    it 'calls the block the first time an event is emitted only' do
+      block_called = 0
+      subject.unsafe_once('event') { block_called += 1 }
+      3.times { subject.trigger 'event', 'data' }
+      expect(block_called).to eql(1)
+    end
+
+    it 'does not catch exceptions in provided blocks' do
+      subject.unsafe_once(:event) { raise 'Intentional exception' }
+      expect { subject.trigger :event }.to raise_error(/Intentional exception/)
+    end
   end
 
   context '#off' do

data/spec/unit/modules/state_emitter_spec.rb

@@ -13,14 +13,17 @@ describe Ably::Modules::StateEmitter do
     )
     include Ably::Modules::StateEmitter
 
-    def initialize
+    def initialize(logger)
       @state = :initializing
+      @logger = logger
     end
+
+    attr_reader :logger
   end
 
   let(:initial_state) { :initializing }
 
-  subject { ExampleStateWithEventEmitter.new }
+  subject { ExampleStateWithEventEmitter.new(double('Logger').as_null_object) }
 
   specify '#state returns current state' do
     expect(subject.state).to eq(:initializing)
@@ -248,6 +251,64 @@ describe Ably::Modules::StateEmitter do
         subject.change_state :connecting, *arguments
       end
     end
+
+    context 'with blocks that raise exceptions' do
+      let(:success_block) do
+        proc { raise 'Success exception' }
+      end
+
+      let(:failure_block) do
+        proc { raise 'Failure exception' }
+      end
+
+      let(:target_state) { :connected }
+
+      before do
+        subject.once_or_if target_state, else: failure_block, &success_block
+      end
+
+      context 'success block' do
+        it 'catches exceptions in the provided block, logs the error and continues' do
+          expect(subject.logger).to receive(:error).with(/Success exception/)
+          subject.change_state target_state
+        end
+      end
+
+      context 'failure block' do
+        it 'catches exceptions in the provided block, logs the error and continues' do
+          expect(subject.logger).to receive(:error).with(/Failure exception/)
+          subject.change_state :connecting
+        end
+      end
+    end
+  end
+
+  context '#unsafe_once_or_if', :api_private do
+    let(:target_state) { :connected }
+
+    let(:success_block) do
+      proc { raise 'Success exception' }
+    end
+
+    let(:failure_block) do
+      proc { raise 'Failure exception' }
+    end
+
+    before do
+      subject.unsafe_once_or_if target_state, else: failure_block, &success_block
+    end
+
+    context 'success block' do
+      it 'catches exceptions in the provided block, logs the error and continues' do
+        expect { subject.change_state target_state }.to raise_error(/Success exception/)
+      end
+    end
+
+    context 'failure block' do
+      it 'catches exceptions in the provided block, logs the error and continues' do
+        expect { subject.change_state :connecting }.to raise_error(/Failure exception/)
+      end
+    end
   end
 
   context '#once_state_changed', :api_private do
@@ -279,5 +340,18 @@ describe Ably::Modules::StateEmitter do
       expect(block_calls.count).to eql(1)
       expect(block_calls.first).to contain_exactly(1, 2)
     end
+
+    it 'catches exceptions in the provided block, logs the error and continues' do
+      subject.once_state_changed { raise 'Intentional exception' }
+      expect(subject.logger).to receive(:error).with(/Intentional exception/)
+      subject.change_state :connected
+    end
+  end
+
+  context '#unsafe_once_state_changed', :api_private do
+    it 'does not catch exceptions in the provided block' do
+      subject.unsafe_once_state_changed { raise 'Intentional exception' }
+      expect { subject.change_state :connected }.to raise_error(/Intentional exception/)
+    end
   end
 end

data/spec/unit/realtime/channel_spec.rb

@@ -133,7 +133,7 @@ describe Ably::Realtime::Channel do
       Ably::Models::Message.new({
         'name' => 'test',
         'data' => 'payload'
-      }, instance_double('Ably::Models::ProtocolMessage'))
+      }, protocol_message: instance_double('Ably::Models::ProtocolMessage'))
     end
     let(:msgbus) { subject.__incoming_msgbus__ }
 
@@ -152,20 +152,45 @@ describe Ably::Realtime::Channel do
 
   context 'subscriptions' do
     let(:message_history) { Hash.new { |hash, key| hash[key] = 0 } }
-    let(:event_name) { 'click' }
-    let(:message) { instance_double('Ably::Models::Message', name: event_name, encode: nil, decode: nil) }
+    let(:click_event) { 'click' }
+    let(:click_message) { instance_double('Ably::Models::Message', name: click_event, encode: nil, decode: nil) }
+    let(:focus_event) { 'focus' }
+    let(:focus_message) { instance_double('Ably::Models::Message', name: focus_event, encode: nil, decode: nil) }
+    let(:blur_message) { instance_double('Ably::Models::Message', name: 'blur', encode: nil, decode: nil) }
 
     context '#subscribe' do
-      specify 'to all events' do
+      specify 'without a block raises an invalid ArgumentError' do
+        expect { subject.subscribe }.to raise_error ArgumentError
+      end
+
+      specify 'with no event name specified subscribes the provided block to all events' do
         subject.subscribe { |message| message_history[:received] += 1}
-        subject.__incoming_msgbus__.publish(:message, message)
+        subject.__incoming_msgbus__.publish(:message, click_message)
+        expect(message_history[:received]).to eql(1)
+      end
+
+      specify 'with a single event name subscribes that block to matching events' do
+        subject.subscribe(click_event) { |message| message_history[:received] += 1 }
+        subject.subscribe('non_match_move')  { |message| message_history[:received] += 1 }
+        subject.__incoming_msgbus__.publish(:message, click_message)
+        expect(message_history[:received]).to eql(1)
+      end
+
+      specify 'with a multiple event name arguments subscribes that block to all of those event names' do
+        subject.subscribe(focus_event, click_event) { |message| message_history[:received] += 1 }
+        subject.__incoming_msgbus__.publish(:message, click_message)
         expect(message_history[:received]).to eql(1)
+        subject.__incoming_msgbus__.publish(:message, focus_message)
+        expect(message_history[:received]).to eql(2)
+
+        # Blur does not match subscribed focus & click events
+        subject.__incoming_msgbus__.publish(:message, blur_message)
+        expect(message_history[:received]).to eql(2)
       end
 
-      specify 'to specific events' do
-        subject.subscribe(event_name) { |message| message_history[:received] += 1 }
-        subject.subscribe('move')  { |message| message_history[:received] += 1 }
-        subject.__incoming_msgbus__.publish(:message, message)
+      specify 'with a multiple duplicate event name arguments subscribes that block to all of those unique event names once' do
+        subject.subscribe(click_event, click_event) { |message| message_history[:received] += 1 }
+        subject.__incoming_msgbus__.publish(:message, click_message)
         expect(message_history[:received]).to eql(1)
       end
     end
@@ -175,30 +200,36 @@ describe Ably::Realtime::Channel do
         Proc.new { |message| message_history[:received] += 1 }
       end
       before do
-        subject.subscribe(event_name, &callback)
+        subject.subscribe(click_event, &callback)
       end
 
-      specify 'to all events' do
+      specify 'with no event name specified unsubscribes that block from all events' do
         subject.unsubscribe &callback
-        subject.__incoming_msgbus__.publish(:message, message)
+        subject.__incoming_msgbus__.publish(:message, click_message)
+        expect(message_history[:received]).to eql(0)
+      end
+
+      specify 'with a single event name argument unsubscribes the provided block with the matching event name' do
+        subject.unsubscribe click_event, &callback
+        subject.__incoming_msgbus__.publish(:message, click_message)
         expect(message_history[:received]).to eql(0)
       end
 
-      specify 'to specific events' do
-        subject.unsubscribe event_name, &callback
-        subject.__incoming_msgbus__.publish(:message, message)
+      specify 'with multiple event name arguments unsubscribes each of those matching event names with the provided block' do
+        subject.unsubscribe focus_event, click_event, &callback
+        subject.__incoming_msgbus__.publish(:message, click_message)
         expect(message_history[:received]).to eql(0)
       end
 
-      specify 'to specific non-matching events' do
+      specify 'with a non-matching event name argument has no effect' do
         subject.unsubscribe 'move', &callback
-        subject.__incoming_msgbus__.publish(:message, message)
+        subject.__incoming_msgbus__.publish(:message, click_message)
         expect(message_history[:received]).to eql(1)
       end
 
-      specify 'all callbacks by not providing a callback' do
-        subject.unsubscribe event_name
-        subject.__incoming_msgbus__.publish(:message, message)
+      specify 'with no block argument unsubscribes all blocks for the event name argument' do
+        subject.unsubscribe click_event
+        subject.__incoming_msgbus__.publish(:message, click_message)
         expect(message_history[:received]).to eql(0)
       end
     end