ably 0.8.1 → 0.8.2

data/lib/ably/rest/channel.rb

@@ -37,6 +37,7 @@ module Ably
       # @return [Boolean] true if the message was published, otherwise false
       def publish(name, data)
         ensure_utf_8 :name, name
+        ensure_supported_payload data
 
         payload = {
           name: name,
@@ -60,7 +61,7 @@ module Ably
       # @option options [Symbol]       :direction  +:forwards+ or +:backwards+, defaults to +:backwards+
       # @option options [Integer]      :limit      Maximum number of messages to retrieve up to 1,000, defaults to 100
       #
-      # @return [Ably::Models::PaginatedResource<Ably::Models::Message>] First {Ably::Models::PaginatedResource page} of {Ably::Models::Message} objects accessible with {Ably::Models::PaginatedResource#items #items}.
+      # @return [Ably::Models::PaginatedResult<Ably::Models::Message>] First {Ably::Models::PaginatedResult page} of {Ably::Models::Message} objects accessible with {Ably::Models::PaginatedResult#items #items}.
       #
       def history(options = {})
         url = "#{base_path}/messages"
@@ -78,7 +79,7 @@ module Ably
 
         response = client.get(url, options)
 
-        Ably::Models::PaginatedResource.new(response, url, client, paginated_options) do |message|
+        Ably::Models::PaginatedResult.new(response, url, client, paginated_options) do |message|
           message.tap do |message|
             decode_message message
           end

data/lib/ably/rest/client.rb

@@ -150,7 +150,7 @@ module Ably
       # @option options [Integer]      :limit      Maximum number of messages to retrieve up to 1,000, defaults to 100
       # @option options [Symbol]       :unit       `:minute`, `:hour`, `:day` or `:month`. Defaults to `:minute`
       #
-      # @return [Ably::Models::PaginatedResource<Ably::Models::Stats>] An Array of Stats
+      # @return [Ably::Models::PaginatedResult<Ably::Models::Stats>] An Array of Stats
       #
       def stats(options = {})
         options = {
@@ -168,7 +168,7 @@ module Ably
         url = '/stats'
         response = get(url, options)
 
-        Ably::Models::PaginatedResource.new(response, url, self, paginated_options)
+        Ably::Models::PaginatedResult.new(response, url, self, paginated_options)
       end
 
       # Retrieve the Ably service time

data/lib/ably/rest/presence.rb

@@ -25,7 +25,7 @@ module Ably
       # @param [Hash] options the options for the set of members present
       # @option options [Integer]      :limit      Maximum number of members to retrieve up to 1,000, defaults to 100
       #
-      # @return [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] First {Ably::Models::PaginatedResource page} of {Ably::Models::PresenceMessage} objects accessible with {Ably::Models::PaginatedResource#items #items}.
+      # @return [Ably::Models::PaginatedResult<Ably::Models::PresenceMessage>] First {Ably::Models::PaginatedResult page} of {Ably::Models::PresenceMessage} objects accessible with {Ably::Models::PaginatedResult#items #items}.
       #
       def get(options = {})
         options = options = {
@@ -39,7 +39,7 @@ module Ably
 
         response = client.get(base_path, options)
 
-        Ably::Models::PaginatedResource.new(response, base_path, client, paginated_options) do |presence_message|
+        Ably::Models::PaginatedResult.new(response, base_path, client, paginated_options) do |presence_message|
           presence_message.tap do |presence_message|
             decode_message presence_message
           end
@@ -54,7 +54,7 @@ module Ably
       # @option options [Symbol]       :direction  +:forwards+ or +:backwards+, defaults to +:backwards+
       # @option options [Integer]      :limit      Maximum number of messages to retrieve up to 1,000, defaults to 100
       #
-      # @return [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] First {Ably::Models::PaginatedResource page} of {Ably::Models::PresenceMessage} objects accessible with {Ably::Models::PaginatedResource#items #items}.
+      # @return [Ably::Models::PaginatedResult<Ably::Models::PresenceMessage>] First {Ably::Models::PaginatedResult page} of {Ably::Models::PresenceMessage} objects accessible with {Ably::Models::PaginatedResult#items #items}.
       #
       def history(options = {})
         url = "#{base_path}/history"
@@ -72,7 +72,7 @@ module Ably
 
         response = client.get(url, options)
 
-        Ably::Models::PaginatedResource.new(response, url, client, paginated_options) do |presence_message|
+        Ably::Models::PaginatedResult.new(response, url, client, paginated_options) do |presence_message|
           presence_message.tap do |presence_message|
             decode_message presence_message
           end

data/lib/ably/util/pub_sub.rb

@@ -37,7 +37,7 @@ module Ably::Util
         configure_event_emitter options
 
         alias_method :subscribe, :unsafe_on
-        alias_method :publish, :trigger
+        alias_method :publish, :emit
         alias_method :unsubscribe, :off
       end
     end

data/lib/ably/util/safe_deferrable.rb

@@ -1,6 +1,6 @@
 module Ably::Util
   # SafeDeferrable class provides a Deferrable that is safe to use for for public interfaces
-  # of this client library.  Any exceptions raised in the success or failure callbacks is
+  # of this client library.  Any exceptions raised in the success or failure callbacks are
   # caught and logged to the provided logger.
   #
   # An exception in a callback provided by a developer should not break this client library

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.8.1'
+  VERSION = '0.8.2'
 end

data/spec/acceptance/realtime/channel_history_spec.rb

@@ -24,7 +24,7 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
         expect(history).to be_a(Ably::Util::SafeDeferrable)
         history.callback do |page|
           expect(page.items.count).to eql(1)
-          expect(page).to be_a(Ably::Models::PaginatedResource)
+          expect(page).to be_a(Ably::Models::PaginatedResult)
           stop_reactor
         end
       end

data/spec/acceptance/realtime/channel_spec.rb

@@ -13,9 +13,9 @@ describe Ably::Realtime::Channel, :event_machine do
     let(:messages)     { [] }
 
     describe 'initialization' do
-      context 'with :connect_automatically option set to false on connection' do
+      context 'with :auto_connect option set to false on connection' do
         let(:client) do
-          Ably::Realtime::Client.new(default_options.merge(connect_automatically: false))
+          Ably::Realtime::Client.new(default_options.merge(auto_connect: false))
         end
 
         it 'remains initialized when accessing a channel' do
@@ -32,16 +32,6 @@ describe Ably::Realtime::Channel, :event_machine do
             stop_reactor
           end
         end
-
-        it 'opens a connection implicitly when accessing #presence' do
-          client.channel('test').tap do |channel|
-            channel.on(:attached) do
-              expect(client.connection).to be_connected
-              stop_reactor
-            end
-            channel.presence
-          end
-        end
       end
     end
 
@@ -162,7 +152,7 @@ describe Ably::Realtime::Channel, :event_machine do
         end
         let(:restricted_channel) { restricted_client.channel("cannot_subscribe") }
 
-        it 'triggers failed event' do
+        it 'emits failed event' do
           restricted_channel.attach
           restricted_channel.on(:failed) do |error|
             expect(restricted_channel.state).to eq(:failed)
@@ -179,7 +169,7 @@ describe Ably::Realtime::Channel, :event_machine do
           end
         end
 
-        it 'triggers an error event' do
+        it 'emits an error event' do
           restricted_channel.attach
           restricted_channel.on(:error) do |error|
             expect(restricted_channel.state).to eq(:failed)
@@ -458,7 +448,7 @@ describe Ably::Realtime::Channel, :event_machine do
             end
           end
 
-          it 'triggers an error event on the channel' do
+          it 'emits an error event on the channel' do
             channel.attach do
               channel.on(:error) do |error|
                 expect(error).to eql(connection_error)

data/spec/acceptance/realtime/connection_failures_spec.rb

@@ -319,7 +319,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
                         disconnected: { retry_every: retry_every, max_time_in_state: 60 })
           end
 
-          it "retries every CONNECT_RETRY_CONFIG[:disconnected][:retry_every] seconds" do
+          it "retries every #{Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG[:disconnected][:retry_every]} seconds" do
             fail_if_suspended_or_failed
 
             stubbed_first_attempt = false
@@ -415,7 +415,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           end
         end
 
-        it 'triggers the resume callback', api_private: true do
+        it 'executes the resume callback', api_private: true do
           channel.attach do
             connection.transport.close_connection_after_writing
             connection.on_resume do

data/spec/acceptance/realtime/connection_spec.rb

@@ -27,9 +27,9 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
 
-      context 'with :connect_automatically option set to false' do
+      context 'with :auto_connect option set to false' do
         let(:client) do
-          Ably::Realtime::Client.new(default_options.merge(connect_automatically: false))
+          Ably::Realtime::Client.new(default_options.merge(auto_connect: false))
         end
 
         it 'does not connect automatically' do
@@ -201,10 +201,10 @@ describe Ably::Realtime::Connection, :event_machine do
 
     context 'initialization state changes' do
       let(:phases) { [:connecting, :connected] }
-      let(:events_triggered) { [] }
+      let(:events_emitted) { [] }
       let(:test_expectation) do
         Proc.new do
-          expect(events_triggered).to eq(phases)
+          expect(events_emitted).to eq(phases)
           stop_reactor
         end
       end
@@ -212,20 +212,20 @@ describe Ably::Realtime::Connection, :event_machine do
       def expect_ordered_phases
         phases.each do |phase|
           connection.on(phase) do
-            events_triggered << phase
-            test_expectation.call if events_triggered.length == phases.length
+            events_emitted << phase
+            test_expectation.call if events_emitted.length == phases.length
           end
         end
       end
 
       context 'with implicit #connect' do
-        it 'are triggered in order' do
+        it 'are emitted in order' do
           expect_ordered_phases
         end
       end
 
       context 'with explicit #connect' do
-        it 'are triggered in order' do
+        it 'are emitted in order' do
           expect_ordered_phases
           connection.connect
         end
@@ -542,10 +542,10 @@ describe Ably::Realtime::Connection, :event_machine do
         let(:states)           { Hash.new }
         let(:client_options)   { default_options.merge(log_level: :none) }
 
-        it 'is composed of connection id and serial that is kept up to date with each message ACK received' do
+        it 'is composed of connection key and serial that is kept up to date with each message ACK received' do
           connection.on(:connected) do
             expected_serial = -1
-            expect(connection.id).to_not be_nil
+            expect(connection.key).to_not be_nil
             expect(connection.serial).to eql(expected_serial)
 
             client.channel('test').attach do |channel|
@@ -556,6 +556,8 @@ describe Ably::Realtime::Connection, :event_machine do
                 channel.publish('event', 'data') do
                   expected_serial += 1 # attach message received
                   expect(connection.serial).to eql(expected_serial)
+
+                  expect(connection.recovery_key).to eql("#{connection.key}:#{connection.serial}")
                   stop_reactor
                 end
               end
@@ -621,7 +623,7 @@ describe Ably::Realtime::Connection, :event_machine do
             end
           end
 
-          it 'does not trigger a resume callback', api_private: true do
+          it 'does not call a resume callback', api_private: true do
             connection.once(:connected) do
               connection.transition_state_machine! :failed
             end
@@ -629,7 +631,7 @@ describe Ably::Realtime::Connection, :event_machine do
             connection.once(:failed) do
               recover_client = Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
               recover_client.connection.on_resume do
-                raise 'Should not trigger resume callback'
+                raise 'Should not call the resume callback'
               end
               recover_client.connection.on(:connected) do
                 EventMachine.add_timer(0.5) { stop_reactor }
@@ -676,7 +678,7 @@ describe Ably::Realtime::Connection, :event_machine do
         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) }
 
