ably-rest 1.0.5 → 1.1.3

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

@@ -45,7 +45,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             connection.on(:failed) do |connection_state_change|
               error = connection_state_change.reason
               expect(connection.state).to eq(:failed)
-              # TODO: Check error type is a TokenNotFOund exception
+              # TODO: Check error type is a TokenNotFound exception
               expect(error.status).to eq(401)
               expect(error.code).to eq(40400) # not found
               stop_reactor
@@ -110,6 +110,72 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
               end
             end
           end
+
+          context 'request fails due to slow response and subsequent timeout', :webmock, em_timeout: (Ably::Rest::Client::HTTP_DEFAULTS.fetch(:request_timeout) + 5) * 2 do
+            let(:auth_url) { "http://#{random_str}.domain.will.be.stubbed/path" }
+            let(:client_options) { default_options.reject { |k, v| k == :key }.merge(auth_url: auth_url, log_level: :fatal) }
+
+            # Timeout +5 seconds, beyond default allowed timeout
+            before do
+              stub_request(:get, auth_url).
+                to_return do |request|
+                  sleep Ably::Rest::Client::HTTP_DEFAULTS.fetch(:request_timeout) + 5
+                  { status: [500, "Internal Server Error"] }
+                end
+            end
+
+            specify 'the connection moves to the disconnected state and tries again, returning again to the disconnected state (#RSA4c, #RSA4c1, #RSA4c2)' do
+              states = Hash.new { |hash, key| hash[key] = [] }
+
+              connection.once(:connected) { raise "Connection can never move to connected because of auth failures" }
+
+              connection.on do |connection_state|
+                states[connection_state.current.to_sym] << Time.now
+                if states[:disconnected].count == 2 && connection_state.current == :disconnected
+                  expect(connection.error_reason).to be_a(Ably::Exceptions::ConnectionError)
+                  expect(connection.error_reason.message).to match(/auth_url/)
+                  EventMachine.add_timer(2) do
+                    expect(states.keys).to include(:connecting, :disconnected)
+                    expect(states[:connecting].count).to eql(2)
+                    expect(states[:connected].count).to eql(0)
+                    stop_reactor
+                  end
+                end
+              end
+            end
+          end
+
+          context 'request fails once due to slow response but succeeds the second time' do
+            let(:auth_url) { "http://#{random_str}.domain.will.be.stubbed/path" }
+            let(:client_options) { default_options.reject { |k, v| k == :key }.merge(auth_url: auth_url, log_level: :fatal) }
+
+            # Timeout +5 seconds, beyond default allowed timeout
+            before do
+              token_response = Ably::Rest::Client.new(default_options).auth.request_token
+              WebMock.enable!
+
+              stub_request(:get, auth_url).
+                to_return do |request|
+                  sleep Ably::Rest::Client::HTTP_DEFAULTS.fetch(:request_timeout)
+                  { status: [500, "Internal Server Error"] }
+                end.then.
+                to_return(:status => 201, :body => token_response.to_json, :headers => { 'Content-Type' => 'application/json' })
+            end
+
+            specify 'the connection moves to the disconnected state and tries again, returning again to the disconnected state (#RSA4c, #RSA4c1, #RSA4c2)' do
+              states = Hash.new { |hash, key| hash[key] = [] }
+
+              connection.once(:connected) do
+                expect(states[:disconnected].count).to eql(1)
+                expect(states[:connecting].count).to eql(2)
+                stop_reactor
+              end
+
+              connection.on do |connection_state|
+                states[connection_state.current.to_sym] << Time.now
+              end
+            end
+          end
         end
 
         context 'existing CONNECTED connection' do
@@ -143,7 +209,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
       context 'with auth_callback' do
         context 'opening a new connection' do
           context 'when callback fails due to an exception' do
-            let(:client_options) { default_options.reject { |k, v| k == :key }.merge(auth_callback: Proc.new { raise "Cannot issue token" }, log_level: :fatal) }
+            let(:client_options) { default_options.reject { |k, v| k == :key }.merge(auth_callback: lambda { |token_params| raise "Cannot issue token" }, log_level: :fatal) }
 
             it 'the connection moves to the disconnected state and tries again, returning again to the disconnected state (#RSA4c, #RSA4c1, #RSA4c2)' do
               states = Hash.new { |hash, key| hash[key] = [] }
