ably 0.8.7 → 0.8.8

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

@@ -98,11 +98,20 @@ module Ably::Realtime
       end
 
       private
-      attr_reader :connection, :driver, :reason_closed
+      def driver
+        @driver
+      end
+
+      def connection
+        @connection
+      end
+
+      def reason_closed
+        @reason_closed
+      end
 
       # Send object down the WebSocket driver connection as a serialized string/byte array based on protocol
       # @param [Object] object to serialize and send to the WebSocket driver
-      # @api public
       def send_object(object)
         case client.protocol
         when :json
@@ -122,7 +131,7 @@ module Ably::Realtime
       end
 
       def clear_timer
-        if @timer
+        if defined?(@timer) && @timer
           @timer.cancel
           @timer = nil
         end

data/lib/ably/realtime/presence.rb

@@ -250,11 +250,11 @@ module Ably::Realtime
       ensure_channel_attached(deferrable) do
         members.get(options).tap do |members_map_deferrable|
           members_map_deferrable.callback do |*args|
-            safe_yield block, *args if block_given?
-            deferrable.succeed *args
+            safe_yield(block, *args) if block_given?
+            deferrable.succeed(*args)
           end
           members_map_deferrable.errback do |*args|
-            deferrable.fail *args
+            deferrable.fail(*args)
           end
         end
       end
@@ -426,14 +426,14 @@ module Ably::Realtime
     end
 
     def deferrable_succeed(deferrable, *args, &block)
-      safe_yield block, self, *args if block_given?
+      safe_yield(block, self, *args) if block_given?
       EventMachine.next_tick { deferrable.succeed self, *args } # allow callback to be added to the returned Deferrable before calling succeed
       deferrable
     end
 
     def deferrable_fail(deferrable, *args, &block)