-          it 'triggers a fatal error on the connection object, sets the #error_reason and disconnects' do
+          it 'emits 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(error.message).to match(/Invalid connection key/)
@@ -691,7 +693,7 @@ describe Ably::Realtime::Connection, :event_machine do
         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
+          it 'emits 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(error.message).to match(/Invalid connection key/i)

data/spec/acceptance/realtime/message_spec.rb

@@ -32,6 +32,87 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       end
     end
 
+    context 'with supported data payload content type' do
+      def publish_and_check_data(data)
+        channel.attach
+        channel.publish 'event', data
+        channel.subscribe do |message|
+          expect(message.data).to eql(data)
+          stop_reactor
+        end
+      end
+
+      context 'JSON Object (Hash)' do
+        let(:data) { { 'Hash' => 'true' } }
+
+        it 'is encoded and decoded to the same hash' do
+          publish_and_check_data data
+        end
+      end
+
+      context 'JSON Array' do
+        let(:data) { [ nil, true, false, 55, 'string', { 'Hash' => true }, ['array'] ] }
+
+        it 'is encoded and decoded to the same Array' do
+          publish_and_check_data data
+        end
+      end
+
+      context 'String' do
+        let(:data) { random_str }
+
+        it 'is encoded and decoded to the same Array' do
+          publish_and_check_data data
+        end
+      end
+
+      context 'Binary' do
+        let(:data) { Base64.encode64(random_str) }
+
+        it 'is encoded and decoded to the same Array' do
+          publish_and_check_data data
+        end
+      end
+    end
+
+    context 'with unsupported data payload content type' do
+      context 'Integer' do
+        let(:data) { 1 }
+
+        it 'is raises an UnsupportedDataTypeError 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+          stop_reactor
+        end
+      end
+
+      context 'Float' do
+        let(:data) { 1.1 }
+
+        it 'is raises an UnsupportedDataTypeError 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+          stop_reactor
+        end
+      end
+
+      context 'Boolean' do
+        let(:data) { true }
+
+        it 'is raises an UnsupportedDataTypeError 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+          stop_reactor
+        end
+      end
+
+      context 'False' do
+        let(:data) { false }
+
+        it 'is raises an UnsupportedDataTypeError 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+          stop_reactor
+        end
+      end
+    end
+
     context 'with ASCII_8BIT message name' do
       let(:message_name) { random_str.encode(Encoding::ASCII_8BIT) }
       it 'is converted into UTF_8' do
