ably 0.8.4 → 0.8.5

data/lib/ably/realtime/connection/connection_manager.rb

@@ -39,7 +39,7 @@ module Ably::Realtime
 
         EventMachine.next_tick do
           # Connect once Connection object is initialised
-          connection.connect if client.auto_connect
+          connection.connect if client.auto_connect && connection.can_transition_to?(:connecting)
         end
       end
 
@@ -89,7 +89,7 @@ module Ably::Realtime
       # @api private
       def connected(protocol_message)
         if connection.key
-          if protocol_message.connection_key == connection.key
+          if connection_key_shared(protocol_message.connection_key) == connection_key_shared(connection.key)
             logger.debug "ConnectionManager: Connection resumed successfully - ID #{connection.id} and key #{connection.key}"
             EventMachine.next_tick { connection.resumed }
           else
@@ -179,7 +179,7 @@ module Ably::Realtime
       #
       # @api private
       def respond_to_transport_disconnected_whilst_connected(error)
-        logger.warn "ConnectionManager: Connection to #{connection.transport.url} was disconnected unexpectedly"
+        logger.warn "ConnectionManager: Connection #{"to #{connection.transport.url}" if connection.transport} was disconnected unexpectedly"
 
         if error.kind_of?(Ably::Models::ErrorInfo) && error.code != RESOLVABLE_ERROR_CODES.fetch(:token_expired)
           connection.emit :error, error
@@ -233,6 +233,12 @@ module Ably::Realtime
         client.channels
       end
 
+      # Connection key left part is consistent between connection resumes
+      # i.e. wVIsgTHAB1UvXh7z-1991d8586 becomes wVIsgTHAB1UvXh7z-1990d8586 after a resume
+      def connection_key_shared(connection_key)
+        (connection_key || '')[/^\w{5,}-/, 0]
+      end
+
       # Create a timer that will execute in timeout_in seconds.
       # If the connection state changes however, cancel the timer
       def create_timeout_timer_whilst_in_state(timer_id, timeout_in)

data/lib/ably/realtime/connection/connection_state_machine.rb

@@ -57,7 +57,7 @@ module Ably::Realtime
         connection.manager.respond_to_transport_disconnected_when_connecting err
       end
 
-      after_transition(to: [:disconnected], from: [:connected]) do |connection, current_transition|
+      after_transition(to: [:disconnected, :suspended], from: [:connected]) do |connection, current_transition|
         err = error_from_state_change(current_transition)
         connection.manager.respond_to_transport_disconnected_whilst_connected err
       end

data/lib/ably/realtime/presence.rb

@@ -405,7 +405,7 @@ module Ably::Realtime
           deferrable_succeed deferrable, &success_block
         end
 
-        protocol_message.errback do |message, error|
+        protocol_message.errback do |error|
           change_state failed_state, error if failed_state
           deferrable_fail deferrable, error
         end
@@ -419,8 +419,8 @@ module Ably::Realtime
     end
 
     def deferrable_fail(deferrable, *args, &block)
-      safe_yield block, self, *args if block_given?
-      EventMachine.next_tick { deferrable.fail self, *args } # allow errback to be added to the returned Deferrable
+      safe_yield block, *args if block_given?
+      EventMachine.next_tick { deferrable.fail *args } # allow errback to be added to the returned Deferrable
       deferrable
     end
 
@@ -431,7 +431,7 @@ module Ably::Realtime
       ensure_channel_attached(deferrable) do
         send_presence_protocol_message(action, client_id, options).tap do |protocol_message|
           protocol_message.callback { |message| deferrable_succeed deferrable, &success_block }
-          protocol_message.errback  { |message, error| deferrable_fail deferrable, error }
+          protocol_message.errback  { |error| deferrable_fail deferrable, error }
         end
       end
     end

data/lib/ably/rest/client.rb

@@ -144,7 +144,7 @@ module Ably
 
         token_params = options.delete(:token_params) || {}
         @options  = options
-        @auth     = Auth.new(self, options, token_params)
+        @auth     = Auth.new(self, token_params, options)
         @channels = Ably::Rest::Channels.new(self)
         @encoders = []
 
@@ -358,7 +358,7 @@ module Ably
         yield
       rescue Ably::Exceptions::TokenExpired => e
         if auth.token_renewable?
-          auth.authorise force: true
+          auth.authorise({}, force: true)
           yield
         else
           raise e

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.8.4'
+  VERSION = '0.8.5'
 end

