ably-rest 1.0.5 → 1.1.3

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

@@ -96,8 +96,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       end
 
       context 'JSON Array' do
-        # TODO: Add nil type back in
-        let(:data) { { 'push' => { 'data' => { 'key' => [ true, false, 55, 'string', { 'Hash' => true }, ['array'] ] } } } }
+        let(:data) { { 'push' => { 'data' => { 'key' => [ true, false, 55, nil, 'string', { 'Hash' => true }, ['array'] ] } } } }
 
         it 'is encoded and decoded to the same Array' do
           publish_and_check_extras data
@@ -116,7 +115,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'Integer' do
         let(:data) { 1 }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
@@ -125,7 +124,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'Float' do
         let(:data) { 1.1 }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
@@ -134,7 +133,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'Boolean' do
         let(:data) { true }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
@@ -143,7 +142,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'False' do
         let(:data) { false }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
@@ -284,7 +283,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       end
 
       it 'sends and receives the messages on both opened connections and calls the success callbacks for each message published', em_timeout: 10 do
-        check_message_and_callback_counts = Proc.new do
+        check_message_and_callback_counts = lambda do
           if echos[:client] == expected_echos && echos[:other] == expected_echos
             # Wait for message backlog to clear
             EventMachine.add_timer(0.5) do
@@ -353,23 +352,25 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
           first_message_protocol_message ||= protocol_message unless protocol_message.messages.empty?
         end
 
-        channel.subscribe do |message|
-          messages_received << message
-          if messages_received.count == 2
-            # simulate a duplicate protocol message being received
-            EventMachine.next_tick do
-              connection.__incoming_protocol_msgbus__.publish :protocol_message, first_message_protocol_message
+        channel.attach do
+          channel.subscribe do |message|
+            messages_received << message
+            if messages_received.count == 2
+              # simulate a duplicate protocol message being received
+              EventMachine.next_tick do
+                connection.__incoming_protocol_msgbus__.publish :protocol_message, first_message_protocol_message
+              end
             end
           end
-        end
-        2.times { |i| EventMachine.add_timer(i.to_f / 5) { channel.publish('event', 'data') } }
+          2.times { |i| EventMachine.add_timer(i.to_f / 5) { channel.publish('event', 'data') } }
 
-        expect(client.logger).to receive(:error) do |*args, &block|
-          expect(args.concat([block ? block.call : nil]).join(',')).to match(/duplicate/)
+          expect(client.logger).to receive(:error) do |*args, &block|
+            expect(args.concat([block ? block.call : nil]).join(',')).to match(/duplicate/)
 
-          EventMachine.add_timer(0.5) do
-            expect(messages_received.count).to eql(2)
-            stop_reactor
+            EventMachine.add_timer(0.5) do
+              expect(messages_received.count).to eql(2)
+              stop_reactor
+            end
           end
         end
       end
@@ -413,30 +414,32 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
           let(:encrypted_channel) { client.channel(channel_name, cipher: cipher_options) }
 
           it 'encrypts message automatically before they are pushed to the server (#RTL7d)' do
-            encrypted_channel.__incoming_msgbus__.unsubscribe # remove all subscribe callbacks that could decrypt the message
+            encrypted_channel.attach do
+              encrypted_channel.__incoming_msgbus__.unsubscribe # remove all subscribe callbacks that could decrypt the message
 
-            encrypted_channel.__incoming_msgbus__.subscribe(:message) do |message|
-              if protocol == :json
-                expect(message['encoding']).to eql(encrypted_encoding)
-                expect(message['data']).to eql(encrypted_data)
-              else
-                # Messages received over binary protocol will not have Base64 encoded data
-                expect(message['encoding']).to eql(encrypted_encoding.gsub(%r{/base64$}, ''))
-                expect(message['data']).to eql(encrypted_data_decoded)
+              encrypted_channel.__incoming_msgbus__.subscribe(:message) do |message|
+                if protocol == :json
+                  expect(message['encoding']).to eql(encrypted_encoding)
+                  expect(message['data']).to eql(encrypted_data)
+                else
+                  # Messages received over binary protocol will not have Base64 encoded data
+                  expect(message['encoding']).to eql(encrypted_encoding.gsub(%r{/base64$}, ''))
+                  expect(message['data']).to eql(encrypted_data_decoded)
+                end
+                stop_reactor
               end
-              stop_reactor
-            end
 