@@ -174,7 +240,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
                 use_token_auth: true,
                 log_level: :fatal)
               }
-              let(:auth_options) { { auth_callback: Proc.new { sleep 10 }, } }
+              let(:auth_options) { { auth_callback: lambda { |token_params| sleep 10 }, } }
 
               it 'the authorization request fails as configured in the realtime_request_timeout (#RSA4c, #RSA4c1, #RSA4c3)' do
                 connection.once(:connected) do
@@ -425,7 +491,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         let(:client_options) do
           default_options.merge(
             log_level: :none,
-            realtime_request_timeout: timeout
+            realtime_request_timeout: timeout,
           )
         end
 
@@ -514,6 +580,216 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           end
         end
 
+        context 'connection state freshness is monitored' do
+          it 'resumes connections when disconnected within the connection_state_ttl period (#RTN15g)' do
+            connection.once(:connected) do
+              connection_id = connection.id
+              reconnected_with_resume = false
+
+              # Make sure the next connect has the resume param
+              allow(EventMachine).to receive(:connect).and_wrap_original do |original, *args, &block|
+                url = args[4]
+                uri = URI.parse(url)
+                expect(CGI::parse(uri.query)['resume'][0]).to_not be_empty
+                reconnected_with_resume = true
+                original.call(*args, &block)
+              end
+
+              connection.once(:disconnected) do
+                disconnected_at = Time.now
+
+                connection.once(:connecting) do
+                  expect(Time.now.to_f - disconnected_at.to_f).to be < connection.connection_state_ttl
+                  connection.once(:connected) do |state_change|
+                    expect(connection.id).to eql(connection_id)
+                    expect(reconnected_with_resume).to be_truthy
+                    stop_reactor
+                  end
+                end
+              end
+
+              connection.transport.unbind
+            end
+          end
+
+          context 'when connection_state_ttl period has passed since being disconnected' do
+            let(:client_options) do
+              default_options.merge(
+                disconnected_retry_timeout: 4,
+                suspended_retry_timeout:    8,
+                max_connection_state_ttl:   2,
+              )
+            end
+
+            it 'clears the local connection state and uses a new connection when the connection_state_ttl period has passed (#RTN15g)' do
+              connection.once(:connected) do
+                connection_id = connection.id
+                resumed_with_clean_connection = false
+
+                connection.once(:disconnected) do
+                  disconnected_at = Time.now
+
+                  connection.once(:connecting) do
+                    connection.once(:disconnected) do
+                      # Make sure the next connect does not have the resume param
+                      allow(EventMachine).to receive(:connect).and_wrap_original do |original, *args, &block|
+                        url = args[4]
+                        uri = URI.parse(url)
+                        expect(CGI::parse(uri.query)['resume']).to be_empty
+                        resumed_with_clean_connection = true
+                        original.call(*args, &block)
+                      end
+
+                      allow(connection.details).to receive(:max_idle_interval).and_return(0)
+                      connection.__incoming_protocol_msgbus__.plugin_listeners
+
+                      connection.once(:connecting) do
+                        expect(Time.now.to_f - disconnected_at.to_f).to be > connection.connection_state_ttl
+                        connection.once(:connected) do |state_change|
+                          expect(connection.id).to_not eql(connection_id)
+                          expect(resumed_with_clean_connection).to be_truthy
+                          stop_reactor
+                        end
+                      end
+                    end
+
+                    # Disconnect the transport and trigger a new disconnected state
+                    wait_until(lambda { connection.transport }) do
+                      connection.transport.unbind
+                    end
+                  end
+
+                  connection.__incoming_protocol_msgbus__.unplug_listeners
+                end
+
+                connection.transport.unbind
+              end
+            end
+          end
+
+          context 'when connection_state_ttl period has passed since last activity on the connection' do
+            let(:client_options) do
+              default_options.merge(
+                max_connection_state_ttl: 2,
+              )
+            end
+
+            it 'does not clear the local connection state when the connection_state_ttl period has passed since last activity, but the idle timeout has not passed (#RTN15g1, #RTN15g2)' do
+              expect(connection.connection_state_ttl).to eql(client_options.fetch(:max_connection_state_ttl))
+
+              connection.once(:connected) do
+                connection_id = connection.id
+                resumed_connection = false
+
+                connection.once(:disconnected) do
+                  disconnected_at = Time.now
+
+                  allow(connection).to receive(:time_since_connection_confirmed_alive?).and_return(connection.connection_state_ttl + 1)
+
+                  # Make sure the next connect does not have the resume param
+                  allow(EventMachine).to receive(:connect).and_wrap_original do |original, *args, &block|
+                    url = args[4]
+                    uri = URI.parse(url)
+                    expect(CGI::parse(uri.query)['resume']).to_not be_empty
+                    resumed_connection = true
+                    original.call(*args, &block)
+                  end
+
+                  connection.once(:connecting) do
+                    connection.once(:connected) do |state_change|
+                      expect(connection.id).to eql(connection_id)
+                      expect(resumed_connection).to be_truthy
+                      stop_reactor
+                    end
+                  end
+                end
+
+                connection.transport.unbind
+              end
+            end
+
+            it 'clears the local connection state and uses a new connection when the connection_state_ttl + max_idle_interval period has passed since last activity (#RTN15g1, #RTN15g2)' do
+              expect(connection.connection_state_ttl).to eql(client_options.fetch(:max_connection_state_ttl))
+
+              connection.once(:connected) do
+                connection_id = connection.id
+                resumed_with_clean_connection = false
+
+                connection.once(:disconnected) do
+                  disconnected_at = Time.now
+
+                  pseudo_time_passed = connection.connection_state_ttl + connection.details.max_idle_interval + 1
+                  allow(connection).to receive(:time_since_connection_confirmed_alive?).and_return(pseudo_time_passed)
+
+                  # Make sure the next connect does not have the resume param
+                  allow(EventMachine).to receive(:connect).and_wrap_original do |original, *args, &block|
+                    url = args[4]
+                    uri = URI.parse(url)
+                    expect(CGI::parse(uri.query)['resume']).to be_empty
+                    resumed_with_clean_connection = true
+                    original.call(*args, &block)
+                  end
+
+                  connection.once(:connecting) do
+                    connection.once(:connected) do |state_change|
+                      expect(connection.id).to_not eql(connection_id)
+                      expect(resumed_with_clean_connection).to be_truthy
+                      stop_reactor
+                    end
+                  end
+                end
+
+                connection.transport.unbind
+              end
+            end
+
+            it 'still reattaches the channels automatically following a new connection being established (#RTN15g2)' do
+              connection.once(:connected) do
+                connection_id = connection.id
+                resumed_with_clean_connection = false
+                channel_emitted_an_attached = false
+
+                channel.attach do
+                  channel.once(:attached) do |channel_state_change|
+                    expect(channel_state_change.resumed).to be_falsey
+                    channel_emitted_an_attached = true
+                  end
+
+                  connection.once(:disconnected) do
+                    disconnected_at = Time.now
+
+                    pseudo_time_passed = connection.connection_state_ttl + connection.details.max_idle_interval + 1
+                    allow(connection).to receive(:time_since_connection_confirmed_alive?).and_return(pseudo_time_passed)
+
+                    # Make sure the next connect does not have the resume param
+                    allow(EventMachine).to receive(:connect).and_wrap_original do |original, *args, &block|
+                      url = args[4]
+                      uri = URI.parse(url)
+                      expect(CGI::parse(uri.query)['resume']).to be_empty
+                      resumed_with_clean_connection = true
+                      original.call(*args, &block)
+                    end
+
+                    connection.once(:connecting) do
+                      connection.once(:connected) do |state_change|
+                        expect(connection.id).to_not eql(connection_id)
+                        expect(resumed_with_clean_connection).to be_truthy
+
+                        wait_until(lambda { channel.attached? }) do
+                          expect(channel_emitted_an_attached).to be_truthy
+                          stop_reactor
+                        end
+                      end
+                    end
+                  end
+
+                  connection.transport.unbind
+                end
+              end
+            end
+          end
+        end
+
         context 'and subsequently fails to reconnect' do
           let(:retry_every) { 1.5 }
 
