ably-rest 0.8.6 → 0.8.9

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

@@ -345,7 +345,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
         let(:secret_key)     { Base64.decode64(data['key']) }
         let(:iv)             { Base64.decode64(data['iv']) }
 
-        let(:cipher_options) { { key: secret_key, iv: iv, algorithm: algorithm, mode: mode, key_length: key_length } }
+        let(:cipher_options) { { key: secret_key, fixed_iv: iv, algorithm: algorithm, mode: mode, key_length: key_length } }
 
         context 'with #publish and #subscribe' do
           let(:encoded)          { item['encoded'] }
@@ -372,7 +372,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
             end
           end
 
-          let(:encrypted_channel) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+          let(:encrypted_channel) { client.channel(channel_name, cipher: cipher_options) }
 
           it 'encrypts message automatically before they are pushed to the server' do
             encrypted_channel.__incoming_msgbus__.unsubscribe # remove all subscribe callbacks that could decrypt the message
@@ -424,9 +424,9 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       end
 
       context 'with multiple sends from one client to another' do
-        let(:cipher_options)            { { key: random_str(32) } }
-        let(:encrypted_channel_client1) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
-        let(:encrypted_channel_client2) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+        let(:cipher_options)            { { key: Ably::Util::Crypto.generate_random_key } }
+        let(:encrypted_channel_client1) { client.channel(channel_name, cipher: cipher_options) }
+        let(:encrypted_channel_client2) { other_client.channel(channel_name, cipher: cipher_options) }
 
         let(:data) { { 'key' => random_str } }
         let(:message_count) { 50 }
@@ -471,9 +471,9 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
           auto_close Ably::Realtime::Client.new(default_options.merge(protocol: other_protocol))
         end
 
