ably-rest 0.8.5 → 0.8.6

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

@@ -53,7 +53,7 @@ describe Ably::Realtime::Client, :event_machine do
                 connection.on(:connected) do
                   expect(auth_params[:access_token]).to_not be_nil
                   expect(auth_params[:key]).to be_nil
-                  expect(subject.auth.current_token_details).to be_nil
+                  expect(subject.auth.current_token_details).to be_a(Ably::Models::TokenDetails)
                   stop_reactor
                 end
               end
@@ -113,6 +113,98 @@ describe Ably::Realtime::Client, :event_machine do
               stop_reactor
             end
           end
+
+          context 'when the returned token has a client_id' do
+            it "sets Auth#client_id to the new token's client_id immediately when connecting" do
+              subject.auth.authorise do
+                expect(subject.connection).to be_connecting
+                expect(subject.auth.client_id).to eql(client_id)
+                stop_reactor
+              end
+            end
+
+            it "sets Client#client_id to the new token's client_id immediately when connecting" do
+              subject.auth.authorise do
+                expect(subject.connection).to be_connecting
+                expect(subject.client_id).to eql(client_id)
+                stop_reactor
+              end
+            end
+          end
+
+          context 'with a wildcard client_id token' do
+            subject                 { auto_close Ably::Realtime::Client.new(client_options) }
+            let(:client_options)    { default_options.merge(auth_callback: Proc.new { auth_token_object }, client_id: client_id) }
+            let(:rest_auth_client)  { Ably::Rest::Client.new(default_options.merge(key: api_key)) }
+            let(:auth_token_object) { rest_auth_client.auth.request_token(client_id: '*') }
+
+            context 'and an explicit client_id in ClientOptions' do
+              let(:client_id) { random_str }
+
+              it 'allows uses the explicit client_id in the connection' do
+                connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                  if protocol_message.action == :connected
+                    expect(protocol_message.connection_details.client_id).to eql(client_id)
+                    @valid_client_id = true
+                  end
+                end
+                subject.connect do
+                  EM.add_timer(0.5) { stop_reactor if @valid_client_id }
+                end
+              end
+            end
+
+            context 'and client_id omitted in ClientOptions' do
+              let(:client_options) { default_options.merge(auth_callback: Proc.new { auth_token_object }) }
+
+              it 'uses the token provided clientId in the connection' do
+                connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                  if protocol_message.action == :connected
+                    expect(protocol_message.connection_details.client_id).to eql('*')
+                    @valid_client_id = true
+                  end
+                end
+                subject.connect do
+                  EM.add_timer(0.5) { stop_reactor if @valid_client_id }
+                end
+              end
+            end
+          end
+        end
+
+        context 'with an invalid wildcard "*" :client_id' do
+          it 'raises an exception' do
+            expect { Ably::Realtime::Client.new(client_options.merge(key: api_key, client_id: '*')) }.to raise_error ArgumentError
+            stop_reactor
+          end
+        end
+      end
+
+      context 'realtime connection settings' do
+        context 'defaults' do
+          specify 'disconnected_retry_timeout is 15s' do
+            expect(subject.connection.defaults[:disconnected_retry_timeout]).to eql(15)
+            stop_reactor
+          end
+
+          specify 'suspended_retry_timeout is 30s' do
+            expect(subject.connection.defaults[:suspended_retry_timeout]).to eql(30)
+            stop_reactor
+          end
+        end
+
+        context 'overriden in ClientOptions' do
+          let(:client_options) { default_options.merge(disconnected_retry_timeout: 1, suspended_retry_timeout: 2) }
+
+          specify 'disconnected_retry_timeout is updated' do
+            expect(subject.connection.defaults[:disconnected_retry_timeout]).to eql(1)
+            stop_reactor
+          end
+
+          specify 'suspended_retry_timeout is updated' do
+            expect(subject.connection.defaults[:suspended_retry_timeout]).to eql(2)
+            stop_reactor
+          end
         end
       end
     end

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

@@ -53,19 +53,17 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
     end
 
     context 'automatic connection retry' do
-      let(:client_failure_options) { default_options.merge(log_level: :none) }
-
       context 'with invalid WebSocket host' do
         let(:retry_every_for_tests)       { 0.2 }
         let(:max_time_in_state_for_tests) { 0.6 }
 
