ably-rest 0.8.15 → 0.9.0

data/lib/submodules/ably-ruby/lib/ably/modules/event_emitter.rb

@@ -50,14 +50,18 @@ module Ably
       #
       # @return [void]
       def on(*event_names, &block)
-        add_callback event_names, proc_for_block(block)
+        event_names.each do |event_name|
+          callbacks[callbacks_event_coerced(event_name)] << proc_for_block(block)
+        end
       end
 
       # Equivalent of {#on} but any exception raised in a block will bubble up and cause this client library to fail.
       # This method should only be used internally by the client library.
       # @api private
       def unsafe_on(*event_names, &block)
-        add_callback event_names, proc_for_block(block, unsafe: true)
+        event_names.each do |event_name|
+          callbacks[callbacks_event_coerced(event_name)] << proc_for_block(block, unsafe: true)
+        end
       end
 
       # On receiving an event maching the event_name, call the provided block only once and remove the registered callback
@@ -66,20 +70,24 @@ module Ably
       #
       # @return [void]
       def once(*event_names, &block)
-        add_callback event_names, proc_for_block(block, delete_once_run: true)
+        event_names.each do |event_name|
+          callbacks[callbacks_event_coerced(event_name)] << proc_for_block(block, delete_once_run: true)
+        end
       end
 
       # Equivalent of {#once} but any exception raised in a block will bubble up and cause this client library to fail.
       # This method should only be used internally by the client library.
       # @api private
       def unsafe_once(*event_names, &block)
-        add_callback event_names, proc_for_block(block, delete_once_run: true, unsafe: true)
+        event_names.each do |event_name|
+          callbacks[callbacks_event_coerced(event_name)] << proc_for_block(block, delete_once_run: true, unsafe: true)
+        end
       end
 
       # Emit an event with event_name that will in turn call all matching callbacks setup with `on`
       def emit(event_name, *args)
-        [callbacks_any, callbacks[callbacks_event_coerced(event_name)]].each do |callback_arr|
-          callback_arr.clone.
+        callbacks[callbacks_event_coerced(event_name)].
+          clone.
           select do |proc_hash|
             if proc_hash[:unsafe]
               proc_hash[:emit_proc].call(*args)
@@ -87,9 +95,8 @@ module Ably
               safe_yield proc_hash[:emit_proc], *args
             end
           end.each do |callback|
-            callback_arr.delete callback
+            callbacks[callbacks_event_coerced(event_name)].delete callback
           end
-        end
       end
 
       # Remove all callbacks for event_name.
@@ -114,14 +121,6 @@ module Ably
             callbacks[callbacks_event_coerced(event_name)].clear
           end
         end
-
-        if event_names.empty?
-          if block_given?
-            callbacks_any.delete_if { |proc_hash| proc_hash[:block] == block }
-          else
-            callbacks_any.clear
-          end
-        end
       end
 
       private
@@ -129,16 +128,6 @@ module Ably
         klass.extend ClassMethods
       end
 
-      def add_callback(event_names, proc_block)
-        if event_names.empty?
-          callbacks_any << proc_block
-        else
-          event_names.each do |event_name|
-            callbacks[callbacks_event_coerced(event_name)] << proc_block
-          end
-        end
-      end
-
       # Create a Hash with a proc that calls the provided block and returns true if option :delete_once_run is set to true.
       # #emit automatically deletes any blocks that return true thus allowing a block to be run once
       def proc_for_block(block, options = {})
@@ -156,10 +145,6 @@ module Ably
         @callbacks ||= Hash.new { |hash, key| hash[key] = [] }
       end
 
-      def callbacks_any
-        @callbacks_any ||= []
-      end
-
       def callbacks_event_coerced(event_name)
         if self.class.event_emitter_coerce_proc
           self.class.event_emitter_coerce_proc.call(event_name)

data/lib/submodules/ably-ruby/lib/ably/modules/model_common.rb

@@ -32,14 +32,6 @@ module Ably::Modules
       as_json.to_json(*args)
     end
 
