ably-rest 0.8.3 → 0.8.5

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

@@ -1,21 +1,23 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe Ably::Realtime::Channels do
+describe Ably::Realtime::Channels, :event_machine do
   shared_examples 'a channel' do
     it 'returns a channel object' do
       expect(channel).to be_a Ably::Realtime::Channel
       expect(channel.name).to eql(channel_name)
+      stop_reactor
     end
 
     it 'returns channel object and passes the provided options' do
       expect(channel_with_options.options).to eql(options)
+      stop_reactor
     end
   end
 
   vary_by_protocol do
     let(:client) do
-      Ably::Realtime::Client.new(key: api_key, environment: environment, protocol: protocol)
+      auto_close Ably::Realtime::Client.new(key: api_key, environment: environment, protocol: protocol)
     end
     let(:channel_name) { random_str }
     let(:options)      { { key: 'value' } }
@@ -41,6 +43,7 @@ describe Ably::Realtime::Channels do
         new_channel = client.channels.get(channel_name, new_channel_options)
         expect(new_channel).to be_a(Ably::Realtime::Channel)
         expect(new_channel.options[:encrypted]).to eql(true)
+        stop_reactor
       end
     end
 
@@ -52,6 +55,7 @@ describe Ably::Realtime::Channels do
         new_channel = client.channels.get(channel_name)
         expect(new_channel).to be_a(Ably::Realtime::Channel)
         expect(original_channel.options).to eql(options)
+        stop_reactor
       end
     end
 

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

@@ -11,7 +11,7 @@ describe Ably::Realtime::Client, :event_machine do
     let(:connection)     { subject.connection }
     let(:auth_params)    { subject.auth.auth_params_sync }
 
-    subject              { Ably::Realtime::Client.new(client_options) }
+    subject              { auto_close Ably::Realtime::Client.new(client_options) }
 
     context 'initialization' do
       context 'basic auth' do
@@ -31,8 +31,8 @@ describe Ably::Realtime::Client, :event_machine do
             it 'fails to connect because a private key cannot be sent over a non-secure connection' do
               connection.on(:connected) { raise 'Should not have connected' }
 
-              connection.on(:failed) do |error|
-                expect(error).to be_a(Ably::Exceptions::InsecureRequest)
+              connection.on(:failed) do |connection_state_change|
+                expect(connection_state_change.reason).to be_a(Ably::Exceptions::InsecureRequest)
                 stop_reactor
               end
             end
@@ -44,7 +44,8 @@ describe Ably::Realtime::Client, :event_machine do
         [true, false].each do |tls_enabled|
           context "with TLS #{tls_enabled ? 'enabled' : 'disabled'}" do
             let(:capability)      { { :foo => ["publish"] } }
-            let(:token_details)   { Ably::Realtime::Client.new(default_options).auth.request_token_sync(capability: capability) }
+            let(:token_client)    { auto_close Ably::Realtime::Client.new(default_options) }
+            let(:token_details)   { token_client.auth.request_token_sync(capability: capability) }
             let(:client_options)  { default_options.merge(token: token_details.token) }
 
             context 'and a pre-generated Token provided with the :token option' do
@@ -93,7 +94,7 @@ describe Ably::Realtime::Client, :event_machine do
           let(:auth)      { subject.auth }
 
           subject do
