ably-rest 1.1.2 → 1.2.2

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

@@ -77,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
@@ -134,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
@@ -143,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
@@ -158,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
@@ -184,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
@@ -453,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
@@ -492,6 +482,138 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
 
+      context "when can't connect to host" do
+        let(:client_options) { super().merge(realtime_host: 'non-existent.ably.io') }
+
+        it 'logs error on failed connection attempt' do
+          logger_expectation = lambda do |*args, &block|
+            error_message = "Connection to non-existent.ably.io:443 failed"
+            expect(args.concat([block ? block.call : nil]).join(',')).to include(error_message)
+            stop_reactor
+          end
+
+          expect(connection.logger).to receive(:warn, &logger_expectation).at_least(:once)
+
+          connection.on(:connected) do
+            raise "Connection should not succeed"
+          end
+
+          connection.connect
+        end
+      end
+
+      context 'when explicitly reconnecting disconnected/suspended connection in retry (#RTN11c)' do
+        let(:close_connection_proc) do
+          lambda do
+            EventMachine.add_timer(0.001) do
+              if connection.transport.nil?
+                close_connection_proc.call
+              else
+                connection.transport.close_connection_after_writing
+              end
+            end
+          end
+        end
+
+        context 'when suspended' do
+          let(:suspended_retry_timeout) { 60 }
+          let(:client_options) do
+            default_options.merge(
+              disconnected_retry_timeout: 0.02,
+              suspended_retry_timeout: suspended_retry_timeout,
+              connection_state_ttl: 0
+            )
+          end
+
+          it 'reconnects immediately' do
+            connection.once(:connecting) { close_connection_proc.call }
+
+            connection.on(:suspended) do |connection_state_change|
+              if connection_state_change.retry_in.zero?
+                # Exhausting immediate retries
+                connection.once(:connecting) { close_connection_proc.call }
+              else
+                suspended_at = Time.now.to_f
+                connection.on(:connected) do
+                  expect(connection_state_change.retry_in).to eq(suspended_retry_timeout)
+                  expect(connection.state).to eq(:connected)
+                  expect(Time.now.to_f).to be_within(4).of(suspended_at)
+                  stop_reactor
+                end
+              end
+
+              connection.connect
+            end
+
+            connection.connect
+          end
+        end
+
+        context 'when disconnected' do
+          let(:retry_timeout) { 60 }
+          let(:client_options) do
+            default_options.merge(
+              disconnected_retry_timeout: retry_timeout,
+              suspended_retry_timeout: retry_timeout,
+              connection_state_ttl: 0
+            )
+          end
+
+          it 'reconnects immediately' do
+            connection.once(:connected) do
+              connection.on(:disconnected) do |connection_state_change|
+                disconnected_at = Time.now.to_f
+                connection.on(:connected) do
+                  if connection_state_change.retry_in.zero?
+                    # Exhausting immediate retries
+                    close_connection_proc.call
+                  else
+                    expect(connection_state_change.retry_in).to eq(retry_timeout)
+                    expect(connection.state).to eq(:connected)
+                    expect(Time.now.to_f).to be_within(4).of(disconnected_at)
+                    stop_reactor
+                  end
+                end
+                connection.connect
+              end
+
+              close_connection_proc.call
+            end
+
+            connection.connect
+          end
+        end
+      end
+
+      context 'when reconnecting a failed connection' do
+        let(:channel) { client.channel(random_str) }
+        let(:client_options) { default_options.merge(log_level: :none) }
+
+        it 'transitions all channels state to initialized and cleares error_reason' do
+          connection.on(:failed) do |connection_state_change|
+            expect(connection.error_reason).to be_a(Ably::Exceptions::BaseAblyException)
+            expect(channel.error_reason).to be_a(Ably::Exceptions::BaseAblyException)
+            expect(channel).to be_failed
+
+            connection.on(:connected) do
+              expect(connection.error_reason).to eq(nil)
+              expect(channel).to be_initialized
+              expect(channel.error_reason).to eq(nil)
+              stop_reactor
+            end
+
+            connection.connect
+          end
+
+          connection.connect do
+            channel.attach do
+              error = Ably::Exceptions::ConnectionFailed.new('forced failure', 500, 50000)
+              client.connection.manager.error_received_from_server error
+            end
+          end
+        end
+      end
+
       context 'with invalid auth details' do
         let(:client_options) { default_options.merge(key: 'this.is:invalid', log_level: :none) }
 
