ably 1.1.4.rc → 1.1.7

data/spec/acceptance/realtime/connection_spec.rb

@@ -77,18 +77,6 @@ describe Ably::Realtime::Connection, :event_machine do
                 end
               end
             end
-
-            context 'with implicit authorisation' do
-              let(:client_options) { default_options.merge(client_id: 'force_token_auth') }
-
-              it 'uses the token created by the implicit authorisation' do
-                expect(client.rest_client.auth).to receive(:request_token).once.and_call_original
-
-                connection.once(:connected) do
-                  stop_reactor
-                end
-              end
-            end
           end
 
           context 'that expire' do
@@ -134,7 +122,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 end
               end
 
-              context 'with immediately expired token' do
+              context 'with immediately expired token and no fallback hosts' do
                 let(:ttl) { 0.001 }
                 let(:auth_requests) { [] }
                 let(:token_callback) do
@@ -143,7 +131,7 @@ describe Ably::Realtime::Connection, :event_machine do
                     Ably::Rest::Client.new(default_options).auth.request_token(ttl: ttl).token
                   end
                 end
-                let(:client_options) { default_options.merge(auth_callback: token_callback) }
+                let(:client_options) { default_options.merge(auth_callback: token_callback, fallback_hosts: []) }
 
                 it 'renews the token on connect, and makes one immediate subsequent attempt to obtain a new token (#RSA4b)' do
                   started_at = Time.now.to_f
@@ -158,7 +146,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 end
 
                 context 'when disconnected_retry_timeout is 0.5 seconds' do
-                  let(:client_options) { default_options.merge(disconnected_retry_timeout: 0.5, auth_callback: token_callback) }
+                  let(:client_options) { default_options.merge(disconnected_retry_timeout: 0.5, auth_callback: token_callback, fallback_hosts: []) }
 
                   it 'renews the token on connect, and continues to attempt renew based on the retry schedule' do
                     disconnect_count = 0
@@ -184,7 +172,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 end
 
                 context 'using implicit token auth' do
-                  let(:client_options) { default_options.merge(use_token_auth: true, default_token_params: { ttl: ttl }) }
+                  let(:client_options) { default_options.merge(use_token_auth: true, default_token_params: { ttl: ttl }, fallback_hosts: []) }
 
                   before do
                     stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', -10 # ensure client lib thinks token is still valid
@@ -453,7 +441,9 @@ describe Ably::Realtime::Connection, :event_machine do
       end
     end
 
-    context '#connect' do
+    context '#connect with no fallbacks' do
+      let(:client_options)   { default_options.merge(fallback_hosts: []) }
+
       it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
         expect(connection.connect).to be_a(Ably::Util::SafeDeferrable)
         stop_reactor
@@ -1179,6 +1169,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 host:   'this.host.does.not.exist.com'
               )
             )
+            allow(client).to receive(:fallback_hosts).and_return([])
 
             connection.transition_state_machine! :disconnected
           end
@@ -1463,7 +1454,7 @@ describe Ably::Realtime::Connection, :event_machine do
             let(:client_options) { default_options.merge(tls: true) }
 
             it 'uses TLS for the Internet check to https://internet-up.ably-realtime.com/is-the-internet-up.txt' do
-              expect(EventMachine::HttpRequest).to receive(:new).with('https://internet-up.ably-realtime.com/is-the-internet-up.txt').and_return(http_request)
+              expect(EventMachine::HttpRequest).to receive(:new).with('https://internet-up.ably-realtime.com/is-the-internet-up.txt', { tls: { verify_peer: true } }).and_return(http_request)
               connection.internet_up?
               stop_reactor
             end
@@ -1473,7 +1464,7 @@ describe Ably::Realtime::Connection, :event_machine do
             let(:client_options) { default_options.merge(tls: false, use_token_auth: true) }
 
             it 'uses TLS for the Internet check to http://internet-up.ably-realtime.com/is-the-internet-up.txt' do
-              expect(EventMachine::HttpRequest).to receive(:new).with('http://internet-up.ably-realtime.com/is-the-internet-up.txt').and_return(http_request)
+              expect(EventMachine::HttpRequest).to receive(:new).with('http://internet-up.ably-realtime.com/is-the-internet-up.txt', { tls: { verify_peer: true } }).and_return(http_request)
               connection.internet_up?
               stop_reactor
             end
@@ -1487,7 +1478,7 @@ describe Ably::Realtime::Connection, :event_machine do
             let(:client_options) { default_options.merge(tls: true) }
 
             it 'checks the Internet up URL over TLS' do