-        before do
-          # Reconfigure client library retry periods and timeouts so that tests run quickly
-          stub_const 'Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG',
-                      Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG.merge(
-                        disconnected: { retry_every: retry_every_for_tests, max_time_in_state: max_time_in_state_for_tests },
-                        suspended:    { retry_every: retry_every_for_tests, max_time_in_state: max_time_in_state_for_tests },
-                      )
+        let(:client_failure_options) do
+          default_options.merge(
+            log_level: :none,
+            disconnected_retry_timeout: retry_every_for_tests,
+            suspended_retry_timeout:    retry_every_for_tests,
+            connection_state_ttl:       max_time_in_state_for_tests
+          )
         end
 
         # retry immediately after failure, then one retry every :retry_every_for_tests
@@ -110,6 +108,27 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             end
           end
 
+          context 'for the first time' do
+            let(:client_options) do
+              default_options.merge(realtime_host: 'non.existent.host', disconnected_retry_timeout: 2, log_level: :error)
+            end
+
+            it 'reattempts connection immediately and then waits disconnected_retry_timeout for a subsequent attempt' do
+              expect(connection.defaults[:disconnected_retry_timeout]).to eql(2)
+              connection.once(:disconnected) do
+                started_at = Time.now.to_f
+                connection.once(:disconnected) do
+                  expect(Time.now.to_f - started_at).to be < 1
+                  started_at = Time.now.to_f
+                  connection.once(:disconnected) do
+                    expect(Time.now.to_f - started_at).to be > 2
+                    stop_reactor
+                  end
+                end
+              end
+            end
+          end
+
           describe '#close' do
             it 'transitions connection state to :closed' do
               connection.on(:connected) { raise 'Connection should not have reached :connected state' }
@@ -130,25 +149,50 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         end
 
         context 'when connection state is :suspended' do
-          it 'enters the failed state after multiple attempts if the max_time_in_state is set' do
+          it 'stays in the suspended state after any number of reconnection attempts' do
             connection.on(:connected) { raise 'Connection should not have reached :connected state' }
 
             connection.once(:suspended) do
               count_state_changes && start_timer
 
-              connection.on(:failed) do
-                expect(connection.state).to eq(:failed)
+              EventMachine.add_timer((retry_every_for_tests + 0.1) * 10) do
+                expect(connection.state).to eq(:suspended)
 
-                expect(state_changes[:connecting]).to   eql(expected_retry_attempts)
-                expect(state_changes[:suspended]).to    eql(expected_retry_attempts)
+                expect(state_changes[:connecting]).to   be >= 10
+                expect(state_changes[:suspended]).to    be >= 10
                 expect(state_changes[:disconnected]).to eql(0)
 
-                expect(time_passed).to be > max_time_in_state_for_tests
                 stop_reactor
               end
             end
           end
 
+          context 'for the first time' do
+            let(:client_options) do
+              default_options.merge(suspended_retry_timeout: 2, connection_state_ttl: 0, log_level: :error)
+            end
+
+            it 'waits suspended_retry_timeout before attempting to reconnect' do
+              expect(client.connection.defaults[:suspended_retry_timeout]).to eql(2)
+              connection.once(:connected) do
+                connection.transition_state_machine :suspended
+                allow(connection).to receive(:current_host).and_return('does.not.exist.com')
+
+                started_at = Time.now.to_f
+                connection.once(:connecting) do
+                  expect(Time.now.to_f - started_at).to be > 1.75
+                  started_at = Time.now.to_f
+                  connection.once(:connecting) do
+                    expect(Time.now.to_f - started_at).to be > 1.75
+                    connection.once(:suspended) do
+                      stop_reactor
+                    end
+                  end
+                end
+              end
+            end
+          end
+
           describe '#close' do
             it 'transitions connection state to :closed' do
               connection.on(:connected) { raise 'Connection should not have reached :connected state' }
@@ -172,6 +216,10 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             it 'will not transition state to :close and raises a InvalidStateChange exception' do
               connection.on(:connected) { raise 'Connection should not have reached :connected state' }
 