-            Ably::Realtime::Client.new(client_options.merge(auth_callback: Proc.new do
+            auto_close Ably::Realtime::Client.new(client_options.merge(auth_callback: Proc.new do
               @block_called = true
               auth.create_token_request_sync(client_id: client_id)
             end))

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

@@ -11,7 +11,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
 
     let(:client_options) { default_options }
     let(:client) do
-      Ably::Realtime::Client.new(client_options)
+      auto_close Ably::Realtime::Client.new(client_options)
     end
 
     context 'authentication failure' do
@@ -24,7 +24,8 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           let(:invalid_key) { 'not_an_app.invalid_key_name:invalid_key_value' }
 
           it 'enters the failed state and returns a not found error' do
-            connection.on(:failed) do |error|
+            connection.on(:failed) do |connection_state_change|
+              error = connection_state_change.reason
               expect(connection.state).to eq(:failed)
               # TODO: Check error type is an InvalidToken exception
               expect(error.status).to eq(404)
@@ -38,7 +39,8 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           let(:invalid_key) { "#{app_id}.invalid_key_name:invalid_key_value" }
 
           it 'enters the failed state and returns an authorization error' do
-            connection.on(:failed) do |error|
+            connection.on(:failed) do |connection_state_change|
+              error = connection_state_change.reason
               expect(connection.state).to eq(:failed)
               # TODO: Check error type is a TokenNotFOund exception
               expect(error.status).to eq(401)
@@ -182,7 +184,8 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         context '#error_reason' do
           [:disconnected, :suspended, :failed].each do |state|
             it "contains the error when state is #{state}" do
-              connection.on(state) do |error|
+              connection.on(state) do |connection_state_change|
+                error = connection_state_change.reason
                 expect(connection.error_reason).to eq(error)
                 expect(connection.error_reason.code).to eql(80000)
                 stop_reactor
@@ -278,7 +281,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
       let(:channel_name) { random_str }
       let(:channel) { client.channel(channel_name) }
       let(:publishing_client) do
-        Ably::Realtime::Client.new(client_options)
+        auto_close Ably::Realtime::Client.new(client_options)
       end
       let(:publishing_client_channel) { publishing_client.channel(channel_name) }
       let(:client_options) { default_options.merge(log_level: :none) }
@@ -389,7 +392,10 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             connection.transport.close_connection_after_writing
 
             connection.once(:connected) do
-              expect(connection.key).to eql(previous_connection_key)
+              # Connection key left part should match new connection key left part i.e.
+              # wVIsgTHAB1UvXh7z-1991d8586 becomes wVIsgTHAB1UvXh7z-1990d8586 after resume
+              expect(connection.key[/^\w{5,}-/, 0]).to_not be_nil
+              expect(connection.key[/^\w{5,}-/, 0]).to eql(previous_connection_key[/^\w{5,}-/, 0])
               expect(connection.id).to eql(previous_connection_id)
               stop_reactor
             end
@@ -462,9 +468,11 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
 
       context 'when failing to resume' do
         context 'because the connection_key is not or no longer valid' do
+          let(:channel) { client.channel(random_str) }
+
           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
+            connection.configure_new '0123456789abcdef', 'wVIsgTHAB1UvXh7z-1991d8586', -1 # force the resume connection key to be invalid
           end
 
           it 'updates the connection_id and connection_key' do
@@ -488,8 +496,9 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             when_all(*channels.map(&:attach)) do
               detached_channels = []
               channels.each do |channel|
-                channel.on(:detached) do |error|
-                  expect(error.message).to match(/Invalid connection key/i)
+                channel.on(:detached) do |channel_state_change|
+                  error = channel_state_change.reason
+                  expect(error.message).to match(/Unable to recover connection/i)
                   detached_channels << channel
                   next unless detached_channels.count == channel_count
                   expect(detached_channels.count).to eql(channel_count)
@@ -502,16 +511,16 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           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
-              end
-
+            channel.attach do
               kill_connection_transport_and_prevent_valid_resume
             end
+
+            channel.on(:error) do |error|
+              expect(error.message).to match(/Unable to recover connection/i)
+              expect(error.code).to eql(80008)
+              expect(channel.error_reason).to eql(error)
+              stop_reactor
+            end
           end
         end
       end
@@ -620,11 +629,11 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
 
           it 'uses a fallback host on every subsequent disconnected attempt until suspended' do
             request = 0
-            expect(EventMachine).to receive(:connect).exactly(retry_count_for_one_state).times do |host|
+            # Expect retry attempts + 1 attempt for the next state
+            expect(EventMachine).to receive(:connect).exactly(retry_count_for_one_state + 1).times do |host|
               if request == 0
                 expect(host).to eql(expected_host)
               else
-                expect(custom_hosts).to include(host)
                 fallback_hosts_used << host
               end
               request += 1
@@ -632,6 +641,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             end
 
             connection.on(:suspended) do
+              fallback_hosts_used.pop # remove suspended attempt host
               expect(fallback_hosts_used.uniq).to match_array(custom_hosts)
               stop_reactor
             end

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

@@ -11,7 +11,7 @@ describe Ably::Realtime::Connection, :event_machine do
     end
 
     let(:client_options) { default_options }
-    let(:client)         { Ably::Realtime::Client.new(client_options) }
+    let(:client)         { auto_close Ably::Realtime::Client.new(client_options) }
 
     before(:example) do
       EventMachine.add_shutdown_hook do
@@ -29,7 +29,7 @@ describe Ably::Realtime::Connection, :event_machine do
 
       context 'with :auto_connect option set to false' do
         let(:client) do
-          Ably::Realtime::Client.new(default_options.merge(auto_connect: false))
+          auto_close Ably::Realtime::Client.new(default_options.merge(auto_connect: false))
         end
 
         it 'does not connect automatically' do
@@ -96,7 +96,7 @@ describe Ably::Realtime::Connection, :event_machine do
               stub_const 'Ably::Auth::TOKEN_DEFAULTS', Ably::Auth::TOKEN_DEFAULTS.merge(renew_token_buffer: 0)
 
               # Authorise synchronously to ensure token has been issued
-              client.auth.authorise_sync(token_params: { ttl: ttl })
+              client.auth.authorise_sync(ttl: ttl)
             end
 
             let(:original_renew_token_buffer) { @original_renew_token_buffer }
@@ -127,8 +127,8 @@ describe Ably::Realtime::Connection, :event_machine do
                 it 'renews the token on connect, and only makes one subsequent attempt to obtain a new token' do
                   expect(client.rest_client.auth).to receive(:authorise).at_least(:twice).and_call_original
                   connection.once(:disconnected) do
-                    connection.once(:failed) do |error|
-                      expect(error.code).to eql(40140) # token expired
+                    connection.once(:failed) do |connection_state_change|
+                      expect(connection_state_change.reason.code).to eql(40140) # token expired
                       stop_reactor
                     end
                   end
@@ -158,7 +158,7 @@ describe Ably::Realtime::Connection, :event_machine do
             context 'when connected with a valid non-expired token' do
               context 'that then expires following the connection being opened' do
                 let(:ttl)     { 5 }
-                let(:channel) { client.channel('test') }
+                let(:channel) { client.channel(random_str) }
 
                 context 'the server' do
                   it 'disconnects the client, and the client automatically renews the token and then reconnects', em_timeout: 15 do
@@ -167,8 +167,8 @@ describe Ably::Realtime::Connection, :event_machine do
 
                     connection.once(:connected) do
                       started_at = Time.now
-                      connection.once(:disconnected) do |error|
-                        expect(error.code).to eq(40140) # Token expired
+                      connection.once(:disconnected) do |connection_state_change|
+                        expect(connection_state_change.reason.code).to eq(40140) # Token expired
 
                         # Token has expired, so now ensure it is not used again
                         stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', original_token_expiry_buffer
@@ -178,7 +178,6 @@ describe Ably::Realtime::Connection, :event_machine do
                           expect(client.auth.current_token_details).to_not be_expired
                           expect(Time.now - started_at >= ttl)
                           expect(original_token).to be_expired
-                          expect(error.code).to eql(40140) # token expired
                           stop_reactor
                         end
                       end
@@ -205,7 +204,8 @@ describe Ably::Realtime::Connection, :event_machine do
 
             let!(:expired_token_details) do
               # Request a token synchronously
-              Ably::Realtime::Client.new(default_options).auth.request_token_sync(token_params: { ttl: 0.01 })
+              token_client = auto_close Ably::Realtime::Client.new(default_options)
+              token_client.auth.request_token_sync(ttl: 0.01)
             end
 
             context 'opening a new connection' do
@@ -271,8 +271,7 @@ describe Ably::Realtime::Connection, :event_machine do
       end
 
       it 'calls the Deferrable callback on success' do
-        connection.connect.callback do |connection|
-          expect(connection).to be_a(Ably::Realtime::Connection)
+        connection.connect.callback do
           expect(connection.state).to eq(:connected)
           stop_reactor
         end
@@ -307,7 +306,8 @@ describe Ably::Realtime::Connection, :event_machine do
       end
 
       describe 'once connected' do
-        let(:connection2) {  Ably::Realtime::Client.new(client_options).connection }
+        let(:client2)     { auto_close Ably::Realtime::Client.new(client_options) }
+        let(:connection2) { client2.connection }
 
         describe 'connection#id' do
           it 'is a string' do
@@ -437,7 +437,7 @@ describe Ably::Realtime::Connection, :event_machine do
 
       it 'calls the Deferrable callback on success' do
         connection.connect do
-          connection.close.callback do |connection|
+          connection.close.callback do
             expect(connection).to be_a(Ably::Realtime::Connection)
             expect(connection.state).to eq(:closed)
             stop_reactor
@@ -577,7 +577,7 @@ describe Ably::Realtime::Connection, :event_machine do
       let(:channel_name) { random_str }
       let(:channel) { client.channel(channel_name) }
       let(:publishing_client) do
-        Ably::Realtime::Client.new(client_options)
+        auto_close Ably::Realtime::Client.new(client_options)
       end
       let(:publishing_client_channel) { publishing_client.channel(channel_name) }
       let(:client_options) { default_options.merge(log_level: :fatal) }
@@ -595,9 +595,10 @@ describe Ably::Realtime::Connection, :event_machine do
         def self.available_states
           [:connecting, :connected, :disconnected, :suspended, :failed]
         end
-        let(:available_states) { self.class.available_states}
+        let(:available_states) { self.class.available_states }
         let(:states)           { Hash.new }
         let(:client_options)   { default_options.merge(log_level: :none) }
+        let(:channel)          { client.channel(random_str) }
 
         it 'is composed of connection key and serial that is kept up to date with each message ACK received' do
           connection.on(:connected) do
@@ -605,7 +606,7 @@ describe Ably::Realtime::Connection, :event_machine do
             expect(connection.key).to_not be_nil
             expect(connection.serial).to eql(expected_serial)
 
-            client.channel('test').attach do |channel|
+            channel.attach do
               channel.publish('event', 'data') do
                 expected_serial += 1 # attach message received
                 expect(connection.serial).to eql(expected_serial)
@@ -671,9 +672,10 @@ describe Ably::Realtime::Connection, :event_machine do
             end
 
             connection.once(:failed) do
-              recover_client = Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
+              recover_client = auto_close Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
               recover_client.connection.on(:connected) do
-                expect(recover_client.connection.key).to eql(previous_connection_key)
+                expect(recover_client.connection.key[/^\w{5,}-/, 0]).to_not be_nil
+                expect(recover_client.connection.key[/^\w{5,}-/, 0]).to eql(previous_connection_key[/^\w{5,}-/, 0])
                 expect(recover_client.connection.id).to eql(previous_connection_id)
                 stop_reactor
               end
@@ -686,7 +688,7 @@ describe Ably::Realtime::Connection, :event_machine do
             end
 
             connection.once(:failed) do
-              recover_client = Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
+              recover_client = auto_close Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
               recover_client.connection.on_resume do
                 raise 'Should not call the resume callback'
               end
@@ -702,14 +704,15 @@ describe Ably::Realtime::Connection, :event_machine do
             let(:client_options)   { default_options.merge(log_level: :none) }
 
             it 'recovers server-side queued messages' do
-              channel.attach do |message|
+              channel.attach do
                 connection.transition_state_machine! :failed
               end
 
               connection.on(:failed) do
                 publishing_client_channel.publish('event', 'message') do
-                  recover_client = Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
-                  recover_client.channel(channel_name).attach do |recover_client_channel|
+                  recover_client = auto_close Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
+                  recover_client_channel = recover_client.channel(channel_name)
+                  recover_client_channel.attach do
                     recover_client_channel.subscribe('event') do |message|
                       expect(message.data).to eql('message')
                       stop_reactor
@@ -738,9 +741,9 @@ describe Ably::Realtime::Connection, :event_machine do
           it 'emits 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(error.message).to match(/Invalid connectionKey/i)
+              expect(connection.error_reason.message).to match(/Invalid connectionKey/i)
+              expect(connection.error_reason.code).to eql(80018)
               expect(connection.error_reason).to eql(error)
               stop_reactor
             end
@@ -748,13 +751,13 @@ describe Ably::Realtime::Connection, :event_machine do
         end
 
         context 'with expired (missing) value sent to server' do
-          let(:client_options) { default_options.merge(recover: '0123456789abcdef:0', log_level: :fatal) }
+          let(:client_options) { default_options.merge(recover: 'wVIsgTHAB1UvXh7z-1991d8586:0', log_level: :fatal) }
 
           it 'emits 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(error.message).to match(/Unable to recover connection/i)
+              expect(connection.error_reason.message).to match(/Unable to recover connection/i)
               expect(connection.error_reason.code).to eql(80008)
               expect(connection.error_reason).to eql(error)
               stop_reactor
@@ -922,12 +925,12 @@ describe Ably::Realtime::Connection, :event_machine do
               expect(connection.__outgoing_message_queue__).to be_empty
               channel.publish 'test'
 
-              EventMachine.add_timer(0.02) do
+              EventMachine.next_tick do
                 expect(connection.__outgoing_message_queue__).to_not be_empty
               end
 
               connection.once(:connected) do
-                EventMachine.add_timer(0.02) do
+                EventMachine.add_timer(0.1) do
                   expect(connection.__outgoing_message_queue__).to be_empty
                   stop_reactor
                 end
@@ -940,6 +943,8 @@ describe Ably::Realtime::Connection, :event_machine do
       end
 
       context 'when connection enters the :suspended state' do
+        let(:client_options) { default_options.merge(:log_level => :fatal) }
+
         before do
           # Reconfigure client library retry periods so that client stays in suspended state
           stub_const 'Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG',
@@ -956,13 +961,21 @@ describe Ably::Realtime::Connection, :event_machine do
               stop_reactor
             end
 
+            close_connection_proc = Proc.new do
+              EventMachine.add_timer(0.001) do
+                if connection.transport.nil?
+                  close_connection_proc.call
+                else
+                  connection.transport.close_connection_after_writing
+                end
+              end
+            end
+
             # Keep disconnecting the websocket transport after it attempts reconnection
-            connection.transport.close_connection_after_writing
             connection.on(:connecting) do
-              EventMachine.add_timer(0.03) do
-                connection.transport.close_connection_after_writing
-              end
+              close_connection_proc.call
             end
+            close_connection_proc.call
           end
         end
       end
@@ -979,5 +992,107 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
     end
+
+    context 'connection state change' do
+      it 'emits a ConnectionStateChange object' do
+        connection.on(:connected) do |connection_state_change|
+          expect(connection_state_change).to be_a(Ably::Models::ConnectionStateChange)
+          stop_reactor
+        end
+      end
+
+      context 'ConnectionStateChange object' do
+        it 'has current state' do
+          connection.on(:connected) do |connection_state_change|
+            expect(connection_state_change.current).to eq(:connected)
+            stop_reactor
+          end
+        end
+
+        it 'has a previous state' do
+          connection.on(:connected) do |connection_state_change|
+            expect(connection_state_change.previous).to eq(:connecting)
+            stop_reactor
+          end
+        end
+
+        it 'contains a private API protocol_message attribute that is used for special state change events', :api_private do
+          connection.on(:connected) do |connection_state_change|
+            expect(connection_state_change.protocol_message).to be_a(Ably::Models::ProtocolMessage)
+            expect(connection_state_change.reason).to be_nil
+            stop_reactor
+          end
+        end
+
+        it 'has an empty reason when there is no error' do
+          connection.on(:closed) do |connection_state_change|
+            expect(connection_state_change.reason).to be_nil
+            stop_reactor
+          end
+          connection.connect do
+            connection.close
+          end
+        end
+
+        context 'on failure' do
+          let(:client_options) { default_options.merge(log_level: :none) }
+
+          it 'has a reason Error object when there is an error on the connection' do
+            connection.on(:failed) do |connection_state_change|
+              expect(connection_state_change.reason).to be_a(Ably::Exceptions::BaseAblyException)
+              stop_reactor
+            end
+            connection.connect do
+              error = Ably::Exceptions::ConnectionFailed.new('forced failure', 500, 50000)
+              client.connection.manager.error_received_from_server error
+            end
+          end
+        end
+
+        context 'retry_in' do
+          let(:client_options) { default_options.merge(log_level: :error) }
+
+          it 'is nil when a retry is not required' do
+            connection.on(:connected) do |connection_state_change|
+              expect(connection_state_change.retry_in).to be_nil
+              stop_reactor
+            end
+          end
+
+          it 'is 0 when first attempt to connect fails' do
+            connection.once(:connecting) do
+              connection.once(:disconnected) do |connection_state_change|
+                expect(connection_state_change.retry_in).to eql(0)
+                stop_reactor
+              end
+              EventMachine.add_timer(0.005) { connection.transport.unbind }
+            end
+          end
+
+          it 'is 0 when an immediate reconnect will occur' do
+            connection.once(:connected) do
+              connection.once(:disconnected) do |connection_state_change|
+                expect(connection_state_change.retry_in).to eql(0)
+                stop_reactor
+              end
+              connection.transport.unbind
+            end
+          end
+
+          it 'contains the next retry period when an immediate reconnect will not occur' do
+            connection.once(:connected) do
+              connection.once(:connecting) do
+                connection.once(:disconnected) do |connection_state_change|
+                  expect(connection_state_change.retry_in).to be > 0
+                  stop_reactor
+                end
+                EventMachine.add_timer(0.005) { connection.transport.unbind }
+              end
+              connection.transport.unbind
+            end
+          end
+        end
+      end
+    end
   end
 end