-      safe_yield block, *args if block_given?
-      EventMachine.next_tick { deferrable.fail *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
 

data/lib/ably/realtime/presence/members_map.rb

@@ -99,12 +99,12 @@ module Ably::Realtime
           end
 
           reset_callbacks = proc do
-            off &in_sync_callback
-            off &failed_callback
-            channel.off &failed_callback
+            off(&in_sync_callback)
+            off(&failed_callback)
+            channel.off(&failed_callback)
           end
 
-          once :in_sync, &in_sync_callback
+          once(:in_sync, &in_sync_callback)
 
           once(:failed, &failed_callback)
           channel.unsafe_once(:detaching, :detached, :failed) do |error_reason|
@@ -131,7 +131,21 @@ module Ably::Realtime
       end
 
       private
-      attr_reader :members, :sync_serial, :presence, :absent_member_cleanup_queue
+      def members
+        @members
+      end
+
+      def sync_serial
+        @sync_serial
+      end
+
+      def presence
+        @presence
+      end
+
+      def absent_member_cleanup_queue
+        @absent_member_cleanup_queue
+      end
 
       def channel
         presence.channel
@@ -156,9 +170,9 @@ module Ably::Realtime
         end
 
         resume_sync_proc = method(:resume_sync).to_proc
-        connection.on_resume &resume_sync_proc
+        connection.on_resume(&resume_sync_proc)
         once(:in_sync, :failed) do
-          connection.off_resume &resume_sync_proc
+          connection.off_resume(&resume_sync_proc)
         end
 
         once(:in_sync) do

data/lib/ably/rest/channel.rb

@@ -65,15 +65,15 @@ module Ably
         end
 
         payload = messages.map do |message|
-          Ably::Models::Message(message.dup).tap do |message|
-            message.encode self
+          Ably::Models::Message(message.dup).tap do |msg|
+            msg.encode self
 
-            next if message.client_id.nil?
-            if message.client_id == '*'
+            next if msg.client_id.nil?
+            if msg.client_id == '*'
               raise Ably::Exceptions::IncompatibleClientId.new('Wildcard client_id is reserved and cannot be used when publishing messages', 400, 40012)
             end
-            unless client.auth.can_assume_client_id?(message.client_id)
-              raise Ably::Exceptions::IncompatibleClientId.new("Cannot publish with client_id '#{message.client_id}' as it is incompatible with the current configured client_id '#{client.client_id}'", 400, 40012)
+            unless client.auth.can_assume_client_id?(msg.client_id)
+              raise Ably::Exceptions::IncompatibleClientId.new("Cannot publish with client_id '#{msg.client_id}' as it is incompatible with the current configured client_id '#{client.client_id}'", 400, 40012)
             end
           end.as_json
         end
@@ -111,8 +111,8 @@ module Ably
         response = client.get(url, options)
 
         Ably::Models::PaginatedResult.new(response, url, client, paginated_options) do |message|
-          message.tap do |message|
-            decode_message message
+          message.tap do |msg|
+            decode_message msg
           end
         end
       end

data/lib/ably/rest/client.rb

@@ -315,7 +315,7 @@ module Ably
       #
       # @api private
       def fallback_connection
-        unless @fallback_connections
+        unless defined?(@fallback_connections) && @fallback_connections
           @fallback_connections = Ably::FALLBACK_HOSTS.shuffle.map { |host| Faraday.new(endpoint_for_host(host).to_s, connection_options) }
         end
         @fallback_index ||= 0

data/lib/ably/rest/middleware/exceptions.rb

@@ -7,6 +7,8 @@ module Ably
       # HTTP exceptions raised by Ably due to an error status code
       # Ably returns JSON/Msgpack error codes and messages so include this if possible in the exception messages
       class Exceptions < Faraday::Response::Middleware
+        TOKEN_EXPIRED_CODE = 40140..40149
+
         def on_complete(env)
           if env.status >= 400
             error_status_code = env.status
@@ -30,7 +32,7 @@ module Ably
 
             if env.status >= 500
               raise Ably::Exceptions::ServerError.new(message, error_status_code, error_code)
-            elsif env.status == 401 && error_code == 40140
+            elsif env.status == 401 && TOKEN_EXPIRED_CODE.include?(error_code)
               raise Ably::Exceptions::TokenExpired.new(message, error_status_code, error_code)
             else
               raise Ably::Exceptions::InvalidRequest.new(message, error_status_code, error_code)

data/lib/ably/rest/presence.rb

@@ -40,8 +40,8 @@ module Ably
         response = client.get(base_path, options)
 
         Ably::Models::PaginatedResult.new(response, base_path, client, paginated_options) do |presence_message|
-          presence_message.tap do |presence_message|
-            decode_message presence_message
+          presence_message.tap do |message|
+            decode_message message
           end
         end
       end
@@ -74,8 +74,8 @@ module Ably
         response = client.get(url, options)
 
         Ably::Models::PaginatedResult.new(response, url, client, paginated_options) do |presence_message|
-          presence_message.tap do |presence_message|
-            decode_message presence_message
+          presence_message.tap do |message|
+            decode_message message
           end
         end
       end

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.8.7'
+  VERSION = '0.8.8'
 end

data/spec/acceptance/realtime/channel_history_spec.rb

@@ -19,7 +19,7 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
     let(:options)      { { :protocol => :json } }
 
     it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
-      channel.publish('event', payload) do |message|
+      channel.publish('event', payload) do
         history = channel.history
         expect(history).to be_a(Ably::Util::SafeDeferrable)
         history.callback do |page|
@@ -32,7 +32,7 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
 
     context 'with a single client publishing and receiving' do
       it 'retrieves realtime history' do
-        channel.publish('event', payload) do |message|
+        channel.publish('event', payload) do
           channel.history do |page|
             expect(page.items.length).to eql(1)
             expect(page.items[0].data).to eql(payload)
@@ -44,8 +44,8 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
 
     context 'with two clients publishing messages on the same channel' do
       it 'retrieves realtime history on both channels' do
-        channel.publish('event', payload) do |message|
-          channel2.publish('event', payload) do |message|
+        channel.publish('event', payload) do
+          channel2.publish('event', payload) do
             channel.history do |page|
               expect(page.items.length).to eql(2)
               expect(page.items.map(&:data).uniq).to eql([payload])

data/spec/acceptance/realtime/connection_failures_spec.rb

@@ -481,8 +481,6 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         end
 
         it 'retains channel subscription state' do
-          messages_received = false
-
           channel.subscribe('event') do |message|
             expect(message.data).to eql('message')
             stop_reactor
@@ -712,6 +710,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         context 'when the Internet is up' do
           before do
             allow(connection).to receive(:internet_up?).and_yield(true)
+            @suspended = 0
           end
 
           it 'uses a fallback host on every subsequent disconnected attempt until suspended' do
@@ -740,14 +739,13 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
                 expect(host).to eql(expected_host)
               else
                 expect(custom_hosts).to include(host)
-                fallback_hosts_used << host if @suspended
+                fallback_hosts_used << host if @suspended > 0
               end
               request += 1
               raise EventMachine::ConnectionError
             end
 
             connection.on(:suspended) do
-              @suspended ||= 0
               @suspended += 1
 
               if @suspended > 3

data/spec/acceptance/realtime/connection_spec.rb

@@ -141,7 +141,7 @@ describe Ably::Realtime::Connection, :event_machine do
                   started_at = Time.now.to_f
                   connection.once(:disconnected) do
                     connection.once(:disconnected) do |connection_state_change|
-                      expect(connection_state_change.reason.code).to eql(40140) # token expired
+                      expect(connection_state_change.reason.code).to eql(40142) # token expired
                       expect(Time.now.to_f - started_at).to be < 1000
                       expect(auth_requests.count).to eql(2)
                       stop_reactor
@@ -156,7 +156,7 @@ describe Ably::Realtime::Connection, :event_machine do
                     started_at = Time.now.to_f
                     disconnect_count = 0
                     connection.on(:disconnected) do |connection_state_change|
-                      expect(connection_state_change.reason.code).to eql(40140) # token expired
+                      expect(connection_state_change.reason.code).to eql(40142) # token expired
                       disconnect_count += 1
                       if disconnect_count == 6
                         expect(Time.now.to_f - started_at).to be > 4 * 0.5 # at least 4 0.5 second pauses should have happened
@@ -207,7 +207,7 @@ describe Ably::Realtime::Connection, :event_machine do
                       expect(original_token).to_not be_expired
                       started_at = Time.now
                       connection.once(:disconnected) do |connection_state_change|
-                        expect(connection_state_change.reason.code).to eq(40140) # Token expired
+                        expect(connection_state_change.reason.code).to eq(40142) # 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
@@ -333,7 +333,7 @@ describe Ably::Realtime::Connection, :event_machine do
                   expect(expired_token_details).to be_expired
                   connection.once(:connected) { raise 'Connection should never connect as token has expired' }
                   connection.once(:failed) do
-                    expect(client.connection.error_reason.code).to eql(40140)
+                    expect(client.connection.error_reason.code).to eql(40142)
                     stop_reactor
                   end
                 end
@@ -800,6 +800,41 @@ describe Ably::Realtime::Connection, :event_machine do
       end
     end
 
+    context '#details' do
+      let(:connection) { client.connection }
+
+      it 'is nil before connected' do
+        connection.on(:connecting) do
+          expect(connection.details).to eql(nil)
+          stop_reactor
+        end
+      end
+
+      it 'contains the ConnectionDetails object once connected' do
+        connection.on(:connected) do
+          expect(connection.details).to be_a(Ably::Models::ConnectionDetails)
+          expect(connection.details.connection_key).to_not be_nil
+          expect(connection.details.server_id).to_not be_nil
+          stop_reactor
+        end
+      end
+
+      it 'contains the new ConnectionDetails object once a subsequent connection is created' do
+        connection.once(:connected) do
+          expect(connection.details.connection_key).to_not be_nil
+          old_key = connection.details.connection_key
+          connection.close do
+            connection.once(:connected) do
+              expect(connection.details.connection_key).to_not be_nil
+              expect(connection.details.connection_key).to_not eql(old_key)
+              stop_reactor
+            end
+            connection.connect
+          end
+        end
+      end
+    end
+
     context 'recovery' do
       let(:channel_name) { random_str }
       let(:channel) { client.channel(channel_name) }
@@ -813,7 +848,8 @@ describe Ably::Realtime::Connection, :event_machine do
           log_level:                  :none,
           disconnected_retry_timeout: 0.1,
           suspended_retry_timeout:    0.1,
-          connection_state_ttl:       0.2
+          connection_state_ttl:       0.2,
+          realtime_request_timeout:   5
         )
       end
 
