ably-rest 1.1.0 → 1.1.2.rc1

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

@@ -112,22 +112,26 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
 
       context 'in multiple ProtocolMessages', em_timeout: (30 / 10) + 5 do
         it 'retrieves limited history forwards with pagination' do
-          messages_sent.times do |index|
-            EventMachine.add_timer(index.to_f / rate_per_second) do
-              channel.publish('event', "history#{index}") do
-                next unless index == messages_sent - 1
-                ensure_message_history_direction_and_paging_is_correct :forwards
+          channel.attach do
+            messages_sent.times do |index|
+              EventMachine.add_timer(index.to_f / rate_per_second) do
+                channel.publish('event', "history#{index}") do
+                  next unless index == messages_sent - 1
+                  ensure_message_history_direction_and_paging_is_correct :forwards
+                end
               end
             end
           end
         end
 
         it 'retrieves limited history backwards with pagination' do
-          messages_sent.times.to_a.reverse.each do |index|
-            EventMachine.add_timer((messages_sent - index).to_f / rate_per_second) do
-              channel.publish('event', "history#{index}") do
-                next unless index == 0
-                ensure_message_history_direction_and_paging_is_correct :backwards if index == 0
+          channel.attach do
+            messages_sent.times.to_a.reverse.each do |index|
+              EventMachine.add_timer((messages_sent - index).to_f / rate_per_second) do
+                channel.publish('event', "history#{index}") do
+                  next unless index == 0
+                  ensure_message_history_direction_and_paging_is_correct :backwards if index == 0
+                end
               end
             end
           end
@@ -139,18 +143,20 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
         let(:messages_per_batch) { 10 }
 
         it 'return the same results with unique matching message IDs' do
-          batches.times do |batch|
-            EventMachine.add_timer(batch.to_f / batches.to_f) do
-              messages_per_batch.times { channel.publish('event', 'data') }
+          channel.attach do
+            batches.times do |batch|
+              EventMachine.add_timer(batch.to_f / batches.to_f) do
+                messages_per_batch.times { |index| channel.publish('event') }
+              end
             end
-          end
 
-          channel.subscribe('event') do |message|
-            messages << message
-            if messages.count == batches * messages_per_batch
-              channel.history do |page|
-                expect(page.items.map(&:id).sort).to eql(messages.map(&:id).sort)
-                stop_reactor
+            channel.subscribe('event') do |message|
+              messages << message
+              if messages.count == batches * messages_per_batch
+                channel.history do |page|
+                  expect(page.items.map(&:id).sort).to eql(messages.map(&:id).sort)
+                  stop_reactor
+                end
               end
             end
           end

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

@@ -279,8 +279,7 @@ describe Ably::Realtime::Channel, :event_machine do
             key: restricted_api_key,
             log_level: :fatal,
             use_token_auth: true,
-            # TODO: Use wildcard / default when intersection issue resolved, realtime#780
-            default_token_params: { capability: { "canpublish:foo" => ["publish"] } }
+            default_token_params: { capability: { "canpublish:foo" => ["*"] } }
           )
         end
         let(:restricted_client) do
@@ -1009,9 +1008,6 @@ describe Ably::Realtime::Channel, :event_machine do
 
             it 'publishes the message without a name attribute in the payload' do
               published = false
-              channel.publish(nil, data) do
-                published = true
-              end
 
               channel.subscribe do |message|
                 expect(message.name).to be_nil
@@ -1024,6 +1020,10 @@ describe Ably::Realtime::Channel, :event_machine do
                   end
                 end
               end
+
+              channel.publish(nil, data) do
+                published = true
+              end
             end
           end
 
@@ -1032,9 +1032,6 @@ describe Ably::Realtime::Channel, :event_machine do
 
             it 'publishes the message without a data attribute in the payload' do
               published = false
-              channel.publish(name, nil) do
-                published = true
-              end
 
               channel.subscribe do |message|
                 expect(message.data).to be_nil
@@ -1047,6 +1044,10 @@ describe Ably::Realtime::Channel, :event_machine do
                   end
                 end
               end
+
+              channel.publish(name, nil) do
+                published = true
+              end
             end
           end
 
@@ -1997,6 +1998,8 @@ describe Ably::Realtime::Channel, :event_machine do
         end
 
         context '#resume (#RTL2f)' do
+          let(:client_options) { default_options.merge(log_level: :fatal) }
+
           it 'is false when a channel first attaches' do
             channel.attach
             channel.on(:attached) do |channel_state_change|

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

@@ -315,8 +315,9 @@ describe Ably::Realtime::Client, :event_machine do
             expect(msg.data).to eql(data)
             stop_reactor
           end
+
+          subject.publish channel_name, event_name, data
         end
-        subject.publish channel_name, event_name, data
       end
 
       specify 'publishing does not result in a channel being created' do
@@ -341,8 +342,9 @@ describe Ably::Realtime::Client, :event_machine do
               expect(msg.extras).to eql(extras)
               stop_reactor
             end
+
+            subject.publish channel_name, event_name, {}, extras: extras
           end
-          subject.publish channel_name, event_name, {}, extras: extras
         end
       end
 
@@ -353,8 +355,9 @@ describe Ably::Realtime::Client, :event_machine do
             expect(msg.data).to eql(data)
             stop_reactor
           end
+
+          subject.publish channel_name, [message]
         end
-        subject.publish channel_name, [message]
       end
 
       specify 'publishing supports an array of Hash objects' do
@@ -364,8 +367,9 @@ describe Ably::Realtime::Client, :event_machine do
             expect(msg.data).to eql(data)
             stop_reactor
           end
+
+          subject.publish channel_name, [name: event_name, data: data]
         end
-        subject.publish channel_name, [name: event_name, data: data]
       end
 
       specify 'publishing on a closed connection fails' do

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
@@ -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,7 +987,7 @@ 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")
 
@@ -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/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))
@@ -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|