+              connection.once(:suspended) do
+                connection.transition_state_machine :failed
+              end
+
               connection.once(:failed) do
                 expect(connection.state).to eq(:failed)
                 expect { connection.close }.to raise_error Ably::Exceptions::InvalidStateChange, /Unable to transition from failed => closing/
@@ -190,6 +238,10 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
                 expect(connection.error_reason.code).to eql(80000)
                 stop_reactor
               end
+
+              connection.once(:suspended) do |connection_state_change|
+                connection.transition_state_machine :failed, reason: connection_state_change.reason
+              end
             end
           end
 
@@ -216,12 +268,16 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
       end
 
       describe '#connect' do
-        let(:timeouts) { Ably::Realtime::Connection::ConnectionManager::TIMEOUTS }
+        let(:timeout) { 1.5 }
 
-        before do
-          stub_const 'Ably::Realtime::Connection::ConnectionManager::TIMEOUTS',
-                      Ably::Realtime::Connection::ConnectionManager::TIMEOUTS.merge(open: 1.5)
+        let(:client_options) do
+          default_options.merge(
+            log_level: :none,
+            realtime_request_timeout: timeout
+          )
+        end
 
+        before do
           connection.on(:connected) { raise "Connection should not open in this test as CONNECTED ProtocolMessage is never received" }
 
           connection.once(:connecting) do
@@ -231,13 +287,11 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         end
 
         context 'connection opening times out' do
-          let(:client_options) { client_failure_options }
-
           it 'attempts to reconnect' do
             started_at = Time.now
 
             connection.once(:disconnected) do
-              expect(Time.now.to_f - started_at.to_f).to be > timeouts.fetch(:open)
+              expect(Time.now.to_f - started_at.to_f).to be > timeout
               connection.once(:connecting) do
                 stop_reactor
               end
@@ -246,21 +300,15 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             connection.connect
           end
 
-          it 'calls the errback of the returned Deferrable object when first connection attempt fails' do
-            connection.connect.errback do |error|
-              expect(connection.state).to eq(:disconnected)
-              stop_reactor
-            end
-          end
-
           context 'when retry intervals are stubbed to attempt reconnection quickly' do
-            before do
-              # Reconfigure client library retry periods and timeouts so that tests run quickly
-              stub_const 'Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG',
-                Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG.merge(
-                  disconnected: { retry_every: 0.1, max_time_in_state: 0.2 },
-                  suspended:    { retry_every: 0.1, max_time_in_state: 0.2 },
-                )
+            let(:client_options) do
+              default_options.merge(
+                log_level: :error,
+                disconnected_retry_timeout: 0.1,
+                suspended_retry_timeout:    0.1,
+                connection_state_ttl:       0.2,
+                realtime_host:              'non.existent.host'
+              )
             end
 
             it 'never calls the provided success block', em_timeout: 10 do
@@ -268,8 +316,10 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
                 raise 'success block should not have been called'
               end
 
-              connection.once(:failed) do
-                stop_reactor
+              connection.once(:suspended) do
+                connection.once(:suspended) do
+                  stop_reactor
+                end
               end
             end
           end
@@ -315,14 +365,16 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         context 'and subsequently fails to reconnect' do
           let(:retry_every) { 1.5 }
 
-          before do
-            # Reconfigure client library retry periods and timeouts so that tests run quickly
-            stub_const 'Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG',
-                      Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG.merge(
-                        disconnected: { retry_every: retry_every, max_time_in_state: 60 })
+          let(:client_options) do
+            default_options.merge(
+              log_level: :none,
+              disconnected_retry_timeout: retry_every,
+              suspended_retry_timeout:    retry_every,
+              connection_state_ttl:       60
+            )
           end
 
-          it "retries every #{Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG[:disconnected][:retry_every]} seconds" do
+          it "retries every #{Ably::Realtime::Connection::DEFAULTS.fetch(:disconnected_retry_timeout)} seconds" do
             fail_if_suspended_or_failed
 
             stubbed_first_attempt = false
@@ -382,26 +434,52 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
       end
 
       context 'after successfully reconnecting and resuming' do
-        it 'retains connection_id and connection_key' do
-          previous_connection_id  = nil
-          previous_connection_key = nil
-
+        it 'retains connection_id and updates the connection_key' do
           connection.once(:connected) do