@@ -889,7 +925,8 @@ describe Ably::Realtime::Connection, :event_machine do
 
       context "opening a new connection using a recently disconnected connection's #recovery_key" do
         context 'connection#id and connection#key after recovery' do
-          it 'remains the same' do
+          it 'remains the same for id and party for key' do
+            connection_key_consistent_part_regex = /.*?!(\w{5,})-/
             previous_connection_id  = nil
             previous_connection_key = nil
 
@@ -902,8 +939,9 @@ describe Ably::Realtime::Connection, :event_machine do
             connection.once(:failed) do
               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[/^\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.key[connection_key_consistent_part_regex, 1]).to_not be_nil
+                expect(recover_client.connection.key[connection_key_consistent_part_regex, 1]).to eql(
+                  previous_connection_key[connection_key_consistent_part_regex, 1])
                 expect(recover_client.connection.id).to eql(previous_connection_id)
                 stop_reactor
               end

data/spec/acceptance/realtime/presence_spec.rb

@@ -509,7 +509,7 @@ describe Ably::Realtime::Presence, :event_machine do
     end
 
     context '250 existing (present) members on a channel (3 SYNC pages)' do
-      context 'requires at least 3 SYNC ProtocolMessages' do
+      context 'requires at least 3 SYNC ProtocolMessages', em_timeout: 30 do
         let(:enter_expected_count) { 250 }
         let(:present) { [] }
         let(:entered) { [] }
