ably 0.7.0 → 0.7.1

data/spec/acceptance/realtime/connection_failures_spec.rb

@@ -192,7 +192,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           it 'is reset to nil when :connected' do
             connection.once(:disconnected) do |error|
               # stub the host so that the connection connects
-              allow(connection).to receive(:host).and_return(TestApp.instance.host)
+              allow(connection).to receive(:determine_host).and_yield(TestApp.instance.realtime_host)
               connection.once(:connected) do
                 expect(connection.error_reason).to be_nil
                 stop_reactor
@@ -393,6 +393,59 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           end
         end
       end
+
+      context 'when failing to resume because the connection_key is not or no longer valid' do
+        def kill_connection_transport_and_prevent_valid_resume
+          connection.transport.close_connection_after_writing
+          connection.update_connection_id_and_key '0123456789abcdef', '0123456789abcdef' # force the resume connection key to be invalid
+        end
+
+        it 'updates the connection_id and connection_key' do
+          connection.once(:connected) do
+            previous_connection_id  = connection.id
+            previous_connection_key = connection.key
+
+            connection.once(:connected) do
+              expect(connection.key).to_not eql(previous_connection_key)
+              expect(connection.id).to_not eql(previous_connection_id)
+              stop_reactor
+            end
+
+            kill_connection_transport_and_prevent_valid_resume
+          end
+        end
+
+        it 'detaches all channels' do
+          channel_count = 10
+          channels = channel_count.times.map { |index| client.channel("channel-#{index}") }
+          when_all(*channels.map(&:attach)) do
+            detached_channels = []
+            channels.each do |channel|
+              channel.on(:detached) do
+                detached_channels << channel
+                next unless detached_channels.count == channel_count
+                expect(detached_channels.count).to eql(channel_count)
+                stop_reactor
+              end
+            end
+
+            kill_connection_transport_and_prevent_valid_resume
+          end
+        end
+
+        it 'emits an error on the channel and sets the error reason' do
+          client.channel(random_str).attach do |channel|
+            channel.on(:error) do |error|
+              expect(error.message).to match(/Invalid connection key/i)
+              expect(error.code).to eql(80008)
+              expect(channel.error_reason).to eql(error)
+              stop_reactor
+            end
+
+            kill_connection_transport_and_prevent_valid_resume
+          end
+        end
+      end
     end
 
     describe 'fallback host feature' do
@@ -456,41 +509,64 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
 
         let(:fallback_hosts_used) { Array.new }
 
-        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|
-            if request == 0
+        context 'when the Internet is down' do
+          before do
+            allow(connection).to receive(:internet_up?).and_yield(false)
+          end
+
+          it 'never uses a fallback host' do
+            expect(EventMachine).to receive(:connect).exactly(retry_count_for_all_states).times do |host|
               expect(host).to eql(expected_host)
-            else
-              expect(custom_hosts).to include(host)
-              fallback_hosts_used << host
+              raise EventMachine::ConnectionError
             end
-            request += 1
-            raise EventMachine::ConnectionError
-          end
 
-          connection.on(:suspended) do
-            expect(fallback_hosts_used.uniq).to match_array(custom_hosts)
-            stop_reactor
+            connection.on(:failed) do
+              stop_reactor
+            end
           end
         end
 
-        it 'uses the primary host when suspended, and a fallback host on every subsequent suspended attempt' do
-          request = 0
-          expect(EventMachine).to receive(:connect).exactly(retry_count_for_all_states).times do |host|
-            if request == 0 || request == expected_retry_attempts + 1
-              expect(host).to eql(expected_host)
-            else
-              expect(custom_hosts).to include(host)
-              fallback_hosts_used << host
+        context 'when the Internet is up' do
+          before do
+            allow(connection).to receive(:internet_up?).and_yield(true)
+          end
+
+          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|
+              if request == 0
+                expect(host).to eql(expected_host)
+              else
+                expect(custom_hosts).to include(host)
+                fallback_hosts_used << host
+              end
+              request += 1
+              raise EventMachine::ConnectionError
+            end
+
+            connection.on(:suspended) do
+              expect(fallback_hosts_used.uniq).to match_array(custom_hosts)
+              stop_reactor
             end