@@ -410,7 +491,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
           end
         end
 
-        it 'triggers a Cipher error on the channel' do
+        it 'emits a Cipher error on the channel' do
           unencrypted_channel_client2.attach do
             encrypted_channel_client1.publish 'example', payload
             unencrypted_channel_client2.on(:error) do |error|
@@ -441,7 +522,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
           end
         end
 
-        it 'triggers a Cipher error on the channel' do
+        it 'emits a Cipher error on the channel' do
           encrypted_channel_client2.attach do
             encrypted_channel_client1.publish 'example', payload
             encrypted_channel_client2.on(:error) do |error|
@@ -464,15 +545,17 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
         let(:payload) { MessagePack.pack({ 'key' => random_str }) }
 
         it 'delivers the message but still encrypted with the cipher details in the #encoding attribute' do
-          encrypted_channel_client1.publish 'example', payload
-          encrypted_channel_client2.subscribe do |message|
-            expect(message.data).to_not eql(payload)
-            expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
-            stop_reactor
+          encrypted_channel_client2.attach do
+            encrypted_channel_client1.publish 'example', payload
+            encrypted_channel_client2.subscribe do |message|
+              expect(message.data).to_not eql(payload)
+              expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
+              stop_reactor
+            end
           end
         end
 
-        it 'triggers a Cipher error on the channel' do
+        it 'emits a Cipher error on the channel' do
           encrypted_channel_client2.attach do
             encrypted_channel_client1.publish 'example', payload
             encrypted_channel_client2.on(:error) do |error|