@@ -518,15 +518,18 @@ describe Ably::Realtime::Presence, :event_machine do
 
         def setup_members_on(presence)
           enter_expected_count.times do |index|
-            presence.enter_client("client:#{index}") do |message|
-              entered << message
-              next unless entered.count == enter_expected_count
-              yield
+            # 10 messages per second max rate on simulation accounts
+            EventMachine.add_timer(index / 10) do
+              presence.enter_client("client:#{index}") do |message|
+                entered << message
+                next unless entered.count == enter_expected_count
+                yield
+              end
             end
           end
         end
 
-        context 'when a client attaches to the presence channel', em_timeout: 10 do
+        context 'when a client attaches to the presence channel' do
           it 'emits :present for each member' do
             setup_members_on(presence_client_one) do
               presence_anonymous_client.subscribe(:present) do |present_message|
@@ -676,14 +679,16 @@ describe Ably::Realtime::Presence, :event_machine do
             context 'with :wait_for_sync option set to true' do
               it 'waits until sync is complete', em_timeout: 15 do
                 enter_expected_count.times do |index|
-                  presence_client_one.enter_client("client:#{index}") do |message|
-                    entered << message
-                    next unless entered.count == enter_expected_count
-
-                    presence_anonymous_client.get(wait_for_sync: true) do |members|
-                      expect(members.map(&:client_id).uniq.count).to eql(enter_expected_count)
-                      expect(members.count).to eql(enter_expected_count)
-                      stop_reactor
+                  EventMachine.add_timer(index / 10) do
+                    presence_client_one.enter_client("client:#{index}") do |message|
+                      entered << message
+                      next unless entered.count == enter_expected_count
+
+                      presence_anonymous_client.get(wait_for_sync: true) do |members|
+                        expect(members.map(&:client_id).uniq.count).to eql(enter_expected_count)
+                        expect(members.count).to eql(enter_expected_count)
+                        stop_reactor
+                      end
                     end
                   end
                 end
