ably-rest 1.2.5 → 1.2.7

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

@@ -342,8 +342,10 @@ describe Ably::Realtime::Channel, :event_machine do
             channel.attach
           end
 
-          channel.attach do
-            channel.detach
+          client.connection.once :connected do
+            channel.attach do
+              channel.detach
+            end
           end
         end
       end
@@ -430,9 +432,35 @@ describe Ably::Realtime::Channel, :event_machine do
       end
 
       context 'with connection state' do
+
+        sent_attach_messages = []
+        received_attached_messages = []
+        before(:each) do
+          sent_attach_messages = []
+          received_attached_messages = []
+          client.connection.__outgoing_protocol_msgbus__.subscribe do |message|
+            if message.action == :attach
+              sent_attach_messages << message
+            end
+          end
+          client.connection.__incoming_protocol_msgbus__.subscribe do |message|
+            if message.action == :attached
+              received_attached_messages << message
+            end
+          end
+        end
+
+        # Should send/receive attach/attached message only once
+        # No duplicates should be sent or received
+        let(:check_for_attach_messages) do
+          expect(sent_attach_messages.size).to eq(1)
+          expect(received_attached_messages.size).to eq(1)
+        end
+
         it 'is initialized (#RTL4i)' do
           expect(connection).to be_initialized
           channel.attach do
+            check_for_attach_messages
             stop_reactor
           end
         end
@@ -440,6 +468,7 @@ describe Ably::Realtime::Channel, :event_machine do
         it 'is connecting (#RTL4i)' do
           connection.once(:connecting) do
             channel.attach do
+              check_for_attach_messages
               stop_reactor
             end
           end
@@ -449,6 +478,7 @@ describe Ably::Realtime::Channel, :event_machine do
           connection.once(:connected) do
             connection.once(:disconnected) do
               channel.attach do
+                check_for_attach_messages
                 stop_reactor
               end
             end
@@ -467,7 +497,9 @@ describe Ably::Realtime::Channel, :event_machine do
               stop_reactor
             end
 
-            channel.attach
+            client.connection.once :connected do
+              channel.attach
+            end
           end
         end
 
@@ -488,7 +520,9 @@ describe Ably::Realtime::Channel, :event_machine do
               channel.detach
             end
 
-            channel.attach
+            client.connection.once :connected do
+              channel.attach
+            end
           end
         end
       end
@@ -497,23 +531,29 @@ describe Ably::Realtime::Channel, :event_machine do
     describe '#detach' do
       context 'when state is :attached' do
         it 'it detaches from a channel (#RTL5d)' do
-          channel.attach do
+          channel.once :attached do
             channel.detach
             channel.on(:detached) do
               expect(channel.state).to eq(:detached)
               stop_reactor
             end
           end
+          connection.once :connected do
+            channel.attach
+          end
         end
 
         it 'detaches from a channel and calls the provided block (#RTL5d, #RTL5e)' do
-          channel.attach do
+          channel.once :attached do
             expect(channel.state).to eq(:attached)
             channel.detach do
               expect(channel.state).to eq(:detached)
               stop_reactor
             end
           end
+          connection.once :connected do
+            channel.attach
+          end
         end
 
         it 'emits :detaching then :detached events' do
@@ -523,26 +563,34 @@ describe Ably::Realtime::Channel, :event_machine do
             end
           end
 
-          channel.attach do
-            channel.detach
+          connection.once :connected do
+            channel.attach do
+              channel.detach
+            end
           end
         end
 
         it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
-          channel.attach do
+          channel.once :attached do
             expect(channel.detach).to be_a(Ably::Util::SafeDeferrable)
             stop_reactor
           end
+          connection.once :connected do
+            channel.attach
+          end
         end
 
         it 'calls the Deferrable callback on success' do
-          channel.attach do
+          channel.once :attached do
             channel.detach.callback do
               expect(channel).to be_a(Ably::Realtime::Channel)
               expect(channel.state).to eq(:detached)
               stop_reactor
             end
           end
+          connection.once :connected do
+            channel.attach
+          end
         end
 
         context 'and DETACHED message is not received within realtime request timeout' do
@@ -551,7 +599,6 @@ describe Ably::Realtime::Channel, :event_machine do
 
           it 'fails the deferrable and returns to the previous state (#RTL5f, #RTL5e)' do
             channel.attach do
-              # don't process any incoming ProtocolMessages so the channel never becomes detached
               connection.__incoming_protocol_msgbus__.unsubscribe
               detached_requested_at = Time.now.to_i
               channel.detach do
@@ -566,6 +613,7 @@ describe Ably::Realtime::Channel, :event_machine do
         end
       end
 
+
       context 'when state is :failed' do
         let(:client_options) { default_options.merge(log_level: :fatal) }
 
@@ -609,15 +657,17 @@ describe Ably::Realtime::Channel, :event_machine do
             channel.detach
           end
 
-          channel.attach do
-            channel.detach
+          connection.once :connected do
+            channel.attach do
+              channel.detach
+            end
           end
         end
       end
 
       context 'when state is :suspended' do
         it 'moves the channel state immediately to DETACHED state (#RTL5j)' do
-          channel.attach do
+          channel.once :attached do
             channel.once(:suspended) do
               channel.on do |channel_state_change|
                 expect(channel_state_change.current).to eq(:detached)
@@ -632,6 +682,9 @@ describe Ably::Realtime::Channel, :event_machine do
             end
             channel.transition_state_machine :suspended
           end