-    # Like to_json but encodes all binary fields to hex
-    def to_safe_json(*args)
-      as_json.
-        each_with_object({}) do |(key, val), obj|
-          obj[key] = to_safe_jsonable_val(val)
-        end.to_json(*args)
-    end
-
     # @!attribute [r] hash
     # @return [Integer] Compute a hash-code for this hash. Two hashes with the same content will have the same hash code
     def hash
@@ -47,23 +39,6 @@ module Ably::Modules
     end
 
     private
-    def to_safe_jsonable_val(val)
-      case val
-      when Array
-        val.map { |array_val| to_safe_jsonable_val(array_val) }
-      when Hash
-        val.each_with_object({}) { |(key, hash_val), obj| obj[key] = to_safe_jsonable_val(hash_val) }
-      when String
-        if val.encoding == Encoding::ASCII_8BIT
-          val.unpack("H*").first
-        else
-          val
-        end
-      else
-        val
-      end
-    end
-
     def ensure_utf8_string_for(attribute, value)
       if value
         raise ArgumentError, "#{attribute} must be a String" unless value.kind_of?(String)

data/lib/submodules/ably-ruby/lib/ably/realtime/auth.rb

@@ -54,8 +54,8 @@ module Ably
       #
       # In the event that a new token request is made, the provided options are used
       #
-      # @param (see Ably::Auth#authorise)
-      # @option (see Ably::Auth#authorise)
+      # @param (see Ably::Auth#authorize)
+      # @option (see Ably::Auth#authorize)
       #
       # @return [Ably::Util::SafeDeferrable]
       # @yield [Ably::Models::TokenDetails]
@@ -63,13 +63,13 @@ module Ably
       # @example
       #    # will issue a simple token request using basic auth
       #    client = Ably::Rest::Client.new(key: 'key.id:secret')
-      #    client.auth.authorise do |token_details|
+      #    client.auth.authorize do |token_details|
       #      token_details #=> Ably::Models::TokenDetails
       #    end
       #
-      def authorise(token_params = nil, auth_options = nil, &success_callback)
+      def authorize(token_params = nil, auth_options = nil, &success_callback)
         async_wrap(success_callback) do
-          auth_sync.authorise(token_params, auth_options, &method(:upgrade_authentication_block).to_proc)
+          auth_sync.authorize(token_params, auth_options, &method(:upgrade_authentication_block).to_proc)
         end.tap do |deferrable|
           deferrable.errback do |error|
             client.connection.transition_state_machine :failed, reason: error if error.kind_of?(Ably::Exceptions::IncompatibleClientId)
@@ -77,13 +77,25 @@ module Ably
         end
       end
 
-      # Synchronous version of {#authorise}. See {Ably::Auth#authorise} for method definition
-      # @param (see Ably::Auth#authorise)
-      # @option (see Ably::Auth#authorise)
+      # @deprecated Use {#authorize} instead
+      def authorise(*args, &block)
+        logger.warn "Auth#authorise is deprecated and will be removed in 1.0. Please use Auth#authorize instead"
+        authorize(*args, &block)
+      end
+
+      # Synchronous version of {#authorize}. See {Ably::Auth#authorize} for method definition
+      # @param (see Ably::Auth#authorize)
+      # @option (see Ably::Auth#authorize)
       # @return [Ably::Models::TokenDetails]
       #
-      def authorise_sync(token_params = nil, auth_options = nil)
-        auth_sync.authorise(token_params, auth_options, &method(:upgrade_authentication_block).to_proc)
+      def authorize_sync(token_params = nil, auth_options = nil)
+        auth_sync.authorize(token_params, auth_options, &method(:upgrade_authentication_block).to_proc)
+      end
+
+      # @deprecated Use {#authorize_sync} instead
+      def authorise_sync(*args)
+        logger.warn "Auth#authorise_sync is deprecated and will be removed in 1.0. Please use Auth#authorize_sync instead"
+        authorize_sync(*args)
       end
 
       # def_delegator :auth_sync, :request_token, :request_token_sync
@@ -113,8 +125,8 @@ module Ably
       end
 
       # Synchronous version of {#request_token}. See {Ably::Auth#request_token} for method definition