-            encrypted_channel.publish 'example', encoded_data_decoded
+              encrypted_channel.publish 'example', encoded_data_decoded
+            end
           end
 
           it 'sends and receives messages that are encrypted & decrypted by the Ably library (#RTL7d)' do
-            encrypted_channel.publish 'example', encoded_data_decoded
             encrypted_channel.subscribe do |message|
               expect(message.data).to eql(encoded_data_decoded)
               expect(message.encoding).to be_nil
               stop_reactor
             end
+            encrypted_channel.publish 'example', encoded_data_decoded
           end
         end
       end
@@ -650,12 +653,11 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       let(:msgs_received)  { [] }
 
       it 'publishes the message again, later receives the ACK and only one message is ever received from Ably' do
-        on_reconnected = Proc.new do
+        on_reconnected = lambda do |*args|
           expect(message_state).to be_empty
           EventMachine.add_timer(2) do
             expect(message_state).to contain_exactly(:delivered)
-            # TODO: Uncomment once issue realtime#42 is resolved
-            # expect(msgs_received.length).to eql(1)
+            expect(msgs_received.length).to eql(1)
             stop_reactor
           end
         end

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

@@ -71,11 +71,14 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
       end
 
       context 'and two pages of messages' do
-        let(:wildcard_token) { Proc.new { Ably::Rest::Client.new(default_options).auth.request_token(client_id: '*') } }
+        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)) }
 
-        it 'retrieves two pages of messages before channel was attached' do
+        # 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|
@@ -85,7 +88,13 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
                 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)
-                  expect(presence_next_page).to be_last
+                  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

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

@@ -14,7 +14,7 @@ describe Ably::Realtime::Presence, :event_machine do
     let(:client_two_id)    { random_str }
     let(:client_two)       { auto_close Ably::Realtime::Client.new(client_options.merge(client_id: client_two_id)) }
 
-    let(:wildcard_token)            { Proc.new { Ably::Rest::Client.new(client_options).auth.request_token(client_id: '*') } }
+    let(:wildcard_token)            { lambda { |token_params| Ably::Rest::Client.new(client_options).auth.request_token(client_id: '*') } }
     let(:channel_name)              { "presence-#{random_str(4)}" }
     let(:channel_anonymous_client)  { anonymous_client.channel(channel_name) }
     let(:presence_anonymous_client) { channel_anonymous_client.presence }
@@ -256,7 +256,7 @@ describe Ably::Realtime::Presence, :event_machine do
         context 'Integer' do
           let(:data) { 1 }
 
-          it 'raises an UnsupportedDataType 40011 exception' do
+          it 'raises an UnsupportedDataType 40013 exception' do
             expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataType)
             stop_reactor
           end
@@ -265,7 +265,7 @@ describe Ably::Realtime::Presence, :event_machine do
         context 'Float' do
           let(:data) { 1.1 }
 
-          it 'raises an UnsupportedDataType 40011 exception' do
+          it 'raises an UnsupportedDataType 40013 exception' do
             expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataType)
             stop_reactor
           end
@@ -274,7 +274,7 @@ describe Ably::Realtime::Presence, :event_machine do
         context 'Boolean' do
           let(:data) { true }
 
-          it 'raises an UnsupportedDataType 40011 exception' do
+          it 'raises an UnsupportedDataType 40013 exception' do
             expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataType)
             stop_reactor
           end
@@ -283,7 +283,7 @@ describe Ably::Realtime::Presence, :event_machine do
         context 'False' do
           let(:data) { false }
 
-          it 'raises an UnsupportedDataType 40011 exception' do
+          it 'raises an UnsupportedDataType 40013 exception' do
             expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataType)
             stop_reactor
           end
@@ -1073,12 +1073,12 @@ describe Ably::Realtime::Presence, :event_machine do
       context 'message #connection_id' do
         it 'matches the current client connection_id' do
           channel_client_two.attach do
-            presence_client_one.enter
-          end
+            presence_client_two.subscribe do |presence|
+              expect(presence.connection_id).to eq(client_one.connection.id)
+              stop_reactor
+            end
 
-          presence_client_two.subscribe do |presence|
-            expect(presence.connection_id).to eq(client_one.connection.id)
-            stop_reactor
+            presence_client_one.enter
           end
         end
       end
