ably-rest 0.7.3 → 0.7.5

data/lib/submodules/ably-ruby/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.7.3'
+  VERSION = '0.7.5'
 end

data/lib/submodules/ably-ruby/spec/acceptance/realtime/channel_history_spec.rb

@@ -17,10 +17,10 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
 
     let(:options)      { { :protocol => :json } }
 
-    it 'returns a Deferrable' do
+    it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
       channel.publish('event', payload) do |message|
         history = channel.history
-        expect(history).to be_a(EventMachine::Deferrable)
+        expect(history).to be_a(Ably::Util::SafeDeferrable)
         history.callback do |messages|
           expect(messages.count).to eql(1)
           expect(messages).to be_a(Ably::Models::PaginatedResource)

data/lib/submodules/ably-ruby/spec/acceptance/realtime/channel_spec.rb

@@ -84,12 +84,12 @@ describe Ably::Realtime::Channel, :event_machine do
         end
       end
 
-      it 'returns a Deferrable' do
-        expect(channel.attach).to be_a(EventMachine::Deferrable)
+      it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
+        expect(channel.attach).to be_a(Ably::Util::SafeDeferrable)
         stop_reactor
       end
 
-      it 'calls the Deferrable callback on success' do
+      it 'calls the SafeDeferrable callback on success' do
         channel.attach.callback do |channel|
           expect(channel).to be_a(Ably::Realtime::Channel)
           expect(channel.state).to eq(:attached)
@@ -195,6 +195,26 @@ describe Ably::Realtime::Channel, :event_machine do
             stop_reactor
           end
         end
+
+        context 'and subsequent authorisation with suitable permissions' do
+          it 'attaches to the channel successfully and resets the channel error_reason' do
+            restricted_channel.attach
+            restricted_channel.once(:failed) do
+              restricted_client.close do
+                # A direct call to #authorise is synchronous
+                restricted_client.auth.authorise(api_key: api_key)
+
+                restricted_client.connect do
+                  restricted_channel.once(:attached) do
+                    expect(restricted_channel.error_reason).to be_nil
+                    stop_reactor
+                  end
+                  restricted_channel.attach
+                end
+              end
+            end
+          end
+        end
       end
     end
 
@@ -230,9 +250,11 @@ describe Ably::Realtime::Channel, :event_machine do
         end
       end
 
-      it 'returns a Deferrable' do
-        expect(channel.attach).to be_a(EventMachine::Deferrable)
-        stop_reactor
+      it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
+        channel.attach do
+          expect(channel.detach).to be_a(Ably::Util::SafeDeferrable)
+          stop_reactor
+        end
       end
 
       it 'calls the Deferrable callback on success' do

data/lib/submodules/ably-ruby/spec/acceptance/realtime/connection_failures_spec.rb

@@ -66,7 +66,8 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
                       )
         end
 
-        let(:expected_retry_attempts) { (max_time_in_state_for_tests / retry_every_for_tests).round }
+        # retry immediately after failure, then one retry every :retry_every_for_tests
+        let(:expected_retry_attempts) { 1 + (max_time_in_state_for_tests / retry_every_for_tests).round }
         let(:state_changes)           { Hash.new { |hash, key| hash[key] = 0 } }
         let(:timer)                   { Hash.new }
 
@@ -288,21 +289,76 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
       end
 
       context 'when DISCONNECTED ProtocolMessage received from the server' do
-        it 'reconnects automatically' do
+        it 'reconnects automatically and immediately' do
           fail_if_suspended_or_failed
 
           connection.once(:connected) do
             connection.once(:disconnected) do
-              connection.once(:connected) do
-                state_history = connection.state_history.map { |transition| transition[:state].to_sym }
-                expect(state_history).to eql([:connecting, :connected, :disconnected, :connecting, :connected])
-                stop_reactor
+              disconnected_at = Time.now.to_f
+              connection.once(:connecting) do
+                expect(Time.now.to_f).to be_within(0.25).of(disconnected_at)
+                connection.once(:connected) do
+                  state_history = connection.state_history.map { |transition| transition[:state].to_sym }
+                  expect(state_history).to eql([:connecting, :connected, :disconnected, :connecting, :connected])
+                  stop_reactor
+                end
               end
             end
             protocol_message = Ably::Models::ProtocolMessage.new(action: Ably::Models::ProtocolMessage::ACTION.Disconnected.to_i)
             connection.__incoming_protocol_msgbus__.publish :protocol_message, protocol_message
           end
         end