@@ -711,11 +987,11 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           end
         end
 
-        it 'retains the client_serial (#RTN15c2, #RTN15c3)' do
+        it 'retains the client_msg_serial (#RTN15c2, #RTN15c3)' do
           last_message = nil
           channel = client.channels.get("foo")
 
-          connection.once(:connected) do
+          channel.attach do
             connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
               if protocol_message.action == :message
                 last_message = protocol_message
@@ -893,7 +1169,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             end
           end
 
-          it 'resets the client_serial (#RTN15c3)' do
+          it 'continues to use the client_msg_serial (#RTN15c3)' do
             last_message = nil
             channel = client.channels.get("foo")
 
@@ -911,7 +1187,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
                   connection.once(:connected) do
                     channel.publish("first on new connection") do
                       # Message serial reset after failed resume
-                      expect(last_message.message_serial).to eql(0)
+                      expect(last_message.message_serial).to eql(2)
                       stop_reactor
                     end
                   end
@@ -935,16 +1211,20 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
               previous_connection_id  = connection.id
               previous_connection_key = connection.key
 
-              five_minutes_time = Time.now + 5 * 60
-              allow(Time).to receive(:now) { five_minutes_time }
-
               connection.once(:connected) do
                 expect(connection.key).to_not eql(previous_connection_key)
                 expect(connection.id).to_not eql(previous_connection_id)
                 stop_reactor
               end
 