-            request += 1
-            raise EventMachine::ConnectionError
           end
 
-          connection.on(:failed) do
-            expect(fallback_hosts_used.uniq).to match_array(custom_hosts)
-            stop_reactor
+          it 'uses the primary host when suspended, and a fallback host on every subsequent suspended attempt' do
+            request = 0
+            expect(EventMachine).to receive(:connect).exactly(retry_count_for_all_states).times do |host|
+              if request == 0 || request == expected_retry_attempts + 1
+                expect(host).to eql(expected_host)
+              else
+                expect(custom_hosts).to include(host)
+                fallback_hosts_used << host
+              end
+              request += 1
+              raise EventMachine::ConnectionError
+            end
+
+            connection.on(:failed) do
+              expect(fallback_hosts_used.uniq).to match_array(custom_hosts)
+              stop_reactor
+            end
           end
         end
       end

data/spec/acceptance/realtime/connection_spec.rb

@@ -93,7 +93,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 it 'renews the token on connect' do
                   sleep ttl + 0.1
                   expect(client.auth.current_token).to be_expired
-                  expect(client.auth).to receive(:authorise).once.and_call_original
+                  expect(client.auth).to receive(:authorise).at_least(:once).and_call_original
                   connection.once(:connected) do
                     expect(client.auth.current_token).to_not be_expired
                     stop_reactor
@@ -105,7 +105,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 let(:ttl) { 0.01 }
 
                 it 'renews the token on connect, and only makes one subsequent attempt to obtain a new token' do