+          connection.once :connected do
+            channel.attach
+          end
         end
       end
 
@@ -655,7 +708,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
       context 'when state is :detached' do
         it 'does nothing as the channel is detached (#RTL5a)' do
-          channel.attach do
+          channel.once :attached do
             channel.detach do
               expect(channel).to be_detached
               channel.on do
@@ -666,6 +719,9 @@ describe Ably::Realtime::Channel, :event_machine do
               end
             end
           end
+          connection.once :connected do
+            channel.attach
+          end
         end
       end
 
@@ -735,8 +791,10 @@ describe Ably::Realtime::Channel, :event_machine do
         context 'initialized' do
           it 'does the detach operation once the connection state is connected (#RTL5h)' do
             expect(connection).to be_initialized
+            channel.on :attaching do
+              channel.detach
+            end
             channel.attach
-            channel.detach
             connection.once(:connected) do
               channel.once(:attached) do
                 channel.once(:detached) do
@@ -750,8 +808,10 @@ describe Ably::Realtime::Channel, :event_machine do
         context 'connecting' do
           it 'does the detach operation once the connection state is connected (#RTL5h)' do
             connection.once(:connecting) do
+              channel.on :attaching do
+                channel.detach
+              end
               channel.attach
-              channel.detach
               connection.once(:connected) do
                 channel.once(:attached) do
                   channel.once(:detached) do
@@ -877,84 +937,92 @@ describe Ably::Realtime::Channel, :event_machine do
       describe '#(RTL17)' do
         context 'when channel is initialized' do
           it 'sends messages only on attach' do
-            expect(channel).to be_initialized
-            channel.publish('event', payload)
+            connection.once :connected do
+              expect(channel).to be_initialized
+              channel.publish('event', payload)
 
-            channel.subscribe do |message|
-              stop_reactor if message.data == payload && channel.attached?
-            end
+              channel.subscribe do |message|
+                stop_reactor if message.data == payload && channel.attached?
+              end
 
-            channel.attach
+              channel.attach
+            end
           end
         end
 
         context 'when channel is attaching' do
           it 'sends messages only on attach' do
-            channel.publish('event', payload)
+            connection.once :connected do
+              channel.publish('event', payload)
 
-            sent_message = nil
-            channel.subscribe do |message|
-              return if message.data != payload
-              sent_message = message
+              sent_message = nil
+              channel.subscribe do |message|
+                return if message.data != payload
+                sent_message = message
 
-              stop_reactor if channel.attached?
-            end
+                stop_reactor if channel.attached?
+              end
 
-            channel.on(:attaching) do
-              expect(channel).to be_attaching
-              expect(sent_message).to be_nil
-            end
+              channel.on(:attaching) do
+                expect(channel).to be_attaching
+                expect(sent_message).to be_nil
+              end
 
-            channel.attach
+              channel.attach
+            end
           end
         end
 
         context 'when channel is detaching' do
           it 'stops sending message' do
-            sent_message = nil
-            event_published = false
-            channel.subscribe do |message|
-              sent_message = message if message.data == payload
-            end
+            connection.once :connected do
+              sent_message = nil
+              event_published = false
+              channel.subscribe do |message|
+                sent_message = message if message.data == payload
+              end
 
-            channel.on(:detaching) do
-              channel.publish('event', payload)
-              event_published = true
-            end
+              channel.on(:detaching) do
+                channel.publish('event', payload)
+                event_published = true
+              end
 
-            channel.on(:detaching) do
-              EventMachine.next_tick do
-                expect(sent_message).to be_nil
-                stop_reactor if event_published
+              channel.on(:detaching) do
+                EventMachine.next_tick do
+                  expect(sent_message).to be_nil
+                  stop_reactor if event_published
+                end
               end
-            end
 
-            channel.attach do
-              channel.detach
+              channel.attach do
+                channel.detach
+              end
             end
           end
         end
 
         context 'when channel is detached' do
           it 'stops sending message' do
-            sent_message = nil
-            event_published = false
-            channel.subscribe do |message|
-              sent_message = message if message.data == payload
-            end
+            connection.once :connected do
+              sent_message = nil
+              event_published = false
+              channel.subscribe do |message|
+                sent_message = message if message.data == payload
+              end
 
-            channel.on(:detaching) do
-              channel.publish('event', payload)
-              event_published = true
-            end
+              channel.on(:detaching) do
+                channel.publish('event', payload)
+                event_published = true
+              end
 
-            channel.on(:detached) do
-              expect(sent_message).to be_nil
-              stop_reactor if event_published
-            end
+              channel.on(:detached) do
+                expect(sent_message).to be_nil
+                stop_reactor if event_published
+              end
 
-            channel.attach do
-              channel.detach
+              channel.attach do
+                channel.detach
+              end
             end
           end
         end
@@ -968,8 +1036,10 @@ describe Ably::Realtime::Channel, :event_machine do
               end
             end
 
-            channel.attach do
-              channel.transition_state_machine(:failed)
+            connection.once :connected do
+              channel.attach do
+                channel.transition_state_machine(:failed)
+              end
             end
           end
         end
@@ -1019,7 +1089,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
       context 'when channel is Detaching (#RTL6c1)' do
         it 'publishes messages immediately (#RTL6c1)' do
-          sub_channel.attach do
+          sub_channel.once :attached do
             channel.attach do
               channel.once(:detaching) do
                 outgoing_message_count = 0
@@ -1041,32 +1111,37 @@ describe Ably::Realtime::Channel, :event_machine do
               channel.detach
             end
           end