@@ -1128,22 +1128,26 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'updates the data if :data argument provided' do
-        presence_client_one.enter('prior') do
-          presence_client_one.update(data_payload)
-        end
-        presence_client_one.subscribe(:update) do |message|
-          expect(message.data).to eql(data_payload)
-          stop_reactor
+        channel_client_one.attach do
+          presence_client_one.enter('prior') do
+            presence_client_one.update(data_payload)
+          end
+          presence_client_one.subscribe(:update) do |message|
+            expect(message.data).to eql(data_payload)
+            stop_reactor
+          end
         end
       end
 
       it 'updates the data to nil if :data argument is not provided (assumes nil value)' do
-        presence_client_one.enter('prior') do
-          presence_client_one.update
-        end
-        presence_client_one.subscribe(:update) do |message|
-          expect(message.data).to be_nil
-          stop_reactor
+        channel_client_one.attach do
+          presence_client_one.enter('prior') do
+            presence_client_one.update
+          end
+          presence_client_one.subscribe(:update) do |message|
+            expect(message.data).to be_nil
+            stop_reactor
+          end
         end
       end
 
@@ -1157,39 +1161,45 @@ describe Ably::Realtime::Presence, :event_machine do
 
         context 'when set to a string' do
           it 'emits the new data for the leave event' do
-            presence_client_one.enter enter_data do
-              presence_client_one.leave data
-            end
+            channel_client_one.attach do
+              presence_client_one.enter enter_data do
+                presence_client_one.leave data
+              end
 
-            presence_client_one.subscribe(:leave) do |presence_message|
-              expect(presence_message.data).to eql(data)
-              stop_reactor
+              presence_client_one.subscribe(:leave) do |presence_message|
+                expect(presence_message.data).to eql(data)
+                stop_reactor
+              end
             end
           end
         end
 
         context 'when set to nil' do
           it 'emits the last value for the data attribute when leaving' do
-            presence_client_one.enter enter_data do
-              presence_client_one.leave nil
-            end
+            channel_client_one.attach do
+              presence_client_one.enter enter_data do
+                presence_client_one.leave nil
+              end
 
-            presence_client_one.subscribe(:leave) do |presence_message|
-              expect(presence_message.data).to eql(enter_data)
-              stop_reactor
+              presence_client_one.subscribe(:leave) do |presence_message|
+                expect(presence_message.data).to eql(enter_data)
+                stop_reactor
+              end
             end
           end
         end
 
         context 'when not passed as an argument (i.e. nil)' do
           it 'emits the previous value for the data attribute when leaving' do
-            presence_client_one.enter enter_data do
-              presence_client_one.leave
-            end
+            channel_client_one.attach do
+              presence_client_one.enter enter_data do
+                presence_client_one.leave
+              end
 
-            presence_client_one.subscribe(:leave) do |presence_message|
-              expect(presence_message.data).to eql(enter_data)
-              stop_reactor
+              presence_client_one.subscribe(:leave) do |presence_message|
+                expect(presence_message.data).to eql(enter_data)
+                stop_reactor
+              end
             end
           end
         end
@@ -1198,38 +1208,42 @@ describe Ably::Realtime::Presence, :event_machine do
           it 'does not cache members that have left' do
             enter_ack = false
 
-            presence_client_one.subscribe(:enter) do
-              presence_client_one.unsubscribe :enter
+            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
-            end
+                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
 
-            presence_client_one.enter(enter_data) do
-              enter_ack = true
-            end
+              presence_client_one.enter(enter_data) do
+                enter_ack = true
+              end
 
-            presence_client_one.subscribe(:leave) do |presence_message|
-              presence_client_one.unsubscribe :leave
-              expect(presence_message.data).to eql(data)
-              expect(presence_client_one.members.send(:members).count).to eql(0)
-              expect(enter_ack).to eql(true)
-              stop_reactor
+              presence_client_one.subscribe(:leave) do |presence_message|
+                presence_client_one.unsubscribe :leave
+                expect(presence_message.data).to eql(data)
+                expect(presence_client_one.members.send(:members).count).to eql(0)
+                expect(enter_ack).to eql(true)
+                stop_reactor
+              end
             end
           end
         end
       end
 
       it 'succeeds and does not emit an event (#RTP10d)' do
-        channel_client_one.presence.leave do
-          # allow enough time for leave event to (not) fire
-          EventMachine.add_timer(2) do
-            stop_reactor
+        channel_client_one.attach do
+          channel_client_one.presence.leave do
+            # allow enough time for leave event to (not) fire
+            EventMachine.add_timer(2) do
+              stop_reactor
+            end
+          end
+          channel_client_one.subscribe(:leave) do
+            raise "No leave event should fire"
           end
-        end
-        channel_client_one.subscribe(:leave) do
-          raise "No leave event should fire"
         end
       end
 