-              kill_connection_transport_and_prevent_valid_resume
+              # Wait until next tick before stubbing otherwise liveness test may
+              # record the stubbed last contact time as the future time
+              EventMachine.next_tick do
+                five_minutes_time = Time.now + 5 * 60
+                allow(Time).to receive(:now) { five_minutes_time }
+
+                kill_connection_transport_and_prevent_valid_resume
+              end
             end
           end
         end
@@ -1017,7 +1297,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
           }
 
           let(:client_options) do
-            default_options.merge(auth_callback: Proc.new do
+            default_options.merge(auth_callback: lambda do |token_params|
               @auth_requests ||= 0
               @auth_requests += 1
 

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

@@ -27,6 +27,13 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
 
+      context 'current_host' do
+        it 'is available immediately after the client is instanced' do
+          expect(connection.current_host.to_s).to match(/\.ably\.io$/)
+          stop_reactor
+        end
+      end
+
       context 'with :auto_connect option set to false' do
         let(:client) do
           auto_close Ably::Realtime::Client.new(default_options.merge(auto_connect: false))
@@ -131,7 +138,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 let(:ttl) { 0.001 }
                 let(:auth_requests) { [] }
                 let(:token_callback) do
-                  Proc.new do
+                  lambda do |token_params|
                     auth_requests << Time.now
                     Ably::Rest::Client.new(default_options).auth.request_token(ttl: ttl).token
                   end
@@ -246,7 +253,7 @@ describe Ably::Realtime::Connection, :event_machine do
                   let(:ttl)           { 4 }
                   let(:auth_requests) { [] }
                   let(:token_callback) do
-                    Proc.new do
+                    lambda do |token_params|
                       sleep 2
                       auth_requests << Time.now
                       Ably::Rest::Client.new(default_options).auth.request_token(ttl: ttl).token
@@ -264,7 +271,7 @@ describe Ably::Realtime::Connection, :event_machine do
                     channel.subscribe('event') do |message|
                       messages_received << message.data.to_i
                       if messages_received.count == total_expected
-                        expect(messages_received).to match(total_expected.times)
+                        expect(messages_received).to match(total_expected.times.to_a)
                         expect(auth_requests.count).to eql(iteration + 1)
                         EventMachine.add_timer(1) do
                           channel.unsubscribe 'event'
@@ -298,7 +305,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 context 'and subsequent token is invalid' do
                   let(:ttl) { 2 }
                   let(:token_callback) do
-                    Proc.new do
+                    lambda do |token_params|
                       if @token_issued
                         "#{app_id}.invalid-token-invalid-token-invalid-token"
                       else
@@ -417,7 +424,7 @@ describe Ably::Realtime::Connection, :event_machine do
       let(:phases) { [:connecting, :connected] }
       let(:events_emitted) { [] }
       let(:test_expectation) do
-        Proc.new do
+        lambda do
           expect(events_emitted).to eq(phases)
           stop_reactor
         end
@@ -466,7 +473,7 @@ describe Ably::Realtime::Connection, :event_machine do
           been_disconnected = true
         end
         connection.once(:connecting) do
-          close_if_transport_available = proc do
+          close_if_transport_available = lambda do
             EventMachine.add_timer(0.001) do
               if connection.transport
                 connection.transport.close_connection_after_writing
@@ -649,16 +656,47 @@ describe Ably::Realtime::Connection, :event_machine do
       end
 
       it 'is set to 1 when the second message is received' do
-        channel.publish('event', 'data') do
-          channel.publish('event', 'data')
+        channel.attach do
+          messages = []
+          channel.subscribe do |message|
+            messages << message
+            if messages.length == 2
+              expect(connection.serial).to eql(1)
+              stop_reactor
+            end
+          end
+
+          channel.publish('event', 'data') do
+            channel.publish('event', 'data')
+          end
         end
+      end
+    end
 
-        messages = []
-        channel.subscribe do |message|
-          messages << message
-          if messages.length == 2
-            expect(connection.serial).to eql(1)
-            stop_reactor
+    describe '#msgSerial' do
+      context 'when messages are queued for publish before a connection is established' do
+        let(:batches) { 6 }
+        let(:messages_per_batch) { 10 }
+
+        let(:publishing_client)  { auto_close Ably::Realtime::Client.new(default_options) }
+        let(:channel_name)       { random_str }
+        let(:publishing_channel) { publishing_client.channels.get(channel_name) }
+        let(:receiving_channel)  { client.channels.get(channel_name) }
+
+        it 'the msgSerial is always incrementing (and not reset when the new connection is established) ensuring messages are never de-duped by the realtime service' do
+          messages = []
+
+          receiving_channel.attach do
+            receiving_channel.subscribe('event') do |message|
+              messages << message
+              stop_reactor if messages.count == batches * messages_per_batch
+            end
+
+            batches.times do |batch|
+              EventMachine.add_timer(batch.to_f / batches.to_f) do
+                messages_per_batch.times { |index| publishing_channel.publish('event') }
+              end
+            end
           end
         end
       end
@@ -796,7 +834,7 @@ describe Ably::Realtime::Connection, :event_machine do
             end
           end
 
-          ping_block = Proc.new do
+          ping_block = lambda do |time|
             pings_complete << true
             if pings_complete.length == 3
               expect(heartbeat_ids.uniq.length).to eql(3)
@@ -980,7 +1018,6 @@ describe Ably::Realtime::Connection, :event_machine do
 
       context 'transport-level heartbeats are supported in the websocket transport' do
         it 'provides the heartbeats argument in the websocket connection params (#RTN23b)' do
-          skip 'Native heartbeats not yet supported in the WS driver https://github.com/ably/ably-ruby/issues/116'
           expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
             uri = URI.parse(url)
             expect(CGI::parse(uri.query)['heartbeats'][0]).to eql('false')
@@ -990,12 +1027,10 @@ describe Ably::Realtime::Connection, :event_machine do
         end
 
         it 'receives websocket heartbeat messages (#RTN23b) [slow test as need to wait for heartbeat]', em_timeout: 45 do
-          skip "Heartbeats param is missing from realtime implementation, see https://github.com/ably/realtime/issues/656"
-
           connection.once(:connected) do
             connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
               if protocol_message.action == :heartbeat
-                expect(protocol_message.attributes[:source]).to eql('websocket')
+                expect(protocol_message.attributes[:source]).to eql(:websocket)
                 expect(connection.time_since_connection_confirmed_alive?).to be_within(1).of(0)
                 stop_reactor
               end
@@ -1008,10 +1043,9 @@ describe Ably::Realtime::Connection, :event_machine do
         let(:client_options) { default_options.merge(websocket_heartbeats_disabled: true) }
 
         it 'does not provide the heartbeats argument in the websocket connection params (#RTN23b)' do
-          skip 'Native heartbeats not yet supported in the WS driver https://github.com/ably/ably-ruby/issues/116'
           expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
             uri = URI.parse(url)
-            expect(CGI::parse(uri.query)['heartbeats'][0]).to be_nil
+            expect(CGI::parse(uri.query)['heartbeats'][0]).to eql('true')
             stop_reactor
           end
           client
@@ -1021,7 +1055,8 @@ describe Ably::Realtime::Connection, :event_machine do
           connection.once(:connected) do
             connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
               if protocol_message.action == :heartbeat
-                expect(protocol_message.attributes[:source]).to_not eql('websocket')
+                next if protocol_message.attributes[:source] == :websocket # ignore the native heartbeats
+                expect(protocol_message.attributes[:source]).to_not eql(:websocket)
                 expect(connection.time_since_connection_confirmed_alive?).to be_within(1).of(0)
                 stop_reactor
               end
@@ -1128,7 +1163,7 @@ describe Ably::Realtime::Connection, :event_machine do
                   expected_serial += 1 # attach message received
                   expect(connection.serial).to eql(expected_serial)
 
-                  expect(connection.recovery_key).to eql("#{connection.key}:#{connection.serial}")
+                  expect(connection.recovery_key).to eql("#{connection.key}:#{connection.serial}:#{connection.send(:client_msg_serial)}")
                   stop_reactor
                 end
               end
@@ -1176,24 +1211,18 @@ describe Ably::Realtime::Connection, :event_machine do
       end
 
       context "opening a new connection using a recently disconnected connection's #recovery_key" do
-        context 'connection#id and connection#key after recovery' do
-          it 'remains the same for id and party for key' do
-            connection_key_consistent_part_regex = /.*?!([\w-]{5,})-\w+/
+        context 'connection#id after recovery' do
+          it 'remains the same' do
             previous_connection_id  = nil
-            previous_connection_key = nil
 
             connection.once(:connected) do
               previous_connection_id  = connection.id
-              previous_connection_key = connection.key
               connection.transition_state_machine! :failed
             end
 
             connection.once(:failed) do
               recover_client = auto_close Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
               recover_client.connection.on(:connected) do
-                expect(recover_client.connection.key[connection_key_consistent_part_regex, 1]).to_not be_nil
-                expect(recover_client.connection.key[connection_key_consistent_part_regex, 1]).to eql(
-                  previous_connection_key[connection_key_consistent_part_regex, 1])
                 expect(recover_client.connection.id).to eql(previous_connection_id)
                 stop_reactor
               end
@@ -1245,6 +1274,80 @@ describe Ably::Realtime::Connection, :event_machine do
             end
           end
         end
+
+        context 'when messages have been published' do
+          describe 'the new connection' do
+            it 'uses the correct msgSerial from the old connection' do
+              msg_serial, recovery_key, connection_id = nil, nil, nil
+
+              channel.attach do
+                expect(connection.send(:client_msg_serial)).to eql(-1) # no messages published yet
+                connection_id = client.connection.id
+                connection.transport.__incoming_protocol_msgbus__
+                channel.publish('event', 'message') do
+                  msg_serial = connection.send(:client_msg_serial)
+                  expect(msg_serial).to eql(0)
+                  recovery_key = client.connection.recovery_key
+                  connection.transition_state_machine! :failed
+                end
+              end
+
+              connection.on(:failed) do
+                recover_client = auto_close Ably::Realtime::Client.new(default_options.merge(recover: recovery_key))
+                recover_client_channel = recover_client.channel(channel_name)
+                recover_client_channel.attach do
+                  expect(recover_client.connection.id).to eql(connection_id)
+                  expect(recover_client.connection.send(:client_msg_serial)).to eql(msg_serial)
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+
+        context 'when messages are published before the new connection is recovered' do
+          describe 'the new connection' do
+            it 'uses the correct msgSerial from the old connection for the queued messages' do
+              msg_serial, recovery_key, connection_id = nil, nil, nil
+
+              channel.attach do
+                expect(connection.send(:client_msg_serial)).to eql(-1) # no messages published yet
+                connection_id = client.connection.id
+                connection.transport.__incoming_protocol_msgbus__
+                channel.subscribe('event') do |message|
+                  expect(message.data).to eql('message-1')
+                  msg_serial = connection.send(:client_msg_serial)
+                  expect(msg_serial).to eql(0)
+                  recovery_key = client.connection.recovery_key
+                  connection.transition_state_machine! :failed
+                end
+                channel.publish('event', 'message-1')
+              end
+
+              connection.on(:failed) do
+                recover_client = auto_close Ably::Realtime::Client.new(default_options.merge(recover: recovery_key))
+                recover_client_channel = recover_client.channel(channel_name)
+                expect(recover_client.connection.send(:client_msg_serial)).to eql(msg_serial)
+
+                recover_client.connection.once(:connecting) do
+                  recover_client_channel.publish('event', 'message-2')
+                  expect(recover_client.connection.send(:client_msg_serial)).to eql(msg_serial + 1)
+                end
+
+                recover_client_channel.attach do
+                  expect(recover_client.connection.id).to eql(connection_id)
+
+                  recover_client_channel.subscribe do |message|
+                    expect(message.data).to eql('message-2')
+                    EventMachine.add_timer(2) do
+                      stop_reactor
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
       end
 
       context 'with :recover option' do
@@ -1258,7 +1361,7 @@ describe Ably::Realtime::Connection, :event_machine do
         end
 
         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) }