-                  expect(client.auth).to receive(:authorise).twice.and_call_original
+                  expect(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
@@ -117,7 +117,10 @@ describe Ably::Realtime::Connection, :event_machine do
                 it 'uses the primary host for subsequent connection and auth requests' do
                   EventMachine.add_timer(1) do # wait for token to expire
                     connection.once(:disconnected) do
-                      expect(client.rest_client.connection).to receive(:post).with(/requestToken$/, anything).and_call_original
+                      expect(client.rest_client.connection).to receive(:post).
+                                                                 with(/requestToken$/, anything).
+                                                                 at_least(:once).
+                                                                 and_call_original
 
                       expect(client.rest_client).to_not receive(:fallback_connection)
                       expect(client).to_not receive(:fallback_endpoint)
@@ -139,23 +142,25 @@ describe Ably::Realtime::Connection, :event_machine do
 
                 context 'the server' do
                   it 'disconnects the client, and the client automatically renews the token and then reconnects', em_timeout: 10 do
-                    expect(client.auth.current_token).to_not be_expired
-
-                    channel.attach
                     original_token = client.auth.current_token
+                    expect(original_token).to_not be_expired
 
                     connection.once(:connected) do
                       started_at = Time.now
                       connection.once(:disconnected) do |error|
-                        expect(Time.now - started_at >= ttl)
-                        expect(original_token).to be_expired
-                        expect(error.code).to eql(40140) # token expired
-                        connection.once(:connected) do
-                          expect(client.auth.current_token).to_not be_expired
-                          stop_reactor
+                        EventMachine.add_timer(1) do # allow 1 second
+                          expect(Time.now - started_at >= ttl)
+                          expect(original_token).to be_expired
+                          expect(error.code).to eql(40140) # token expired
+                          connection.once(:connected) do
+                            expect(client.auth.current_token).to_not be_expired
+                            stop_reactor
+                          end
                         end
                       end
                     end
+
+                    channel.attach
                   end
                 end
 
@@ -601,13 +606,28 @@ describe Ably::Realtime::Connection, :event_machine do
           end
         end
 
-        context 'with invalid value' do
-          let(:client_options) { default_options.merge(recover: 'invalid:key', log_level: :fatal) }
+        context 'with invalid formatted value sent to server' do
+          let(:client_options) { default_options.merge(recover: 'not-a-valid-connection-key:1', log_level: :none) }
 
-          skip 'triggers an error on the connection object, sets the #error_reason and connects anyway' do
-            connection.on(:error) do |error|
+          it 'triggers a fatal error on the connection object, sets the #error_reason and disconnects' do
+            connection.once(:error) do |error|
+              expect(connection.state).to eq(:failed)
+              expect(connection.error_reason.message).to match(/Invalid connection key/)
+              expect(connection.error_reason.code).to eql(40006)
+              expect(connection.error_reason).to eql(error)
+              stop_reactor
+            end
+          end
+        end
+
+        context 'with expired (missing) value sent to server' do
+          let(:client_options) { default_options.merge(recover: '0123456789abcdef:0', log_level: :fatal) }
+
+          it 'triggers an error on the connection object, sets the #error_reason, yet will connect anyway' do
+            connection.once(:error) do |error|
               expect(connection.state).to eq(:connected)
-              expect(connection.error_reason.message).to match(/Recover/)
+              expect(connection.error_reason.message).to match(/Invalid connection key/i)
+              expect(connection.error_reason.code).to eql(80008)
               expect(connection.error_reason).to eql(error)
               stop_reactor
             end
@@ -652,5 +672,49 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
     end
+
+
+    context 'undocumented method' do
+      context '#internet_up?' do
+        it 'returns a Deferrable' do
+          expect(connection.internet_up?).to be_a(EventMachine::Deferrable)
+          stop_reactor
+        end
+
+        context 'when the Internet is up' do
+          it 'calls the block with true' do
+            connection.internet_up? do |result|
+              expect(result).to be_truthy
+              stop_reactor
+            end
+          end
+
+          it 'calls the success callback of the Deferrable' do
+            connection.internet_up?.callback do
+              stop_reactor
+            end
+          end
+        end
+
+        context 'when the Internet is down' do
+          before do
+            stub_const 'Ably::INTERNET_CHECK', { url: 'http://does.not.exist.com', ok_text: 'no.way.this.will.match' }
+          end
+
+          it 'calls the block with false' do
+            connection.internet_up? do |result|
+              expect(result).to be_falsey
+              stop_reactor
+            end
+          end
+
+          it 'calls the failure callback of the Deferrable' do
+            connection.internet_up?.errback do
+              stop_reactor
+            end
+          end
+        end
+      end
+    end
   end
 end

data/spec/acceptance/realtime/presence_spec.rb

@@ -256,6 +256,16 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
+      it 'updates the data to nil if :data argument is not provided (assumes nil value)' do
+        presence_client_one.enter(data: 'prior') do
+          presence_client_one.update
+        end
+        presence_client_one.subscribe(:update) do |message|
+          expect(message.data).to be_nil
+          stop_reactor
+        end
+      end
+
       it 'returns a Deferrable' do
         presence_client_one.enter do
           expect(presence_client_one.update).to be_a(EventMachine::Deferrable)
@@ -277,10 +287,11 @@ describe Ably::Realtime::Presence, :event_machine do
     context '#leave' do
       context ':data option' do
         let(:data) { random_str }
+        let(:enter_data) { random_str }
 
         context 'when set to a string' do
           it 'emits the new data for the leave event' do
-            presence_client_one.enter data: random_str do
+            presence_client_one.enter data: enter_data do
               presence_client_one.leave data: data
             end
 
@@ -292,26 +303,26 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         context 'when set to nil' do
-          it 'emits nil data for the leave event' do
-            presence_client_one.enter data: random_str do
+          it 'emits the previously defined value as a convenience' do
+            presence_client_one.enter data: enter_data do
               presence_client_one.leave data: nil
             end
 
             presence_client_one.subscribe(:leave) do |presence_message|
-              expect(presence_message.data).to be_nil
+              expect(presence_message.data).to eql(enter_data)
               stop_reactor
             end
           end
         end
 
         context 'when not passed as an argument' do
-          it 'emits the original data for the leave event' do
-            presence_client_one.enter data: data do
+          it 'emits the previously defined value as a convenience' do
+            presence_client_one.enter data: enter_data do
               presence_client_one.leave
             end
 
             presence_client_one.subscribe(:leave) do |presence_message|
-              expect(presence_message.data).to eql(data)
+              expect(presence_message.data).to eql(enter_data)
               stop_reactor
             end
           end
@@ -380,7 +391,7 @@ describe Ably::Realtime::Presence, :event_machine do
                 presence_client_one.on(:entered) { raise 'Should not have entered' }
                 next unless client_id == client_count - 1
 
-                EventMachine.add_timer(0.5) do
+                EventMachine.add_timer(1) do
                   expect(presence_client_one.state).to eq(:initialized)
                   stop_reactor
                 end
@@ -435,7 +446,7 @@ describe Ably::Realtime::Presence, :event_machine do
               clients << presence
               next unless clients.count == 5
 
-              EventMachine.add_timer(0.5) do
+              wait_until(proc { updated_callback_count == 5 }) do
                 expect(clients.map(&:client_id).uniq.count).to eql(5)
                 expect(updated_callback_count).to eql(5)
                 stop_reactor
@@ -443,6 +454,18 @@ describe Ably::Realtime::Presence, :event_machine do
             end
           end
 
+          it 'updates the data attribute to null for the member when :data option is not provided (assumed null)' do
+            presence_client_one.enter_client('client_1') do
+              presence_client_one.update_client('client_1')
+            end
+
+            presence_anonymous_client.subscribe(:update) do |presence|
+              expect(presence.client_id).to eql('client_1')
+              expect(presence.data).to be_nil
+              stop_reactor
+            end
+          end
+
           it 'enters if not already entered' do
             updated_callback_count = 0
 
@@ -457,7 +480,7 @@ describe Ably::Realtime::Presence, :event_machine do
               clients << presence
               next unless clients.count == 5
 
-              EventMachine.add_timer(0.5) do
+              wait_until(proc { updated_callback_count == 5 }) do
                 expect(clients.map(&:client_id).uniq.count).to eql(5)
                 expect(updated_callback_count).to eql(5)
                 stop_reactor
@@ -498,7 +521,7 @@ describe Ably::Realtime::Presence, :event_machine do
                 clients << presence
                 next unless clients.count == 5
 
-                EventMachine.add_timer(0.5) do
+                wait_until(proc { left_callback_count == 5 }) do
                   expect(clients.map(&:client_id).uniq.count).to eql(5)
                   expect(left_callback_count).to eql(5)
                   stop_reactor
@@ -520,7 +543,7 @@ describe Ably::Realtime::Presence, :event_machine do
                 clients << presence
                 next unless clients.count == 5
 
-                EventMachine.add_timer(1) do
+                wait_until(proc { left_callback_count == 5 }) do
                   expect(clients.map(&:client_id).uniq.count).to eql(5)
                   expect(left_callback_count).to eql(5)
                   stop_reactor
@@ -543,20 +566,20 @@ describe Ably::Realtime::Presence, :event_machine do
           end
 
           context 'with a nil value in :data option' do
-            it 'emits the leave event with a nil value' do
+            it 'emits the leave event with the previous value as a convenience' do
               presence_client_one.enter_client("client:unique", data: data) do
                 presence_client_one.leave_client("client:unique", data: nil)
               end
 
               presence_client_one.subscribe(:leave) do |presence_message|
-                expect(presence_message.data).to be_nil
+                expect(presence_message.data).to eql(data)
                 stop_reactor
               end
             end
           end
 
           context 'with no :data option' do
-            it 'emits the leave event with the previous data value' do
+            it 'emits the leave event with the previous value as a convenience' do
               presence_client_one.enter_client("client:unique", data: data) do
                 presence_client_one.leave_client("client:unique")
               end
@@ -612,7 +635,14 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'filters by connection_id option if provided' do
-        when_all(presence_client_one.enter, presence_client_two.enter, and_wait: 0.5) do
+        presence_client_one.enter do
+          presence_client_two.enter
+        end
+
+        presence_client_one.subscribe(:enter) do |presence_message|
+          # wait until the client_two enter event has been sent to client_one
+          next unless presence_message.client_id == client_two.client_id
+
           presence_client_one.get(connection_id: client_one.connection.id) do |members|
             expect(members.count).to eq(1)
             expect(members.first.connection_id).to eql(client_one.connection.id)
@@ -627,7 +657,14 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'filters by client_id option if provided' do
-        when_all(presence_client_one.enter(client_id: 'one'), presence_client_two.enter(client_id: 'two')) do
+        presence_client_one.enter(client_id: 'one') do
+          presence_client_two.enter client_id: 'two'
+        end
+
+        presence_client_one.subscribe(:enter) do |presence_message|
+          # wait until the client_two enter event has been sent to client_one
+          next unless presence_message.client_id == 'two'
+
           presence_client_one.get(client_id: 'one') do |members|
             expect(members.count).to eq(1)
             expect(members.first.client_id).to eql('one')
@@ -665,21 +702,36 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
-      it 'returns both members on both simultaneously connected clients' do
-        when_all(presence_client_one.enter(data: data_payload), presence_client_two.enter) do
-          EventMachine.add_timer(0.5) do
-            presence_client_one.get do |client_one_members|
-              presence_client_two.get do |client_two_members|
-                expect(client_one_members.count).to eq(client_two_members.count)
+      context 'with lots of members on different clients' do
+        let(:members_per_client) { 10 }
+        let(:clients_entered)    { Hash.new { |hash, key| hash[key] = 0 } }
+        let(:total_members)      { members_per_client * 2 }
 
-                member_client_one = client_one_members.find { |presence| presence.client_id == client_one.client_id }
-                member_client_two = client_one_members.find { |presence| presence.client_id == client_two.client_id }
+        it 'returns a complete list of members on all clients' do
+          members_per_client.times do |index|
+            presence_client_one.enter_client("client_1:#{index}")
+            presence_client_two.enter_client("client_2:#{index}")
+          end
 
-                expect(member_client_one).to be_a(Ably::Models::PresenceMessage)
-                expect(member_client_one.data).to eql(data_payload)
-                expect(member_client_two).to be_a(Ably::Models::PresenceMessage)
+          presence_client_one.subscribe(:enter) do
+            clients_entered[:client_one] += 1
+          end
 
-                stop_reactor
+          presence_client_two.subscribe(:enter) do
+            clients_entered[:client_two] += 1
+          end
+
+          wait_until(proc { clients_entered[:client_one] + clients_entered[:client_two] == total_members * 2 }) do
+            presence_anonymous_client.get do |anonymous_members|
+              expect(anonymous_members.count).to eq(total_members)
+              expect(anonymous_members.map(&:client_id).uniq.count).to eq(total_members)
+
+              presence_client_one.get do |client_one_members|
+                presence_client_two.get do |client_two_members|
+                  expect(client_one_members.count).to eq(total_members)
+                  expect(client_one_members.count).to eq(client_two_members.count)
+                  stop_reactor
+                end
               end
             end
           end
@@ -720,7 +772,7 @@ describe Ably::Realtime::Presence, :event_machine do
             presence_client_one.enter
             presence_client_one.update
             presence_client_one.leave do
-              EventMachine.add_timer(0.5) do
+              EventMachine.add_timer(1) do
                 stop_reactor
               end
             end