-              expect(EventMachine::HttpRequest).to receive(:new).with("https:#{Ably::INTERNET_CHECK.fetch(:url)}").and_return(double('request', get: EventMachine::DefaultDeferrable.new))
+              expect(EventMachine::HttpRequest).to receive(:new).with("https:#{Ably::INTERNET_CHECK.fetch(:url)}", { tls: { verify_peer: true } }).and_return(double('request', get: EventMachine::DefaultDeferrable.new))
               connection.internet_up?
               stop_reactor
             end
@@ -1497,7 +1488,7 @@ describe Ably::Realtime::Connection, :event_machine do
             let(:client_options) { default_options.merge(tls: false, use_token_auth: true) }
 
             it 'checks the Internet up URL over TLS' do
-              expect(EventMachine::HttpRequest).to receive(:new).with("http:#{Ably::INTERNET_CHECK.fetch(:url)}").and_return(double('request', get: EventMachine::DefaultDeferrable.new))
+              expect(EventMachine::HttpRequest).to receive(:new).with("http:#{Ably::INTERNET_CHECK.fetch(:url)}", { tls: { verify_peer: true } }).and_return(double('request', get: EventMachine::DefaultDeferrable.new))
               connection.internet_up?
               stop_reactor
             end
@@ -1849,32 +1840,39 @@ describe Ably::Realtime::Connection, :event_machine do
         client
       end
 
-      it 'sends the lib version param lib (#RTN2g)' do
+      it 'sends the lib version param agent (#RCS7d)' do
         expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
           uri = URI.parse(url)
-          expect(CGI::parse(uri.query)['lib'][0]).to match(/^ruby-1\.1\.\d+(-[\w\.]+)?+$/)
+          expect(CGI::parse(uri.query)['agent'][0]).to match(/^ably-ruby\/\d\.\d\.\d ruby\/\d\.\d\.\d$/)
           stop_reactor
         end
         client
       end
+    end
 
-      context 'with variant' do
-        let(:variant) { 'foo' }
+    context 'transport_params (#RTC1f)' do
+      let(:client_options) { default_options.merge(transport_params: { 'extra_param' => 'extra_param' }) }
 
-        before do
-          Ably.lib_variant = variant
-        end
+      it 'pases transport_params to query' do
+        expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
+            uri = URI.parse(url)
+            expect(CGI::parse(uri.query)['extra_param'][0]).to eq('extra_param')
+            stop_reactor
+          end
 
-        after do
-          Ably.lib_variant = nil
-        end
+          client
+      end
 
-        it 'sends the lib version param lib with the variant (#RTN2g + #RSC7b)' do
+      context 'when changing default param' do
+        let(:client_options) { default_options.merge(transport_params: { v: '1.0' }) }
+
+        it 'overrides default param (#RTC1f1)' do
           expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
             uri = URI.parse(url)