@@ -693,15 +698,17 @@ describe Ably::Realtime::Presence, :event_machine do
             context 'by default' do
               it 'it does not wait for sync', em_timeout: 15 do
                 enter_expected_count.times do |index|
-                  presence_client_one.enter_client("client:#{index}") do |message|
-                    entered << message
-                    next unless entered.count == enter_expected_count
-
-                    channel_anonymous_client.attach do
-                      presence_anonymous_client.get do |members|
-                        expect(presence_anonymous_client.members).to_not be_in_sync
-                        expect(members.count).to eql(0)
-                        stop_reactor
+                  EventMachine.add_timer(index / 10) do
+                    presence_client_one.enter_client("client:#{index}") do |message|
+                      entered << message
+                      next unless entered.count == enter_expected_count
+
+                      channel_anonymous_client.attach do
+                        presence_anonymous_client.get do |members|
+                          expect(presence_anonymous_client.members).to_not be_in_sync
+                          expect(members.count).to eql(0)
+                          stop_reactor
+                        end
                       end
                     end
                   end
@@ -1225,7 +1232,7 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
-      context 'during a sync' do
+      context 'during a sync', em_timeout: 30 do
         let(:pages)               { 2 }
         let(:members_per_page)    { 100 }
         let(:sync_pages_received) { [] }
@@ -1234,7 +1241,15 @@ describe Ably::Realtime::Presence, :event_machine do
 
         def connect_members_deferrables
           (members_per_page * pages + 1).times.map do |index|
-            presence_client_one.enter_client("client:#{index}")
+            # rate limit to 10 per second
+            EventMachine::DefaultDeferrable.new.tap do |deferrable|
+              EventMachine.add_timer(index / 10) do
+                presence_client_one.enter_client("client:#{index}").tap do |enter_deferrable|
+                  enter_deferrable.callback { |*args| deferrable.succeed *args }
+                  enter_deferrable.errback { |*args| deferrable.fail *args }
+                end
+              end
+            end
           end
         end
 
@@ -1316,9 +1331,9 @@ describe Ably::Realtime::Presence, :event_machine do
             expect(members.count).to eq(1)
             expect(members.first.connection_id).to eql(client_one.connection.id)
 
-            presence_client_one.get(connection_id: client_two.connection.id) do |members|
-              expect(members.count).to eq(1)
-              expect(members.first.connection_id).to eql(client_two.connection.id)
+            presence_client_one.get(connection_id: client_two.connection.id) do |members_two|
+              expect(members_two.count).to eq(1)
+              expect(members_two.first.connection_id).to eql(client_two.connection.id)
               stop_reactor
             end
           end
@@ -1339,10 +1354,10 @@ describe Ably::Realtime::Presence, :event_machine do
             expect(members.first.client_id).to eql(client_one_id)
             expect(members.first.connection_id).to eql(client_one.connection.id)
 
-            presence_client_one.get(client_id: client_two_id) do |members|
-              expect(members.count).to eq(1)
-              expect(members.first.client_id).to eql(client_two_id)
-              expect(members.first.connection_id).to eql(client_two.connection.id)
+            presence_client_one.get(client_id: client_two_id) do |members_two|
+              expect(members_two.count).to eq(1)
+              expect(members_two.first.client_id).to eql(client_two_id)
+              expect(members_two.first.connection_id).to eql(client_two.connection.id)
               stop_reactor
             end
           end
@@ -1469,8 +1484,8 @@ describe Ably::Realtime::Presence, :event_machine do
         it 'removes the callback for all presence events' do
           when_all(channel_client_one.attach, channel_client_two.attach) do
             subscribe_callback = proc { raise 'Should not be called' }
-            presence_client_two.subscribe &subscribe_callback
-            presence_client_two.unsubscribe &subscribe_callback
+            presence_client_two.subscribe(&subscribe_callback)
+            presence_client_two.unsubscribe(&subscribe_callback)
 
             presence_client_one.enter
             presence_client_one.update