data/spec/acceptance/realtime/presence_spec.rb

@@ -53,6 +53,107 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
+      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)
+          else
+            presence_client_one.public_send(method_name, data: data)
+          end
+
+          presence_client_one.subscribe do |presence_message|
+            expect(presence_message.data).to eql(data)
+            stop_reactor
+          end
+        end
+
+        context 'JSON Object (Hash)' do
+          let(:data) { { 'Hash' => 'true' } }
+
+          it 'is encoded and decoded to the same hash' do
+            setup_test(method_name, args, options) do
+              register_presence_and_check_data method_name, data
+            end
+          end
+        end
+
+        context 'JSON Array' do
+          let(:data) { [ nil, true, false, 55, 'string', { 'Hash' => true }, ['array'] ] }
+
+          it 'is encoded and decoded to the same Array' do
+            setup_test(method_name, args, options) do
+              register_presence_and_check_data method_name, data
+            end
+          end
+        end
+
+        context 'String' do
+          let(:data) { random_str }
+
+          it 'is encoded and decoded to the same Array' do
+            setup_test(method_name, args, options) do
+              register_presence_and_check_data method_name, data
+            end
+          end
+        end
+
+        context 'Binary' do
+          let(:data) { Base64.encode64(random_str) }
+
+          it 'is encoded and decoded to the same Array' do
+            setup_test(method_name, args, options) do
+              register_presence_and_check_data method_name, data
+            end
+          end
+        end
+      end
+
+      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)
+          else
+            presence_client_one.public_send(method_name, data: data)
+          end
+        end
+
+        context 'Integer' do
+          let(:data) { 1 }
+
+          it 'raises an UnsupportedDataTypeError 40011 exception' do
+            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+            stop_reactor
+          end
+        end
+
+        context 'Float' do
+          let(:data) { 1.1 }
+
+          it 'raises an UnsupportedDataTypeError 40011 exception' do
+            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+            stop_reactor
+          end
+        end
+
+        context 'Boolean' do
+          let(:data) { true }
+
+          it 'raises an UnsupportedDataTypeError 40011 exception' do
+            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+            stop_reactor
+          end
+        end
+
+        context 'False' do
+          let(:data) { false }
+
+          it 'raises an UnsupportedDataTypeError 40011 exception' do
+            expect { presence_action(method_name, data) }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+            stop_reactor
+          end
+        end
+      end
+
       it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
         setup_test(method_name, args, options) do
           expect(presence_client_one.public_send(method_name, args)).to be_a(Ably::Util::SafeDeferrable)
