ably 0.8.5 → 0.8.6

data/spec/acceptance/rest/auth_spec.rb

@@ -197,6 +197,85 @@ describe Ably::Auth do
         end
       end
 
+      context 'with :auth_url option merging', :webmock do
+        context 'with existing configured auth options' do
+          let(:client_id)    { random_str }
+          let(:auth_url)     { "https://www.fictitious.com/#{random_str}" }
+          let(:auth_method)  { :get }
+          let(:auth_params)  { { key: 'val', client_id: 'isOverridenByClient' } }
+          let(:auth_headers) { { 'Header-X' => 'val1', 'Header-Y' => 'val2' } }
+
+          let(:base_options) do
+            default_options.merge(
+              client_id:    client_id,
+              auth_url:     auth_url,
+              auth_params:  auth_params,
+              auth_headers: auth_headers
+            )
+          end
+          let(:client_options) { base_options }
+
+          let!(:auth_request) do
+            stub_request(auth_method, auth_url).to_return(
+              :status => 201,
+              :body => '123123.12312321321312321', # token string
+              :headers => { 'Content-Type' => 'text/plain' }
+            )
+          end
+
+          let(:request_token_auth_options) { Hash.new }
+          let(:request_token_token_params) { Hash.new }
+          after do
+            client.auth.request_token(request_token_token_params, request_token_auth_options)
+            expect(auth_request).to have_been_requested
+          end
+
+          context 'using unspecified :auth_method' do
+            it 'requests a token using a GET request with provided headers, and merges client_id into auth_params' do
+              auth_request.with(headers: auth_headers)
+              auth_request.with(query: auth_params.merge(client_id: client_id))
+            end
+
+            context 'with provided token_params' do
+              let(:request_token_token_params) { { client_id: 'custom', key2: 'val2' } }
+
+              it 'merges provided token_params with existing auth_params and client_id' do
+                auth_request.with(query: auth_params.merge(client_id: client_id).merge(request_token_token_params))
+              end
+            end
+
+            context 'with provided auth option auth_params and auth_headers' do
+              let(:request_token_auth_options) { { auth_params: {}, auth_headers: {} } }
+
+              it 'replaces any preconfigured auth_params' do
+                auth_request.with(query: {}.merge(client_id: client_id))
+                auth_request.with(headers: { 'Accept'=>'*/*' }) # mock library needs at least one header, accept is default
+              end
+            end
+          end
+
+          context 'using :get :auth_method and query params in the URL' do
+            let(:auth_method) { :get }
+            let(:client_options) { base_options.merge(auth_method: :get, auth_url: "#{auth_url}?urlparam=true") }
+
+            it 'requests a token using a GET request with provided headers, and merges client_id into auth_params and existing URL querystring into new URL querystring' do
+              auth_request.with(headers: auth_headers)
+              auth_request.with(query: auth_params.merge(client_id: client_id).merge(urlparam: 'true'))
+            end
+          end
+
+          context 'using :post :auth_method' do
+            let(:auth_method) { :post }
+            let(:client_options) { base_options.merge(auth_method: :post) }
+
+            it 'requests a token using a POST request with provided headers, and merges client_id into auth_params as form-encoded post data' do
+              auth_request.with(headers: auth_headers)
+              auth_request.with(body: auth_params.merge(client_id: client_id))
+            end
+          end
+        end
+      end
+
       context 'with :auth_url option', :webmock do
         let(:auth_url)          { 'https://www.fictitious.com/get_token' }
         let(:auth_url_response) { { keyName: key_name }.to_json }
@@ -365,6 +444,18 @@ describe Ably::Auth do
           it 'uses the token request returned from the callback when requesting a new token' do
             expect(request_token.client_id).to eql(client_id)
           end
+
+          context 'when authorised' do
+            before { auth.authorise(token_params, auth_callback: auth_callback) }
+
+            it "sets Auth#client_id to the new token's client_id" do
+              expect(auth.client_id).to eql(client_id)
+            end
+
+            it "sets Client#client_id to the new token's client_id" do
+              expect(client.client_id).to eql(client_id)
+            end
+          end
         end
 
         context 'that returns a TokenDetails JSON object' do