@@ -1238,26 +1252,30 @@ describe Ably::Realtime::Presence, :event_machine do
 
     context ':left event' do
       it 'emits the data defined in enter' do
-        channel_client_one.presence.enter('data') do
-          channel_client_one.presence.leave
-        end
+        channel_client_two.attach do
+          channel_client_one.presence.enter('data') do
+            channel_client_one.presence.leave
+          end
 
-        channel_client_two.presence.subscribe(:leave) do |message|
-          expect(message.data).to eql('data')
-          stop_reactor
+          channel_client_two.presence.subscribe(:leave) do |message|
+            expect(message.data).to eql('data')
+            stop_reactor
+          end
         end
       end
 
       it 'emits the data defined in update' do
-        channel_client_one.presence.enter('something else') do
-          channel_client_one.presence.update('data') do
-            channel_client_one.presence.leave
+        channel_client_two.attach do
+          channel_client_one.presence.enter('something else') do
+            channel_client_one.presence.update('data') do
+              channel_client_one.presence.leave
+            end
           end
-        end
 
-        channel_client_two.presence.subscribe(:leave) do |message|
-          expect(message.data).to eql('data')
-          stop_reactor
+          channel_client_two.presence.subscribe(:leave) do |message|
+            expect(message.data).to eql('data')
+            stop_reactor
+          end
         end
       end
     end
@@ -1286,17 +1304,19 @@ describe Ably::Realtime::Presence, :event_machine do
           end
 
           it 'enters a channel and sets the data based on the provided :data option' do
-            client_count.times do |client_id|
-              presence_client_one.enter_client("client:#{client_id}", data)
-            end
+            channel_anonymous_client.attach do
+              client_count.times do |client_id|
+                presence_client_one.enter_client("client:#{client_id}", data)
+              end
 
-            presence_anonymous_client.subscribe(:enter) do |presence|
-              expect(presence.data).to eql(data)
-              clients << presence
-              next unless clients.count == 5
+              presence_anonymous_client.subscribe(:enter) do |presence|
+                expect(presence.data).to eql(data)
+                clients << presence
+                next unless clients.count == 5
 
-              expect(clients.map(&:client_id).uniq.count).to eql(5)
-              stop_reactor
+                expect(clients.map(&:client_id).uniq.count).to eql(5)
+                stop_reactor
+              end
             end
           end
         end
@@ -1307,12 +1327,12 @@ describe Ably::Realtime::Presence, :event_machine do
           it 'matches the current client connection_id' do
             channel_client_two.attach do
               presence_client_one.enter_client(client_id)
-            end
 
-            presence_client_two.subscribe do |presence|
-              expect(presence.client_id).to eq(client_id)
-              expect(presence.connection_id).to eq(client_one.connection.id)
-              stop_reactor
+              presence_client_two.subscribe do |presence|
+                expect(presence.client_id).to eq(client_id)
+                expect(presence.connection_id).to eq(client_one.connection.id)
+                stop_reactor
+              end
             end
           end
         end
@@ -1341,57 +1361,63 @@ describe Ably::Realtime::Presence, :event_machine do
           it 'updates the data attribute for the member when :data option provided' do
             updated_callback_count = 0
 
-            client_count.times do |client_id|
-              presence_client_one.enter_client("client:#{client_id}") do
-                presence_client_one.update_client("client:#{client_id}", data) do
-                  updated_callback_count += 1
+            channel_anonymous_client.attach do
+              client_count.times do |client_id|
+                presence_client_one.enter_client("client:#{client_id}") do
+                  presence_client_one.update_client("client:#{client_id}", data) do
+                    updated_callback_count += 1
+                  end
                 end
               end
-            end
 
-            presence_anonymous_client.subscribe(:update) do |presence|
-              expect(presence.data).to eql(data)
-              clients << presence
-              next unless clients.count == 5
+              presence_anonymous_client.subscribe(:update) do |presence|
+                expect(presence.data).to eql(data)
+                clients << presence
+                next unless clients.count == 5
 
-              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
+                wait_until(lambda { updated_callback_count == 5 }) do
+                  expect(clients.map(&:client_id).uniq.count).to eql(5)
+                  expect(updated_callback_count).to eql(5)
+                  stop_reactor
+                end
               end
             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
+            channel_anonymous_client.attach 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
+              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
           end
 
           it 'enters if not already entered' do
             updated_callback_count = 0
 