+          connection.once :connected do
+            sub_channel.attach
+          end
         end
       end
 
       context 'when channel is Detached (#RTL6c1)' do
         it 'publishes messages immediately (#RTL6c1)' do
-          sub_channel.attach do
-            channel.attach
-            channel.once(:attached) do
-              channel.once(:detached) do
-                outgoing_message_count = 0
-                client.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
-                  if protocol_message.action == :message
-                    raise "Expected channel state to be attaching when publishing messages, not #{channel.state}" unless channel.detached?
-                    outgoing_message_count += protocol_message.messages.count
+          connection.once :connected do
+            sub_channel.attach do
+              channel.attach
+              channel.once(:attached) do
+                channel.once(:detached) do
+                  outgoing_message_count = 0
+                  client.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                    if protocol_message.action == :message
+                      raise "Expected channel state to be attaching when publishing messages, not #{channel.state}" unless channel.detached?
+                      outgoing_message_count += protocol_message.messages.count
+                    end
                   end
-                end
-                sub_channel.subscribe do |message|
-                  messages << message if message.name == 'event'
-                  if messages.count == 3
-                    expect(outgoing_message_count).to eql(3)
-                    stop_reactor
+                  sub_channel.subscribe do |message|
+                    messages << message if message.name == 'event'
+                    if messages.count == 3
+                      expect(outgoing_message_count).to eql(3)
+                      stop_reactor
+                    end
                   end
+                  3.times { channel.publish('event', random_str) }
                 end
-                3.times { channel.publish('event', random_str) }
+                channel.detach
               end
-              channel.detach
             end
           end
         end
@@ -1429,12 +1504,14 @@ describe Ably::Realtime::Channel, :event_machine do
 
           context 'with a valid client_id in the message' do
             it 'succeeds' do
-              channel.publish([name: 'event', client_id: 'validClient']).tap do |deferrable|
-                deferrable.errback { raise 'Should have succeeded' }
-              end
-              channel.subscribe('event') do |message|
-                expect(message.client_id).to eql('validClient')
-                EM.add_timer(0.5) { stop_reactor }
+              connection.once :connected do
+                channel.publish([name: 'event', client_id: 'validClient']).tap do |deferrable|
+                  deferrable.errback { raise 'Should have succeeded' }
+                end
+                channel.subscribe('event') do |message|
+                  expect(message.client_id).to eql('validClient')
+                  EM.add_timer(0.5) { stop_reactor }
+                end
               end
             end
           end
@@ -1455,12 +1532,14 @@ describe Ably::Realtime::Channel, :event_machine do
 
           context 'with an empty client_id in the message' do
             it 'succeeds and publishes without a client_id' do
-              channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
-                deferrable.errback { raise 'Should have succeeded' }
-              end
-              channel.subscribe('event') do |message|
-                expect(message.client_id).to be_nil
-                EM.add_timer(0.5) { stop_reactor }
+              connection.once :connected do
+                channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
+                  deferrable.errback { raise 'Should have succeeded' }
+                end
+                channel.subscribe('event') do |message|
+                  expect(message.client_id).to be_nil
+                  EM.add_timer(0.5) { stop_reactor }
+                end
               end
             end
           end
@@ -1475,20 +1554,25 @@ describe Ably::Realtime::Channel, :event_machine do
           context 'before the client is CONNECTED and the client\'s identity has been obtained' do
             context 'with a valid client_id in the message' do
               it 'succeeds' do
-                channel.publish([name: 'event', client_id: 'valid']).tap do |deferrable|
-                  deferrable.errback { raise 'Should have succeeded' }
-                end
-                channel.subscribe('event') do |message|
-                  expect(message.client_id).to eql('valid')
-                  EM.add_timer(0.5) { stop_reactor }
+                connection.once :connected do
+                  channel.publish([name: 'event', client_id: 'valid']).tap do |deferrable|
+                    deferrable.errback { raise 'Should have succeeded' }
+                  end
+                  channel.subscribe('event') do |message|
+                    expect(message.client_id).to eql('valid')
+                    EM.add_timer(0.5) { stop_reactor }
+                  end
                 end
               end
             end
 
             context 'with an invalid client_id in the message' do
               let(:client_options)   { default_options.merge(key: nil, token: token, log_level: :error) }
-              it 'succeeds in the client library but then fails when delivered to Ably' do
+              it 'succeeds in the client library ( while connecting ) but then fails when delivered to Ably' do
                 channel.publish([name: 'event', client_id: 'invalid']).tap do |deferrable|
+                  deferrable.errback do |err|
+                    expect(err).to be_truthy
+                  end
                   EM.add_timer(0.5) { stop_reactor }
                 end
                 channel.subscribe('event') do |message|
@@ -1499,12 +1583,14 @@ describe Ably::Realtime::Channel, :event_machine do
 
             context 'with an empty client_id in the message' do
               it 'succeeds and publishes with an implicit client_id' do
-                channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
-                  deferrable.errback { raise 'Should have succeeded' }
-                end
-                channel.subscribe('event') do |message|
-                  expect(message.client_id).to eql('valid')
-                  EM.add_timer(0.5) { stop_reactor }
+                connection.once :connected do
+                  channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
+                    deferrable.errback { raise 'Should have succeeded' }
+                  end
+                  channel.subscribe('event') do |message|
+                    expect(message.client_id).to eql('valid')
+                    EM.add_timer(0.5) { stop_reactor }
+                  end
                 end
               end
             end
