ably 1.0.7 → 1.1.4.rc

data/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
@@ -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
 
@@ -921,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
@@ -1103,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")
 
@@ -1121,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

data/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))
@@ -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'
@@ -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
@@ -1005,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
@@ -1126,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
@@ -1237,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
@@ -1250,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|
@@ -1265,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|
@@ -1472,7 +1583,7 @@ 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
@@ -1732,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
@@ -1741,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
@@ -1761,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

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
@@ -116,7 +115,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'Integer' do
         let(:data) { 1 }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
@@ -125,7 +124,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'Float' do
         let(:data) { 1.1 }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
@@ -134,7 +133,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'Boolean' do
         let(:data) { true }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
@@ -143,7 +142,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'False' do
         let(:data) { false }
 
-        it 'is raises an UnsupportedDataType 40011 exception' do
+        it 'is raises an UnsupportedDataType 40013 exception' do
           expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
           stop_reactor
         end
@@ -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
@@ -413,30 +414,32 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
           let(:encrypted_channel) { client.channel(channel_name, cipher: cipher_options) }
 
           it 'encrypts message automatically before they are pushed to the server (#RTL7d)' do
-            encrypted_channel.__incoming_msgbus__.unsubscribe # remove all subscribe callbacks that could decrypt the message
+            encrypted_channel.attach do
+              encrypted_channel.__incoming_msgbus__.unsubscribe # remove all subscribe callbacks that could decrypt the message
 
-            encrypted_channel.__incoming_msgbus__.subscribe(:message) do |message|
-              if protocol == :json
-                expect(message['encoding']).to eql(encrypted_encoding)
-                expect(message['data']).to eql(encrypted_data)
-              else
-                # Messages received over binary protocol will not have Base64 encoded data
-                expect(message['encoding']).to eql(encrypted_encoding.gsub(%r{/base64$}, ''))
-                expect(message['data']).to eql(encrypted_data_decoded)
+              encrypted_channel.__incoming_msgbus__.subscribe(:message) do |message|
+                if protocol == :json
+                  expect(message['encoding']).to eql(encrypted_encoding)
+                  expect(message['data']).to eql(encrypted_data)
+                else
+                  # Messages received over binary protocol will not have Base64 encoded data
+                  expect(message['encoding']).to eql(encrypted_encoding.gsub(%r{/base64$}, ''))
+                  expect(message['data']).to eql(encrypted_data_decoded)
+                end
+                stop_reactor
               end
-              stop_reactor
-            end
 
-            encrypted_channel.publish 'example', encoded_data_decoded
+              encrypted_channel.publish 'example', encoded_data_decoded
+            end
           end
 
           it 'sends and receives messages that are encrypted & decrypted by the Ably library (#RTL7d)' do
-            encrypted_channel.publish 'example', encoded_data_decoded
             encrypted_channel.subscribe do |message|
               expect(message.data).to eql(encoded_data_decoded)
               expect(message.encoding).to be_nil
               stop_reactor
             end
+            encrypted_channel.publish 'example', encoded_data_decoded
           end
         end
       end
@@ -654,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