@@ -377,7 +468,11 @@ describe Ably::Auth do
           let(:capability_str) { JSON.dump(capability) }
 
           let!(:token_details) do
-            auth.request_token(token_params, auth_callback: Proc.new do |token_params_arg|
+            auth.request_token(token_params, auth_callback: auth_callback)
+          end
+
+          let(:auth_callback) do
+            Proc.new do |token_params_arg|
               @block_called = true
               @block_params = token_params_arg
               {
@@ -388,7 +483,7 @@ describe Ably::Auth do
                 'expires' => expires.to_i * 1000,
                 'capability'=> capability_str
               }
-            end)
+            end
           end
 
           it 'calls the Proc when authenticating to obtain the request token' do
@@ -404,6 +499,18 @@ describe Ably::Auth do
             expect(token_details.issued).to be_within(1).of(issued)
             expect(token_details.capability).to eql(capability)
           end
+
+          context 'when authorised' do
+            before { auth.authorise(token_params, auth_callback: auth_callback) }
+
+            it "sets Auth#client_id to the new token's client_id" do
+              expect(auth.client_id).to eql(client_id)
+            end
+
+            it "sets Client#client_id to the new token's client_id" do
+              expect(client.client_id).to eql(client_id)
+            end
+          end
         end
 
         context 'that returns a TokenDetails object' do
@@ -602,6 +709,37 @@ describe Ably::Auth do
           end
         end
       end
+
+      context '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) }
+        let(: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) { auth_client.auth.request_token }
+
+          it 'rejects a TokenDetails object with an incompatible client_id and raises an exception' do
+            expect { client.auth.authorise({}, force: true) }.to raise_error Ably::Exceptions::IncompatibleClientId
+          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) { auth_client.auth.create_token_request }
+
+          it 'rejects a TokenRequests object with an incompatible client_id and raises an exception' do
+            expect { client.auth.authorise({}, force: true) }.to raise_error Ably::Exceptions::IncompatibleClientId
+          end
+        end
+
+        context 'and a token string without any retrievable client_id' do
+          let(:auth_token_object) { auth_client.auth.request_token(client_id: 'different').token }
+
+          it 'rejects a TokenRequests object with an incompatible client_id and raises an exception' do
+            client.auth.authorise({}, force: true)
+            expect(client.client_id).to eql(client_id)
+          end
+        end
+      end
     end
 
     describe '#create_token_request' do
@@ -799,7 +937,7 @@ describe Ably::Auth do
         end
       end
 
-      context 'when implicit as a result of using :client id' do
+      context 'when implicit as a result of using :client_id' do
         let(:client_id) { '999' }
         let(:client) do
           Ably::Rest::Client.new(key: api_key, client_id: client_id, environment: environment, protocol: protocol)
@@ -849,11 +987,91 @@ describe Ably::Auth do
             expect(token.expires.to_i).to be_within(2).of(Time.now.to_i + Ably::Auth::TOKEN_DEFAULTS.fetch(:ttl))
             expect(token.client_id).to eq(client_id)
           end
+
+          specify '#client_id contains the client_id' do
+            expect(client.auth.client_id).to eql(client_id)
+          end
+        end
+      end
+
+      context 'when :client_id is provided in a token' do
+        let(:client_id) { '123' }
+        let(:token) do
+          Ably::Rest::Client.new(key: api_key, environment: environment, protocol: protocol).auth.request_token(client_id: client_id)
+        end
+        let(:client) do
+          Ably::Rest::Client.new(token: token, environment: environment, protocol: protocol)
+        end
+
+        specify '#client_id contains the client_id' do
+          expect(client.auth.client_id).to eql(client_id)
+        end
+      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) }
+
+        it 'is false as basic auth users do not have an identity' do
+          expect(client.auth).to_not be_client_id_validated
+        end
+      end
+
+      context 'when using a token auth string for a token with a client_id' do
+        let(:client_options) { default_options.merge(token: auth.request_token(client_id: 'present').token) }
+
+        it 'is false as identification is not possible from an opaque token string' do
+          expect(client.auth).to_not be_client_id_validated
+        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
+          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
+          end
+        end
+
+        context 'with a wildcard client_id (anonymous)' do
+          let(:client_options) { default_options.merge(token: auth.request_token(client_id: '*')) }
+
+          it 'is false' do
+            expect(client.auth).to be_client_id_validated
+          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
+        end
+
+        context 'after authentication' do
+          before { client.channel('test').publish('a') }
+
+          it 'is true as identification is completed during implicit authentication' do
+            expect(client.auth).to be_client_id_validated
+          end
         end
       end
     end
 