@@ -153,13 +254,15 @@ describe Ably::Realtime::Presence, :event_machine do
         stop_reactor
       end
 
-      it 'will trigger an :in_sync event when synchronisation is complete' do
+      it 'will emit an :in_sync event when synchronisation is complete' do
         presence_client_one.enter
         presence_client_two.enter
 
         presence_anonymous_client.members.once(:in_sync) do
           stop_reactor
         end
+
+        channel_anonymous_client.attach
       end
 
       context 'before server sync complete' do
@@ -180,6 +283,8 @@ describe Ably::Realtime::Presence, :event_machine do
               expect(member_ids.uniq.count).to eql(2)
               stop_reactor
             end
+
+            channel_anonymous_client.attach
           end
         end
       end
@@ -200,7 +305,7 @@ describe Ably::Realtime::Presence, :event_machine do
           presence_client_one.enter do
             channel_anonymous_client.attach do
               expect(channel_anonymous_client.presence).to_not be_sync_complete
-              channel_anonymous_client.presence.get do
+              channel_anonymous_client.presence.get(wait_for_sync: true) do
                 expect(channel_anonymous_client.presence).to be_sync_complete
                 stop_reactor
               end
@@ -319,7 +424,7 @@ describe Ably::Realtime::Presence, :event_machine do
               end
             end
 