-            expect(CGI::parse(uri.query)['lib'][0]).to match(/^ruby-#{variant}-1\.1\.\d+(-[\w\.]+)?$/)
+            expect(CGI::parse(uri.query)['v'][0]).to eq('1.0')
             stop_reactor
           end
+
           client
         end
       end

data/spec/acceptance/realtime/presence_history_spec.rb

@@ -20,7 +20,7 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
 
     it 'provides up to the moment presence history' do
       presence_client_one.enter(data) do
-        presence_client_one.leave(leave_data) do
+        presence_client_one.subscribe(:leave) do
           presence_client_one.history do |history_page|
             expect(history_page).to be_a(Ably::Models::PaginatedResult)
             expect(history_page.items.count).to eql(2)
@@ -36,6 +36,8 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
             stop_reactor
           end
         end
+
+        presence_client_one.leave(leave_data)
       end
     end
 
@@ -52,63 +54,5 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
 
       presence_client_one.enter(data)
     end
-
-    context 'with option until_attach: true' do
-      let(:event) { random_str }
-      let(:presence_data_before_attach) { random_str }
-      let(:presence_data_after_attach) { random_str }
-
-      it 'retrieves all presence messages before channel was attached' do
-        presence_client_two.enter(presence_data_before_attach) do
-          presence_client_one.enter(presence_data_after_attach) do
-            presence_client_one.history(until_attach: true) do |presence_page|
-              expect(presence_page.items.count).to eql(1)
-              expect(presence_page.items.first.data).to eql(presence_data_before_attach)
-              stop_reactor
-            end
-          end
-        end
-      end
-
-      context 'and two pages of messages' do
-        let(:wildcard_token) { lambda { |token_params| Ably::Rest::Client.new(default_options).auth.request_token(client_id: '*') } }
-        let(:client_one)     { auto_close Ably::Realtime::Client.new(default_options.merge(auth_callback: wildcard_token)) }
-        let(:client_two)     { auto_close Ably::Realtime::Client.new(default_options.merge(auth_callback: wildcard_token)) }
-
-        # TODO: Remove retry logic when presence history regression fixed
-        #       https://github.com/ably/realtime/issues/1707
-        #
-        it 'retrieves two pages of messages before channel was attached', retry: 10, :retry_wait => 5 do
-          when_all(*10.times.map { |i| presence_client_two.enter_client("client:#{i}", presence_data_before_attach) }) do
-            when_all(*10.times.map { |i| presence_client_one.enter_client("client:#{i}", presence_data_after_attach) }) do
-              presence_client_one.history(until_attach: true, limit: 5) do |presence_page|
-                expect(presence_page.items.count).to eql(5)
-                expect(presence_page.items.map(&:data).uniq.first).to eql(presence_data_before_attach)
-
-                presence_page.next do |presence_next_page|
-                  expect(presence_next_page.items.count).to eql(5)
-                  expect(presence_next_page.items.map(&:data).uniq.first).to eql(presence_data_before_attach)
-                  if presence_next_page.has_next?
-                    presence_next_page.next do |last|
-                      expect(last.items.count).to eql(0)
-                    end
-                  else
-                    expect(presence_next_page).to be_last
-                  end
-                  stop_reactor
-                end
-              end
-            end
-          end
-        end
-      end
-
-      it 'fails with an exception unless state is attached' do
-        presence_client_one.history(until_attach: true).errback do |error|
-          expect(error.message).to match(/not attached/)
-          stop_reactor
-        end
-      end
-    end
   end
 end

data/spec/acceptance/realtime/presence_spec.rb

@@ -498,7 +498,9 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         presence_client_one.enter do
-          presence_client_one.leave
+          EventMachine.add_timer(0.5) do
+            presence_client_one.leave
+          end
         end
       end
     end
@@ -705,7 +707,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
     context '#sync_complete? and SYNC flags (#RTP1)' do
       context 'when attaching to a channel without any members present' do
-        it 'sync_complete? is true, there is no presence flag, and the presence channel is considered synced immediately (#RTP1)' do
+        xit 'sync_complete? is true, there is no presence flag, and the presence channel is considered synced immediately (#RTP1)' do
           flag_checked = false
 
           anonymous_client.connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
@@ -1211,10 +1213,11 @@ describe Ably::Realtime::Presence, :event_machine do
             channel_client_one.attach do
               presence_client_one.subscribe(:enter) do
                 presence_client_one.unsubscribe :enter
-
-                expect(presence_client_one.members).to be_in_sync
-                expect(presence_client_one.members.send(:members).count).to eql(1)
-                presence_client_one.leave data
+                EventMachine.add_timer(0.5) do
+                  expect(presence_client_one.members).to be_in_sync
+                  expect(presence_client_one.members.send(:members).count).to eql(1)
+                  presence_client_one.leave data
+                end
               end
 
               presence_client_one.enter(enter_data) do
@@ -2137,16 +2140,18 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         it 'emits an error when cipher does not match and presence data cannot be decoded' do
-          incompatible_encrypted_channel.attach do
+          incompatible_encrypted_channel.once(:attached) do
             expect(client_two.logger).to receive(:error) do |*args, &block|
               expect(args.concat([block ? block.call : nil]).join(',')).to match(/Cipher algorithm AES-128-CBC does not match/)
               stop_reactor
-            end
+            end.at_least(:once)
 
             encrypted_channel.attach do
               encrypted_channel.presence.enter data
             end
           end
+
+          incompatible_encrypted_channel.attach
         end
       end
     end
@@ -2449,173 +2454,77 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
-      context 'when a channel becomes attached again' do
-        let(:attached_action) { Ably::Models::ProtocolMessage::ACTION.Attached.to_i }
-        let(:sync_action) { Ably::Models::ProtocolMessage::ACTION.Sync.to_i }
-        let(:presence_action) { Ably::Models::ProtocolMessage::ACTION.Presence.to_i }
-        let(:present_action) { Ably::Models::PresenceMessage::ACTION.Present.to_i }
-        let(:resume_flag) { 4 }
-        let(:presence_flag) { 1 }
-
-        def fabricate_incoming_protocol_message(protocol_message)
-          client_one.connection.__incoming_protocol_msgbus__.publish :protocol_message, protocol_message
-        end
-
-        # Prevents any messages from the WebSocket transport being sent / received
-        # Connection protocol message subscriptions are still active, but nothing reaches or comes from the WebSocket transport
-        def cripple_websocket_transport
-          client_one.connection.transport.__incoming_protocol_msgbus__.unsubscribe
-          client_one.connection.transport.__outgoing_protocol_msgbus__.unsubscribe
-        end
-
-        context 'and the resume flag is true' do
-          context 'and the presence flag is false' do
-            it 'does not send any presence events as the PresenceMap is in sync (#RTP5c1)' do
-              presence_client_one.enter
-              presence_client_one.subscribe(:enter) do
-                presence_client_one.unsubscribe :enter
+      describe '#RTP17b' do
+        let(:leave_action) { Ably::Models::PresenceMessage::ACTION.Leave }
 
-                client_one.connection.transport.__outgoing_protocol_msgbus__.subscribe do |message|
-                  raise "No presence state updates to Ably are expected. Message sent: #{message.to_json}" if client_one.connection.connected?
+        it 'updates presence members on leave' do
+          presence_client_two.subscribe(:enter) do
+            channel_anonymous_client.attach do
+              channel_anonymous_client.presence.get do |members|
+                presence_client_two.subscribe(:leave) do
+                  expect(presence_client_two.members.local_members).to be_empty
+                  stop_reactor
                 end
 
-                cripple_websocket_transport
-
-                fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                  action: attached_action,
-                  channel: channel_name,
-                  flags: resume_flag
+                leave_message = Ably::Models::PresenceMessage.new(
+                  'id' => "#{client_two.connection.id}:#{presence_client_two.client_id}:1",
+                  'clientId' => presence_client_two.client_id,
+                  'connectionId' => client_two.connection.id,
+                  'timestamp' => as_since_epoch(Time.now),
+                  'action' => leave_action
                 )
 
-                EventMachine.add_timer(1) do
-                  presence_client_one.get do |members|
-                    expect(members.length).to eql(1)
-                    expect(presence_client_one.members.local_members.length).to eql(1)
-                    stop_reactor
-                  end
-                end
+                presence_client_two.__incoming_msgbus__.publish :presence, leave_message
               end
             end
           end
 
-          context 'and the presence flag is true' do
-            context 'and following the SYNC all local MemberMap members are present in the PresenceMap' do
-              it 'does nothing as MemberMap is in sync (#RTP5c2)' do
-                presence_client_one.enter
-                presence_client_one.subscribe(:enter) do
-                  presence_client_one.unsubscribe :enter
-
-                  expect(presence_client_one.members.length).to eql(1)
-                  expect(presence_client_one.members.local_members.length).to eql(1)
-
-                  presence_client_one.members.once(:in_sync) do
-                    presence_client_one.get do |members|
-                      expect(members.length).to eql(1)
-                      expect(presence_client_one.members.local_members.length).to eql(1)
-                      stop_reactor
-                    end
-                  end
-
-                  client_one.connection.transport.__outgoing_protocol_msgbus__.subscribe do |message|
-                    raise "No presence state updates to Ably are expected. Message sent: #{message.to_json}" if client_one.connection.connected?
-                  end
+          presence_client_two.enter
+        end
 
-                  cripple_websocket_transport
+        it 'does no update presence members on fabricated leave' do
+          presence_client_two.subscribe(:enter) do
+            channel_anonymous_client.attach do
+              channel_anonymous_client.presence.get do |members|
+                presence_client_two.subscribe(:leave) do
+                  expect(presence_client_two.members.local_members).to_not be_empty
+                  stop_reactor
+                end
 
-                  fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                    action: attached_action,
-                    channel: channel_name,
-                    flags: resume_flag + presence_flag
-                  )
+                fabricated_leave_message = Ably::Models::PresenceMessage.new(
+                  'id' => "#{client_two.connection.id}:#{presence_client_two.client_id}:1",
+                  'clientId' => presence_client_two.client_id,
+                  'connectionId' => "fabricated:#{presence_client_two.client_id}:0",
+                  'timestamp' => as_since_epoch(Time.now),
+                  'action' => leave_action
+                )
 
