ably 1.1.0 → 1.1.4

data/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
@@ -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
@@ -656,8 +657,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
           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/spec/acceptance/realtime/presence_history_spec.rb

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

data/spec/acceptance/realtime/presence_spec.rb

@@ -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(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
+                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(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
+                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(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
+                  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(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
+                  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
@@ -2341,15 +2377,13 @@ describe Ably::Realtime::Presence, :event_machine do
       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
 
@@ -2415,6 +2449,60 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
+      describe '#RTP17b' do
+        let(:leave_action) { Ably::Models::PresenceMessage::ACTION.Leave }
+
+        it 'updates presence members on leave' do
+          presence_client_two.subscribe(:enter) do
+            channel_anonymous_client.attach do
+              channel_anonymous_client.presence.get do |members|
+                presence_client_two.subscribe(:leave) do
+                  expect(presence_client_two.members.local_members).to be_empty
+                  stop_reactor
+                end
+
+                leave_message = Ably::Models::PresenceMessage.new(
+                  'id' => "#{client_two.connection.id}:#{presence_client_two.client_id}:1",
+                  'clientId' => presence_client_two.client_id,
+                  'connectionId' => client_two.connection.id,
+                  'timestamp' => as_since_epoch(Time.now),
+                  'action' => leave_action
+                )
+
+                presence_client_two.__incoming_msgbus__.publish :presence, leave_message
+              end
+            end
+          end
+
+          presence_client_two.enter
+        end
+
+        it 'does no update presence members on fabricated leave' do
+          presence_client_two.subscribe(:enter) do
+            channel_anonymous_client.attach do
+              channel_anonymous_client.presence.get do |members|
+                presence_client_two.subscribe(:leave) do
+                  expect(presence_client_two.members.local_members).to_not be_empty
+                  stop_reactor
+                end
+
+                fabricated_leave_message = Ably::Models::PresenceMessage.new(
+                  'id' => "#{client_two.connection.id}:#{presence_client_two.client_id}:1",
+                  'clientId' => presence_client_two.client_id,
+                  'connectionId' => "fabricated:#{presence_client_two.client_id}:0",
+                  'timestamp' => as_since_epoch(Time.now),
+                  'action' => leave_action
+                )
+
+                presence_client_two.__incoming_msgbus__.publish :presence, fabricated_leave_message
+              end
+            end
+          end
+
+          presence_client_two.enter
+        end
+      end
+
       context 'when a channel becomes attached again' do
         let(:attached_action) { Ably::Models::ProtocolMessage::ACTION.Attached.to_i }
         let(:sync_action) { Ably::Models::ProtocolMessage::ACTION.Sync.to_i }