-        let(:cipher_options)            { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-        let(:encrypted_channel_client1) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
-        let(:encrypted_channel_client2) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+        let(:cipher_options)            { { key: Ably::Util::Crypto.generate_random_key, algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+        let(:encrypted_channel_client1) { client.channel(channel_name, cipher: cipher_options) }
+        let(:encrypted_channel_client2) { other_client.channel(channel_name, cipher: cipher_options) }
 
         before do
           expect(other_client.protocol_binary?).to_not eql(client.protocol_binary?)
@@ -495,9 +495,9 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
 
       context 'publishing on an unencrypted channel and subscribing on an encrypted channel with another client' do
         let(:client_options)              { default_options.merge(log_level: :fatal) }
-        let(:cipher_options)              { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+        let(:cipher_options)              { { key: Ably::Util::Crypto.generate_random_key, algorithm: 'aes', mode: 'cbc', key_length: 256 } }
         let(:unencrypted_channel_client1) { client.channel(channel_name) }
-        let(:encrypted_channel_client2)   { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+        let(:encrypted_channel_client2)   { other_client.channel(channel_name, cipher: cipher_options) }
 
         let(:payload) { MessagePack.pack({ 'key' => random_str }) }
 
@@ -513,8 +513,8 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
 
       context 'publishing on an encrypted channel and subscribing on an unencrypted channel with another client' do
         let(:client_options)              { default_options.merge(log_level: :fatal) }
-        let(:cipher_options)              { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-        let(:encrypted_channel_client1)   { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+        let(:cipher_options)              { { key: Ably::Util::Crypto.generate_random_key, algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+        let(:encrypted_channel_client1)   { client.channel(channel_name, cipher: Ably::Util::Crypto.get_default_params(cipher_options)) }
         let(:unencrypted_channel_client2) { other_client.channel(channel_name) }
 
         let(:payload) { MessagePack.pack({ 'key' => random_str }) }
@@ -543,10 +543,10 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
 
       context 'publishing on an encrypted channel and subscribing with a different algorithm on another client' do
         let(:client_options)              { default_options.merge(log_level: :fatal) }
-        let(:cipher_options_client1)    { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-        let(:encrypted_channel_client1) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client1) }
-        let(:cipher_options_client2)    { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 128 } }
-        let(:encrypted_channel_client2) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client2) }
+        let(:cipher_options_client1)    { { key: Ably::Util::Crypto.generate_random_key, algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+        let(:encrypted_channel_client1) { client.channel(channel_name, cipher: Ably::Util::Crypto.get_default_params(cipher_options_client1)) }
+        let(:cipher_options_client2)    { { key: Ably::Util::Crypto.generate_random_key(128), algorithm: 'aes', mode: 'cbc', key_length: 128 } }
+        let(:encrypted_channel_client2) { other_client.channel(channel_name, cipher: Ably::Util::Crypto.get_default_params(cipher_options_client2)) }
 
         let(:payload) { MessagePack.pack({ 'key' => random_str }) }
 
@@ -574,10 +574,10 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
 
       context 'publishing on an encrypted channel and subscribing with a different key on another client' do
         let(:client_options)              { default_options.merge(log_level: :fatal) }
-        let(:cipher_options_client1)    { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-        let(:encrypted_channel_client1) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client1) }
-        let(:cipher_options_client2)    { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-        let(:encrypted_channel_client2) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client2) }
+        let(:cipher_options_client1)    { { key: Ably::Util::Crypto.generate_random_key, algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+        let(:encrypted_channel_client1) { client.channel(channel_name, cipher: cipher_options_client1) }
+        let(:cipher_options_client2)    { { key: Ably::Util::Crypto.generate_random_key, algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+        let(:encrypted_channel_client2) { other_client.channel(channel_name, cipher: cipher_options_client2) }
 
         let(:payload) { MessagePack.pack({ 'key' => random_str }) }
 

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

@@ -19,8 +19,8 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
     let(:leave_data)          { random_str }
 
     it 'provides up to the moment presence history' do
-      presence_client_one.enter(data: data) do
-        presence_client_one.leave(data: leave_data) do
+      presence_client_one.enter(data) do
+        presence_client_one.leave(leave_data) 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)
@@ -50,7 +50,7 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
         end
       end
 
-      presence_client_one.enter(data: data)
+      presence_client_one.enter(data)
     end
 
     context 'with option until_attach: true' do
@@ -59,8 +59,8 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
       let(:presence_data_after_attach) { random_str }
 
       it 'retrieves all presence messages before channel was attached' do
-        presence_client_two.enter(data: presence_data_before_attach) do
-          presence_client_one.enter(data: presence_data_after_attach) 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)
@@ -76,8 +76,8 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
         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
-          when_all(*10.times.map { |i| presence_client_two.enter_client("client:#{i}", data: presence_data_before_attach) }) do
-            when_all(*10.times.map { |i| presence_client_one.enter_client("client:#{i}", data: presence_data_after_attach) }) 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)

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

@@ -133,9 +133,9 @@ describe Ably::Realtime::Presence, :event_machine do
       context 'with supported data payload content type' do
         def register_presence_and_check_data(method_name, data)
           if method_name.to_s.match(/_client/)
-            presence_client_one.public_send(method_name, client_id, data: data)
+            presence_client_one.public_send(method_name, client_id, data)
           else
-            presence_client_one.public_send(method_name, data: data)
+            presence_client_one.public_send(method_name, data)
           end
 
           presence_client_one.subscribe do |presence_message|
@@ -188,9 +188,9 @@ describe Ably::Realtime::Presence, :event_machine do
       context 'with unsupported data payload content type' do
         def presence_action(method_name, data)
           if method_name.to_s.match(/_client/)
-            presence_client_one.public_send(method_name, client_id, data: data)
+            presence_client_one.public_send(method_name, client_id, data)
           else
-            presence_client_one.public_send(method_name, data: data)
+            presence_client_one.public_send(method_name, data)
           end
         end
 
@@ -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|
@@ -674,16 +677,18 @@ describe Ably::Realtime::Presence, :event_machine do
 
           context '#get' do
             context 'with :wait_for_sync option set to true' do
-              it 'waits until sync is complete', em_timeout: 15 do
+              it 'waits until sync is complete', em_timeout: 30 do # allow for slow connections and lots of messages
                 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
@@ -691,17 +696,19 @@ describe Ably::Realtime::Presence, :event_machine do
             end
 
             context 'by default' do
-              it 'it does not wait for sync', em_timeout: 15 do
+              it 'it does not wait for sync', em_timeout: 30 do # allow for slow connections and lots of messages
                 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
@@ -738,21 +745,12 @@ describe Ably::Realtime::Presence, :event_machine do
     end
 
     context '#enter' do
-      it 'allows client_id to be set on enter for anonymous clients' do
-        channel_anonymous_client.presence.enter client_id: "123"
-
-        channel_anonymous_client.presence.subscribe do |presence|
-          expect(presence.client_id).to eq("123")
-          stop_reactor
-        end
-      end
-
       context 'data attribute' do
         context 'when provided as argument option to #enter' do
-          it 'remains intact following #leave' do
+          it 'changes to value provided in #leave' do
             leave_callback_called = false
 
-            presence_client_one.enter(data: 'stored') do
+            presence_client_one.enter('stored') do
               expect(presence_client_one.data).to eql('stored')
 
               presence_client_one.leave do |presence|
@@ -760,7 +758,7 @@ describe Ably::Realtime::Presence, :event_machine do
               end
 
               presence_client_one.on(:left) do
-                expect(presence_client_one.data).to eql('stored')
+                expect(presence_client_one.data).to eql(nil)
 
                 EventMachine.next_tick do
                   expect(leave_callback_called).to eql(true)
@@ -785,11 +783,6 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
-      it 'raises an exception if client_id is not set' do
-        expect { channel_anonymous_client.presence.enter }.to raise_error(Ably::Exceptions::IncompatibleClientId, /without a client_id/)
-        stop_reactor
-      end
-
       context 'without necessary capabilities to join presence' do
         let(:restricted_client) do
           auto_close Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
@@ -798,7 +791,7 @@ describe Ably::Realtime::Presence, :event_machine do
         let(:restricted_presence) { restricted_channel.presence }
 
         it 'calls the Deferrable errback on capabilities failure' do
-          restricted_presence.enter(client_id: 'clientId').tap do |deferrable|
+          restricted_presence.enter_client('bob').tap do |deferrable|
             deferrable.callback { raise "Should not succeed" }
             deferrable.errback { stop_reactor }
           end
@@ -810,7 +803,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
     context '#update' do
       it 'without previous #enter automatically enters' do
-        presence_client_one.update(data: data_payload) do
+        presence_client_one.update(data_payload) do
           EventMachine.add_timer(1) do
             expect(presence_client_one.state).to eq(:entered)
             stop_reactor
@@ -823,7 +816,7 @@ describe Ably::Realtime::Presence, :event_machine do
           presence_client_one.enter do
             presence_client_one.once_state_changed { fail 'State should not have changed ' }
 
-            presence_client_one.update(data: data_payload) do
+            presence_client_one.update(data_payload) do
               EventMachine.add_timer(1) do
                 expect(presence_client_one.state).to eq(:entered)
                 presence_client_one.off
@@ -835,8 +828,8 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'updates the data if :data argument provided' do
-        presence_client_one.enter(data: 'prior') do
-          presence_client_one.update(data: data_payload)
+        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)
@@ -845,7 +838,7 @@ describe Ably::Realtime::Presence, :event_machine do
       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.enter('prior') do
           presence_client_one.update
         end
         presence_client_one.subscribe(:update) do |message|
@@ -864,8 +857,8 @@ 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 data: enter_data do
-              presence_client_one.leave data: data
+            presence_client_one.enter enter_data do
+              presence_client_one.leave data
             end
 
             presence_client_one.subscribe(:leave) do |presence_message|
@@ -876,9 +869,9 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         context 'when set to nil' do
-          it 'emits a nil value for the data attribute when leaving' do
-            presence_client_one.enter data: enter_data do
-              presence_client_one.leave data: nil
+          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
 
             presence_client_one.subscribe(:leave) do |presence_message|
@@ -888,9 +881,9 @@ describe Ably::Realtime::Presence, :event_machine do
           end
         end
 
-        context 'when not passed as an argument' do
-          it 'emits the previously defined value as a convenience' do
-            presence_client_one.enter data: enter_data do
+        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
 
@@ -903,10 +896,10 @@ describe Ably::Realtime::Presence, :event_machine do
 
         context 'and sync is complete' do
           it 'does not cache members that have left' do
-            presence_client_one.enter data: enter_data do
+            presence_client_one.enter enter_data 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: data
+              presence_client_one.leave data
             end
 
             presence_client_one.subscribe(:leave) do |presence_message|
@@ -928,7 +921,7 @@ 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: 'data') do
+        channel_client_one.presence.enter('data') do
           channel_client_one.presence.leave
         end
 
@@ -939,8 +932,8 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'emits the data defined in update' do
-        channel_client_one.presence.enter(data: 'something else') do
-          channel_client_one.presence.update(data: 'data') do
+        channel_client_one.presence.enter('something else') do
+          channel_client_one.presence.update('data') do
             channel_client_one.presence.leave
           end
         end
@@ -977,7 +970,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
           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: data)
+              presence_client_one.enter_client("client:#{client_id}", data)
             end
 
             presence_anonymous_client.subscribe(:enter) do |presence|
@@ -1033,7 +1026,7 @@ describe Ably::Realtime::Presence, :event_machine 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: data) do
+                presence_client_one.update_client("client:#{client_id}", data) do
                   updated_callback_count += 1
                 end
               end
@@ -1068,7 +1061,7 @@ describe Ably::Realtime::Presence, :event_machine do
             updated_callback_count = 0
 
             client_count.times do |client_id|
-              presence_client_one.update_client("client:#{client_id}", data: data) do
+              presence_client_one.update_client("client:#{client_id}", data) do
                 updated_callback_count += 1
               end
             end
@@ -1098,8 +1091,8 @@ describe Ably::Realtime::Presence, :event_machine do
               left_callback_count = 0
 
               client_count.times do |client_id|
-                presence_client_one.enter_client("client:#{client_id}", data: random_str) do
-                  presence_client_one.leave_client("client:#{client_id}", data: data) do
+                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
@@ -1143,8 +1136,8 @@ 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", data: random_str) do
-                presence_client_one.leave_client("client:unique", data: data)
+              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|
@@ -1156,8 +1149,8 @@ describe Ably::Realtime::Presence, :event_machine do
 
           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: data) do
-                presence_client_one.leave_client("client:unique", data: nil)
+              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|
@@ -1169,7 +1162,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
           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: data) do
