ably 1.1.2 → 1.1.6

data/lib/ably/rest/client.rb

@@ -3,6 +3,9 @@ require 'json'
 require 'logger'
 require 'uri'
 
+require 'typhoeus'
+require 'typhoeus/adapters/faraday'
+
 require 'ably/rest/middleware/exceptions'
 
 module Ably
@@ -32,6 +35,13 @@ module Ably
 
       FALLBACK_RETRY_TIMEOUT = 10 * 60
 
+      # Faraday 1.0 introduced new error types, however we want to support Faraday <1 too which only used Faraday::ClientError
+      FARADAY_CLIENT_OR_SERVER_ERRORS = if defined?(Faraday::ParsingError)
+        [Faraday::ClientError, Faraday::ServerError, Faraday::ConnectionFailed, Faraday::SSLError, Faraday::ParsingError]
+      else
+        Faraday::ClientError
+      end
+
       def_delegators :auth, :client_id, :auth_options
 
       # Custom environment to use such as 'sandbox' when testing the client library against an alternate Ably environment
@@ -174,16 +184,18 @@ module Ably
         @idempotent_rest_publishing = options.delete(:idempotent_rest_publishing) || Ably.major_minor_version_numeric > 1.1
 
 
-        if options[:fallback_hosts_use_default] && options[:fallback_jhosts]
-          raise ArgumentError, "fallback_hosts_use_default cannot be set to trye when fallback_jhosts is also provided"
+        if options[:fallback_hosts_use_default] && options[:fallback_hosts]
+          raise ArgumentError, "fallback_hosts_use_default cannot be set to try when fallback_hosts is also provided"
         end
         @fallback_hosts = case
         when options.delete(:fallback_hosts_use_default)
           Ably::FALLBACK_HOSTS
         when options_fallback_hosts = options.delete(:fallback_hosts)
           options_fallback_hosts
-        when environment || custom_host || options[:realtime_host] || custom_port || custom_tls_port
+        when custom_host || options[:realtime_host] || custom_port || custom_tls_port
           []
+        when environment
+          CUSTOM_ENVIRONMENT_FALLBACKS_SUFFIXES.map { |host| "#{environment}#{host}" }
         else
           Ably::FALLBACK_HOSTS
         end
@@ -195,6 +207,8 @@ module Ably
         @http_defaults = HTTP_DEFAULTS.dup
         options.each do |key, val|
           if http_key = key[/^http_(.+)/, 1]
+            # Typhoeus converts decimal durations to milliseconds, so 0.0001 timeout is treated as 0 (no timeout)
+            val = 0.001 if val.kind_of?(Numeric) && (val > 0) && (val < 0.001)
             @http_defaults[http_key.to_sym] = val if val && @http_defaults.has_key?(http_key.to_sym)
           end
         end
@@ -336,14 +350,14 @@ module Ably
       #
       # @return [Ably::Models::HttpPaginatedResponse<>]
       def request(method, path, params = {}, body = nil, headers = {}, options = {})
-        raise "Method #{method.to_s.upcase} not supported" unless [:get, :put, :post].include?(method.to_sym)
+        raise "Method #{method.to_s.upcase} not supported" unless %i(get put patch post delete).include?(method.to_sym)
 
         response = case method.to_sym
-        when :get
+        when :get, :delete
           reauthorize_on_authorization_failure do
             send_request(method, path, params, headers: headers)
           end
-        when :post
+        when :post, :patch, :put
           path_with_params = Addressable::URI.new
           path_with_params.query_values = params || {}
           query = path_with_params.query
@@ -559,12 +573,14 @@ module Ably
               request.options.context = {} if request.options.context.nil?
               request.options.context[:request_id] = request_id
             end
+            if options[:qs_params]
+              request.params.merge!(options[:qs_params])
+            end
             unless options[:send_auth_header] == false
               request.headers[:authorization] = auth.auth_header
