ably 1.1.1 → 1.1.5

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,82 @@ 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' })
+
+              stub_request(:get, 'https://internet-up.ably-realtime.com/is-the-internet-up.txt')
+                .with(
+                  headers: {
+                    'Accept-Encoding' => 'gzip, compressed',
+                    'Connection' => 'close',
+                    'Host' => 'internet-up.ably-realtime.com',
+                    'User-Agent' => 'EventMachine HttpClient'
+                  }
+                ).to_return(status: 200, body: 'yes\n', headers: { 'Content-Type' => 'text/plain' })
+            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 +501,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
 
@@ -1357,14 +1433,19 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
         let(:expected_host)  { "#{environment}-#{Ably::Realtime::Client::DOMAIN}" }
         let(:client_options) { timeout_options.merge(environment: environment) }
 
-        it 'does not use a fallback host by default' do
-          expect(connection).to receive(:create_transport).exactly(retry_count_for_all_states).times do |host|
-            expect(host).to eql(expected_host)
-            raise EventMachine::ConnectionError
-          end
+        context ':fallback_hosts_use_default is unset' do
+          let(:max_time_in_state_for_tests) { 8 }
+          let(:expected_hosts) { Ably::CUSTOM_ENVIRONMENT_FALLBACKS_SUFFIXES.map { |suffix| "#{environment}#{suffix}" } + [expected_host] }
+          let(:fallback_hosts_used) { Array.new }
+
+          it 'uses fallback hosts by default' do
+            allow(connection).to receive(:create_transport) do |host|
+              fallback_hosts_used << host
+              raise EventMachine::ConnectionError
+            end
 
-          connection.once(:suspended) do
             connection.once(:suspended) do
+              expect(fallback_hosts_used.uniq).to match_array(expected_hosts)
               stop_reactor
             end
           end
@@ -1442,7 +1523,7 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
       end
 
       context 'with production environment' do
-        let(:custom_hosts)   { %w(A.ably-realtime.com B.ably-realtime.com) }
+        let(:custom_hosts)   { %w(a.ably-realtime.com b.ably-realtime.com) }
         before do
           stub_const 'Ably::FALLBACK_HOSTS', custom_hosts
         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))
@@ -70,18 +77,6 @@ describe Ably::Realtime::Connection, :event_machine do
                 end
               end
             end
-
-            context 'with implicit authorisation' do
-              let(:client_options) { default_options.merge(client_id: 'force_token_auth') }
-
-              it 'uses the token created by the implicit authorisation' do
-                expect(client.rest_client.auth).to receive(:request_token).once.and_call_original
-
-                connection.once(:connected) do
-                  stop_reactor
-                end
-              end
-            end
           end
 
           context 'that expire' do
@@ -127,7 +122,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 end
               end
 
-              context 'with immediately expired token' do
+              context 'with immediately expired token and no fallback hosts' do
                 let(:ttl) { 0.001 }
                 let(:auth_requests) { [] }
                 let(:token_callback) do
@@ -136,7 +131,7 @@ describe Ably::Realtime::Connection, :event_machine do
                     Ably::Rest::Client.new(default_options).auth.request_token(ttl: ttl).token
                   end
                 end
-                let(:client_options) { default_options.merge(auth_callback: token_callback) }
+                let(:client_options) { default_options.merge(auth_callback: token_callback, fallback_hosts: []) }
 
                 it 'renews the token on connect, and makes one immediate subsequent attempt to obtain a new token (#RSA4b)' do
                   started_at = Time.now.to_f
@@ -151,7 +146,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 end
 
                 context 'when disconnected_retry_timeout is 0.5 seconds' do
-                  let(:client_options) { default_options.merge(disconnected_retry_timeout: 0.5, auth_callback: token_callback) }
+                  let(:client_options) { default_options.merge(disconnected_retry_timeout: 0.5, auth_callback: token_callback, fallback_hosts: []) }
 
                   it 'renews the token on connect, and continues to attempt renew based on the retry schedule' do
                     disconnect_count = 0
@@ -177,7 +172,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 end
 
                 context 'using implicit token auth' do
-                  let(:client_options) { default_options.merge(use_token_auth: true, default_token_params: { ttl: ttl }) }
+                  let(:client_options) { default_options.merge(use_token_auth: true, default_token_params: { ttl: ttl }, fallback_hosts: []) }
 
                   before do
                     stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', -10 # ensure client lib thinks token is still valid
@@ -446,7 +441,9 @@ describe Ably::Realtime::Connection, :event_machine do
       end
     end
 
-    context '#connect' do
+    context '#connect with no fallbacks' do
+      let(:client_options)   { default_options.merge(fallback_hosts: []) }
+
       it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
         expect(connection.connect).to be_a(Ably::Util::SafeDeferrable)
         stop_reactor
@@ -1172,6 +1169,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 host:   'this.host.does.not.exist.com'
               )
             )
+            allow(client).to receive(:fallback_hosts).and_return([])
 
             connection.transition_state_machine! :disconnected
           end
