ably 0.8.5 → 0.8.6

data/lib/ably/rest/client.rb

@@ -21,12 +21,12 @@ module Ably
       # Default Ably domain for REST
       DOMAIN = 'rest.ably.io'
 
-      # Configuration for connection retry attempts
-      CONNECTION_RETRY = {
-        single_request_open_timeout: 4,
-        single_request_timeout: 15,
-        cumulative_request_open_timeout: 10,
-        max_retry_attempts: 3
+      # Configuration for HTTP timeouts and HTTP request reattempts to fallback hosts
+      HTTP_DEFAULTS = {
+        open_timeout:       4,
+        request_timeout:    15,
+        max_retry_duration: 10,
+        max_retry_count:    3
       }.freeze
 
       def_delegators :auth, :client_id, :auth_options
@@ -51,18 +51,23 @@ module Ably
       # @return [Logger::Severity]
       attr_reader :log_level
 
-      # The custom host that is being used if it was provided with the option `:rest_host` when the {Client} was created
+      # The custom host that is being used if it was provided with the option +:rest_host+ when the {Client} was created
       # @return [String,Nil]
       attr_reader :custom_host
 
-      # The custom port for non-TLS requests if it was provided with the option `:port` when the {Client} was created
+      # The custom port for non-TLS requests if it was provided with the option +:port+ when the {Client} was created
       # @return [Integer,Nil]
       attr_reader :custom_port
 
-      # The custom TLS port for TLS requests if it was provided with the option `:tls_port` when the {Client} was created
+      # The custom TLS port for TLS requests if it was provided with the option +:tls_port+ when the {Client} was created
       # @return [Integer,Nil]
       attr_reader :custom_tls_port
 
+      # The immutable configured HTTP defaults for this client.
+      # See {#initialize} for the configurable HTTP defaults prefixed with +http_+
+      # @return [Hash]
+      attr_reader :http_defaults
+
       # The registered encoders that are used to encode and decode message payloads
       # @return [Array<Ably::Models::MessageEncoder::Base>]
       # @api private
@@ -96,6 +101,11 @@ module Ably
       # @option options [Boolean]                 :query_time          when true will query the {https://www.ably.io Ably} system for the current time instead of using the local time
       # @option options [Hash]                    :token_params        convenience to pass in +token_params+ that will be used as a default for all token requests. See {Auth#create_token_request}
       #
+      # @option options [Integer]                 :http_open_timeout       (4 seconds) timeout in seconds for opening an HTTP connection for all HTTP requests
+      # @option options [Integer]                 :http_request_timeout    (15 seconds) timeout in seconds for any single complete HTTP request and response
+      # @option options [Integer]                 :http_max_retry_count    (3) maximum number of fallback host retries for HTTP requests that fail due to network issues or server problems
+      # @option options [Integer]                 :http_max_retry_duration (10 seconds) maximum elapsed time in which fallback host retries for HTTP requests will be attempted i.e. if the first default host attempt takes 5s, and then the subsequent fallback retry attempt takes 7s, no further fallback host attempts will be made as the total elapsed time of 12s exceeds the default 10s limit
+      #
       # @return [Ably::Rest::Client]
       #
       # @example
@@ -127,6 +137,14 @@ module Ably
         @custom_port      = options.delete(:port)
         @custom_tls_port  = options.delete(:tls_port)
 
+        @http_defaults = HTTP_DEFAULTS.dup
+        options.each do |key, val|
+          if http_key = key[/^http_(.+)/, 1]
+            @http_defaults[http_key.to_sym] = val if val && @http_defaults.has_key?(http_key.to_sym)
+          end
+        end
+        @http_defaults.freeze
+
         if @log_level == :none
           @custom_logger = Ably::Models::NilLogger.new
         else
@@ -322,8 +340,8 @@ module Ably
       # Sends HTTP request to connection end point
       # Connection failures will automatically be reattempted until thresholds are met
       def send_request(method, path, params, options)
-        max_retry_attempts = CONNECTION_RETRY.fetch(:max_retry_attempts)
-        cumulative_timeout = CONNECTION_RETRY.fetch(:cumulative_request_open_timeout)
+        max_retry_count    = http_defaults.fetch(:max_retry_count)
+        max_retry_duration = http_defaults.fetch(:max_retry_duration)
         requested_at       = Time.now
         retry_count        = 0
 
@@ -338,7 +356,7 @@ module Ably
 
         rescue Faraday::TimeoutError, Faraday::ClientError, Ably::Exceptions::ServerError => error
           time_passed = Time.now - requested_at
-          if can_fallback_to_alternate_ably_host? && retry_count < max_retry_attempts && time_passed <= cumulative_timeout
+          if can_fallback_to_alternate_ably_host? && retry_count < max_retry_count && time_passed <= max_retry_duration
             retry_count += 1
             retry
           end
@@ -395,8 +413,8 @@ module Ably
             user_agent:   user_agent
           },
           request: {
-            open_timeout: CONNECTION_RETRY.fetch(:single_request_open_timeout),
-            timeout:      CONNECTION_RETRY.fetch(:single_request_timeout)
+            open_timeout: http_defaults.fetch(:open_timeout),
+            timeout:      http_defaults.fetch(:request_timeout)
           }
         }
       end