-                  fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                    action: sync_action,
-                    channel: channel_name,
-                    presence: presence_client_one.members.map(&:shallow_clone).map(&:as_json),
-                    channelSerial: nil # no further SYNC messages expected
-                  )
-                end
+                presence_client_two.__incoming_msgbus__.publish :presence, fabricated_leave_message
               end
             end
+          end
 
-            context 'and following the SYNC a local MemberMap member is not present in the PresenceMap' do
-              it 're-enters the missing members automatically (#RTP5c2)' do
-                sync_check_completed = false
-
-                presence_client_one.enter
-                presence_client_one.subscribe(:enter) do
-                  presence_client_one.unsubscribe :enter
-
-                  expect(presence_client_one.members.length).to eql(1)
-                  expect(presence_client_one.members.local_members.length).to eql(1)
-
-                  client_one.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |message|
-                    next if message.action == :close # ignore finalization of connection
-
-                    expect(message.action).to eq(:presence)
-                    presence_message = message.presence.first
-                    expect(presence_message.action).to eq(:enter)
-                    expect(presence_message.client_id).to eq(client_one.auth.client_id)
-
-                    presence_client_one.subscribe(:enter) do |message|
-                      expect(message.connection_id).to eql(client_one.connection.id)
-                      expect(message.client_id).to eq(client_one.auth.client_id)
-
-                      EventMachine.next_tick do
-                        expect(presence_client_one.members.length).to eql(2)
-                        expect(presence_client_one.members.local_members.length).to eql(1)
-                        expect(sync_check_completed).to be_truthy
-                        stop_reactor
-                      end
-                    end
-
-                    # Fabricate Ably sending back the Enter PresenceMessage to the client a short while after
-                    # ensuring the PresenceMap for a short period does not have this member as to be expected in reality
-                    EventMachine.add_timer(0.2) do
-                      connection_id = random_str
-                      fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                        action: presence_action,
-                        channel: channel_name,
-                        connectionId: client_one.connection.id,
-                        connectionSerial: 50,
-                        timestamp: as_since_epoch(Time.now),
-                        presence: [presence_message.shallow_clone(id: "#{client_one.connection.id}:0:0", timestamp: as_since_epoch(Time.now)).as_json]
-                      )
-                    end
-                  end
-
-                  presence_client_one.members.once(:in_sync) do
-                    # For a brief period, the client will have re-entered the missing members from the local_members
-                    # but the enter from Ably will have not been received, so at this point the local_members will be empty
-                    presence_client_one.get do |members|
-                      expect(members.length).to eql(1)
-                      expect(members.first.connection_id).to_not eql(client_one.connection.id)
-                      expect(presence_client_one.members.local_members.length).to eql(0)
-                      sync_check_completed = true
-                    end
-                  end
+          presence_client_two.enter
+        end
+      end
 