-      # @param (see Ably::Auth#authorise)
-      # @option (see Ably::Auth#authorise)
+      # @param (see Ably::Auth#authorize)
+      # @option (see Ably::Auth#authorize)
       # @return [Ably::Models::TokenDetails]
       #
       def request_token_sync(token_params = {}, auth_options = {})
@@ -140,8 +152,8 @@ module Ably
       end
 
       # Synchronous version of {#create_token_request}. See {Ably::Auth#create_token_request} for method definition
-      # @param (see Ably::Auth#authorise)
-      # @option (see Ably::Auth#authorise)
+      # @param (see Ably::Auth#authorize)
+      # @option (see Ably::Auth#authorize)
       # @return [Ably::Models::TokenRequest]
       #
       def create_token_request_sync(token_params = {}, auth_options = {})
@@ -149,7 +161,7 @@ module Ably
       end
 
       # Auth header string used in HTTP requests to Ably
-      # Will reauthorise implicitly if required and capable
+      # Will reauthorize implicitly if required and capable
       #
       # @return [Ably::Util::SafeDeferrable]
       # @yield [String] HTTP authentication value used in HTTP_AUTHORIZATION header
@@ -168,7 +180,7 @@ module Ably
       end
 
       # Auth params used in URI endpoint for Realtime connections
-      # Will reauthorise implicitly if required and capable
+      # Will reauthorize implicitly if required and capable
       #
       # @return [Ably::Util::SafeDeferrable]
       # @yield [Hash] Auth params for a new Realtime connection
@@ -197,12 +209,12 @@ module Ably
         @client
       end
 
-      # If authorise is called with true, this block is executed so that it
+      # If authorize is called with true, this block is executed so that it
       # can perform the authentication upgrade
       def upgrade_authentication_block(new_token)
         # This block is called if the authorisation was forced
         if client.connection.connected? || client.connection.connecting?
-          logger.debug "Realtime::Auth - authorise called with { force: true } so forcibly disconnecting transport to initiate auth upgrade"
+          logger.debug "Realtime::Auth - authorize was called so forcibly disconnecting transport to initiate auth upgrade"
           block = Proc.new do
             if client.connection.transport
               logger.debug "Realtime::Auth - current transport disconnected"

data/lib/submodules/ably-ruby/lib/ably/realtime/channel/channel_manager.rb

@@ -58,7 +58,7 @@ module Ably::Realtime
       # all messages awaiting an ACK response should fail immediately
       def fail_messages_awaiting_ack(error)
         # Allow a short time for other queued operations to complete before failing all messages
-        EventMachine.next_tick do
+        EventMachine.add_timer(0.1) do
           error = Ably::Exceptions::MessageDeliveryFailed.new("Channel cannot publish messages whilst state is '#{channel.state}'") unless error
           fail_messages_in_queue connection.__pending_message_ack_queue__, error
           fail_messages_in_queue connection.__outgoing_message_queue__, error
@@ -76,10 +76,10 @@ module Ably::Realtime
 
       def nack_messages(protocol_message, error)
         (protocol_message.messages + protocol_message.presence).each do |message|
-          logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_safe_json}, protocol message: #{protocol_message}"
+          logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json}, protocol message: #{protocol_message}"
           message.fail error
         end
-        logger.debug "Calling NACK failure callbacks for #{protocol_message.class.name} - #{protocol_message.to_safe_json}"
+        logger.debug "Calling NACK failure callbacks for #{protocol_message.class.name} - #{protocol_message.to_json}"
         protocol_message.fail error
       end
 

data/lib/submodules/ably-ruby/lib/ably/realtime/client.rb

@@ -68,9 +68,6 @@ module Ably
       #
       # @param (see Ably::Rest::Client#initialize)
       # @option options (see Ably::Rest::Client#initialize)