data/lib/ably/rest/presence.rb

@@ -82,7 +82,7 @@ module Ably
 
       private
       def base_path
-        "/channels/#{CGI.escape(channel.name)}/presence"
+        "/channels/#{Addressable::URI.encode(channel.name)}/presence"
       end
 
       def decode_message(presence_message)

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.8.5'
+  VERSION = '0.8.6'
 end

data/lib/ably.rb

@@ -1,3 +1,5 @@
+require 'addressable/uri'
+
 %w(modules util).each do |namespace|
   Dir.glob(File.expand_path("ably/#{namespace}/*.rb", File.dirname(__FILE__))).sort.each do |file|
     require file

data/spec/acceptance/realtime/auth_spec.rb

@@ -70,15 +70,6 @@ describe Ably::Realtime::Auth, :event_machine do
         end
       end
 
-      context '#token' do
-        let(:client_options) { default_options.merge(token: random_str) }
-
-        it 'contains the current token after auth' do
-          expect(auth.token).to_not be_nil
-          stop_reactor
-        end
-      end
-
       context '#current_token_details' do
         it 'contains the current token after auth' do
           expect(auth.current_token_details).to be_nil
@@ -99,6 +90,7 @@ describe Ably::Realtime::Auth, :event_machine do
       context '#options (auth_options)' do
         let(:auth_url) { "https://echo.ably.io/?type=text" }
         let(:auth_params) { { :body => random_str } }
+        let(:client_options) { default_options.merge(auto_connect: false) }
 
         it 'contains the configured auth options' do
           auth.authorise({}, auth_url: auth_url, auth_params: auth_params) do
@@ -193,6 +185,75 @@ describe Ably::Realtime::Auth, :event_machine do
             stop_reactor
           end
         end
+
+        context 'when implicitly called, with an explicit ClientOptions client_id' do
+          let(:client_id)        { random_str }
+          let(:client_options)   { default_options.merge(auth_callback: Proc.new { auth_token_object }, client_id: client_id, log_level: :none) }
+          let(:rest_auth_client) { Ably::Rest::Client.new(default_options.merge(key: api_key, client_id: 'invalid')) }
+
+          context 'and an incompatible client_id in a TokenDetails object passed to the auth callback' do
+            let(:auth_token_object) { rest_auth_client.auth.request_token }
+
+            it 'rejects a TokenDetails object with an incompatible client_id and raises an exception' do
+              client.connect
+              client.connection.on(:error) do |error|
+                expect(error).to be_a(Ably::Exceptions::IncompatibleClientId)
+                EventMachine.add_timer(0.1) do
+                  expect(client.connection).to be_failed
+                  stop_reactor
+                end
+              end
+            end
+          end
+
+          context 'and an incompatible client_id in a TokenRequest object passed to the auth callback and raises an exception' do
+            let(:auth_token_object) { rest_auth_client.auth.create_token_request }
+
+            it 'rejects a TokenRequests object with an incompatible client_id and raises an exception' do
+              client.connect
+              client.connection.on(:error) do |error|
+                expect(error).to be_a(Ably::Exceptions::IncompatibleClientId)
+                EventMachine.add_timer(0.1) do
+                  expect(client.connection).to be_failed
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+
+        context 'when explicitly called, with an explicit ClientOptions client_id' do
+          let(:auth_proc) do
+            Proc.new do
+              if !@requested
+                @requested = true
+                valid_auth_token
+              else
+                invalid_auth_token
+              end
+            end
+          end
+
+          let(:client_id)          { random_str }
+          let(:client_options)     { default_options.merge(auth_callback: auth_proc, client_id: client_id, log_level: :none) }
+          let(:valid_auth_token)   { Ably::Rest::Client.new(default_options.merge(key: api_key, client_id: client_id)).auth.request_token }
+          let(:invalid_auth_token) { Ably::Rest::Client.new(default_options.merge(key: api_key, client_id: 'invalid')).auth.request_token }
+
+          context 'and an incompatible client_id in a TokenDetails object passed to the auth callback' do
+            it 'rejects a TokenDetails object with an incompatible client_id and raises an exception' do
+              client.connection.once(:connected) do
+                client.auth.authorise({}, force: true)
+                client.connection.on(:error) do |error|
+                  expect(error).to be_a(Ably::Exceptions::IncompatibleClientId)
+                  EventMachine.add_timer(0.1) do
+                    expect(client.connection).to be_failed
+                    stop_reactor
+                  end
+                end
+              end
+            end
+          end
+        end
       end
 
       context '#authorise_async' do
@@ -216,7 +277,7 @@ describe Ably::Realtime::Auth, :event_machine do
       end
     end
 
-    context '#auth_params' do
+    context '#auth_params_sync' do
       it 'returns the auth params synchronously' do
         expect(auth.auth_params_sync).to be_a(Hash)
         stop_reactor