data/spec/acceptance/realtime/auth_spec.rb

@@ -8,7 +8,7 @@ describe Ably::Realtime::Auth, :event_machine do
   vary_by_protocol do
     let(:default_options) { { key: api_key, environment: environment, protocol: protocol } }
     let(:client_options)  { default_options }
-    let(:client)          { Ably::Realtime::Client.new(client_options) }
+    let(:client)          { auto_close Ably::Realtime::Client.new(client_options) }
     let(:auth)            { client.auth }
 
     context 'with basic auth' do
@@ -101,7 +101,7 @@ describe Ably::Realtime::Auth, :event_machine do
         let(:auth_params) { { :body => random_str } }
 
         it 'contains the configured auth options' do
-          auth.authorise(auth_url: auth_url, auth_params: auth_params) do
+          auth.authorise({}, auth_url: auth_url, auth_params: auth_params) do
             expect(auth.options[:auth_url]).to eql(auth_url)
             stop_reactor
           end
@@ -112,7 +112,7 @@ describe Ably::Realtime::Auth, :event_machine do
         let(:custom_ttl) { 33 }
 
         it 'contains the configured auth options' do
-          auth.authorise({}, ttl: custom_ttl) do
+          auth.authorise(ttl: custom_ttl) do
             expect(auth.token_params[:ttl]).to eql(custom_ttl)
             stop_reactor
           end
@@ -144,7 +144,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#create_token_request' do
         it 'returns a token request asynchronously' do
-          auth.create_token_request({}, { ttl: custom_ttl }) do |token_request|
+          auth.create_token_request(ttl: custom_ttl) do |token_request|
             expect(token_request).to be_a(Ably::Models::TokenRequest)
             expect(token_request.ttl).to eql(custom_ttl)
             stop_reactor
@@ -154,7 +154,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#create_token_request_async' do
         it 'returns a token request synchronously' do
-          auth.create_token_request_sync(token_params: { ttl: custom_ttl }).tap do |token_request|
+          auth.create_token_request_sync(ttl: custom_ttl).tap do |token_request|
             expect(token_request).to be_a(Ably::Models::TokenRequest)
             expect(token_request.ttl).to eql(custom_ttl)
             stop_reactor
@@ -164,7 +164,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#request_token' do
         it 'returns a token asynchronously' do
-          auth.request_token({ client_id: custom_client_id }, ttl: custom_ttl) do |token_details|
+          auth.request_token(client_id: custom_client_id, ttl: custom_ttl) do |token_details|
             expect(token_details).to be_a(Ably::Models::TokenDetails)
             expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
             expect(token_details.client_id).to eql(custom_client_id)
@@ -175,7 +175,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#request_token_async' do
         it 'returns a token synchronously' do
-          auth.request_token_sync(client_id: custom_client_id, token_params: { ttl: custom_ttl }).tap do |token_details|
+          auth.request_token_sync(ttl: custom_ttl, client_id: custom_client_id).tap do |token_details|
             expect(token_details).to be_a(Ably::Models::TokenDetails)
             expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
             expect(token_details.client_id).to eql(custom_client_id)
@@ -186,7 +186,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#authorise' do
         it 'returns a token asynchronously' do
-          auth.authorise({ client_id: custom_client_id }, ttl: custom_ttl) do |token_details|
+          auth.authorise(ttl: custom_ttl, client_id: custom_client_id) do |token_details|
             expect(token_details).to be_a(Ably::Models::TokenDetails)
             expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
             expect(token_details.client_id).to eql(custom_client_id)
@@ -197,7 +197,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#authorise_async' do
         it 'returns a token synchronously' do
-          auth.authorise_sync(client_id: custom_client_id, token_params: { ttl: custom_ttl }).tap do |token_details|
+          auth.authorise_sync(ttl: custom_ttl, client_id: custom_client_id).tap do |token_details|
             expect(auth.authorise_sync).to be_a(Ably::Models::TokenDetails)
             expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
             expect(token_details.client_id).to eql(custom_client_id)

data/spec/acceptance/realtime/channel_history_spec.rb

@@ -5,11 +5,11 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
   vary_by_protocol do
     let(:default_options) { options.merge(key: api_key, environment: environment, protocol: protocol) }
 
-    let(:client)       { Ably::Realtime::Client.new(default_options) }
+    let(:client)       { auto_close Ably::Realtime::Client.new(default_options) }
     let(:channel)      { client.channel(channel_name) }
     let(:rest_channel) { client.rest_client.channel(channel_name) }
 