@@ -1558,12 +1644,14 @@ describe Ably::Realtime::Channel, :event_machine do
 
           context 'with a valid client_id' do
             it 'succeeds' do
-              channel.publish([name: 'event', client_id: 'valid']).tap do |deferrable|
-                deferrable.errback { raise 'Should have succeeded' }
-              end
-              channel.subscribe('event') do |message|
-                expect(message.client_id).to eql('valid')
-                EM.add_timer(0.5) { stop_reactor }
+              connection.once :connected do
+                channel.publish([name: 'event', client_id: 'valid']).tap do |deferrable|
+                  deferrable.errback { raise 'Should have succeeded' }
+                end
+                channel.subscribe('event') do |message|
+                  expect(message.client_id).to eql('valid')
+                  EM.add_timer(0.5) { stop_reactor }
+                end
               end
             end
           end
@@ -1584,12 +1672,14 @@ describe Ably::Realtime::Channel, :event_machine do
 
           context 'with an empty client_id in the message' do
             it 'succeeds and publishes with an implicit client_id' do
-              channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
-                deferrable.errback { raise 'Should have succeeded' }
-              end
-              channel.subscribe('event') do |message|
-                expect(message.client_id).to eql('valid')
-                EM.add_timer(0.5) { stop_reactor }
+              connection.once :connected do
+                channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
+                  deferrable.errback { raise 'Should have succeeded' }
+                end
+                channel.subscribe('event') do |message|
+                  expect(message.client_id).to eql('valid')
+                  EM.add_timer(0.5) { stop_reactor }
+                end
               end
             end
           end
@@ -1617,12 +1707,14 @@ describe Ably::Realtime::Channel, :event_machine do
 
           context 'with an empty client_id in the message' do
             it 'succeeds and publishes with an implicit client_id' do
-              channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
-                deferrable.errback { raise 'Should have succeeded' }
-              end
-              channel.subscribe('event') do |message|
-                expect(message.client_id).to be_nil
-                EM.add_timer(0.5) { stop_reactor }
+              connection.once :connected do
+                channel.publish([name: 'event', client_id: nil]).tap do |deferrable|
+                  deferrable.errback { raise 'Should have succeeded' }
+                end
+                channel.subscribe('event') do |message|
+                  expect(message.client_id).to be_nil
+                  EM.add_timer(0.5) { stop_reactor }
+                end
               end
             end
           end
@@ -1766,18 +1858,20 @@ describe Ably::Realtime::Channel, :event_machine do
         let(:exception) { StandardError.new("Intentional error") }
 
         it 'logs the error and continues' do