-      # @option options [Proc]                    :auth_callback       when provided, the Proc will be called with the token params hash as the first argument, whenever a new token is required.
-      #                                                                Whilst the proc is called synchronously, it does not block the EventMachine reactor as it is run in a separate thread.
-      #                                                                The Proc should return a token string, {Ably::Models::TokenDetails} or JSON equivalent, {Ably::Models::TokenRequest} or JSON equivalent
       # @option options [Boolean] :queue_messages If false, this disables the default behaviour whereby the library queues messages on a connection in the disconnected or connecting states
       # @option options [Boolean] :echo_messages  If false, prevents messages originating from this connection being echoed back on the same connection
       # @option options [String]  :recover        When a recover option is specified a connection inherits the state of a previous connection that may have existed under a different instance of the Realtime library, please refer to the API documentation for further information on connection state recovery

data/lib/submodules/ably-ruby/lib/ably/realtime/client/incoming_message_dispatcher.rb

@@ -178,14 +178,14 @@ module Ably::Realtime
 
       def ack_messages(messages)
         messages.each do |message|
-          logger.debug "Calling ACK success callbacks for #{message.class.name} - #{message.to_safe_json}"
+          logger.debug "Calling ACK success callbacks for #{message.class.name} - #{message.to_json}"
           message.succeed message
         end
       end
 
       def nack_messages(messages, protocol_message)
         messages.each do |message|
-          logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_safe_json}, protocol message: #{protocol_message}"
+          logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json}, protocol message: #{protocol_message}"
           message.fail protocol_message.error
         end
       end

data/lib/submodules/ably-ruby/lib/ably/realtime/connection/connection_manager.rb

@@ -402,8 +402,8 @@ module Ably::Realtime
           @renewing_token = true
           logger.info "ConnectionManager: Token has expired and is renewable, renewing token now"
 
-          client.auth.authorise(nil, force: true).tap do |authorise_deferrable|
-            authorise_deferrable.callback do |token_details|
+          client.auth.authorize.tap do |authorize_deferrable|
+            authorize_deferrable.callback do |token_details|
               logger.info 'ConnectionManager: Token renewed succesfully following expiration'
 
               connection.once_state_changed { @renewing_token = false }
@@ -415,7 +415,7 @@ module Ably::Realtime
               end
             end
 
-            authorise_deferrable.errback do |auth_error|
+            authorize_deferrable.errback do |auth_error|
               @renewing_token = false
               logger.error "ConnectionManager: Error authorising following token expiry: #{auth_error}"
               connection.transition_state_machine :failed, reason: auth_error

data/lib/submodules/ably-ruby/lib/ably/realtime/presence/members_map.rb

@@ -200,7 +200,7 @@ module Ably::Realtime
         return unless ensure_presence_message_is_valid(presence_message)
 
         unless should_update_member?(presence_message)
-          logger.debug "#{self.class.name}: Skipped presence member #{presence_message.action} on channel #{presence.channel.name}.\n#{presence_message.to_safe_json}"
+          logger.debug "#{self.class.name}: Skipped presence member #{presence_message.action} on channel #{presence.channel.name}.\n#{presence_message.to_json}"
           return
         end
 
@@ -239,13 +239,13 @@ module Ably::Realtime
       end
 
       def add_presence_member(presence_message)
-        logger.debug "#{self.class.name}: Member '#{presence_message.member_key}' for event '#{presence_message.action}' #{members.has_key?(presence_message.member_key) ? 'updated' : 'added'}.\n#{presence_message.to_safe_json}"
+        logger.debug "#{self.class.name}: Member '#{presence_message.member_key}' for event '#{presence_message.action}' #{members.has_key?(presence_message.member_key) ? 'updated' : 'added'}.\n#{presence_message.to_json}"
         members[presence_message.member_key] = { present: true, message: presence_message }
         presence.emit_message presence_message.action, presence_message
       end
 
       def remove_presence_member(presence_message)
-        logger.debug "#{self.class.name}: Member '#{presence_message.member_key}' removed.\n#{presence_message.to_safe_json}"
+        logger.debug "#{self.class.name}: Member '#{presence_message.member_key}' removed.\n#{presence_message.to_json}"
 
         if in_sync?
           members.delete presence_message.member_key