@@ -703,6 +825,18 @@ describe Ably::Realtime::Connection, :event_machine do
     end
 
     context '#close' do
+      let(:close_connection_proc) do
+        lambda do
+          EventMachine.add_timer(0.001) do
+            if connection.transport.nil?
+              close_connection_proc.call
+            else
+              connection.transport.close_connection_after_writing
+            end
+          end
+        end
+      end
+
       it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
         connection.connect do
           expect(connection.close).to be_a(Ably::Util::SafeDeferrable)
@@ -764,6 +898,56 @@ describe Ably::Realtime::Connection, :event_machine do
           end
         end
 
+        context ':connecting RTN12f' do
+          context ":connected does not arrive when trying to close" do
+            it 'moves to closed' do
+              connection.on(:closed) do |state_change|
+                state_changes = connection.state_history.map { |t| t[:state].to_sym }
+
+                expect(state_changes).to eq([:connecting, :closing, :closed])
+                stop_reactor
+              end
+
+              connection.on(:connecting) do
+                connection.close
+                connection.__outgoing_protocol_msgbus__.unsubscribe
+              end
+
+              connection.connect
+            end
+          end
+
+          context ":connected arrive when trying to close" do
+            let(:protocol_message_attributes) do
+              {
+                action: Ably::Models::ProtocolMessage::ACTION.Connected.to_i,
+                connection_serial: 55,
+                connection_details: {
+                  max_idle_interval: 2 * 1000
+                }
+              }
+            end
+
+            it 'moves to connected and then to closed' do
+              connection.on(:closed) do |state_change|
+                state_changes = connection.state_history.map { |t| t[:state].to_sym }
+
+                expect(state_changes).to eq([:connecting, :connected, :closing, :closed])
+                stop_reactor
+              end
+
+              connection.on(:connecting) do
+                connection.__outgoing_protocol_msgbus__.unsubscribe
+
+                connection.__incoming_protocol_msgbus__.publish :protocol_message, Ably::Models::ProtocolMessage.new(protocol_message_attributes)
+                connection.close
+              end
+
+              connection.connect
+            end
+          end
+        end
+
         context ':connected' do
           it 'changes the connection state to :closing and waits for the server to confirm connection is :closed with a ProtocolMessage' do
             connection.on(:connected) do
@@ -810,6 +994,81 @@ describe Ably::Realtime::Connection, :event_machine do
             end
           end
         end
+
+        context ':suspended RTN12d' do
+          let(:suspended_retry_timeout) { 60 }
+          let(:client_options) do
+            default_options.merge(
+              disconnected_retry_timeout: 0.02,
+              suspended_retry_timeout: suspended_retry_timeout,
+              connection_state_ttl: 0
+            )
+          end
+
+          it 'immediatly closes connection' do
+            connection.on(:connecting) { close_connection_proc.call }
+            connection.on(:suspended) do |connection_state_change|
+              if connection_state_change.retry_in.zero?
+                # Exhausting immediate retries
+                connection.once(:connecting) { close_connection_proc.call }
+              else
+                suspended_at = Time.now.to_f
+                connection.on(:closed) do
+                  expect(connection_state_change.retry_in).to eq(suspended_retry_timeout)
+                  expect(connection.state).to eq(:closed)
+                  expect(Time.now.to_f).to be_within(4).of(suspended_at)
+                  stop_reactor
+                end
+
+                connection.close
+              end
+
+              connection.connect
+            end
+
+            connection.connect
+          end
+        end
+
+        context ':disconnected RTN12d' do
+          let(:retry_timeout) { 60 }
+          let(:client_options) do
+            default_options.merge(
+              disconnected_retry_timeout: retry_timeout,
+              suspended_retry_timeout: retry_timeout,
+              connection_state_ttl: 0
+            )
+          end
+
+          it 'immediatly closes connection' do
+            connection.once(:connected) do
+              connection.on(:disconnected) do |connection_state_change|
+                disconnected_at = Time.now.to_f
+                connection.on(:connected) do
+                  if connection_state_change.retry_in.zero?
+                    # Exhausting immediate retries
+                    close_connection_proc.call
+                  else
+                    connection.once(:closed) do
+                      expect(connection_state_change.retry_in).to eq(retry_timeout)
+                      expect(connection.state).to eq(:closed)
+                      expect(Time.now.to_f).to be_within(4).of(disconnected_at)
+                      stop_reactor
+                    end
+
+                    connection.close
+                  end
+                end
+
+                connection.connect
+              end
+
+              close_connection_proc.call
+            end
+
+            connection.connect
+          end
+        end
       end
     end
 