+          let(:client_options) { default_options.merge(recover: 'not-a-valid-connection-key:1:0', log_level: :none) }
 
           it 'sets the #error_reason and moves the connection to FAILED' do
             connection.once(:failed) do |state_change|
@@ -1273,7 +1376,7 @@ describe Ably::Realtime::Connection, :event_machine do
         end
 
         context 'with expired (missing) value sent to server' do
-          let(:client_options) { default_options.merge(recover: 'wVIsgTHAB1UvXh7z-1991d8586:0', log_level: :fatal) }
+          let(:client_options) { default_options.merge(recover: 'wVIsgTHAB1UvXh7z-1991d8586:0:0', log_level: :fatal) }
 
           it 'connects but sets the error reason and includes the reason in the state change' do
             connection.once(:connected) do |state_change|
@@ -1480,12 +1583,12 @@ describe Ably::Realtime::Connection, :event_machine do
           channel.attach do
             channel.once(:suspended) do
               channel.publish('test').errback do |error|
-                expect(error).to be_a(Ably::Exceptions::MessageQueueingDisabled)
+                expect(error).to be_a(Ably::Exceptions::ChannelInactive)
                 stop_reactor
               end
             end
 
-            close_connection_proc = Proc.new do
+            close_connection_proc = lambda do
               EventMachine.add_timer(0.001) do
                 if connection.transport.nil?
                   close_connection_proc.call