-            client_count.times do |client_id|
-              presence_client_one.update_client("client:#{client_id}", data) do
-                updated_callback_count += 1
+            channel_anonymous_client.attach do
+              client_count.times do |client_id|
+                presence_client_one.update_client("client:#{client_id}", data) do
+                  updated_callback_count += 1
+                end
               end
-            end
 
-            presence_anonymous_client.subscribe(:enter) do |presence|
-              expect(presence.data).to eql(data)
-              clients << presence
-              next unless clients.count == 5
+              presence_anonymous_client.subscribe(:enter) do |presence|
+                expect(presence.data).to eql(data)
+                clients << presence
+                next unless clients.count == 5
 
-              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
+                wait_until(lambda { updated_callback_count == 5 }) do
+                  expect(clients.map(&:client_id).uniq.count).to eql(5)
+                  expect(updated_callback_count).to eql(5)
+                  stop_reactor
+                end
               end
             end
           end
@@ -1407,23 +1433,25 @@ describe Ably::Realtime::Presence, :event_machine do
             it 'emits the :leave event for each client_id' do
               left_callback_count = 0
 
-              client_count.times do |client_id|
-                presence_client_one.enter_client("client:#{client_id}", random_str) do
-                  presence_client_one.leave_client("client:#{client_id}", data) do
-                    left_callback_count += 1
+              channel_anonymous_client.attach do
+                client_count.times do |client_id|
+                  presence_client_one.enter_client("client:#{client_id}", random_str) do
+                    presence_client_one.leave_client("client:#{client_id}", data) do
+                      left_callback_count += 1
+                    end
                   end
                 end
-              end
 
-              presence_anonymous_client.subscribe(:leave) do |presence|
-                expect(presence.data).to eql(data)
-                clients << presence
-                next unless clients.count == 5
+                presence_anonymous_client.subscribe(:leave) do |presence|
+                  expect(presence.data).to eql(data)
+                  clients << presence
+                  next unless clients.count == 5
 
-                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
+                  wait_until(lambda { left_callback_count == 5 }) do
+                    expect(clients.map(&:client_id).uniq.count).to eql(5)
+                    expect(left_callback_count).to eql(5)
+                    stop_reactor
+                  end
                 end
               end
             end
@@ -1431,21 +1459,23 @@ describe Ably::Realtime::Presence, :event_machine do
             it 'succeeds if that client_id has not previously entered the channel' do
               left_callback_count = 0
 
-              client_count.times do |client_id|
-                presence_client_one.leave_client("client:#{client_id}") do
-                  left_callback_count += 1
+              channel_anonymous_client.attach do
+                client_count.times do |client_id|
+                  presence_client_one.leave_client("client:#{client_id}") do
+                    left_callback_count += 1
+                  end
                 end
-              end
 
-              presence_anonymous_client.subscribe(:leave) do |presence|
-                expect(presence.data).to be_nil
-                clients << presence
-                next unless clients.count == 5
+                presence_anonymous_client.subscribe(:leave) do |presence|
+                  expect(presence.data).to be_nil
+                  clients << presence
+                  next unless clients.count == 5
 
-                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
+                  wait_until(lambda { left_callback_count == 5 }) do
+                    expect(clients.map(&:client_id).uniq.count).to eql(5)
+                    expect(left_callback_count).to eql(5)
+                    stop_reactor
+                  end
                 end
               end
             end
@@ -1453,39 +1483,45 @@ describe Ably::Realtime::Presence, :event_machine do
 
           context 'with a new value in :data option' do
             it 'emits the leave event with the new data value' do
-              presence_client_one.enter_client("client:unique", random_str) do
-                presence_client_one.leave_client("client:unique", data)
-              end
+              channel_client_one.attach do
+                presence_client_one.enter_client("client:unique", random_str) do
+                  presence_client_one.leave_client("client:unique", data)
+                end
 
-              presence_client_one.subscribe(:leave) do |presence_message|
-                expect(presence_message.data).to eql(data)
-                stop_reactor
+                presence_client_one.subscribe(:leave) do |presence_message|
+                  expect(presence_message.data).to eql(data)
+                  stop_reactor
+                end
               end
             end
           end
 
           context 'with a nil value in :data option' do
             it 'emits the leave event with the previous value as a convenience' do
-              presence_client_one.enter_client("client:unique", data) do
-                presence_client_one.leave_client("client:unique", nil)
-              end
+              channel_client_one.attach do
+                presence_client_one.enter_client("client:unique", data) do
+                  presence_client_one.leave_client("client:unique", nil)
+                end
 