@@ -1179,6 +1438,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
@@ -1463,7 +1723,7 @@ describe Ably::Realtime::Connection, :event_machine do
             let(:client_options) { default_options.merge(tls: true) }
 
             it 'uses TLS for the Internet check to https://internet-up.ably-realtime.com/is-the-internet-up.txt' do
-              expect(EventMachine::HttpRequest).to receive(:new).with('https://internet-up.ably-realtime.com/is-the-internet-up.txt').and_return(http_request)
+              expect(EventMachine::HttpRequest).to receive(:new).with('https://internet-up.ably-realtime.com/is-the-internet-up.txt', { tls: { verify_peer: true } }).and_return(http_request)
               connection.internet_up?
               stop_reactor
             end
@@ -1473,7 +1733,7 @@ describe Ably::Realtime::Connection, :event_machine do
             let(:client_options) { default_options.merge(tls: false, use_token_auth: true) }
 
             it 'uses TLS for the Internet check to http://internet-up.ably-realtime.com/is-the-internet-up.txt' do
-              expect(EventMachine::HttpRequest).to receive(:new).with('http://internet-up.ably-realtime.com/is-the-internet-up.txt').and_return(http_request)
+              expect(EventMachine::HttpRequest).to receive(:new).with('http://internet-up.ably-realtime.com/is-the-internet-up.txt', { tls: { verify_peer: true } }).and_return(http_request)
               connection.internet_up?
               stop_reactor
             end
@@ -1487,7 +1747,7 @@ describe Ably::Realtime::Connection, :event_machine do
             let(:client_options) { default_options.merge(tls: true) }
 
             it 'checks the Internet up URL over TLS' do
-              expect(EventMachine::HttpRequest).to receive(:new).with("https:#{Ably::INTERNET_CHECK.fetch(:url)}").and_return(double('request', get: EventMachine::DefaultDeferrable.new))
+              expect(EventMachine::HttpRequest).to receive(:new).with("https:#{Ably::INTERNET_CHECK.fetch(:url)}", { tls: { verify_peer: true } }).and_return(double('request', get: EventMachine::DefaultDeferrable.new))
               connection.internet_up?
               stop_reactor
             end
@@ -1497,7 +1757,7 @@ describe Ably::Realtime::Connection, :event_machine do
             let(:client_options) { default_options.merge(tls: false, use_token_auth: true) }
 
             it 'checks the Internet up URL over TLS' do
-              expect(EventMachine::HttpRequest).to receive(:new).with("http:#{Ably::INTERNET_CHECK.fetch(:url)}").and_return(double('request', get: EventMachine::DefaultDeferrable.new))
+              expect(EventMachine::HttpRequest).to receive(:new).with("http:#{Ably::INTERNET_CHECK.fetch(:url)}", { tls: { verify_peer: true } }).and_return(double('request', get: EventMachine::DefaultDeferrable.new))
               connection.internet_up?
               stop_reactor
             end
@@ -1843,38 +2103,45 @@ 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.1')
+          expect(CGI::parse(uri.query)['v'][0]).to eql('1.2')
           stop_reactor
         end
         client
       end
 
-      it 'sends the lib version param lib (#RTN2g)' do
+      it 'sends the lib version param agent (#RCS7d)' 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\.1\.\d+(-[\w\.]+)?+$/)
+          expect(CGI::parse(uri.query)['agent'][0]).to match(/^ably-ruby\/\d\.\d\.\d ruby\/\d\.\d\.\d$/)
           stop_reactor
         end
         client
       end