data/lib/submodules/ably-ruby/lib/ably/rest/client.rb

@@ -285,14 +285,14 @@ module Ably
 
         response = case method.to_sym
         when :get
-          reauthorise_on_authorisation_failure do
+          reauthorize_on_authorisation_failure do
             send_request(method, path, params, headers: headers)
           end
         when :post
           path_with_params = Addressable::URI.new
           path_with_params.query_values = params || {}
           query = path_with_params.query
-          reauthorise_on_authorisation_failure do
+          reauthorize_on_authorisation_failure do
             send_request(method, "#{path}#{"?#{query}" unless query.nil? || query.empty?}", body, headers: headers)
           end
         end
@@ -414,10 +414,10 @@ module Ably
       private
       def raw_request(method, path, params = {}, options = {})
         options = options.clone
-        if options.delete(:disable_automatic_reauthorise) == true
+        if options.delete(:disable_automatic_reauthorize) == true
           send_request(method, path, params, options)
         else
-          reauthorise_on_authorisation_failure do
+          reauthorize_on_authorisation_failure do
             send_request(method, path, params, options)
           end
         end
@@ -464,11 +464,11 @@ module Ably
         end
       end
 
-      def reauthorise_on_authorisation_failure
+      def reauthorize_on_authorisation_failure
         yield
       rescue Ably::Exceptions::TokenExpired => e
         if auth.token_renewable?
-          auth.authorise(nil, force: true)
+          auth.authorize
           yield
         else
           raise e

data/lib/submodules/ably-ruby/lib/ably/version.rb

@@ -1,6 +1,6 @@
 module Ably
-  VERSION = '0.8.15'
-  PROTOCOL_VERSION = '0.8'
+  VERSION = '0.9.0'
+  PROTOCOL_VERSION = '0.9'
 
   # Allow a variant to be configured for all instances of this client library
   # such as ruby-rest-[VERSION]

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

@@ -73,7 +73,7 @@ describe Ably::Realtime::Auth, :event_machine do
       context '#current_token_details' do
         it 'contains the current token after auth' do
           expect(auth.current_token_details).to be_nil
-          auth.authorise do
+          auth.authorize do
             expect(auth.current_token_details).to be_a(Ably::Models::TokenDetails)
             stop_reactor
           end
@@ -93,7 +93,7 @@ describe Ably::Realtime::Auth, :event_machine do
         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
+          auth.authorize({}, auth_url: auth_url, auth_params: auth_params) do
             expect(auth.options[:auth_url]).to eql(auth_url)
             stop_reactor
           end
@@ -104,7 +104,7 @@ describe Ably::Realtime::Auth, :event_machine do
         let(:custom_ttl) { 33 }
 
         it 'contains the configured auth options' do
-          auth.authorise(ttl: custom_ttl) do
+          auth.authorize(ttl: custom_ttl) do
             expect(auth.token_params[:ttl]).to eql(custom_ttl)
             stop_reactor
           end
@@ -113,7 +113,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#using_basic_auth?' do
         it 'is false when using Token Auth' do
-          auth.authorise do
+          auth.authorize do
             expect(auth).to_not be_using_basic_auth
             stop_reactor
           end
@@ -122,7 +122,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
       context '#using_token_auth?' do
         it 'is true when using Token Auth' do
-          auth.authorise do
+          auth.authorize do
             expect(auth).to be_using_token_auth
             stop_reactor
           end
@@ -176,9 +176,9 @@ describe Ably::Realtime::Auth, :event_machine do
         end
       end
 
-      context '#authorise' do
+      context '#authorize' do
         it 'returns a token asynchronously' do
-          auth.authorise(ttl: custom_ttl, client_id: custom_client_id) do |token_details|
+          auth.authorize(ttl: custom_ttl, client_id: custom_client_id) do |token_details|
             expect(token_details).to be_a(Ably::Models::TokenDetails)
             expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
             expect(token_details.client_id).to eql(custom_client_id)
@@ -186,35 +186,6 @@ describe Ably::Realtime::Auth, :event_machine do
           end
         end
 
-        context 'with auth_callback blocking' do
-          let(:rest_auth_client) { Ably::Rest::Client.new(default_options.merge(key: api_key)) }
-          let(:client_options)   { default_options.merge(auth_callback: auth_callback) }
-          let(:pause)            { 5 }
-
-          context 'with a slow auth callback response' do
-            let(:auth_callback) do
-              Proc.new do
-                sleep pause
-                rest_auth_client.auth.request_token
-              end
-            end
-
-            it 'asynchronously authenticates' do
-              timers_called = 0
-              block = Proc.new do
-                timers_called += 1
-                EventMachine.add_timer(0.5, &block)
-              end
-              block.call
-              client.connect
-              client.connection.on(:connected) do
-                expect(timers_called).to be >= (pause-1) / 0.5
-                stop_reactor
-              end
-            end
-          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) }
@@ -271,7 +242,7 @@ describe Ably::Realtime::Auth, :event_machine do
           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.auth.authorize({})
                 client.connection.on(:error) do |error|
                   expect(error).to be_a(Ably::Exceptions::IncompatibleClientId)
                   EventMachine.add_timer(0.1) do