@@ -232,11 +293,190 @@ describe Ably::Realtime::Auth, :event_machine do
       end
     end
 
-    context '#auth_header' do
+    context '#auth_header_sync' do
       it 'returns an auth header synchronously' do
         expect(auth.auth_header_sync).to be_a(String)
         stop_reactor
       end
     end
+
+    describe '#client_id_validated?' do
+      let(:auth) { Ably::Rest::Client.new(default_options.merge(key: api_key)).auth }
+
+      context 'when using basic auth' do
+        let(:client_options) { default_options.merge(key: api_key) }
+
+        context 'before connected' do
+          it 'is false as basic auth users do not have an identity' do
+            expect(client.auth).to_not be_client_id_validated
+            stop_reactor
+          end
+        end
+
+        context 'once connected' do
+          it 'is true' do
+            client.connection.once(:connected) do
+              expect(client.auth).to be_client_id_validated
+              stop_reactor
+            end
+          end
+
+          it 'contains a validated wildcard client_id' do
+            client.connection.once(:connected) do
+              expect(client.auth.client_id).to eql('*')
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      context 'when using a token string' do
+        context 'with a valid client_id' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: 'present').token) }
+
+          context 'before connected' do
+            it 'is false as identification is not possible from an opaque token string' do
+              expect(client.auth).to_not be_client_id_validated
+              stop_reactor
+            end
+
+            specify '#client_id is nil' do
+              expect(client.auth.client_id).to be_nil
+              stop_reactor
+            end
+          end
+
+          context 'once connected' do
+            it 'is true' do
+              client.connection.once(:connected) do
+                expect(client.auth).to be_client_id_validated
+                stop_reactor
+              end
+            end
+
+            specify '#client_id is populated' do
+              client.connection.once(:connected) do
+                expect(client.auth.client_id).to eql('present')
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'with no client_id (anonymous)' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: nil).token) }
+
+          context 'before connected' do
+            it 'is false as identification is not possible from an opaque token string' do
+              expect(client.auth).to_not be_client_id_validated
+              stop_reactor
+            end
+          end
+
+          context 'once connected' do
+            it 'is true' do
+              client.connection.once(:connected) do
+                expect(client.auth).to be_client_id_validated
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'with a wildcard client_id (anonymous)' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: '*').token) }
+
+          context 'before connected' do
+            it 'is false as identification is not possible from an opaque token string' do
+              expect(client.auth).to_not be_client_id_validated
+              stop_reactor
+            end
+          end
+
+          context 'once connected' do
+            it 'is true' do
+              client.connection.once(:connected) do
+                expect(client.auth).to be_client_id_validated
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+
+      context 'when using a token' do
+        context 'with a client_id' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: 'present')) }
+
+          it 'is true' do
+            expect(client.auth).to be_client_id_validated
+            stop_reactor
+          end
+
+          context 'once connected' do
+            it 'is true' do
+              client.connection.once(:connected) do
+                expect(client.auth).to be_client_id_validated
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'with no client_id (anonymous)' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: nil)) }
+
+          it 'is true' do
+            expect(client.auth).to be_client_id_validated
+            stop_reactor
+          end
+
+          context 'once connected' do
+            it 'is true' do
+              client.connection.once(:connected) do
+                expect(client.auth).to be_client_id_validated
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'with a wildcard client_id (anonymous)' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: '*')) }
+
+          it 'is true' do
+            expect(client.auth).to be_client_id_validated
+            stop_reactor
+          end
+
+          context 'once connected' do
+            it 'is true' do
+              client.connection.once(:connected) do
+                expect(client.auth).to be_client_id_validated
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+
+      context 'when using a token request with a client_id' do
+        let(:client_options) { default_options.merge(token: auth.create_token_request(client_id: 'present')) }
+
+        it 'is not true as identification is not confirmed until authenticated' do
+          expect(client.auth).to_not be_client_id_validated
+          stop_reactor
+        end
+
+        context 'once connected' do
+          it 'is true as identification is completed following CONNECTED ProtocolMessage' do
+            client.channel('test').publish('a') do
+              expect(client.auth).to be_client_id_validated
+              stop_reactor
+            end
+          end
+        end
+      end
+    end
   end
 end

data/spec/acceptance/realtime/channel_history_spec.rb

@@ -186,9 +186,19 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
                 messages.next do |next_page_messages|
                   expect(next_page_messages.items.count).to eql(5)
                   expect(next_page_messages.items.map(&:data).uniq.first).to eql(message_before_attach)
-                  expect(next_page_messages).to be_last
 
-                  stop_reactor
+                  if next_page_messages.last?
+                    expect(next_page_messages).to be_last
+                    stop_reactor
+                  else
+                    # If previous page said there is another page it is plausible and correct that
+                    # the next page is empty and then the last, if the limit was satisfied
+                    next_page_messages.next do |empty_page|
+                      expect(empty_page.items.count).to eql(0)
+                      expect(empty_page).to be_last
+                      stop_reactor
+                    end
+                  end
                 end
               end
             end