@@ -1523,7 +1626,7 @@ describe Ably::Realtime::Connection, :event_machine do
       # See https://github.com/ably/ably-ruby/issues/103
       it 'emits event to all and single subscribers' do
         connected_emitted = []
-        block = Proc.new do |state_change|
+        block = lambda do |state_change|
           if state_change.current == :connected
             connected_emitted << state_change
             EventMachine.add_timer(0.5) do
@@ -1740,7 +1843,7 @@ describe Ably::Realtime::Connection, :event_machine do
       it 'sends the protocol version param v (#G4, #RTN2f)' do
         expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
           uri = URI.parse(url)
-          expect(CGI::parse(uri.query)['v'][0]).to eql('1.0')
+          expect(CGI::parse(uri.query)['v'][0]).to eql('1.1')
           stop_reactor
         end
         client
@@ -1749,7 +1852,7 @@ describe Ably::Realtime::Connection, :event_machine do
       it 'sends the lib version param lib (#RTN2g)' do
         expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
           uri = URI.parse(url)
-          expect(CGI::parse(uri.query)['lib'][0]).to match(/^ruby-1\.0\.\d+(-[\w\.]+)?+$/)
+          expect(CGI::parse(uri.query)['lib'][0]).to match(/^ruby-1\.1\.\d+(-[\w\.]+)?+$/)
           stop_reactor
         end
         client
@@ -1769,7 +1872,7 @@ describe Ably::Realtime::Connection, :event_machine do
         it 'sends the lib version param lib with the variant (#RTN2g + #RSC7b)' do
           expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
             uri = URI.parse(url)
-            expect(CGI::parse(uri.query)['lib'][0]).to match(/^ruby-#{variant}-1\.0\.\d+(-[\w\.]+)?$/)
+            expect(CGI::parse(uri.query)['lib'][0]).to match(/^ruby-#{variant}-1\.1\.\d+(-[\w\.]+)?$/)
             stop_reactor
           end
           client