-          emitted_exception = false
-          expect(client.logger).to receive(:error) do |*args, &block|
-            expect(args.concat([block ? block.call : nil]).join(',')).to match(/#{exception.message}/)
-          end
-          channel.subscribe('click') do |message|
-            emitted_exception = true
-            raise exception
-          end
-          channel.publish('click', 'data') do
-            EventMachine.add_timer(1) do
-              expect(emitted_exception).to eql(true)
-              stop_reactor
+          connection.once :connected do
+            emitted_exception = false
+            expect(client.logger).to receive(:error) do |*args, &block|
+              expect(args.concat([block ? block.call : nil]).join(',')).to match(/#{exception.message}/)
+            end
+            channel.subscribe('click') do |message|
+              emitted_exception = true
+              raise exception
+            end
+            channel.publish('click', 'data') do
+              EventMachine.add_timer(1) do
+                expect(emitted_exception).to eql(true)
+                stop_reactor
+              end
             end
           end
         end
@@ -1785,19 +1879,21 @@ describe Ably::Realtime::Channel, :event_machine do
 
       context 'many times with different event names' do
         it 'filters events accordingly to each callback' do
-          click_callback = lambda { |message| messages << message }
+          connection.once :connected do
+            click_callback = lambda { |message| messages << message }
 
-          channel.subscribe('click', &click_callback)
-          channel.subscribe('move', &click_callback)
-          channel.subscribe('press', &click_callback)
+            channel.subscribe('click', &click_callback)
+            channel.subscribe('move', &click_callback)
+            channel.subscribe('press', &click_callback)
 
-          channel.attach do
-            channel.publish('click', 'data')
-            channel.publish('move', 'data')
-            channel.publish('press', 'data') do
-              EventMachine.add_timer(2) do
-                expect(messages.count).to eql(3)
-                stop_reactor
+            channel.attach do
+              channel.publish('click', 'data')
+              channel.publish('move', 'data')
+              channel.publish('press', 'data') do
+                EventMachine.add_timer(2) do
+                  expect(messages.count).to eql(3)
+                  stop_reactor
+                end
               end
             end
           end
@@ -1808,12 +1904,14 @@ describe Ably::Realtime::Channel, :event_machine do
     describe '#unsubscribe' do
       context 'with an event argument' do
         it 'unsubscribes for a single event' do
-          channel.subscribe('click') { raise 'Should not have been called' }
-          channel.unsubscribe('click')
+          connection.once :connected do
+            channel.subscribe('click') { raise 'Should not have been called' }
+            channel.unsubscribe('click')
 
-          channel.publish('click', 'data') do
-            EventMachine.add_timer(1) do
-              stop_reactor
+            channel.publish('click', 'data') do
+              EventMachine.add_timer(1) do
+                stop_reactor
+              end
             end
           end
         end
@@ -1821,12 +1919,14 @@ describe Ably::Realtime::Channel, :event_machine do
 
       context 'with no event argument' do
         it 'unsubscribes for a single event' do
-          channel.subscribe { raise 'Should not have been called' }
-          channel.unsubscribe
+          connection.once :connected do
+            channel.subscribe { raise 'Should not have been called' }
+            channel.unsubscribe
 
-          channel.publish('click', 'data') do
-            EventMachine.add_timer(1) do
-              stop_reactor
+            channel.publish('click', 'data') do
+              EventMachine.add_timer(1) do
+                stop_reactor
+              end
             end
           end
         end
@@ -1861,33 +1961,37 @@ describe Ably::Realtime::Channel, :event_machine do
 
         context 'an :attached channel' do
           it 'transitions state to :failed (#RTL3a)' do
-            channel.attach do
-              channel.on(:failed) do |connection_state_change|
-                error = connection_state_change.reason
-                expect(error).to be_a(Ably::Exceptions::ConnectionFailed)
-                expect(error.code).to eql(50000)
-                stop_reactor
+            connection.once :connected do
+              channel.attach do
+                channel.on(:failed) do |connection_state_change|
+                  error = connection_state_change.reason
+                  expect(error).to be_a(Ably::Exceptions::ConnectionFailed)
+                  expect(error.code).to eql(50000)
+                  stop_reactor
+                end
+                fake_error connection_error
               end
-              fake_error connection_error
             end
           end
 
           it 'updates the channel error_reason (#RTL3a)' do
-            channel.attach do
-              channel.on(:failed) do |connection_state_change|
-                error = connection_state_change.reason
-                expect(error).to be_a(Ably::Exceptions::ConnectionFailed)
-                expect(error.code).to eql(50000)
-                stop_reactor
+            connection.once :connected do
+              channel.attach do
+                channel.on(:failed) do |connection_state_change|
+                  error = connection_state_change.reason
+                  expect(error).to be_a(Ably::Exceptions::ConnectionFailed)
+                  expect(error.code).to eql(50000)
+                  stop_reactor
+                end
+                fake_error connection_error
               end
-              fake_error connection_error
             end
           end
         end
 
         context 'a :detached channel' do
           it 'remains in the :detached state (#RTL3a)' do
-            channel.attach do
+            channel.once :attached do
               channel.on(:failed) { raise 'Failed state should not have been reached' }
 
               channel.detach do
@@ -1899,6 +2003,10 @@ describe Ably::Realtime::Channel, :event_machine do
                 fake_error connection_error
               end
             end
+
+            connection.once :connected do
+              channel.attach
+            end
           end
         end
 
@@ -1906,20 +2014,22 @@ describe Ably::Realtime::Channel, :event_machine do
           let(:original_error) { RuntimeError.new }
 
           it 'remains in the :failed state and ignores the failure error (#RTL3a)' do
-            channel.attach do
-              channel.on(:failed) do
-                channel.on(:failed) { raise 'Failed state should not have been reached' }
+            connection.once :connected do
+              channel.attach do
+                channel.on(:failed) do
+                  channel.on(:failed) { raise 'Failed state should not have been reached' }
 
-                EventMachine.add_timer(1) do
-                  expect(channel).to be_failed
-                  expect(channel.error_reason).to eql(original_error)
-                  stop_reactor
+                  EventMachine.add_timer(1) do
+                    expect(channel).to be_failed
+                    expect(channel.error_reason).to eql(original_error)
+                    stop_reactor
+                  end
+
+                  fake_error connection_error
                 end
 
-                fake_error connection_error
+                channel.transition_state_machine :failed, reason: original_error
               end
-
-              channel.transition_state_machine :failed, reason: original_error
             end
           end
         end
@@ -1942,11 +2052,13 @@ describe Ably::Realtime::Channel, :event_machine do
       context ':closed' do
         context 'an :attached channel' do
           it 'transitions state to :detached (#RTL3b)' do
-            channel.attach do
-              channel.on(:detached) do
-                stop_reactor
+            connection.once :connected do
+              channel.attach do
+                channel.on(:detached) do
+                  stop_reactor
+                end
+                client.connection.close
               end
-              client.connection.close
             end
           end
         end
@@ -1962,13 +2074,15 @@ describe Ably::Realtime::Channel, :event_machine do
               closed_message = Ably::Models::ProtocolMessage.new(action: 8) # CLOSED
               client.connection.__incoming_protocol_msgbus__.publish :protocol_message, closed_message
             end
-            channel.attach
+            connection.once :connected do
+              channel.attach
+            end
           end
         end
 
         context 'a :detached channel' do
           it 'remains in the :detached state (#RTL3b)' do
-            channel.attach do
+            channel.once :attached do
               channel.detach do
                 channel.on(:detached) { raise 'Detached state should not have been reached' }
 
@@ -1980,6 +2094,9 @@ describe Ably::Realtime::Channel, :event_machine do
                 client.connection.close
               end
             end
+            connection.once :connected do
+              channel.attach
+            end
           end
         end
 
@@ -1988,20 +2105,22 @@ describe Ably::Realtime::Channel, :event_machine do
           let(:original_error) { Ably::Models::ErrorInfo.new(message: 'Error') }
 
           it 'remains in the :failed state and retains the error_reason (#RTL3b)' do
-            channel.attach do
-              channel.once(:failed) do
-                channel.on(:detached) { raise 'Detached state should not have been reached' }
+            connection.on :connected do
+              channel.attach do
+                channel.once(:failed) do
+                  channel.on(:detached) { raise 'Detached state should not have been reached' }
 
-                EventMachine.add_timer(1) do
-                  expect(channel).to be_failed
-                  expect(channel.error_reason).to eql(original_error)
-                  stop_reactor
+                  EventMachine.add_timer(1) do
+                    expect(channel).to be_failed
+                    expect(channel.error_reason).to eql(original_error)
+                    stop_reactor
+                  end
+
+                  client.connection.close
                 end
 
-                client.connection.close
+                channel.transition_state_machine :failed, reason: original_error
               end
-
-              channel.transition_state_machine :failed, reason: original_error
             end
           end
         end
@@ -2046,23 +2165,26 @@ describe Ably::Realtime::Channel, :event_machine do
                 client.connection.transition_state_machine :suspended
               end
             end
-            channel.attach
+              channel.attach
           end
         end
 
         context 'an :attached channel' do
           it 'transitions state to :suspended (#RTL3c)' do
-            channel.attach do
+            channel.once :attached do
               channel.on(:suspended) do
                 stop_reactor
               end
               client.connection.transition_state_machine :suspended
             end
+            connection.once :connected do
+              channel.attach
+            end
           end
 
           describe 'reattaching (#RTN15c3)' do
             it 'transitions state automatically to :attaching once the connection is re-established ' do
-              channel.attach do
+              channel.once :attached do
                 channel.on(:suspended) do
                   client.connection.connect
                   channel.once(:attached) do
@@ -2071,10 +2193,13 @@ describe Ably::Realtime::Channel, :event_machine do
                 end
                 client.connection.transition_state_machine :suspended
               end
+              connection.once :connected do
+                channel.attach
+              end
             end
 
             it 'sends ATTACH_RESUME flag when reattaching (RTL4j)' do
-              channel.attach do
+              channel.once :attached do
                 channel.on(:suspended) do
                   client.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
                     next if protocol_message.action != :attach
@@ -2087,13 +2212,16 @@ describe Ably::Realtime::Channel, :event_machine do
                 end
                 client.connection.transition_state_machine :suspended
               end
+              connection.once :connected do
+                channel.attach
+              end
             end
           end
         end
 
         context 'a :detached channel' do
           it 'remains in the :detached state (#RTL3c)' do
-            channel.attach do
+            channel.once :attached do
               channel.detach do
                 channel.on(:detached) { raise 'Detached state should not have been reached' }
 
@@ -2105,6 +2233,9 @@ describe Ably::Realtime::Channel, :event_machine do
                 client.connection.transition_state_machine :suspended
               end
             end
+            connection.once :connected do
+              channel.attach
+            end
           end
         end
 
@@ -2113,20 +2244,22 @@ describe Ably::Realtime::Channel, :event_machine do
           let(:client_options) { default_options.merge(log_level: :fatal) }
 
           it 'remains in the :failed state and retains the error_reason (#RTL3c)' do
-            channel.attach do
-              channel.once(:failed) do
-                channel.on(:detached) { raise 'Detached state should not have been reached' }
+            connection.once :connected do
+              channel.attach do
+                channel.once(:failed) do
+                  channel.on(:detached) { raise 'Detached state should not have been reached' }
 
-                EventMachine.add_timer(1) do
-                  expect(channel).to be_failed
-                  expect(channel.error_reason).to eql(original_error)
-                  stop_reactor
+                  EventMachine.add_timer(1) do
+                    expect(channel).to be_failed
+                    expect(channel.error_reason).to eql(original_error)
+                    stop_reactor
+                  end
+
+                  client.connection.transition_state_machine :suspended
                 end
 
-                client.connection.transition_state_machine :suspended
+                channel.transition_state_machine :failed, reason: original_error
               end
-
-              channel.transition_state_machine :failed, reason: original_error
             end
           end
         end
@@ -2151,14 +2284,16 @@ describe Ably::Realtime::Channel, :event_machine do
       context ':connected' do
         context 'a :suspended channel' do
           it 'is automatically reattached (#RTL3d)' do
-            channel.attach do
-              channel.once(:suspended) do
-                client.connection.connect
-                channel.once(:attached) do
-                  stop_reactor
+            connection.once :connected do
+              channel.attach do
+                channel.once(:suspended) do
+                  client.connection.connect
+                  channel.once(:attached) do
+                    stop_reactor
+                  end
                 end
+                client.connection.transition_state_machine :suspended
               end
-              client.connection.transition_state_machine :suspended
             end
           end
 
@@ -2168,29 +2303,32 @@ describe Ably::Realtime::Channel, :event_machine do
             end
 
             it 'returns to a suspended state (#RTL3d)' do
-              channel.attach do
-                channel.once(:attached) do
-                  fail "Channel should not have become attached"
-                end
+              connection.once :connected do
+                channel.attach do
+                  channel.once(:attached) do
+                    fail "Channel should not have become attached"
+                  end
 
-                channel.once(:suspended) do
-                  client.connection.connect
-                  channel.once(:attaching) do
-                    # don't process any incoming ProtocolMessages so the connection never opens
-                    client.connection.__incoming_protocol_msgbus__.unsubscribe
-                    channel.once(:suspended) do |state_change|
-                      expect(state_change.reason.code).to eql(90007)
-                      stop_reactor
+                  channel.once(:suspended) do
+                    client.connection.connect
+                    channel.once(:attaching) do
+                      # don't process any incoming ProtocolMessages so the connection never opens
+                      client.connection.__incoming_protocol_msgbus__.unsubscribe
+                      channel.once(:suspended) do |state_change|
+                        expect(state_change.reason.code).to eql(90007)
+                        stop_reactor
+                      end
                     end
                   end
+                  client.connection.transition_state_machine :suspended
                 end
-                client.connection.transition_state_machine :suspended
               end
             end
           end
         end
       end
 
+
       context ':disconnected' do
         context 'with an initialized channel' do
           it 'has no effect on the channel states (#RTL3e)' do
@@ -2222,25 +2360,31 @@ describe Ably::Realtime::Channel, :event_machine do
 
         context 'with an attached channel' do
           it 'has no effect on the channel states (#RTL3e)' do
-            channel.attach do
+            channel.once :attached do
               connection.once(:disconnected) do
                 expect(channel).to be_attached
                 stop_reactor
               end
               disconnect_transport
             end
+
+            connection.once :connected do
+              channel.attach
+            end
           end
         end
 
         context 'with a detached channel' do
           it 'has no effect on the channel states (#RTL3e)' do
-            channel.attach do
-              channel.detach do
-                connection.once(:disconnected) do
-                  expect(channel).to be_detached
-                  stop_reactor
+            connection.once :connected do
+              channel.attach do
+                channel.detach do
+                  connection.once(:disconnected) do
+                    expect(channel).to be_detached
+                    stop_reactor
+                  end
+                  disconnect_transport
                 end
-                disconnect_transport
               end
             end
           end
@@ -2288,12 +2432,12 @@ describe Ably::Realtime::Channel, :event_machine do
 
       shared_examples 'an update that sends ATTACH message' do |state, flags|
         it 'sends an ATTACH message on options change' do
-          attach_sent = nil
+          attach_sent_with_flags_set_via_channel_options = nil
 
           client.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
             if protocol_message.action == :attach && protocol_message.flags.nonzero?
-              attach_sent = true
               expect(protocol_message.flags).to eq(flags)
+              attach_sent_with_flags_set_via_channel_options = true
             end
           end
 
@@ -2302,10 +2446,7 @@ describe Ably::Realtime::Channel, :event_machine do
           end
 
           channel.on(:attached) do
-            client.connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
-              next if protocol_message.action != :attached
-
-              expect(attach_sent).to eq(true)
+            wait_until(lambda { attach_sent_with_flags_set_via_channel_options }) do
               stop_reactor
             end
           end
@@ -2318,7 +2459,7 @@ describe Ably::Realtime::Channel, :event_machine do
         it_behaves_like 'an update that sends ATTACH message', :attaching, build_flags(%i[subscribe])
       end
 
-      context 'when channel is attaching' do
+      context 'when channel is attached' do
         it_behaves_like 'an update that sends ATTACH message', :attached, build_flags(%i[resume subscribe])
       end
 
@@ -2389,8 +2530,10 @@ describe Ably::Realtime::Channel, :event_machine do
             expect(channel_state_change.reason).to be_nil
             stop_reactor
           end
-          channel.attach do
-            channel.detach
+          connection.once :connected do
+            channel.attach do
+              channel.detach
+            end
           end
         end
 
@@ -2426,7 +2569,7 @@ describe Ably::Realtime::Channel, :event_machine do
               connection_id = client.connection.id
               expect(channel_state_change.resumed).to be_falsey
 
-              recover_client = auto_close Ably::Realtime::Client.new(client_options.merge(recover: client.connection.recovery_key))
+              recover_client = auto_close Ably::Realtime::Client.new(client_options.merge(recover: client.connection.create_recovery_key))
               recover_client.connection.once(:connected) do
                 expect(recover_client.connection.id).to eql(connection_id)
                 recover_channel = recover_client.channels.get(channel_name)
@@ -2441,7 +2584,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
           it 'is false when a connection fails to recover and the channel is attached' do
             client.connection.once(:connected) do
-              recovery_key = client.connection.recovery_key
+              recovery_key = client.connection.create_recovery_key
               client.connection.once(:closed) do
                 recover_client = auto_close Ably::Realtime::Client.new(client_options.merge(recover: recovery_key, log_level: :error))
                 recover_client.connection.once(:connected) do
@@ -2458,11 +2601,11 @@ describe Ably::Realtime::Channel, :event_machine do
             end
           end
 
-          context 'when a resume fails' do
+          context 'when a connection resume fails' do
             let(:client_options) { default_options.merge(log_level: :error) }
 
-            it 'is false when a resume fails to recover and the channel is automatically re-attached' do
-              channel.attach do
+            it 'is false when channel_serial goes nil (RTP5a1) and the channel is automatically re-attached' do
+              channel.once :attached do
                 connection_id = client.connection.id
                 channel.once(:attached) do |channel_state_change|
                   expect(client.connection.id).to_not eql(connection_id)
@@ -2470,7 +2613,29 @@ describe Ably::Realtime::Channel, :event_machine do
                   stop_reactor
                 end
                 client.connection.transport.close_connection_after_writing
-                client.connection.configure_new '0123456789abcdef', 'wVIsgTHAB1UvXh7z-1991d8586', -1 # force the resume connection key to be invalid
+                channel.properties.channel_serial = nil
+                client.connection.configure_new '0123456789abcdef', 'wVIsgTHAB1UvXh7z-1991d8586' # force the resume connection key to be invalid
+              end
+
+              connection.once :connected do
+                channel.attach
+              end
+            end
+
+            it 'is true when channel_serial is intact and the channel is automatically re-attached' do
+              channel.once :attached do
+                connection_id = client.connection.id
+                channel.once(:attached) do |channel_state_change|
+                  expect(client.connection.id).to_not eql(connection_id)
+                  expect(channel_state_change.resumed).to be_truthy
+                  stop_reactor
+                end
+                client.connection.transport.close_connection_after_writing
+                client.connection.configure_new '0123456789abcdef', 'wVIsgTHAB1UvXh7z-1991d8586' # force the resume connection key to be invalid
+              end
+
+              connection.once :connected do
+                channel.attach
               end
             end
           end
@@ -2601,7 +2766,9 @@ describe Ably::Realtime::Channel, :event_machine do
             client.connection.__incoming_protocol_msgbus__.publish :protocol_message, detach_message
           end
 
-          channel.attach
+          connection.once :connected do
+            channel.attach
+          end
         end
       end
 
@@ -2632,26 +2799,30 @@ describe Ably::Realtime::Channel, :event_machine do
             client.connection.__incoming_protocol_msgbus__.publish :protocol_message, detach_message
           end
 
-          channel.attach
+          connection.once :connected do
+            channel.attach
+          end
         end
 
         context 'when connection is no longer connected' do
           it 'will not attempt to reattach (#RTL13c)' do
-            channel.attach do
-              connection.once(:closing) do
-                channel.once(:attaching) do |state_change|
-                  raise 'Channel should not attempt to reattach'
+            connection.once :connected do
+              channel.attach do
+                connection.once(:closing) do
+                  channel.once(:attaching) do |state_change|
+                    raise 'Channel should not attempt to reattach'
+                  end
+
+                  channel.transition_state_machine! :suspended
                 end
 
-                channel.transition_state_machine! :suspended
-              end
+                connection.once(:closed) do
+                  expect(channel).to be_suspended
+                  stop_reactor
+                end
 
-              connection.once(:closed) do
-                expect(channel).to be_suspended
-                stop_reactor
+                connection.close
               end
-
-              connection.close
             end
           end
         end
@@ -2672,35 +2843,36 @@ describe Ably::Realtime::Channel, :event_machine do
               end
             end
             prevent_protocol_messages_proc.call
-          end
 
-          channel.once(:attaching) do
-            attaching_at = Time.now
-            # First attaching fails during server-initiated ATTACHED received
-            channel.once(:suspended) do |state_change|
-              expect(Time.now.to_i - attaching_at.to_i).to be_within(1).of(1)
-
-              suspended_at = Time.now
-              # Automatic attach happens at channel_retry_timeout
-              channel.once(:attaching) do
-                expect(Time.now.to_i - attaching_at.to_i).to be_within(1).of(2)
-                channel.once(:suspended) do
-                  channel.once(:attaching) do
-                    channel.once(:attached) do
-                      stop_reactor
+            channel.once(:attaching) do
+              attaching_at = Time.now
+              # First attaching fails during server-initiated ATTACHED received
+              channel.once(:suspended) do |state_change|
+                expect(Time.now.to_i - attaching_at.to_i).to be_within(1).of(1)
+
+                suspended_at = Time.now
+                # Automatic attach happens at channel_retry_timeout
+                channel.once(:attaching) do
+                  expect(Time.now.to_i - attaching_at.to_i).to be_within(1).of(2)
+                  channel.once(:suspended) do
+                    channel.once(:attaching) do
+                      channel.once(:attached) do
+                        stop_reactor
+                      end
+                      # Simulate ATTACHED from Ably
+                      attached_message = Ably::Models::ProtocolMessage.new(action: 11, channel: channel_name) # ATTACHED
+                      client.connection.__incoming_protocol_msgbus__.publish :protocol_message, attached_message
                     end
-                    # Simulate ATTACHED from Ably
-                    attached_message = Ably::Models::ProtocolMessage.new(action: 11, channel: channel_name) # ATTACHED
-                    client.connection.__incoming_protocol_msgbus__.publish :protocol_message, attached_message
                   end
                 end
               end
+
+              detach_message = Ably::Models::ProtocolMessage.new(action: detached_action, channel: channel_name)
+              client.connection.__incoming_protocol_msgbus__.publish :protocol_message, detach_message
             end
 
-            detach_message = Ably::Models::ProtocolMessage.new(action: detached_action, channel: channel_name)
-            client.connection.__incoming_protocol_msgbus__.publish :protocol_message, detach_message
+            channel.attach
           end
-          channel.attach
         end
       end
     end
@@ -2709,14 +2881,16 @@ describe Ably::Realtime::Channel, :event_machine do
       let(:client_options) { default_options.merge(log_level: :fatal) }
 
       it 'should transition to the failed state and the error_reason should be set (#RTL14)' do
-        channel.attach do
-          channel.once(:failed) do |state_change|
-            expect(state_change.reason.code).to eql(50505)
-            expect(channel.error_reason.code).to eql(50505)
-            stop_reactor
+        connection.once :connected do
+          channel.attach do
+            channel.once(:failed) do |state_change|
+              expect(state_change.reason.code).to eql(50505)
+              expect(channel.error_reason.code).to eql(50505)
+              stop_reactor
+            end
+            error_message = Ably::Models::ProtocolMessage.new(action: 9, channel: channel_name, error: { code: 50505 }) # ProtocolMessage ERROR type
+            client.connection.__incoming_protocol_msgbus__.publish :protocol_message, error_message
           end
-          error_message = Ably::Models::ProtocolMessage.new(action: 9, channel: channel_name, error: { code: 50505 }) # ProtocolMessage ERROR type
-          client.connection.__incoming_protocol_msgbus__.publish :protocol_message, error_message
         end
       end
     end