-            it 'does not emit :present after the :leave event has been emitted, and that member is not included in the list of members via #get' do
+            it 'does not emit :present after the :leave event has been emitted, and that member is not included in the list of members via #get with :wait_for_sync' do
               left_client = 10
               left_client_id = "client:#{left_client}"
 
@@ -341,7 +446,7 @@ describe Ably::Realtime::Presence, :event_machine do
                   member_left_emitted = true
                 end
 
-                presence_anonymous_client.get do |members|
+                presence_anonymous_client.get(wait_for_sync: true) do |members|
                   expect(members.count).to eql(enter_expected_count - 1)
                   expect(member_left_emitted).to eql(true)
                   expect(members.map(&:client_id)).to_not include(left_client_id)
@@ -365,43 +470,40 @@ describe Ably::Realtime::Presence, :event_machine do
           end
 
           context '#get' do
-            it 'waits until sync is complete', event_machine: 15 do
-              enter_expected_count.times do |index|
-                presence_client_one.enter_client("client:#{index}") do |message|
-                  entered << message
-                  next unless entered.count == enter_expected_count
-
-                  presence_anonymous_client.get do |members|
-                    expect(members.map(&:client_id).uniq.count).to eql(enter_expected_count)
-                    expect(members.count).to eql(enter_expected_count)
-                    stop_reactor
+            context 'with :wait_for_sync option set to true' do
+              it 'waits until sync is complete', event_machine: 15 do
+                enter_expected_count.times do |index|
+                  presence_client_one.enter_client("client:#{index}") do |message|
+                    entered << message
+                    next unless entered.count == enter_expected_count
+
+                    presence_anonymous_client.get(wait_for_sync: true) do |members|
+                      expect(members.map(&:client_id).uniq.count).to eql(enter_expected_count)
+                      expect(members.count).to eql(enter_expected_count)
+                      stop_reactor
+                    end
                   end
                 end
               end
             end
-          end
-        end
-      end
-    end
 
-    context 'automatic attachment of channel on access to presence object' do
-      it 'is implicit if presence state is initialized' do
-        channel_client_one.presence
-        channel_client_one.on(:attached) do
-          expect(channel_client_one.state).to eq(:attached)
-          stop_reactor
-        end
-      end
-
-      it 'is disabled if presence state is not initialized' do
-        channel_client_one.attach do
-          channel_client_one.detach do
-            expect(channel_client_one.state).to eq(:detached)
-
-            channel_client_one.presence # access the presence object
-            EventMachine.add_timer(1) do
-              expect(channel_client_one.state).to eq(:detached)
-              stop_reactor
+            context 'by default' do
+              it 'it does not wait for sync', event_machine: 15 do
+                enter_expected_count.times do |index|
+                  presence_client_one.enter_client("client:#{index}") do |message|
+                    entered << message
+                    next unless entered.count == enter_expected_count
+
+                    channel_anonymous_client.attach do
+                      presence_anonymous_client.get do |members|
+                        expect(presence_anonymous_client.members).to_not be_in_sync
+                        expect(members.count).to eql(0)
+                        stop_reactor
+                      end
+                    end
+                  end
+                end
+              end
             end
           end
         end
@@ -571,7 +673,7 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         context 'when set to nil' do
-          it 'emits the previously defined value as a convenience' 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
             end
@@ -595,6 +697,22 @@ describe Ably::Realtime::Presence, :event_machine do
             end
           end
         end
+
+        context 'and sync is complete' do
+          it 'does not cache members that have left' do
+            presence_client_one.enter data: 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
+            end
+
+            presence_client_one.subscribe(:leave) do |presence_message|
+              expect(presence_message.data).to eql(data)
+              expect(presence_client_one.members.send(:members).count).to eql(0)
+              stop_reactor
+            end
+          end
+        end
       end
 
       it 'raises an exception if not entered' do