+
+        context 'and subsequently fails to reconnect' do
+          let(:retry_every) { 1.5 }
+
+          before do
+            # Reconfigure client library retry periods and timeouts so that tests run quickly
+            stub_const 'Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG',
+                      Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG.merge(
+                        disconnected: { retry_every: retry_every, max_time_in_state: 60 })
+          end
+
+          it "retries every CONNECT_RETRY_CONFIG[:disconnected][:retry_every] seconds" do
+            fail_if_suspended_or_failed
+
+            stubbed_first_attempt = false
+
+            connection.once(:connected) do
+              connection.once(:disconnected) do
+                connection.once(:connecting) do
+                  connection.once(:disconnected) do
+                    disconnected_at = Time.now.to_f
+                    connection.once(:connecting) do
+                      expect(Time.now.to_f - disconnected_at).to be > retry_every
+                      state_history = connection.state_history.map { |transition| transition[:state].to_sym }
+                      expect(state_history).to eql([:connecting, :connected, :disconnected, :connecting, :disconnected, :connecting])
+
+                      # allow one more recoonect when reactor stopped
+                      expect(connection.manager).to receive(:reconnect_transport)
+                      stop_reactor
+                    end
+                  end
+
+                  # When reconnect called simply open the transport and close immediately
+                  expect(connection.manager).to receive(:reconnect_transport) do
+                    next if stubbed_first_attempt
+
+                    connection.manager.setup_transport do
+                      EventMachine.next_tick do
+                        connection.transport.unbind
+                        stubbed_first_attempt = true
+                      end
+                    end
+                  end
+                end
+              end
+
+              protocol_message = Ably::Models::ProtocolMessage.new(action: Ably::Models::ProtocolMessage::ACTION.Disconnected.to_i)
+              connection.__incoming_protocol_msgbus__.publish :protocol_message, protocol_message
+            end
+          end
+        end
       end
 
       context 'when websocket transport is closed' do
@@ -359,6 +415,16 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           end
         end
 
+        it 'triggers the resume callback', api_private: true do
+          channel.attach do
+            connection.transport.close_connection_after_writing
+            connection.on_resume do
+              expect(connection).to be_connected
+              stop_reactor
+            end
+          end
+        end
+
         context 'when messages were published whilst the client was disconnected' do
           it 'receives the messages published whilst offline' do
             messages_received = false
@@ -394,55 +460,57 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         end
       end
 
-      context 'when failing to resume because the connection_key is not or no longer valid' do
-        def kill_connection_transport_and_prevent_valid_resume
-          connection.transport.close_connection_after_writing
-          connection.configure_new '0123456789abcdef', '0123456789abcdef', -1 # force the resume connection key to be invalid
-        end
-
-        it 'updates the connection_id and connection_key' do
-          connection.once(:connected) do
-            previous_connection_id  = connection.id
-            previous_connection_key = connection.key
+      context 'when failing to resume' do
+        context 'because the connection_key is not or no longer valid' do
+          def kill_connection_transport_and_prevent_valid_resume
+            connection.transport.close_connection_after_writing
+            connection.configure_new '0123456789abcdef', '0123456789abcdef', -1 # force the resume connection key to be invalid
+          end
 
+          it 'updates the connection_id and connection_key' do
             connection.once(:connected) do
-              expect(connection.key).to_not eql(previous_connection_key)
-              expect(connection.id).to_not eql(previous_connection_id)
-              stop_reactor
-            end
-
-            kill_connection_transport_and_prevent_valid_resume
-          end
-        end
+              previous_connection_id  = connection.id
+              previous_connection_key = connection.key
 
-        it 'detaches all channels' do
-          channel_count = 10
-          channels = channel_count.times.map { |index| client.channel("channel-#{index}") }
-          when_all(*channels.map(&:attach)) do
-            detached_channels = []
-            channels.each do |channel|
-              channel.on(:detached) do
-                detached_channels << channel
-                next unless detached_channels.count == channel_count
-                expect(detached_channels.count).to eql(channel_count)
+              connection.once(:connected) do
+                expect(connection.key).to_not eql(previous_connection_key)
+                expect(connection.id).to_not eql(previous_connection_id)
                 stop_reactor
               end