@@ -1307,12 +1305,14 @@ describe Ably::Realtime::Connection, :event_machine 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-1') do
+                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
@@ -1329,7 +1329,7 @@ describe Ably::Realtime::Connection, :event_machine do
                   expect(recover_client.connection.id).to eql(connection_id)
 
                   recover_client_channel.subscribe do |message|
-                    raise "Unexpected message #{message}" if message.data != 'message-2'
+                    expect(message.data).to eql('message-2')
                     EventMachine.add_timer(2) do
                       stop_reactor
                     end
@@ -1870,5 +1870,33 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
     end
+
+    context 'transport_params (#RTC1f)' do
+      let(:client_options) { default_options.merge(transport_params: { 'extra_param' => 'extra_param' }) }
+
+      it 'pases transport_params to query' do
+        expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
+            uri = URI.parse(url)
+            expect(CGI::parse(uri.query)['extra_param'][0]).to eq('extra_param')
+            stop_reactor
+          end
+
+          client
+      end
+
+      context 'when changing default param' do
+        let(:client_options) { default_options.merge(transport_params: { v: '1.0' }) }
+
+        it 'overrides default param (#RTC1f1)' do
+          expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
+            uri = URI.parse(url)
+            expect(CGI::parse(uri.query)['v'][0]).to eq('1.0')
+            stop_reactor
+          end
+
+          client
+        end
+      end
+    end
   end
 end

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
@@ -658,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

data/spec/acceptance/realtime/presence_history_spec.rb

@@ -52,63 +52,5 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
 
       presence_client_one.enter(data)
     end
-
-    context 'with option until_attach: true' do
-      let(:event) { random_str }
-      let(:presence_data_before_attach) { random_str }
-      let(:presence_data_after_attach) { random_str }
-
-      it 'retrieves all presence messages before channel was attached' do
-        presence_client_two.enter(presence_data_before_attach) do
-          presence_client_one.enter(presence_data_after_attach) do
-            presence_client_one.history(until_attach: true) do |presence_page|
-              expect(presence_page.items.count).to eql(1)
-              expect(presence_page.items.first.data).to eql(presence_data_before_attach)
-              stop_reactor
-            end
-          end
-        end
-      end
-
-      context 'and two pages of messages' do
-        let(:wildcard_token) { lambda { |token_params| Ably::Rest::Client.new(default_options).auth.request_token(client_id: '*') } }
-        let(:client_one)     { auto_close Ably::Realtime::Client.new(default_options.merge(auth_callback: wildcard_token)) }
-        let(:client_two)     { auto_close Ably::Realtime::Client.new(default_options.merge(auth_callback: wildcard_token)) }
-
-        # TODO: Remove retry logic when presence history regression fixed
-        #       https://github.com/ably/realtime/issues/1707
-        #
-        it 'retrieves two pages of messages before channel was attached', retry: 10, :retry_wait => 5 do
-          when_all(*10.times.map { |i| presence_client_two.enter_client("client:#{i}", presence_data_before_attach) }) do
-            when_all(*10.times.map { |i| presence_client_one.enter_client("client:#{i}", presence_data_after_attach) }) do
-              presence_client_one.history(until_attach: true, limit: 5) do |presence_page|
-                expect(presence_page.items.count).to eql(5)
-                expect(presence_page.items.map(&:data).uniq.first).to eql(presence_data_before_attach)
-
-                presence_page.next do |presence_next_page|
-                  expect(presence_next_page.items.count).to eql(5)
-                  expect(presence_next_page.items.map(&:data).uniq.first).to eql(presence_data_before_attach)
-                  if presence_next_page.has_next?
-                    presence_next_page.next do |last|
-                      expect(last.items.count).to eql(0)
-                    end
-                  else
-                    expect(presence_next_page).to be_last
-                  end
-                  stop_reactor
-                end
-              end
-            end
-          end
-        end
-      end
-
-      it 'fails with an exception unless state is attached' do
-        presence_client_one.history(until_attach: true).errback do |error|
-          expect(error.message).to match(/not attached/)
-          stop_reactor
-        end
-      end
-    end
   end
 end

data/spec/acceptance/realtime/presence_spec.rb

@@ -2449,6 +2449,60 @@ describe Ably::Realtime::Presence, :event_machine do
         end
       end
 