-            previous_connection_id  = connection.id
-            previous_connection_key = connection.key
+            previous_connection_id = connection.id
             connection.transport.close_connection_after_writing
 
+            expect(connection).to receive(:configure_new).with(previous_connection_id, anything, anything).and_call_original
+
             connection.once(:connected) do
-              # Connection key left part should match new connection key left part i.e.
-              # wVIsgTHAB1UvXh7z-1991d8586 becomes wVIsgTHAB1UvXh7z-1990d8586 after resume
-              expect(connection.key[/^\w{5,}-/, 0]).to_not be_nil
-              expect(connection.key[/^\w{5,}-/, 0]).to eql(previous_connection_key[/^\w{5,}-/, 0])
+              expect(connection.key).to_not be_nil
               expect(connection.id).to eql(previous_connection_id)
               stop_reactor
             end
           end
         end
 
+        it 'emits any error received from Ably but leaves the channels attached' do
+          emitted_error = nil
+          channel.attach do
+            connection.transport.close_connection_after_writing
+
+            connection.once(:connecting) do
+              connection.__incoming_protocol_msgbus__.unsubscribe
+              connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+                allow(protocol_message).to receive(:error).and_return(Ably::Exceptions::Standard.new('Injected error'))
+              end
+              # Create a new message dispatcher that subscribes to ProtocolMessages after the previous subscription allowing us
+              # to modify the ProtocolMessage
+              Ably::Realtime::Client::IncomingMessageDispatcher.new(client, connection)
+            end
+
+            connection.once(:connected) do
+              EM.add_timer(0.5) do
+                expect(emitted_error).to be_a(Ably::Exceptions::Standard)
+                expect(emitted_error.message).to match(/Injected error/)
+                expect(connection.error_reason).to be_a(Ably::Exceptions::Standard)
+                expect(channel).to be_attached
+                stop_reactor
+              end
+            end
+
+            connection.once(:error) do |error|
+              emitted_error = error
+            end
+          end
+        end
+
         it 'retains channel subscription state' do
           messages_received = false
 
@@ -527,27 +605,28 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
     end
 
     describe 'fallback host feature' do
-      let(:retry_every_for_tests)       { 0.1 }
-      let(:max_time_in_state_for_tests) { 0.3 }
-
-      before do
-        # Reconfigure client library retry periods and timeouts so that tests run quickly
-        stub_const 'Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG',
-                    Ably::Realtime::Connection::ConnectionManager::CONNECT_RETRY_CONFIG.merge(
-                      disconnected: { retry_every: retry_every_for_tests, max_time_in_state: max_time_in_state_for_tests },
-                      suspended:    { retry_every: retry_every_for_tests, max_time_in_state: max_time_in_state_for_tests },
-                    )
+      let(:retry_every_for_tests)       { 0.2  }
+      let(:max_time_in_state_for_tests) { 0.59 }
+
+      let(:timeout_options) do
+        default_options.merge(
+          environment:                :production,
+          log_level:                  :none,
+          disconnected_retry_timeout: retry_every_for_tests,
+          suspended_retry_timeout:    retry_every_for_tests,
+          connection_state_ttl:       max_time_in_state_for_tests
+        )
       end
 
       # Retry immediately and then wait retry_every before every subsequent attempt
-      let(:expected_retry_attempts) { 1 + (max_time_in_state_for_tests / retry_every_for_tests).round }
+      let(:expected_retry_attempts)    { 1 + (max_time_in_state_for_tests / retry_every_for_tests).round }
 
       let(:retry_count_for_one_state)  { 1 + expected_retry_attempts } # initial connect then disconnected
-      let(:retry_count_for_all_states) { 1 + expected_retry_attempts * 2 } # initial connection, disconnected & then suspended
+      let(:retry_count_for_all_states) { 1 + expected_retry_attempts + 1 } # initial connection, disconnected & then one suspended attempt
 
       context 'with custom realtime websocket host option' do
         let(:expected_host) { 'this.host.does.not.exist' }
-        let(:client_options) { default_options.merge(realtime_host: expected_host, :environment => :production, log_level: :none) }
+        let(:client_options) { timeout_options.merge(realtime_host: expected_host) }
 
         it 'never uses a fallback host' do
           expect(EventMachine).to receive(:connect).exactly(retry_count_for_all_states).times do |host|