+    end
 
-      context 'with variant' do
-        let(:variant) { 'foo' }
+    context 'transport_params (#RTC1f)' do
+      let(:client_options) { default_options.merge(transport_params: { 'extra_param' => 'extra_param' }) }
 
-        before do
-          Ably.lib_variant = variant
-        end
+      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
 
-        after do
-          Ably.lib_variant = nil
-        end
+          client
+      end
 
-        it 'sends the lib version param lib with the variant (#RTN2g + #RSC7b)' do
+      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)['lib'][0]).to match(/^ruby-#{variant}-1\.1\.\d+(-[\w\.]+)?$/)
+            expect(CGI::parse(uri.query)['v'][0]).to eq('1.0')
             stop_reactor
           end
+
           client
         end
       end

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

@@ -75,6 +75,83 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       end
     end
 
+    context 'a single Message object (#RSL1a)' do
+      let(:name) { random_str }
+      let(:data) { random_str }
+      let(:message) { Ably::Models::Message.new(name: name, data: data) }
+
+      it 'publishes the message' do
+        channel.attach
+        channel.publish(message)
+        channel.subscribe do |msg|
+          expect(msg.name).to eq(message.name)
+          expect(msg.data).to eq(message.data)
+          stop_reactor
+        end
+      end
+    end
+
+    context 'an array of Message objects (#RSL1a)' do
+      let(:data) { random_str }
+      let(:message1) { Ably::Models::Message.new(name: random_str, data: data) }
+      let(:message2) { Ably::Models::Message.new(name: random_str, data: data) }
+      let(:message3) { Ably::Models::Message.new(name: random_str, data: data) }
+
+      it 'publishes three messages' do
+        channel.attach
+        channel.publish([message1, message2, message3])
+        counter = 0
+        channel.subscribe do |message|
+          counter += 1
+          expect(message.data).to eq(data)
+          expect(message.name).to eq(message1.name) if counter == 1
+          expect(message.name).to eq(message2.name) if counter == 2
+          if counter == 3
+            expect(message.name).to eq(message3.name)
+            stop_reactor
+          end
+        end
+      end
+    end
+
+    context 'an array of hashes (#RSL1a)' do
+      let(:data) { random_str }
+      let(:message1) { { name: random_str, data: data } }
+      let(:message2) { { name: random_str, data: data } }
+      let(:message3) { { name: random_str, data: data } }
+
+      it 'publishes three messages' do
+        channel.attach
+        channel.publish([message1, message2, message3])
+        counter = 0
+        channel.subscribe do |message|
+          counter += 1
+          expect(message.data).to eq(data)
+          expect(message.name).to eq(message1[:name]) if counter == 1
+          expect(message.name).to eq(message2[:name]) if counter == 2
+          if counter == 3
+            expect(message.name).to eq(message3[:name])
+            stop_reactor
+          end
+        end
+      end
+    end
+
+    context 'a name with data payload (#RSL1a, #RSL1b)' do
+      let(:name) { random_str }
+      let(:data) { random_str }
+
+      it 'publishes a message' do
+        channel.attach
+        channel.publish(name, data)
+        channel.subscribe do |message|
+          expect(message.name).to eql(name)
+          expect(message.data).to eq(data)
+          stop_reactor
+        end
+      end
+    end
+
     context 'with supported extra payload content type (#RTL6h, #RSL6a2)' do
       let(:channel) { client.channel("pushenabled:#{random_str}") }
 

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

@@ -20,7 +20,7 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
 
     it 'provides up to the moment presence history' do
       presence_client_one.enter(data) do
-        presence_client_one.leave(leave_data) do
+        presence_client_one.subscribe(:leave) do
           presence_client_one.history do |history_page|
             expect(history_page).to be_a(Ably::Models::PaginatedResult)
             expect(history_page.items.count).to eql(2)
@@ -36,6 +36,8 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
             stop_reactor
           end
         end
+
+        presence_client_one.leave(leave_data)
       end
     end
 
@@ -52,63 +54,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