@@ -911,43 +1029,45 @@ describe Ably::Realtime::Presence, :event_machine do
                       )
         end
 
-        it 'fails if the connection fails' do
-          when_all(*connect_members_deferrables) do
-            channel_client_two.attach 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 == 1
+        context 'when :wait_for_sync is true' do
+          it 'fails if the connection fails' do
+            when_all(*connect_members_deferrables) do
+              channel_client_two.attach 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 == 1
+                  end
                 end
               end
-            end
 
-            presence_client_two.get.tap do |deferrable|
-              deferrable.callback { raise 'Get should not succeed' }
-              deferrable.errback do |error|
-                stop_reactor
+              presence_client_two.get(wait_for_sync: true).tap do |deferrable|
+                deferrable.callback { raise 'Get should not succeed' }
+                deferrable.errback do |error|
+                  stop_reactor
+                end
               end
             end
           end
-        end
 
-        it 'fails if the channel is detached' do
-          when_all(*connect_members_deferrables) do
-            channel_client_two.attach do
-              client_two.connection.transport.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
-                if protocol_message.action == :sync
-                  # prevent any more SYNC messages coming through
-                  client_two.connection.transport.__incoming_protocol_msgbus__.unsubscribe
-                  channel_client_two.change_state :detaching
-                  channel_client_two.change_state :detached
+          it 'fails if the channel is detached' do
+            when_all(*connect_members_deferrables) do
+              channel_client_two.attach do
+                client_two.connection.transport.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                  if protocol_message.action == :sync
+                    # prevent any more SYNC messages coming through
+                    client_two.connection.transport.__incoming_protocol_msgbus__.unsubscribe
+                    channel_client_two.change_state :detaching
+                    channel_client_two.change_state :detached
+                  end
                 end
               end
-            end
 
-            presence_client_two.get.tap do |deferrable|
-              deferrable.callback { raise 'Get should not succeed' }
-              deferrable.errback do |error|
-                stop_reactor
+              presence_client_two.get(wait_for_sync: true).tap do |deferrable|
+                deferrable.callback { raise 'Get should not succeed' }
+                deferrable.errback do |error|
+                  stop_reactor
+                end
               end
             end
           end
@@ -1059,12 +1179,12 @@ describe Ably::Realtime::Presence, :event_machine do
           end
 
           wait_until(proc { clients_entered[:client_one] + clients_entered[:client_two] == total_members * 2 }) do
-            presence_anonymous_client.get do |anonymous_members|
+            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)
 
-              presence_client_one.get do |client_one_members|
-                presence_client_two.get do |client_two_members|
+              presence_client_one.get(wait_for_sync: true) do |client_one_members|
+                presence_client_two.get(wait_for_sync: true) 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
@@ -1319,7 +1439,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       specify 'expect :left event with client data from enter event' do
         presence_client_one.subscribe(:leave) do |message|
-          presence_client_one.get do |members|
+          presence_client_one.get(wait_for_sync: true) do |members|
             expect(members.count).to eq(0)
             expect(message.data).to eql(data_payload)
             stop_reactor
@@ -1335,8 +1455,7 @@ describe Ably::Realtime::Presence, :event_machine do
       let(:members_count) { 400 }
       let(:sync_pages_received) { [] }
 
-      # Will re-enable once https://github.com/ably/realtime/issues/91 is resolved
-      skip 'resumes the SYNC operation', em_timeout: 15 do
+      it 'resumes the SYNC operation', em_timeout: 15 do
         when_all(*members_count.times.map do |index|
           presence_client_one.enter_client("client:#{index}")
         end) do
@@ -1349,7 +1468,7 @@ describe Ably::Realtime::Presence, :event_machine do
             end
           end
 
-          presence_client_two.get do |members|
+          presence_client_two.get(wait_for_sync: true) do |members|
             expect(members.count).to eql(members_count)
             expect(members.map(&:member_key).uniq.count).to eql(members_count)
             stop_reactor