-            end
 
-            kill_connection_transport_and_prevent_valid_resume
+              kill_connection_transport_and_prevent_valid_resume
+            end
           end
-        end
 
-        it 'emits an error on the channel and sets the error reason' do
-          client.channel(random_str).attach do |channel|
-            channel.on(:error) do |error|
-              expect(error.message).to match(/Invalid connection key/i)
-              expect(error.code).to eql(80008)
-              expect(channel.error_reason).to eql(error)
-              stop_reactor
+          it 'detaches all channels' do
+            channel_count = 10
+            channels = channel_count.times.map { |index| client.channel("channel-#{index}") }
+            when_all(*channels.map(&:attach)) do
+              detached_channels = []
+              channels.each do |channel|
+                channel.on(:detached) do
+                  detached_channels << channel
+                  next unless detached_channels.count == channel_count
+                  expect(detached_channels.count).to eql(channel_count)
+                  stop_reactor
+                end
+              end
+
+              kill_connection_transport_and_prevent_valid_resume
             end
+          end
 
-            kill_connection_transport_and_prevent_valid_resume
+          it 'emits an error on the channel and sets the error reason' do
+            client.channel(random_str).attach do |channel|
+              channel.on(:error) do |error|
+                expect(error.message).to match(/Invalid connection key/i)
+                expect(error.code).to eql(80008)
+                expect(channel.error_reason).to eql(error)
+                stop_reactor
+              end
+
+              kill_connection_transport_and_prevent_valid_resume
+            end
           end
         end
       end
@@ -461,7 +529,9 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
                     )
       end
 
-      let(:expected_retry_attempts) { (max_time_in_state_for_tests / retry_every_for_tests).round }
+      # Retry immediately and then wait retry_every before every subsequent attempt
+      let(:expected_retry_attempts) { 1 + (max_time_in_state_for_tests / retry_every_for_tests).round }
+
       let(:retry_count_for_one_state)  { 1 + expected_retry_attempts } # initial connect then disconnected
       let(:retry_count_for_all_states) { 1 + expected_retry_attempts * 2 } # initial connection, disconnected & then suspended
 

data/lib/submodules/ably-ruby/spec/acceptance/realtime/connection_spec.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 require 'spec_helper'
+require 'ostruct'
 
 describe Ably::Realtime::Connection, :event_machine do
   let(:connection) { client.connection }
@@ -148,14 +149,12 @@ describe Ably::Realtime::Connection, :event_machine do
                     connection.once(:connected) do
                       started_at = Time.now
                       connection.once(:disconnected) do |error|
-                        EventMachine.add_timer(1) do # allow 1 second
+                        connection.once(:connected) do
+                          expect(client.auth.current_token).to_not be_expired
                           expect(Time.now - started_at >= ttl)
                           expect(original_token).to be_expired
                           expect(error.code).to eql(40140) # token expired
-                          connection.once(:connected) do
-                            expect(client.auth.current_token).to_not be_expired
-                            stop_reactor
-                          end
+                          stop_reactor
                         end
                       end
                     end
@@ -234,8 +233,8 @@ describe Ably::Realtime::Connection, :event_machine do
     end
 
     context '#connect' do
-      it 'returns a Deferrable' do
-        expect(connection.connect).to be_a(EventMachine::Deferrable)
+      it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
+        expect(connection.connect).to be_a(Ably::Util::SafeDeferrable)
         stop_reactor
       end
 
@@ -372,9 +371,9 @@ describe Ably::Realtime::Connection, :event_machine do
     end
 
     context '#close' do
-      it 'returns a Deferrable' do
+      it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
         connection.connect do
-          expect(connection.close).to be_a(EventMachine::Deferrable)
+          expect(connection.close).to be_a(Ably::Util::SafeDeferrable)
           stop_reactor
         end
       end
@@ -504,6 +503,17 @@ describe Ably::Realtime::Connection, :event_machine do
           stop_reactor
         end
       end
+
+      context 'with a success block that raises an exception' do
+        it 'catches the exception and logs the error' do
+          connection.on(:connected) do
+            expect(connection.logger).to receive(:error).with(/Forced exception/) do
+              stop_reactor
+            end
+            connection.ping { raise 'Forced exception' }
+          end
+        end
+      end
     end
 
     context 'recovery' do