@@ -284,7 +255,7 @@ describe Ably::Realtime::Auth, :event_machine do
           end
         end
 
-        context 'with force: true to trigger an authentication upgrade' do
+        context 'when already authenticated with a valid token' do
           let(:rest_client)      { Ably::Rest::Client.new(default_options) }
           let(:client_publisher) { auto_close Ably::Realtime::Client.new(default_options) }
           let(:basic_capability) { JSON.dump("foo" => ["subscribe"]) }
@@ -308,7 +279,7 @@ describe Ably::Realtime::Auth, :event_machine do
           it 'forces the connection to disconnect and reconnect with a new token when in the CONNECTED state' do
             client.connection.once(:connected) do
               existing_token = client.auth.current_token_details
-              client.auth.authorise(nil, force: true)
+              client.auth.authorize(nil)
               client.connection.once(:disconnected) do
                 client.connection.once(:connected) do
                   expect(existing_token).to_not eql(client.auth.current_token_details)
@@ -321,7 +292,7 @@ describe Ably::Realtime::Auth, :event_machine do
           it 'forces the connection to disconnect and reconnect with a new token when in the CONNECTING state' do
             client.connection.once(:connecting) do
               existing_token = client.auth.current_token_details
-              client.auth.authorise(nil, force: true)
+              client.auth.authorize(nil)
               client.connection.once(:disconnected) do
                 client.connection.once(:connected) do
                   expect(existing_token).to_not eql(client.auth.current_token_details)
@@ -340,7 +311,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
             it 'transisitions the connection state to FAILED if the client_id changes' do
               client.connection.once(:connected) do
-                client.auth.authorise(nil, auth_callback: identified_token_cb, force: true)
+                client.auth.authorize(nil, auth_callback: identified_token_cb)
                 client.connection.once(:failed) do
                   expect(client.connection.error_reason.message).to match(/incompatible.*client ID/)
                   stop_reactor
@@ -358,7 +329,7 @@ describe Ably::Realtime::Auth, :event_machine do
                 channel.publish('not-allowed').errback do |error|
                   expect(error.code).to eql(40160)
                   expect(error.message).to match(/permission denied/)
-                  client.auth.authorise(nil, auth_callback: upgraded_token_cb, force: true)
+                  client.auth.authorize(nil, auth_callback: upgraded_token_cb)
                   client.connection.once(:connected) do
                     expect(client.connection.error_reason).to be_nil
                     channel.subscribe('allowed') do |message|
@@ -378,7 +349,7 @@ describe Ably::Realtime::Auth, :event_machine do
               client.connection.once(:connected) do
                 channel = client.channels.get('foo')
                 channel.attach do
-                  client.auth.authorise(nil, auth_callback: downgraded_token_cb, force: true)
+                  client.auth.authorize(nil, auth_callback: downgraded_token_cb)
                   channel.once(:failed) do
                     expect(channel.error_reason.code).to eql(40160)
                     expect(channel.error_reason.message).to match(/Channel denied access/)