-    context 'when using an :key and basic auth' do
+    context 'when using a :key and basic auth' do
       specify '#using_token_auth? is false' do
         expect(auth).to_not be_using_token_auth
       end

data/spec/acceptance/rest/channel_spec.rb

@@ -125,6 +125,137 @@ describe Ably::Rest::Channel do
           end
         end
       end
+
+      context 'identified clients' do
+        context 'when authenticated with a wildcard client_id' do
+          let(:token)            { Ably::Rest::Client.new(default_options).auth.request_token(client_id: '*') }
+          let(:client_options)   { default_options.merge(key: nil, token: token) }
+          let(:client)           { Ably::Rest::Client.new(client_options) }
+          let(:channel)          { client.channels.get(channel_name) }
+
+          context 'with a valid client_id in the message' do
+            it 'succeeds' do
+              channel.publish([name: 'event', client_id: 'valid'])
+                channel.history do |messages|
+                  expect(messages.first.client_id).to eql('valid')
+                end
+            end
+          end
+
+          context 'with a wildcard client_id in the message' do
+            it 'throws an exception' do
+              expect { channel.publish([name: 'event', client_id: '*']) }.to raise_error Ably::Exceptions::IncompatibleClientId
+            end
+          end
+
+          context 'with an empty client_id in the message' do
+            it 'succeeds and publishes without a client_id' do
+              channel.publish([name: 'event', client_id: nil])
+              channel.history do |messages|
+                expect(messages.first.client_id).to eql('valid')
+              end
+            end
+          end
+        end
+
+        context 'when authenticated with a Token string with an implicit client_id' do
+          let(:token)            { Ably::Rest::Client.new(default_options).auth.request_token(client_id: 'valid').token }
+          let(:client_options)   { default_options.merge(key: nil, token: token) }
+          let(:client)           { Ably::Rest::Client.new(client_options) }
+          let(:channel)          { client.channels.get(channel_name) }
+
+          context 'without having a confirmed identity' do
+            context 'with a valid client_id in the message' do
+              it 'succeeds' do
+                channel.publish([name: 'event', client_id: 'valid'])
+                channel.history do |messages|
+                  expect(messages.first.client_id).to eql('valid')
+                end
+              end
+            end
+
+            context 'with an invalid client_id in the message' do
+              it 'succeeds in the client library but then fails when published to Ably' do
+                expect { channel.publish([name: 'event', client_id: 'invalid']) }.to raise_error Ably::Exceptions::InvalidRequest, /mismatched clientId/
+              end
+            end
+
+            context 'with an empty client_id in the message' do
+              it 'succeeds and publishes with an implicit client_id' do
+                channel.publish([name: 'event', client_id: nil])
+                channel.history do |messages|
+                  expect(messages.first.client_id).to eql('valid')
+                end
+              end
+            end
+          end
+        end
+
+        context 'when authenticated with TokenDetails with a valid client_id' do
+          let(:token)            { Ably::Rest::Client.new(default_options).auth.request_token(client_id: 'valid') }
+          let(:client_options)   { default_options.merge(key: nil, token: token) }
+          let(:client)           { Ably::Rest::Client.new(client_options) }
+          let(:channel)          { client.channels.get(channel_name) }
+
+          context 'with a valid client_id in the message' do
+            it 'succeeds' do
+              channel.publish([name: 'event', client_id: 'valid'])
+              channel.history do |messages|
+                expect(messages.first.client_id).to eql('valid')
+              end
+            end
+          end
+
+          context 'with a wildcard client_id in the message' do
+            it 'throws an exception' do
+              expect { channel.publish([name: 'event', client_id: '*']) }.to raise_error Ably::Exceptions::IncompatibleClientId
+            end
+          end
+
+          context 'with an invalid client_id in the message' do
+            it 'throws an exception' do
+              expect { channel.publish([name: 'event', client_id: 'invalid']) }.to raise_error Ably::Exceptions::IncompatibleClientId
+            end
+          end
+
+          context 'with an empty client_id in the message' do
+            it 'succeeds and publishes with an implicit client_id' do
+              channel.publish([name: 'event', client_id: nil])
+              channel.history do |messages|
+                expect(messages.first.client_id).to eql('valid')
+              end
+            end
+          end
+        end
+
+        context 'when anonymous and no client_id' do
+          let(:token)            { Ably::Rest::Client.new(default_options).auth.request_token(client_id: nil) }
+          let(:client_options)   { default_options.merge(key: nil, token: token) }
+          let(:client)           { Ably::Rest::Client.new(client_options) }
+          let(:channel)          { client.channels.get(channel_name) }
+
+          context 'with a client_id in the message' do
+            it 'throws an exception' do
+              expect { channel.publish([name: 'event', client_id: '*']) }.to raise_error Ably::Exceptions::IncompatibleClientId
+            end
+          end
+
+          context 'with a wildcard client_id in the message' do
+            it 'throws an exception' do
+              expect { channel.publish([name: 'event', client_id: '*']) }.to raise_error Ably::Exceptions::IncompatibleClientId
+            end
+          end
+
+          context 'with an empty client_id in the message' do
+            it 'succeeds and publishes with an implicit client_id' do
+              channel.publish([name: 'event', client_id: nil])
+              channel.history do |messages|
+                expect(messages.first.client_id).to be_nil
+              end
+            end
+          end
+        end
+      end
     end
 
     describe '#history' do