@@ -591,7 +601,7 @@ describe Ably::Realtime::Connection, :event_machine do
         context 'connection#id and connection#key after recovery' do
           let(:client_options)   { default_options.merge(log_level: :none) }
 
-          it 'remain the same' do
+          it 'remains the same' do
             previous_connection_id  = nil
             previous_connection_key = nil
 
@@ -610,6 +620,22 @@ describe Ably::Realtime::Connection, :event_machine do
               end
             end
           end
+
+          it 'does not trigger a resume callback', api_private: true do
+            connection.once(:connected) do
+              connection.transition_state_machine! :failed
+            end
+
+            connection.once(:failed) do
+              recover_client = Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
+              recover_client.connection.on_resume do
+                raise 'Should not trigger resume callback'
+              end
+              recover_client.connection.on(:connected) do
+                EventMachine.add_timer(0.5) { stop_reactor }
+              end
+            end
+          end
         end
 
         context 'when messages have been sent whilst the old connection is disconnected' do
@@ -653,6 +679,7 @@ describe Ably::Realtime::Connection, :event_machine do
           it 'triggers a fatal error on the connection object, sets the #error_reason and disconnects' do
             connection.once(:error) do |error|
               expect(connection.state).to eq(:failed)
+              expect(error.message).to match(/Invalid connection key/)
               expect(connection.error_reason.message).to match(/Invalid connection key/)
               expect(connection.error_reason.code).to eql(40006)
               expect(connection.error_reason).to eql(error)
@@ -667,6 +694,7 @@ describe Ably::Realtime::Connection, :event_machine do
           it 'triggers an error on the connection object, sets the #error_reason, yet will connect anyway' do
             connection.once(:error) do |error|
               expect(connection.state).to eq(:connected)
+              expect(error.message).to match(/Invalid connection key/i)
               expect(connection.error_reason.message).to match(/Invalid connection key/i)
               expect(connection.error_reason.code).to eql(80008)
               expect(connection.error_reason).to eql(error)
@@ -714,6 +742,23 @@ describe Ably::Realtime::Connection, :event_machine do
       end
     end
 
+    context 'protocol failure' do
+      let(:client_options) { default_options.merge(protocol: :json) }
+
+      context 'receiving an invalid ProtocolMessage' do
+        it 'emits an error on the connection and logs a fatal error message' do
+          connection.connect do
+            connection.transport.send(:driver).emit 'message', OpenStruct.new(data: { action: 500 }.to_json)
+          end
+
+          expect(client.logger).to receive(:fatal).with(/Invalid Protocol Message/)
+          connection.on(:error) do |error|
+            expect(error.message).to match(/Invalid Protocol Message/)
+            stop_reactor
+          end
+        end
+      end
+    end
 
     context 'undocumented method' do
       context '#internet_up?' do

data/lib/submodules/ably-ruby/spec/acceptance/realtime/message_spec.rb

@@ -195,6 +195,38 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       end
     end
 
+    context 'server incorrectly resends a message that was already received by the client library' do
+      let(:messages_received) { [] }
+      let(:connection)        { client.connection }
+      let(:client_options)    { default_options.merge(log_level: :fatal) }
+
+      it 'discards the message and logs it as an error to the channel' do
+        first_message_protocol_message = nil
+        connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+          first_message_protocol_message ||= protocol_message unless protocol_message.messages.empty?
+        end
+
+        channel.subscribe do |message|
+          messages_received << message
+          if messages_received.count == 2
+            # simulate a duplicate protocol message being received
+            EventMachine.next_tick do
+              connection.__incoming_protocol_msgbus__.publish :protocol_message, first_message_protocol_message
+            end
+          end
+        end
+        2.times { |i| EventMachine.add_timer(i.to_f / 5) { channel.publish('event', 'data') } }
+
+        channel.on(:error) do |error|
+          expect(error.message).to match(/duplicate/)
+          EventMachine.add_timer(0.5) do
+            expect(messages_received.count).to eql(2)
+            stop_reactor
+          end
+        end
+      end
+    end
+
     context 'encoding and decoding encrypted messages' do
       shared_examples 'an Ably encrypter and decrypter' do |item, data|
         let(:algorithm)      { data['algorithm'].upcase }