+      describe '#RTP17b' do
+        let(:leave_action) { Ably::Models::PresenceMessage::ACTION.Leave }
+
+        it 'updates presence members on leave' do
+          presence_client_two.subscribe(:enter) do
+            channel_anonymous_client.attach do
+              channel_anonymous_client.presence.get do |members|
+                presence_client_two.subscribe(:leave) do
+                  expect(presence_client_two.members.local_members).to be_empty
+                  stop_reactor
+                end
+
+                leave_message = Ably::Models::PresenceMessage.new(
+                  'id' => "#{client_two.connection.id}:#{presence_client_two.client_id}:1",
+                  'clientId' => presence_client_two.client_id,
+                  'connectionId' => client_two.connection.id,
+                  'timestamp' => as_since_epoch(Time.now),
+                  'action' => leave_action
+                )
+
+                presence_client_two.__incoming_msgbus__.publish :presence, leave_message
+              end
+            end
+          end
+
+          presence_client_two.enter
+        end
+
+        it 'does no update presence members on fabricated leave' do
+          presence_client_two.subscribe(:enter) do
+            channel_anonymous_client.attach do
+              channel_anonymous_client.presence.get do |members|
+                presence_client_two.subscribe(:leave) do
+                  expect(presence_client_two.members.local_members).to_not be_empty
+                  stop_reactor
+                end
+
+                fabricated_leave_message = Ably::Models::PresenceMessage.new(
+                  'id' => "#{client_two.connection.id}:#{presence_client_two.client_id}:1",
+                  'clientId' => presence_client_two.client_id,
+                  'connectionId' => "fabricated:#{presence_client_two.client_id}:0",
+                  'timestamp' => as_since_epoch(Time.now),
+                  'action' => leave_action
+                )
+
+                presence_client_two.__incoming_msgbus__.publish :presence, fabricated_leave_message
+              end
+            end
+          end
+
+          presence_client_two.enter
+        end
+      end
+
       context 'when a channel becomes attached again' do
         let(:attached_action) { Ably::Models::ProtocolMessage::ACTION.Attached.to_i }
         let(:sync_action) { Ably::Models::ProtocolMessage::ACTION.Sync.to_i }

data/spec/acceptance/realtime/push_admin_spec.rb

@@ -101,31 +101,15 @@ describe Ably::Realtime::Push::Admin, :event_machine do
           end
         end
 
-        def request_body(request, protocol)
-          if protocol == :msgpack
-            MessagePack.unpack(request.body)
-          else
-            JSON.parse(request.body)
-          end
-        end
-
-        def serialize(object, protocol)
-          if protocol == :msgpack
-            MessagePack.pack(object)
-          else
-            JSON.dump(object)
-          end
-        end
-
         let!(:publish_stub) do
           stub_request(:post, "#{client.rest_client.endpoint}/push/publish").
             with do |request|
-              expect(request_body(request, protocol)['recipient']['camelCase']['secondLevelCamelCase']).to eql('val')
-              expect(request_body(request, protocol)['recipient']).to_not have_key('camel_case')
+              expect(deserialize_body(request.body, protocol)['recipient']['camelCase']['secondLevelCamelCase']).to eql('val')
+              expect(deserialize_body(request.body, protocol)['recipient']).to_not have_key('camel_case')
               true
             end.to_return(
               :status => 201,
-              :body => serialize({}, protocol),
+              :body => serialize_body({}, protocol),
               :headers => { 'Content-Type' => content_type }
             )
         end
@@ -217,6 +201,12 @@ describe Ably::Realtime::Push::Admin, :event_machine do
         let(:client_id) { random_str }
         let(:fixture_count) { 6 }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           fixture_count.times.map do |index|
             Thread.new do # Parallelise the setup
@@ -274,6 +264,12 @@ describe Ably::Realtime::Push::Admin, :event_machine do
         let(:fixture_count) { 2 }
         let(:client_id) { random_str }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           fixture_count.times.map do |index|
             Thread.new do # Parallelise the setup
@@ -353,6 +349,12 @@ describe Ably::Realtime::Push::Admin, :event_machine do
           }
         end
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         after do
           rest_device_registrations.remove_where client_id: client_id
         end
@@ -388,6 +390,12 @@ describe Ably::Realtime::Push::Admin, :event_machine do
         let(:device_id) { random_str }
         let(:client_id) { random_str }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           rest_device_registrations.save({
                                            id: "device-#{client_id}-0",
@@ -421,6 +429,12 @@ describe Ably::Realtime::Push::Admin, :event_machine do
         let(:device_id) { random_str }
         let(:client_id) { random_str }
 
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
+        end
+
         before do
           rest_device_registrations.save({
                                            id: "device-#{client_id}-0",
@@ -481,6 +495,12 @@ describe Ably::Realtime::Push::Admin, :event_machine do
         client.push.admin.channel_subscriptions
       }
 
+      before(:all) do
+        # As push tests often use the global scope (devices),
+        #   we need to ensure tests cannot conflict
+        reload_test_app
+      end
+
       # Set up 2 devices with the same client_id
       #  and two device with the unique device_id and no client_id
       before do
@@ -543,8 +563,10 @@ describe Ably::Realtime::Push::Admin, :event_machine do
       describe '#list_channels' do
         let(:fixture_count) { 6 }
 
-        before(:context) do
-          reload_test_app # TODO: Review if necessary later, currently other tests may affect list_channels
+        before(:all) do
+          # As push tests often use the global scope (devices),
+          #   we need to ensure tests cannot conflict
+          reload_test_app
         end
 
         before do