@@ -246,7 +377,7 @@ describe Ably::Rest::Channel do
           let!(:history_stub) {
             query_params = default_history_options
             .merge(option => milliseconds).map { |k, v| "#{k}=#{v}" }.join('&')
-            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/messages?#{query_params}").
+            stub_request(:get, "#{endpoint}/channels/#{Addressable::URI.encode(channel_name)}/messages?#{query_params}").
               to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
           }
 

data/spec/acceptance/rest/client_spec.rb

@@ -8,7 +8,7 @@ describe Ably::Rest::Client do
 
     let(:client) { Ably::Rest::Client.new(client_options) }
 
-    connection_retry = Ably::Rest::Client::CONNECTION_RETRY
+    http_defaults = Ably::Rest::Client::HTTP_DEFAULTS
 
     def encode64(text)
       Base64.encode64(text).gsub("\n", '')
@@ -50,6 +50,12 @@ describe Ably::Rest::Client do
         end
       end
 
+      context 'with an invalid wildcard "*" :client_id' do
+        it 'raises an exception' do
+          expect { Ably::Rest::Client.new(client_options.merge(key: api_key, client_id: '*')) }.to raise_error ArgumentError
+        end
+      end
+
       context 'with an :auth_callback Proc' do
         let(:client) { Ably::Rest::Client.new(client_options.merge(auth_callback: Proc.new { token_request })) }
 
@@ -83,7 +89,7 @@ describe Ably::Rest::Client do
 
         context 'before any REST request' do
           before do
-            expect(client.auth).to receive(:token_request_from_auth_url).with(token_request_url, hash_including(:auth_method => :get)).once do
+            expect(client.auth).to receive(:token_request_from_auth_url).with(token_request_url, hash_including(:auth_method => :get), anything).once do
               client.auth.create_token_request(client_id: client_id)
             end
           end
@@ -154,8 +160,10 @@ describe Ably::Rest::Client do
           send("token_request_#{@request_index > 2 ? 'next' : @request_index}")
         end))
       end
-      let(:token_request_1) { client.auth.create_token_request({}, token_request_options.merge(client_id: random_str)) }
-      let(:token_request_2) { client.auth.create_token_request({}, token_request_options.merge(client_id: random_str)) }
+      let(:client_id)       { random_str }
+      let(:client_id_2)     { client_id }
+      let(:token_request_1) { client.auth.create_token_request({}, token_request_options.merge(client_id: client_id)) }
+      let(:token_request_2) { client.auth.create_token_request({}, token_request_options.merge(client_id: client_id_2)) }
 
       # If token expires against whilst runnig tests in a slower CI environment then use this token
       let(:token_request_next) { client.auth.create_token_request({}, token_request_options.merge(client_id: random_str)) }