@@ -555,15 +634,17 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             raise EventMachine::ConnectionError
           end
 
-          connection.on(:failed) do
-            stop_reactor
+          connection.once(:suspended) do
+            connection.once(:suspended) do
+              stop_reactor
+            end
           end
         end
       end
 
       context 'with custom realtime websocket port option' do
         let(:custom_port) { 666}
-        let(:client_options) { default_options.merge(tls_port: custom_port, :environment => :production, log_level: :none) }
+        let(:client_options) { timeout_options.merge(tls_port: custom_port) }
 
         it 'never uses a fallback host' do
           expect(EventMachine).to receive(:connect).exactly(retry_count_for_all_states).times do |host, port|
@@ -571,8 +652,10 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             raise EventMachine::ConnectionError
           end
 
-          connection.on(:failed) do
-            stop_reactor
+          connection.once(:suspended) do
+            connection.once(:suspended) do
+              stop_reactor
+            end
           end
         end
       end
@@ -580,7 +663,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
       context 'with non-production environment' do
         let(:environment)    { 'sandbox' }
         let(:expected_host)  { "#{environment}-#{Ably::Realtime::Client::DOMAIN}" }
-        let(:client_options) { default_options.merge(environment: environment, log_level: :none) }
+        let(:client_options) { timeout_options.merge(environment: environment) }
 
         it 'never uses a fallback host' do
           expect(EventMachine).to receive(:connect).exactly(retry_count_for_all_states).times do |host|
@@ -588,8 +671,10 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
             raise EventMachine::ConnectionError
           end
 
-          connection.on(:failed) do
-            stop_reactor
+          connection.once(:suspended) do
+            connection.once(:suspended) do
+              stop_reactor
+            end
           end
         end
       end
@@ -601,7 +686,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         end
 
         let(:expected_host)  { Ably::Realtime::Client::DOMAIN }
-        let(:client_options) { default_options.merge(environment: nil, log_level: :none) }
+        let(:client_options) { timeout_options.merge(environment: nil) }
 
         let(:fallback_hosts_used) { Array.new }
 
@@ -616,8 +701,10 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
               raise EventMachine::ConnectionError
             end
 
-            connection.on(:failed) do
-              stop_reactor
+            connection.once(:suspended) do
+              connection.once(:suspended) do
+                stop_reactor
+              end
             end
           end
         end
@@ -629,8 +716,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
 
           it 'uses a fallback host on every subsequent disconnected attempt until suspended' do
             request = 0
-            # Expect retry attempts + 1 attempt for the next state
-            expect(EventMachine).to receive(:connect).exactly(retry_count_for_one_state + 1).times do |host|
+            expect(EventMachine).to receive(:connect).exactly(retry_count_for_one_state).times do |host|
               if request == 0
                 expect(host).to eql(expected_host)
               else
@@ -640,7 +726,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
               raise EventMachine::ConnectionError
             end
 
-            connection.on(:suspended) do
+            connection.once(:suspended) do
               fallback_hosts_used.pop # remove suspended attempt host
               expect(fallback_hosts_used.uniq).to match_array(custom_hosts)
               stop_reactor
@@ -649,20 +735,25 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
 
           it 'uses the primary host when suspended, and a fallback host on every subsequent suspended attempt' do
             request = 0
-            expect(EventMachine).to receive(:connect).exactly(retry_count_for_all_states).times do |host|
+            expect(EventMachine).to receive(:connect).at_least(:once) do |host|
               if request == 0 || request == expected_retry_attempts + 1
                 expect(host).to eql(expected_host)
               else
                 expect(custom_hosts).to include(host)
-                fallback_hosts_used << host
+                fallback_hosts_used << host if @suspended
               end
               request += 1
               raise EventMachine::ConnectionError
             end
 
-            connection.on(:failed) do
-              expect(fallback_hosts_used.uniq).to match_array(custom_hosts)
-              stop_reactor
+            connection.on(:suspended) do
+              @suspended ||= 0
+              @suspended += 1
+
+              if @suspended > 3
+                expect(fallback_hosts_used.uniq).to match_array(custom_hosts)
+                stop_reactor
+              end
             end
           end
         end