-              presence_client_one.subscribe(:leave) do |presence_message|
-                expect(presence_message.data).to eql(data)
-                stop_reactor
+                presence_client_one.subscribe(:leave) do |presence_message|
+                  expect(presence_message.data).to eql(data)
+                  stop_reactor
+                end
               end
             end
           end
 
           context 'with no :data option' do
             it 'emits the leave event with the previous value as a convenience' do
-              presence_client_one.enter_client("client:unique", data) do
-                presence_client_one.leave_client("client:unique")
-              end
+              channel_client_one.attach do
+                presence_client_one.enter_client("client:unique", data) do
+                  presence_client_one.leave_client("client:unique")
+                end
 
-              presence_client_one.subscribe(:leave) do |presence_message|
-                expect(presence_message.data).to eql(data)
-                stop_reactor
+                presence_client_one.subscribe(:leave) do |presence_message|
+                  expect(presence_message.data).to eql(data)
+                  stop_reactor
+                end
               end
             end
           end
@@ -1789,7 +1825,7 @@ describe Ably::Realtime::Presence, :event_machine do
             clients_entered[:client_two] += 1
           end
 
-          wait_until(proc { clients_entered[:client_one] + clients_entered[:client_two] == total_members * 2 }) do
+          wait_until(lambda { clients_entered[:client_one] + clients_entered[:client_two] == total_members * 2 }) do
             presence_anonymous_client.get(wait_for_sync: true) do |anonymous_members|
               expect(anonymous_members.count).to eq(total_members)
               expect(anonymous_members.map(&:client_id).uniq.count).to eq(total_members)
@@ -1886,7 +1922,7 @@ describe Ably::Realtime::Presence, :event_machine do
       context 'with no arguments' 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' }
+            subscribe_callback = lambda { raise 'Should not be called' }
             presence_client_two.subscribe(&subscribe_callback)
             presence_client_two.unsubscribe(&subscribe_callback)
 
@@ -1904,7 +1940,7 @@ describe Ably::Realtime::Presence, :event_machine do
       context 'with event name' do
         it 'removes the callback for specified presence event' do
           when_all(channel_client_one.attach, channel_client_two.attach) do
-            subscribe_callback = proc { raise 'Should not be called' }
+            subscribe_callback = lambda { raise 'Should not be called' }
             presence_client_two.subscribe :leave, &subscribe_callback
             presence_client_two.unsubscribe :leave, &subscribe_callback
 
@@ -2299,7 +2335,7 @@ describe Ably::Realtime::Presence, :event_machine do
                   presence_events << [presence_message.client_id, presence_message.action.to_sym]
                   if presence_message.action == :leave
                     expect(presence_message.id).to be_nil
-                    expect(presence_message.timestamp.to_f * 1000).to be_within(20).of(Time.now.to_f * 1000)
+                    expect(presence_message.timestamp.to_f * 1000).to be_within(200).of(Time.now.to_f * 1000)
                   end
                 end
 
@@ -2337,19 +2373,17 @@ describe Ably::Realtime::Presence, :event_machine do
       let(:present_only_capability) do
         { channel_name => ["presence"] }
       end
-      let(:present_only_callback) { Proc.new { Ably::Rest::Client.new(client_options).auth.request_token(client_id: '*', capability: present_only_capability) } }
+      let(:present_only_callback) { lambda { |token_params| Ably::Rest::Client.new(client_options).auth.request_token(client_id: '*', capability: present_only_capability) } }
       let(:client_one) { auto_close Ably::Realtime::Client.new(client_options.merge(auth_callback: present_only_callback)) }
 
       it 'receives presence updates for all presence events generated by the current connection and the presence map is kept up to date (#RTP17a)' do
-        skip 'This functionality is not yet in sandbox, see https://github.com/ably/realtime/issues/656'
-
         enter_client_ids = []
         presence_client_one.subscribe(:enter) do |presence_message|
           enter_client_ids << presence_message.client_id
         end
 
         leave_client_ids = []
-        presence_client_one.subscribe(:leave) do
+        presence_client_one.subscribe(:leave) do |presence_message|
           leave_client_ids << presence_message.client_id
         end
 
@@ -2751,7 +2785,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'channel transitions to the SUSPENDED state' do
         let(:auth_callback) do
-          Proc.new do
+          lambda do |token_params|
             # Pause to allow presence updates to occur whilst disconnected
             sleep 1
             Ably::Rest::Client.new(client_options).auth.request_token