@@ -177,6 +185,16 @@ describe Ably::Rest::Client do
           expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token_details }
           expect(client.auth.current_token_details.client_id).to eql(token_request_2.client_id)
         end
+
+        context 'with a different client_id in the subsequent token' do
+          let(:client_id_2) { random_str }
+
+          it 'fails to authenticate and raises an exception' do
+            client.channel('channel_name').publish('event', 'message')
+            sleep 1
+            expect { client.channel('channel_name').publish('event', 'message') }.to raise_error(Ably::Exceptions::IncompatibleClientId)
+          end
+        end
       end
 
       context 'when token has not expired' do
@@ -195,25 +213,53 @@ describe Ably::Rest::Client do
     end
 
     context 'connection transport' do
-      let(:client_options) { default_options.merge(key: api_key) }
+      context 'defaults' do
+        let(:client_options) { default_options.merge(key: api_key) }
+
+        context 'for default host' do
+          it "is configured to timeout connection opening in #{http_defaults.fetch(:open_timeout)} seconds" do
+            expect(client.connection.options.open_timeout).to eql(http_defaults.fetch(:open_timeout))
+          end
 
-      context 'for default host' do
-        it "is configured to timeout connection opening in #{connection_retry.fetch(:single_request_open_timeout)} seconds" do
-          expect(client.connection.options.open_timeout).to eql(connection_retry.fetch(:single_request_open_timeout))
+          it "is configured to timeout connection requests in #{http_defaults.fetch(:request_timeout)} seconds" do
+            expect(client.connection.options.timeout).to eql(http_defaults.fetch(:request_timeout))
+          end
         end
 
-        it "is configured to timeout connection requests in #{connection_retry.fetch(:single_request_timeout)} seconds" do
-          expect(client.connection.options.timeout).to eql(connection_retry.fetch(:single_request_timeout))
+        context 'for the fallback hosts' do
+          it "is configured to timeout connection opening in #{http_defaults.fetch(:open_timeout)} seconds" do
+            expect(client.fallback_connection.options.open_timeout).to eql(http_defaults.fetch(:open_timeout))
+          end
+
+          it "is configured to timeout connection requests in #{http_defaults.fetch(:request_timeout)} seconds" do
+            expect(client.fallback_connection.options.timeout).to eql(http_defaults.fetch(:request_timeout))
+          end
         end
       end
 
-      context 'for the fallback hosts' do
-        it "is configured to timeout connection opening in #{connection_retry.fetch(:single_request_open_timeout)} seconds" do
-          expect(client.fallback_connection.options.open_timeout).to eql(connection_retry.fetch(:single_request_open_timeout))
+      context 'with custom http_open_timeout and http_request_timeout options' do
+        let(:http_open_timeout)    { 999 }
+        let(:http_request_timeout) { 666 }
+        let(:client_options)       { default_options.merge(key: api_key, http_open_timeout: http_open_timeout, http_request_timeout: http_request_timeout) }
+
+        context 'for default host' do
+          it 'is configured to use custom open timeout' do
+            expect(client.connection.options.open_timeout).to eql(http_open_timeout)
+          end
+
+          it 'is configured to use custom request timeout' do
+            expect(client.connection.options.timeout).to eql(http_request_timeout)
+          end
         end
 
-        it "is configured to timeout connection requests in #{connection_retry.fetch(:single_request_timeout)} seconds" do
-          expect(client.fallback_connection.options.timeout).to eql(connection_retry.fetch(:single_request_timeout))
+        context 'for the fallback hosts' do
+          it "is configured to timeout connection opening in #{http_defaults.fetch(:open_timeout)} seconds" do
+            expect(client.fallback_connection.options.open_timeout).to eql(http_open_timeout)
+          end
+
+          it "is configured to timeout connection requests in #{http_defaults.fetch(:request_timeout)} seconds" do
+            expect(client.fallback_connection.options.timeout).to eql(http_request_timeout)
+          end
         end
       end
     end
@@ -249,19 +295,20 @@ describe Ably::Rest::Client do
 
       context 'when environment is production' do
         let(:custom_hosts)       { %w(A.ably-realtime.com B.ably-realtime.com) }