-                  cripple_websocket_transport
+      context 'when a channel becomes attached again' do
+        let(:attached_action) { Ably::Models::ProtocolMessage::ACTION.Attached.to_i }
+        let(:sync_action) { Ably::Models::ProtocolMessage::ACTION.Sync.to_i }
+        let(:presence_action) { Ably::Models::ProtocolMessage::ACTION.Presence.to_i }
+        let(:present_action) { Ably::Models::PresenceMessage::ACTION.Present.to_i }
+        let(:resume_flag) { 4 }
+        let(:presence_flag) { 1 }
 
-                  fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                    action: attached_action,
-                    channel: channel_name,
-                    flags: resume_flag + presence_flag
-                  )
+        def fabricate_incoming_protocol_message(protocol_message)
+          client_one.connection.__incoming_protocol_msgbus__.publish :protocol_message, protocol_message
+        end
 
-                  # Complete the SYNC but without the member who was entered by this client
-                  connection_id = random_str
-                  fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                    action: sync_action,
-                    channel: channel_name,
-                    timestamp: as_since_epoch(Time.now),
-                    presence: [{ id: "#{connection_id}:0:0", action: present_action, connection_id: connection_id, client_id: random_str }],
-                    chanenlSerial: nil # no further SYNC messages expected
-                  )
-                end
-              end
-            end
-          end
+        # Prevents any messages from the WebSocket transport being sent / received
+        # Connection protocol message subscriptions are still active, but nothing reaches or comes from the WebSocket transport
+        def cripple_websocket_transport
+          client_one.connection.transport.__incoming_protocol_msgbus__.unsubscribe
+          client_one.connection.transport.__outgoing_protocol_msgbus__.unsubscribe
         end
 
         context 'and the resume flag is false' do