-    let(:client2)      { Ably::Realtime::Client.new(default_options) }
+    let(:client2)      { auto_close Ably::Realtime::Client.new(default_options) }
     let(:channel2)     { client2.channel(channel_name) }
 
     let(:channel_name) { "persisted:#{random_str(2)}" }

data/spec/acceptance/realtime/channel_spec.rb

@@ -6,7 +6,7 @@ describe Ably::Realtime::Channel, :event_machine do
     let(:default_options) { { key: api_key, environment: environment, protocol: protocol } }
     let(:client_options)  { default_options }
 
-    let(:client)       { Ably::Realtime::Client.new(client_options) }
+    let(:client)       { auto_close Ably::Realtime::Client.new(client_options) }
     let(:channel_name) { random_str }
     let(:payload)      { random_str }
     let(:channel)      { client.channel(channel_name) }
@@ -15,7 +15,7 @@ describe Ably::Realtime::Channel, :event_machine do
     describe 'initialization' do
       context 'with :auto_connect option set to false on connection' 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 'remains initialized when accessing a channel' do
@@ -80,7 +80,7 @@ describe Ably::Realtime::Channel, :event_machine do
       end
 
       it 'calls the SafeDeferrable callback on success' do
-        channel.attach.callback do |channel|
+        channel.attach.callback do
           expect(channel).to be_a(Ably::Realtime::Channel)
           expect(channel.state).to eq(:attached)
           stop_reactor
@@ -131,7 +131,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
         it 'attaches all channels', em_timeout: 15 do
           connection_count.times.map do
-            Ably::Realtime::Client.new(default_options)
+            auto_close Ably::Realtime::Client.new(default_options)
           end.each do |client|
             channel_count.times.map do |index|
               client.channel("channel-#{index}").attach do
@@ -148,7 +148,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
       context 'failure as a result of insufficient key permissions' do
         let(:restricted_client) do
-          Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
+          auto_close Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
         end
         let(:restricted_channel) { restricted_client.channel("cannot_subscribe") }
 
@@ -162,7 +162,7 @@ describe Ably::Realtime::Channel, :event_machine do
         end
 
         it 'calls the errback of the returned Deferrable' do
-          restricted_channel.attach.errback do |channel, error|
+          restricted_channel.attach.errback do |error|
             expect(restricted_channel.state).to eq(:failed)
             expect(error.status).to eq(401)
             stop_reactor
@@ -192,7 +192,7 @@ describe Ably::Realtime::Channel, :event_machine do
             restricted_channel.once(:failed) do
               restricted_client.close do
                 # A direct call to #authorise is synchronous
-                restricted_client.auth.authorise(key: api_key)
+                restricted_client.auth.authorise({}, key: api_key)
 
                 restricted_client.connect do
                   restricted_channel.once(:attached) do
@@ -220,9 +220,10 @@ describe Ably::Realtime::Channel, :event_machine do
       end
 
       it 'detaches from a channel and calls the provided block' do
-        channel.attach do |chan|
-          chan.detach do |detached_chan|
-            expect(detached_chan.state).to eq(:detached)
+        channel.attach do
+          expect(channel.state).to eq(:attached)
+          channel.detach do
+            expect(channel.state).to eq(:detached)
             stop_reactor
           end
         end
@@ -249,7 +250,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
       it 'calls the Deferrable callback on success' do
         channel.attach do
-          channel.detach.callback do |channel|
+          channel.detach.callback do
             expect(channel).to be_a(Ably::Realtime::Channel)
             expect(channel.state).to eq(:detached)
             stop_reactor
@@ -563,7 +564,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
         it 'publishes all messages, all success callbacks are called, and a history request confirms all messages were published' do
           connection_count.times.map do
-            Ably::Realtime::Client.new(client_options)
+            auto_close Ably::Realtime::Client.new(client_options)
           end.each do |client|
             channel = client.channels.get(channel_name)
             messages.each do |message|

data/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/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
@@ -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/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
@@ -281,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) }
@@ -392,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
@@ -465,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
@@ -493,7 +498,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
               channels.each do |channel|
                 channel.on(:detached) do |channel_state_change|
                   error = channel_state_change.reason
-                  expect(error.message).to match(/Invalid connection key/i)
+                  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)
@@ -506,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
@@ -624,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
@@ -636,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