+              presence_client_one.enter_client("client:unique", data) do
                 presence_client_one.leave_client("client:unique")
               end
 
@@ -1225,7 +1218,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 +1227,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 +1317,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 +1340,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 +1470,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
@@ -1504,7 +1505,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
     context 'REST #get' do
       it 'returns current members' do
-        presence_client_one.enter(data: data_payload) do
+        presence_client_one.enter(data_payload) do
           members_page = channel_rest_client_one.presence.get
           this_member = members_page.items.first
 
@@ -1517,7 +1518,7 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'returns no members once left' do
-        presence_client_one.enter(data: data_payload) do
+        presence_client_one.enter(data_payload) do
           presence_client_one.leave do
             members_page = channel_rest_client_one.presence.get
             expect(members_page.items.count).to eql(0)
@@ -1547,32 +1548,34 @@ describe Ably::Realtime::Presence, :event_machine do
         let(:client_one)  { auto_close Ably::Realtime::Client.new(default_options) }
 
         it 'is converted into UTF_8' do
-          presence_client_one.enter(client_id: client_id)
-          presence_client_one.on(:entered) do |presence|
-            expect(presence.client_id.encoding).to eql(Encoding::UTF_8)
-            expect(presence.client_id.encode(Encoding::ASCII_8BIT)).to eql(client_id)
-            stop_reactor
+          channel_client_one.attach do
+            presence_client_one.subscribe(:enter) do |presence|
+              expect(presence.client_id.encoding).to eql(Encoding::UTF_8)
+              expect(presence.client_id.encode(Encoding::ASCII_8BIT)).to eql(client_id)
+              stop_reactor
+            end
+            presence_anonymous_client.enter_client(client_id)
           end
         end
       end
     end
 
     context 'encoding and decoding of presence message data' do