-              if options[:headers]
-                options[:headers].map do |key, val|
-                  request.headers[key] = val
-                end
+
+              options[:headers].to_h.merge(auth.extra_auth_headers).map do |key, val|
+                request.headers[key] = val
               end
             end
           end.tap do
@@ -578,7 +594,7 @@ module Ably
             end
           end
 
-        rescue Faraday::TimeoutError, Faraday::ClientError, Ably::Exceptions::ServerError => error
+        rescue *([Faraday::TimeoutError, Ably::Exceptions::ServerError] + FARADAY_CLIENT_OR_SERVER_ERRORS) => error
           retry_sequence_id ||= SecureRandom.urlsafe_base64(4)
           time_passed = Time.now - requested_at
 
@@ -598,7 +614,7 @@ module Ably
           case error
             when Faraday::TimeoutError
               raise Ably::Exceptions::ConnectionTimeout.new(error.message, nil, Ably::Exceptions::Codes::CONNECTION_TIMED_OUT, error, { request_id: request_id })
-            when Faraday::ClientError
+            when *FARADAY_CLIENT_OR_SERVER_ERRORS
               # request_id is also available in the request context
               raise Ably::Exceptions::ConnectionError.new(error.message, nil, Ably::Exceptions::Codes::CONNECTION_FAILED, error, { request_id: request_id })
             else
@@ -656,7 +672,7 @@ module Ably
         }
       end
 
-      # Return a Faraday middleware stack to initiate the Faraday::Connection with
+      # Return a Faraday middleware stack to initiate the Faraday::RackBuilder with
       #
       # @see http://mislav.uniqpath.com/2011/07/faraday-advanced-http/
       def middleware
@@ -668,8 +684,8 @@ module Ably
 
           setup_incoming_middleware builder, logger, fail_if_unsupported_mime_type: true
 
-          # Set Faraday's HTTP adapter
-          builder.adapter :excon
+          # Set Faraday's HTTP adapter with support for HTTP/2
+          builder.adapter :typhoeus, http_version: :httpv2_0
         end
       end
 

data/lib/ably/rest/middleware/fail_if_unsupported_mime_type.rb

@@ -7,7 +7,10 @@ module Ably
       class FailIfUnsupportedMimeType < Faraday::Response::Middleware
         def on_complete(env)
           unless env.response_headers['Ably-Middleware-Parsed'] == true
-            unless  (500..599).include?(env.status)
+            # Ignore empty body with success status code for no body response
+            return if env.body.to_s.empty? && env.status == 204
+
+            unless (500..599).include?(env.status)
               raise Ably::Exceptions::InvalidResponseBody,
                     "Content Type #{env.response_headers['Content-Type']} is not supported by this client library"
             end

data/lib/ably/version.rb

@@ -1,5 +1,5 @@
 module Ably
-  VERSION = '1.1.2'
+  VERSION = '1.1.6'
   PROTOCOL_VERSION = '1.1'
 
   # Allow a variant to be configured for all instances of this client library

data/spec/acceptance/realtime/auth_spec.rb

@@ -1058,7 +1058,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
           it 'disconnected includes and invalid signature message' do
             client.connection.once(:disconnected) do |state_change|
-              expect(state_change.reason.message.match(/invalid signature/i)).to_not be_nil
+              expect(state_change.reason.message.match(/signature verification failed/i)).to_not be_nil
               expect(state_change.reason.code).to eql(40144)
               stop_reactor
             end
@@ -1111,7 +1111,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
           it 'authentication fails and reason for disconnection is invalid signature' do
             client.connection.once(:disconnected) do |state_change|
-              expect(state_change.reason.message.match(/invalid signature/i)).to_not be_nil
+              expect(state_change.reason.message.match(/signature verification failed/i)).to_not be_nil
               expect(state_change.reason.code).to eql(40144)
               stop_reactor
             end
@@ -1143,7 +1143,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
           it 'fails with an invalid signature error' do
             client.connection.once(:disconnected) do |state_change|