@@ -401,7 +372,7 @@ describe Ably::Realtime::Auth, :event_machine do
                 publisher_channel.publish('foo') do
                   EventMachine.add_timer(2) do
                     expect(received_messages.length).to eql(1)
-                    client.auth.authorise(nil, force: true)
+                    client.auth.authorize(nil)
                     client.connection.once(:disconnected) do
                       publisher_channel.publish('bar') do
                         expect(received_messages.length).to eql(1)
@@ -422,9 +393,9 @@ describe Ably::Realtime::Auth, :event_machine do
           it 'does not change the connection state if current connection state is closing' do
             client.connection.once(:connected) do
               client.connection.once(:closing) do
-                client.auth.authorise(nil, force: true)
+                client.auth.authorize(nil)
                 client.connection.once(:connected) do
-                  raise "Should not reconnect following auth force: true"
+                  raise "Should not reconnect following #authorize"
                 end
                 EventMachine.add_timer(4) do
                   expect(client.connection).to be_closed
@@ -438,9 +409,9 @@ describe Ably::Realtime::Auth, :event_machine do
           it 'does not change the connection state if current connection state is closed' do
             client.connection.once(:connected) do
               client.connection.once(:closed) do
-                client.auth.authorise(nil, force: true)
+                client.auth.authorize(nil)
                 client.connection.once(:connected) do
-                  raise "Should not reconnect following auth force: true"
+                  raise "Should not reconnect following #authorize"
                 end
                 EventMachine.add_timer(4) do
                   expect(client.connection).to be_closed
@@ -457,9 +428,9 @@ describe Ably::Realtime::Auth, :event_machine do
             it 'does not change the connection state' do
               client.connection.once(:connected) do
                 client.connection.once(:failed) do
-                  client.auth.authorise(nil, force: true)
+                  client.auth.authorize(nil)
                   client.connection.once(:connected) do
-                    raise "Should not reconnect following auth force: true"
+                    raise "Should not reconnect following #authorize"
                   end
                   EventMachine.add_timer(4) do
                     expect(client.connection).to be_failed
@@ -474,10 +445,10 @@ describe Ably::Realtime::Auth, :event_machine do
         end
       end
 
-      context '#authorise_async' do
+      context '#authorize_async' do
         it 'returns a token synchronously' do
-          auth.authorise_sync(ttl: custom_ttl, client_id: custom_client_id).tap do |token_details|
-            expect(auth.authorise_sync).to be_a(Ably::Models::TokenDetails)
+          auth.authorize_sync(ttl: custom_ttl, client_id: custom_client_id).tap do |token_details|
+            expect(auth.authorize_sync).to be_a(Ably::Models::TokenDetails)
             expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
             expect(token_details.client_id).to eql(custom_client_id)
             stop_reactor
@@ -696,5 +667,47 @@ describe Ably::Realtime::Auth, :event_machine do
         end
       end
     end
+
+    context 'deprecated #authorise' do
+      let(:client_options)  { default_options.merge(key: api_key, logger: custom_logger_object) }
+      let(:custom_logger) do
+        Class.new do
+          def initialize
+            @messages = []
+          end
+
+          [:fatal, :error, :warn, :info, :debug].each do |severity|
+            define_method severity do |message|
+              @messages << [severity, message]
+            end
+          end
+
+          def logs
+            @messages
+          end
+
+          def level
+            1
+          end
+
+          def level=(new_level)
+          end
+        end
+      end
+      let(:custom_logger_object) { custom_logger.new }
+
+      it 'logs a deprecation warning (#RSA10l)' do
+        client.auth.authorise
+        expect(custom_logger_object.logs.find { |severity, message| message.match(/authorise.*deprecated/i)} ).to_not be_nil
+        stop_reactor
+      end
+
+      it 'returns a valid token (#RSA10l)' do
+        client.auth.authorise do |response|
+          expect(response).to be_a(Ably::Models::TokenDetails)
+          stop_reactor
+        end
+      end
+    end
   end
 end