-      let(:secret_key)              { random_str }
+      let(:secret_key)              { Ably::Util::Crypto.generate_random_key(256) }
       let(:cipher_options)          { { key: secret_key, algorithm: 'aes', mode: 'cbc', key_length: 256 } }
       let(:channel_name)            { random_str }
-      let(:encrypted_channel)       { client_one.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
-      let(:channel_rest_client_one) { client_one.rest_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+      let(:encrypted_channel)       { client_one.channel(channel_name, cipher: cipher_options) }
+      let(:channel_rest_client_one) { client_one.rest_client.channel(channel_name, cipher: cipher_options) }
 
       let(:crypto)                  { Ably::Util::Crypto.new(cipher_options) }
 
-      let(:data)                    { { 'key' => random_str } }
+      let(:data)                    { { 'hash_id' => random_str } }
       let(:data_as_json)            { data.to_json }
       let(:data_as_cipher)          { crypto.encrypt(data.to_json) }
 
       it 'encrypts presence message data' do
         encrypted_channel.attach do
-          encrypted_channel.presence.enter data: data
+          encrypted_channel.presence.enter data
         end
 
         encrypted_channel.presence.__incoming_msgbus__.unsubscribe(:presence) # remove all subscribe callbacks that could decrypt the message
@@ -1591,7 +1594,7 @@ describe Ably::Realtime::Presence, :event_machine do
       context '#subscribe' do
         it 'emits decrypted enter events' do
           encrypted_channel.attach do
-            encrypted_channel.presence.enter data: data
+            encrypted_channel.presence.enter data
           end
 
           encrypted_channel.presence.subscribe(:enter) do |presence_message|
@@ -1603,8 +1606,8 @@ describe Ably::Realtime::Presence, :event_machine do
 
         it 'emits decrypted update events' do
           encrypted_channel.attach do
-            encrypted_channel.presence.enter(data: 'to be updated') do
-              encrypted_channel.presence.update data: data
+            encrypted_channel.presence.enter('to be updated') do
+              encrypted_channel.presence.update data
             end
           end
 
@@ -1617,7 +1620,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
         it 'emits previously set data for leave events' do
           encrypted_channel.attach do
-            encrypted_channel.presence.enter(data: data) do
+            encrypted_channel.presence.enter(data) do
               encrypted_channel.presence.leave
             end
           end
@@ -1632,7 +1635,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context '#get' do
         it 'returns a list of members with decrypted data' do
-          encrypted_channel.presence.enter(data: data) do
+          encrypted_channel.presence.enter(data) do
             encrypted_channel.presence.get do |members|
               member = members.first
               expect(member.encoding).to be_nil
@@ -1645,7 +1648,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'REST #get' do
         it 'returns a list of members with decrypted data' do
-          encrypted_channel.presence.enter(data: data) do
+          encrypted_channel.presence.enter(data) do
             member = channel_rest_client_one.presence.get.items.first
             expect(member.encoding).to be_nil
             expect(member.data).to eql(data)
@@ -1656,11 +1659,11 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'when cipher settings do not match publisher' do
         let(:client_options)                 { default_options.merge(log_level: :fatal) }
-        let(:incompatible_cipher_options)    { { key: secret_key, algorithm: 'aes', mode: 'cbc', key_length: 128 } }
-        let(:incompatible_encrypted_channel) { client_two.channel(channel_name, encrypted: true, cipher_params: incompatible_cipher_options) }
+        let(:incompatible_cipher_options)    { { key: Ably::Util::Crypto.generate_random_key(128), algorithm: 'aes', mode: 'cbc', key_length: 128 } }
+        let(:incompatible_encrypted_channel) { client_two.channel(channel_name, cipher: incompatible_cipher_options) }
 
         it 'delivers an unencoded presence message left with encoding value' do
-          encrypted_channel.presence.enter data: data
+          encrypted_channel.presence.enter data
 
           incompatible_encrypted_channel.presence.subscribe(:enter) do
             incompatible_encrypted_channel.presence.get do |members|
@@ -1681,7 +1684,7 @@ describe Ably::Realtime::Presence, :event_machine do
             end
 
             encrypted_channel.attach do
-              encrypted_channel.presence.enter data: data
+              encrypted_channel.presence.enter data
             end
           end
         end
@@ -1707,14 +1710,14 @@ describe Ably::Realtime::Presence, :event_machine do
             stop_reactor
           end
         end
-        presence_client_one.enter(data: data_payload) do
+        presence_client_one.enter(data_payload) do
           presence_client_one.leave
         end
       end
     end
 
     context 'connection failure mid-way through a large member sync' do
-      let(:members_count) { 400 }
+      let(:members_count) { 250 }
       let(:sync_pages_received) { [] }
       let(:client_options)  { default_options.merge(log_level: :error) }
 
@@ -1726,7 +1729,7 @@ describe Ably::Realtime::Presence, :event_machine do
             client_two.connection.transport.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
               if protocol_message.action == :sync
                 sync_pages_received << protocol_message
-                force_connection_failure client_two if sync_pages_received.count == 2
+                force_connection_failure client_two if sync_pages_received.count == 1
               end
             end
           end