-              expect(state_change.reason.message.match(/invalid signature/i)).to_not be_nil
+              expect(state_change.reason.message.match(/signature verification failed/i)).to_not be_nil
               expect(state_change.reason.code).to eql(40144)
               stop_reactor
             end

data/spec/acceptance/realtime/channel_spec.rb

@@ -83,6 +83,16 @@ describe Ably::Realtime::Channel, :event_machine do
           end
         end
 
+        it 'sets attach_serial property after the attachment (#RTL15a)' do
+          expect(channel.properties.attach_serial).to be_nil
+
+          channel.attach
+          channel.on(:attached) do
+            expect(channel.properties.attach_serial).to_not be_nil
+            stop_reactor
+          end
+        end
+
         it 'sends an ATTACH and waits for an ATTACHED (#RTL4c)' do
           connection.once(:connected) do
             attach_count = 0

data/spec/acceptance/realtime/client_spec.rb

@@ -87,22 +87,6 @@ describe Ably::Realtime::Client, :event_machine do
                 end
               end
             end
-
-            context 'with client_id' do
-              let(:client_options) do
-                default_options.merge(client_id: random_str)
-              end
-              it 'connects using token auth' do
-                run_reactor do
-                  connection.on(:connected) do
-                    expect(connection.state).to eq(:connected)
-                    expect(auth_params[:access_token]).to_not be_nil
-                    expect(auth_params[:key]).to be_nil
-                    stop_reactor
-                  end
-                end
-              end
-            end
           end
         end
 
@@ -249,6 +233,8 @@ describe Ably::Realtime::Client, :event_machine do
 
     context '#request (#RSC19*)' do
       let(:client_options) { default_options.merge(key: api_key) }
+      let(:device_id) { random_str }
+      let(:endpoint) { subject.rest_client.endpoint }
 
       context 'get' do
         it 'returns an HttpPaginatedResponse object' do
@@ -297,6 +283,76 @@ describe Ably::Realtime::Client, :event_machine do
           end
         end
       end
+
+
+      context 'post', :webmock do
+        before do
+          stub_request(:delete, "#{endpoint}/push/deviceRegistrations/#{device_id}/resetUpdateToken").
+            to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports post' do
+          subject.request(:delete, "push/deviceRegistrations/#{device_id}/resetUpdateToken").callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
+
+      context 'delete', :webmock do
+        before do
+          stub_request(:delete, "#{endpoint}/push/channelSubscriptions?deviceId=#{device_id}").
+            to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports delete' do
+          subject.request(:delete, "/push/channelSubscriptions", { deviceId: device_id}).callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
+
+      context 'patch', :webmock do
+        let(:body_params) { { 'metadata' => { 'key' => 'value' } } }
+
+        before do
+          stub_request(:patch, "#{endpoint}/push/deviceRegistrations/#{device_id}")
+            .with(body: serialize_body(body_params, protocol))
+            .to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports patch' do
+          subject.request(:patch, "/push/deviceRegistrations/#{device_id}", {}, body_params).callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
+
+      context 'put', :webmock do
+        let(:body_params) do
+          {
+            'id' => random_str,
+            'platform' => 'ios',
+            'formFactor' => 'phone',
+            'metadata' => { 'key' => 'value' }
+          }
+        end
+
+        before do
+          stub_request(:put, "#{endpoint}/push/deviceRegistrations/#{device_id}")
+            .with(body: serialize_body(body_params, protocol))
+            .to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports put' do
+          subject.request(:put, "/push/deviceRegistrations/#{device_id}", {}, body_params).callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
     end
 
     context '#publish (#TBC)' do

data/spec/acceptance/realtime/connection_failures_spec.rb

@@ -156,10 +156,20 @@ describe Ably::Realtime::Connection, 'failures', :event_machine do
 
               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' })
+                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
@@ -1423,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
@@ -1508,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

@@ -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
@@ -1179,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
@@ -1879,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