-        let(:max_attempts)       { 2 }
-        let(:cumulative_timeout) { 0.5 }
-        let(:client_options)     { default_options.merge(environment: nil, key: api_key) }
+        let(:max_retry_count)    { 2 }
+        let(:max_retry_duration) { 0.5 }
         let(:fallback_block)     { Proc.new { raise Faraday::SSLError.new('ssl error message') } }
+        let(:client_options) do
+          default_options.merge(
+            environment: nil,
+            key: api_key,
+            http_max_retry_duration: max_retry_duration,
+            http_max_retry_count: max_retry_count
+          )
+        end
 
         before do
           stub_const 'Ably::FALLBACK_HOSTS', custom_hosts
-          stub_const 'Ably::Rest::Client::CONNECTION_RETRY', {
-            single_request_open_timeout: 4,
-            single_request_timeout: 15,
-            cumulative_request_open_timeout: cumulative_timeout,
-            max_retry_attempts: max_attempts
-          }
         end
 
         let!(:first_fallback_request_stub) do
@@ -279,17 +326,17 @@ describe Ably::Rest::Client do
             end
           end
 
-          it "tries fallback hosts #{connection_retry[:max_retry_attempts]} times" do
+          it "tries fallback hosts #{http_defaults.fetch(:max_retry_count)} times" do
             expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionError, /ssl error message/
             expect(default_host_request_stub).to have_been_requested
             expect(first_fallback_request_stub).to have_been_requested
             expect(second_fallback_request_stub).to have_been_requested
           end
 
-          context "and the total request time exeeds #{connection_retry[:cumulative_request_open_timeout]} seconds" do
+          context "and the total request time exeeds #{http_defaults.fetch(:max_retry_duration)} seconds" do
             let!(:default_host_request_stub) do
               stub_request(:post, "https://#{api_key}@#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
-                sleep cumulative_timeout * 1.5
+                sleep max_retry_duration * 1.5
                 raise Faraday::TimeoutError.new('timeout error message')
               end
             end
@@ -310,7 +357,7 @@ describe Ably::Rest::Client do
             end
           end
 
-          it "tries fallback hosts #{connection_retry[:max_retry_attempts]} times" do
+          it "tries fallback hosts #{http_defaults.fetch(:max_retry_count)} times" do
             expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionError, /ssl error message/
             expect(default_host_request_stub).to have_been_requested
             expect(first_fallback_request_stub).to have_been_requested
@@ -429,6 +476,60 @@ describe Ably::Rest::Client do
       end
     end
 
+    context 'HTTP configuration options' do
+      let(:client_options) { default_options.merge(key: api_key) }
+
+      context 'defaults' do
+        specify '#http_open_timeout is 4s' do
+          expect(client.http_defaults[:open_timeout]).to eql(4)
+        end
+
+        specify '#http_request_timeout is 15s' do
+          expect(client.http_defaults[:request_timeout]).to eql(15)
+        end
+
+        specify '#http_max_retry_count is 3' do
+          expect(client.http_defaults[:max_retry_count]).to eql(3)
+        end
+
+        specify '#http_max_retry_duration is 10s' do
+          expect(client.http_defaults[:max_retry_duration]).to eql(10)
+        end
+      end
+
+      context 'configured' do
+        let(:client_options) do
+          default_options.merge(
+            key: api_key,
+            http_open_timeout: 1,
+            http_request_timeout: 2,
+            http_max_retry_count: 33,
+            http_max_retry_duration: 4
+          )
+        end
+
+        specify '#http_open_timeout uses provided value' do
+          expect(client.http_defaults[:open_timeout]).to eql(1)
+        end
+
+        specify '#http_request_timeout uses provided value' do
+          expect(client.http_defaults[:request_timeout]).to eql(2)
+        end
+
+        specify '#http_max_retry_count uses provided value' do
+          expect(client.http_defaults[:max_retry_count]).to eql(33)
+        end
+
+        specify '#http_max_retry_duration uses provided value' do
+          expect(client.http_defaults[:max_retry_duration]).to eql(4)
+        end
+      end
+
+      it 'is frozen' do
+        expect(client.http_defaults).to be_frozen
+      end
+    end
+
     context '#auth' do
       let(:dummy_auth_url) { 'http://dummy.url' }
       let(:unique_ttl)     { 1234 }