ably-rest 0.8.15 → 0.9.0

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

@@ -92,14 +92,12 @@ describe Ably::Realtime::Channel, :event_machine do
 
         it 'reattaches' do
           channel.attach do
-            channel.once(:failed) do
-              expect(channel).to be_failed
-              channel.attach do
-                expect(channel).to be_attached
-                stop_reactor
-              end
-            end
             channel.transition_state_machine :failed, reason: RuntimeError.new
+            expect(channel).to be_failed
+            channel.attach do
+              expect(channel).to be_attached
+              stop_reactor
+            end
           end
         end
       end
@@ -193,8 +191,8 @@ describe Ably::Realtime::Channel, :event_machine do
             restricted_channel.attach
             restricted_channel.once(:failed) do
               restricted_client.close do
-                # A direct call to #authorise is synchronous
-                restricted_client.auth.authorise({}, key: api_key)
+                # A direct call to #authorize is synchronous
+                restricted_client.auth.authorize({}, key: api_key)
 
                 restricted_client.connect do
                   restricted_channel.once(:attached) do
@@ -373,7 +371,7 @@ describe Ably::Realtime::Channel, :event_machine do
             expect(message_id.uniq.count).to eql(1)
 
             # Check that messages use index 0,1,2 in the ID
-            message_indexes = messages.map { |msg| msg.id.split(':').last }
+            message_indexes = messages.map { |msg| msg.id.split(':')[1] }
             expect(message_indexes).to include("0", "1", "2")
             stop_reactor
           end

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

@@ -62,7 +62,7 @@ describe Ably::Realtime::Client, :event_machine do
             context 'with valid :key and :use_token_auth option set to true' do
               let(:client_options)  { default_options.merge(use_token_auth: true) }
 
-              it 'automatically authorises on connect and generates a token' do
+              it 'automatically authorizes on connect and generates a token' do
                 connection.on(:connected) do
                   expect(subject.auth.current_token_details).to_not be_nil
                   expect(auth_params[:access_token]).to_not be_nil
@@ -116,7 +116,7 @@ describe Ably::Realtime::Client, :event_machine do
 
           context 'when the returned token has a client_id' do
             it "sets Auth#client_id to the new token's client_id immediately when connecting" do
-              subject.auth.authorise do
+              subject.auth.authorize do
                 expect(subject.connection).to be_connecting
                 expect(subject.auth.client_id).to eql(client_id)
                 stop_reactor
@@ -124,7 +124,7 @@ describe Ably::Realtime::Client, :event_machine do
             end
 
             it "sets Client#client_id to the new token's client_id immediately when connecting" do
-              subject.auth.authorise do
+              subject.auth.authorize do
                 expect(subject.connection).to be_connecting
                 expect(subject.client_id).to eql(client_id)
                 stop_reactor

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

@@ -60,9 +60,9 @@ describe Ably::Realtime::Connection, :event_machine do
 
         context 'for renewable tokens' do
           context 'that are valid for the duration of the test' do
-            context 'with valid pre authorised token expiring in the future' do
+            context 'with valid pre authorized token expiring in the future' do
               it 'uses the existing token created by Auth' do
-                client.auth.authorise(ttl: 300)
+                client.auth.authorize(ttl: 300)
                 expect(client.auth).to_not receive(:request_token)
                 connection.once(:connected) do
                   stop_reactor
@@ -101,8 +101,8 @@ describe Ably::Realtime::Connection, :event_machine do
             context 'opening a new connection' do
               context 'with almost expired tokens' do
                 before do
-                  # Authorise synchronously to ensure token has been issued
-                  client.auth.authorise_sync(ttl: ttl)
+                  # Authorize synchronously to ensure token has been issued
+                  client.auth.authorize_sync(ttl: ttl)
                 end
 
                 let(:ttl) { 2 }
@@ -615,23 +615,16 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
 
-      it 'is set to 0 when a message is received back' do
-        channel.publish('event', 'data')
-        channel.subscribe do
+      it 'is set to 0 when a message sent ACK is received' do
+        channel.publish('event', 'data') do
           expect(connection.serial).to eql(0)
           stop_reactor
         end
       end
 
-      it 'is set to 1 when the second message is received' do
+      it 'is set to 1 when the second message sent ACK is received' do
         channel.publish('event', 'data') do
-          channel.publish('event', 'data')
-        end
-
-        messages = []
-        channel.subscribe do |message|
-          messages << message
-          if messages.length == 2
+          channel.publish('event', 'data') do
             expect(connection.serial).to eql(1)
             stop_reactor
           end
@@ -891,16 +884,11 @@ describe Ably::Realtime::Connection, :event_machine do
             expect(connection.serial).to eql(expected_serial)
 
             channel.attach do
-              channel.publish('event', 'data')
-              channel.subscribe do
-                channel.unsubscribe
-
+              channel.publish('event', 'data') do
                 expected_serial += 1 # attach message received
                 expect(connection.serial).to eql(expected_serial)
 
-                channel.publish('event', 'data')
-                channel.subscribe do
-                  channel.unsubscribe
+                channel.publish('event', 'data') do
                   expected_serial += 1 # attach message received
                   expect(connection.serial).to eql(expected_serial)
 
@@ -1290,22 +1278,6 @@ describe Ably::Realtime::Connection, :event_machine do
     end
 
     context 'connection state change' do
-      # See https://github.com/ably/ably-ruby/issues/103
-      it 'emits event to all and single subscribers' do
-        connected_emitted = []
-        block = Proc.new do |state_change|
-          if state_change.current == :connected
-            connected_emitted << state_change
-            EventMachine.add_timer(0.5) do
-              expect(connected_emitted.length).to eql(2)
-              stop_reactor
-            end
-          end
-        end
-        connection.on(&block)
-        connection.on(:connected, &block)
-      end
-
       it 'emits a ConnectionStateChange object' do
         connection.on(:connected) do |connection_state_change|
           expect(connection_state_change).to be_a(Ably::Models::ConnectionStateChange)
@@ -1314,14 +1286,6 @@ describe Ably::Realtime::Connection, :event_machine do
       end
 
       context 'ConnectionStateChange object' do
-        def unbind
-          if connection.transport
-            connection.transport.unbind
-          else
-            EventMachine.add_timer(0.005) { unbind }
-          end
-        end
-
         it 'has current state' do
           connection.on(:connected) do |connection_state_change|
             expect(connection_state_change.current).to eq(:connected)
@@ -1385,7 +1349,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 expect(connection_state_change.retry_in).to eql(0)
                 stop_reactor
               end
-              unbind
+              EventMachine.add_timer(0.005) { connection.transport.unbind }
             end
           end
 
@@ -1406,7 +1370,7 @@ describe Ably::Realtime::Connection, :event_machine do
                   expect(connection_state_change.retry_in).to be > 0
                   stop_reactor
                 end
-                unbind
+                EventMachine.add_timer(0.005) { connection.transport.unbind }
               end
               connection.transport.unbind
             end

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

@@ -42,11 +42,9 @@ describe Ably::Realtime::Presence, :event_machine do
 
       def setup_test(method_name, args, options)
         if options[:enter_first]
-          presence_client_one.subscribe do
-            presence_client_one.unsubscribe
+          presence_client_one.public_send(method_name.to_s.gsub(/leave|update/, 'enter'), args) do
             yield
           end
-          presence_client_one.public_send(method_name.to_s.gsub(/leave|update/, 'enter'), args)
         else
           yield
         end
@@ -470,14 +468,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'once server sync is complete' do
         it 'behaves like an Enumerable allowing direct access to current members' do
-          presence_client_one.enter
-          presence_client_two.enter
-
-          entered = 0
-          presence_client_one.subscribe(:enter) do
-            entered += 1
-            next unless entered == 2
-
+          when_all(presence_client_one.enter, presence_client_two.enter) do
             presence_anonymous_client.members.once(:in_sync) do
               expect(presence_anonymous_client.members.count).to eql(2)
               member_ids = presence_anonymous_client.members.map(&:member_key)
@@ -504,10 +495,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'when attaching to a channel with members present' do
         it 'is false and the presence channel will subsequently be synced' do
-          presence_client_one.enter
-          presence_client_one.subscribe(:enter) do
-            presence_client_one.unsubscribe :enter
-
+          presence_client_one.enter do
             channel_anonymous_client.attach do
               expect(channel_anonymous_client.presence).to_not be_sync_complete
               channel_anonymous_client.presence.get(wait_for_sync: true) do
@@ -692,18 +680,16 @@ describe Ably::Realtime::Presence, :event_machine do
               it 'waits until sync is complete', em_timeout: 30 do # allow for slow connections and lots of messages
                 enter_expected_count.times do |index|
                   EventMachine.add_timer(index / 10) do
-                    presence_client_one.enter_client("client:#{index}")
-                  end
-                end
+                    presence_client_one.enter_client("client:#{index}") do |message|
+                      entered << message
+                      next unless entered.count == enter_expected_count
 
-                presence_client_one.subscribe(:enter) do |message|
-                  entered << message
-                  next unless entered.count == enter_expected_count
-
-                  presence_anonymous_client.get(wait_for_sync: true) do |members|
-                    expect(members.map(&:client_id).uniq.count).to eql(enter_expected_count)
-                    expect(members.count).to eql(enter_expected_count)
-                    stop_reactor
+                      presence_anonymous_client.get(wait_for_sync: true) do |members|
+                        expect(members.map(&:client_id).uniq.count).to eql(enter_expected_count)
+                        expect(members.count).to eql(enter_expected_count)
+                        stop_reactor
+                      end
+                    end
                   end
                 end
               end
@@ -711,21 +697,19 @@ describe Ably::Realtime::Presence, :event_machine do
 
             context 'by default' do
               it 'it does not wait for sync', em_timeout: 30 do # allow for slow connections and lots of messages
-                enter_expected_count.times do |indx|
-                  EventMachine.add_timer(indx / 10) do
-                    presence_client_one.enter_client "client:#{indx}"
-                  end
-                end
-
-                presence_client_one.subscribe(:enter) do |message|
-                  entered << message
-                  next unless entered.count == enter_expected_count
-
-                  channel_anonymous_client.attach do
-                    presence_anonymous_client.get do |members|
-                      expect(presence_anonymous_client.members).to_not be_in_sync
-                      expect(members.count).to eql(0)
-                      stop_reactor
+                enter_expected_count.times do |index|
+                  EventMachine.add_timer(index / 10) do
+                    presence_client_one.enter_client("client:#{index}") do |message|
+                      entered << message
+                      next unless entered.count == enter_expected_count
+
+                      channel_anonymous_client.attach do
+                        presence_anonymous_client.get do |members|
+                          expect(presence_anonymous_client.members).to_not be_in_sync
+                          expect(members.count).to eql(0)
+                          stop_reactor
+                        end
+                      end
                     end
                   end
                 end
@@ -912,25 +896,15 @@ describe Ably::Realtime::Presence, :event_machine do
 
         context 'and sync is complete' do
           it 'does not cache members that have left' do
-            enter_ack = false
-
-            presence_client_one.subscribe(:enter) do
-              presence_client_one.unsubscribe :enter
-
+            presence_client_one.enter enter_data do
               expect(presence_client_one.members).to be_in_sync
               expect(presence_client_one.members.send(:members).count).to eql(1)
               presence_client_one.leave data
             end
 
-            presence_client_one.enter(enter_data) do
-              enter_ack = true
-            end
-
             presence_client_one.subscribe(:leave) do |presence_message|
-              presence_client_one.unsubscribe :leave
               expect(presence_message.data).to eql(data)
               expect(presence_client_one.members.send(:members).count).to eql(0)
-              expect(enter_ack).to eql(true)
               stop_reactor
             end
           end
@@ -1316,9 +1290,7 @@ describe Ably::Realtime::Presence, :event_machine do
       # skip 'it fails if the connection changes to failed state'
 
       it 'returns the current members on the channel' do
-        presence_client_one.enter
-        presence_client_one.subscribe(:enter) do
-          presence_client_one.unsubscribe :enter
+        presence_client_one.enter do
           presence_client_one.get do |members|
             expect(members.count).to eq(1)
 
@@ -1379,10 +1351,7 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       it 'does not wait for SYNC to complete if :wait_for_sync option is false' do
-        presence_client_one.enter
-        presence_client_one.subscribe(:enter) do
-          presence_client_one.unsubscribe :enter
-
+        presence_client_one.enter do
           presence_client_two.get(wait_for_sync: false) do |members|
             expect(members.count).to eql(0)
             stop_reactor
@@ -1393,13 +1362,11 @@ describe Ably::Realtime::Presence, :event_machine do
       context 'when a member enters and then leaves' do
         it 'has no members' do
           presence_client_one.enter do
-            presence_client_one.leave
-          end
-
-          presence_client_one.subscribe(:leave) do
-            presence_client_one.get do |members|
-              expect(members.count).to eq(0)
-              stop_reactor
+            presence_client_one.leave do
+              presence_client_one.get do |members|
+                expect(members.count).to eq(0)
+                stop_reactor
+              end
             end
           end
         end
@@ -1557,10 +1524,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
     context 'REST #get' do
       it 'returns current members' do
-        presence_client_one.enter data_payload
-        presence_client_one.subscribe(:enter) do
-          presence_client_one.unsubscribe :enter
-
+        presence_client_one.enter(data_payload) do
           members_page = channel_rest_client_one.presence.get
           this_member = members_page.items.first
 
@@ -1574,10 +1538,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       it 'returns no members once left' do
         presence_client_one.enter(data_payload) do
-          presence_client_one.leave
-          presence_client_one.subscribe(:leave) do
-            presence_client_one.unsubscribe :leave
-
+          presence_client_one.leave do
             members_page = channel_rest_client_one.presence.get
             expect(members_page.items.count).to eql(0)
             stop_reactor
@@ -1693,8 +1654,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context '#get' do
         it 'returns a list of members with decrypted data' do
-          encrypted_channel.presence.enter(data)
-          encrypted_channel.presence.subscribe(:enter) do
+          encrypted_channel.presence.enter(data) do
             encrypted_channel.presence.get do |members|
               member = members.first
               expect(member.encoding).to be_nil
@@ -1707,8 +1667,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'REST #get' do
         it 'returns a list of members with decrypted data' do
-          encrypted_channel.presence.enter(data)
-          encrypted_channel.presence.subscribe(:enter) do
+          encrypted_channel.presence.enter(data) do
             member = channel_rest_client_one.presence.get.items.first
             expect(member.encoding).to be_nil
             expect(member.data).to eql(data)
@@ -1779,7 +1738,7 @@ describe Ably::Realtime::Presence, :event_machine do
     context 'connection failure mid-way through a large member sync' do
       let(:members_count) { 250 }
       let(:sync_pages_received) { [] }
-      let(:client_options)  { default_options.merge(log_level: :fatal) }
+      let(:client_options)  { default_options.merge(log_level: :error) }
 
       it 'resumes the SYNC operation', em_timeout: 15 do
         when_all(*members_count.times.map do |index|

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

@@ -445,8 +445,8 @@ describe Ably::Auth do
             expect(request_token.client_id).to eql(client_id)
           end
 
-          context 'when authorised' do
-            before { auth.authorise(token_params, auth_callback: auth_callback) }
+          context 'when authorized' do
+            before { auth.authorize(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)
@@ -500,8 +500,8 @@ describe Ably::Auth do
             expect(token_details.capability).to eql(capability)
           end
 
-          context 'when authorised' do
-            before { auth.authorise(token_params, auth_callback: auth_callback) }
+          context 'when authorized' do
+            before { auth.authorize(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)
@@ -583,13 +583,13 @@ describe Ably::Auth do
       end
     end
 
-    context 'before #authorise has been called' do
+    context 'before #authorize has been called' do
       it 'has no current_token_details' do
         expect(auth.current_token_details).to be_nil
       end
     end
 
-    describe '#authorise' do
+    describe '#authorize (#RSA10, #RSA10j)' do
       context 'when called for the first time since the client has been instantiated' do
         let(:auth_options) do
           { auth_url: 'http://somewhere.com/' }
@@ -600,15 +600,15 @@ describe Ably::Auth do
 
         it 'passes all auth_options and token_params to #request_token' do
           expect(auth).to receive(:request_token).with(token_params, auth_options)
-          auth.authorise token_params, auth_options
+          auth.authorize token_params, auth_options
         end
 
         it 'returns a valid token' do
-          expect(auth.authorise).to be_a(Ably::Models::TokenDetails)
+          expect(auth.authorize).to be_a(Ably::Models::TokenDetails)
         end
 
-        it 'issues a new token if option :force => true' do
-          expect { auth.authorise(force: true) }.to change { auth.current_token_details }
+        it 'issues a new token every time (#RSA10a)' do
+          expect { auth.authorize }.to change { auth.current_token_details }
         end
       end
 
@@ -624,8 +624,8 @@ describe Ably::Auth do
         it 'only queries the server time once and then works out the offset, query_time option is never persisted' do
           expect(client).to receive(:time).once.and_return(server_time)
 
-          auth.authorise({}, query_time: true)
-          auth.authorise({}, force: true)
+          auth.authorize({}, query_time: true)
+          auth.authorize({})
           expect(auth.auth_options).to_not have_key(:query_time)
         end
       end
@@ -634,26 +634,26 @@ describe Ably::Auth do
         let(:default_token_params) { { ttl: 23 } }
 
         before do
-          auth.authorise default_token_params
+          auth.authorize default_token_params
         end
 
         it 'has no effect on the defaults when null and TokenParam defaults remain the same' do
           old_token = auth.current_token_details
-          auth.authorise(nil, force: true)
+          auth.authorize
           expect(old_token).to_not eql(auth.current_token_details)
           expect(auth.token_params[:ttl]).to eql(23)
         end
 
         it 'updates defaults when present and all previous configured TokenParams are discarded' do
           old_token = auth.current_token_details
-          auth.authorise({ client_id: 'bob' }, { force: true })
+          auth.authorize({ client_id: 'bob' })
           expect(old_token).to_not eql(auth.current_token_details)
           expect(auth.token_params[:ttl]).to_not eql(23)
           expect(auth.token_params[:client_id]).to eql('bob')
         end
 
         it 'updates Auth#token_params attribute with an immutable hash' do
-          auth.authorise({ client_id: 'bob' }, { force: true })
+          auth.authorize({ client_id: 'bob' })
           expect { auth.token_params['key_name'] = 'new_name' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
         end
       end
@@ -669,68 +669,63 @@ describe Ably::Auth do
           stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', 0 # allow token to be used even if about to expire
           stub_const 'Ably::Auth::TOKEN_DEFAULTS', Ably::Auth::TOKEN_DEFAULTS.merge(renew_token_buffer: 0) # Ensure tokens issued expire immediately after issue
 
-          auth.authorise(nil, default_auth_options)
+          auth.authorize(nil, default_auth_options)
           @old_token = auth.current_token_details
           sleep token_ttl + 0.5
         end
 
         it 'has no effect on the defaults when null and AuthOptions defaults remain the same' do
-          auth.authorise(nil, nil)
+          auth.authorize(nil, nil)
           expect(@old_token).to_not eql(auth.current_token_details)
           expect(auth.options[:auth_callback]).to eql(auth_callback)
         end
 
         it 'updates defaults when present and all previous configured AuthOptions are discarded' do
-          auth.authorise(nil, auth_method: :post)
+          auth.authorize(nil, auth_method: :post)
           expect(@old_token).to_not eql(auth.current_token_details)
           expect(auth.options[:auth_callback]).to be_nil
           expect(auth.options[:auth_method]).to eql(:post)
         end
 
         it 'updates Auth#options attribute with an immutable hash' do
-          auth.authorise(nil, auth_callback: Proc.new { '1231232.12321:12321312' })
+          auth.authorize(nil, auth_callback: Proc.new { '1231232.12321:12321312' })
           expect { auth.options['key_name'] = 'new_name' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
         end
       end
 
       context 'with previous authorisation' do
         before do
-          auth.authorise
+          auth.authorize
           expect(auth.current_token_details).to_not be_expired
         end
 
-        it 'does not request a token if current_token_details has not expired' do
-          expect(auth).to_not receive(:request_token)
-          auth.authorise
-        end
-
         it 'requests a new token if token is expired' do
           allow(auth.current_token_details).to receive(:expired?).and_return(true)
           expect(auth).to receive(:request_token)
-          expect { auth.authorise }.to change { auth.current_token_details }
+          expect { auth.authorize }.to change { auth.current_token_details }
         end
 
-        it 'issues a new token if option :force => true' do
-          expect { auth.authorise({}, force: true) }.to change { auth.current_token_details }
+        it 'issues a new token every time #authorize is called' do
+          expect { auth.authorize({}) }.to change { auth.current_token_details }
         end
       end
 
-      it 'updates the persisted token params that are then used for subsequent authorise requests' do
+      it 'updates the persisted token params that are then used for subsequent authorize requests' do
         expect(auth.token_params[:ttl]).to_not eql(26)
-        auth.authorise(ttl: 26)
+        auth.authorize(ttl: 26)
         expect(auth.token_params[:ttl]).to eql(26)
       end
 
-      it 'updates the persisted auth options that are then used for subsequent authorise requests' do
+      it 'updates the persisted auth options that are then used for subsequent authorize requests' do
         expect(auth.options[:authUrl]).to be_nil
-        auth.authorise({}, authUrl: 'http://foo.com')
+        auth.authorize({}, authUrl: 'http://foo.com')
         expect(auth.options[:authUrl]).to eql('http://foo.com')
       end
 
       context 'with a Proc for the :auth_callback option' do
         let(:client_id) { random_str }
         let!(:token) do
-          auth.authorise({}, auth_callback: Proc.new do
+          auth.authorize({}, auth_callback: Proc.new do
             @block_called ||= 0
             @block_called += 1
             auth.create_token_request(client_id: client_id)
@@ -800,7 +795,7 @@ describe Ably::Auth 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
+            expect { client.auth.authorize({}) }.to raise_error Ably::Exceptions::IncompatibleClientId
           end
         end
 
@@ -808,7 +803,7 @@ describe Ably::Auth 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
+            expect { client.auth.authorize({}) }.to raise_error Ably::Exceptions::IncompatibleClientId
           end
         end
 
@@ -816,7 +811,7 @@ describe Ably::Auth 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)
+            client.auth.authorize({})
             expect(client.client_id).to eql(client_id)
           end
         end
@@ -838,7 +833,7 @@ describe Ably::Auth do
         auth_callback = Proc.new { subject }
         client_without_api_key = Ably::Rest::Client.new(default_options.merge(auth_callback: auth_callback))
         expect(client_without_api_key.auth).to be_using_token_auth
-        expect { client_without_api_key.auth.authorise }.to_not raise_error
+        expect { client_without_api_key.auth.authorize }.to_not raise_error
       end
 
       it 'uses the key name from the client' do
@@ -897,7 +892,7 @@ describe Ably::Auth do
         it 'uses these capabilities when Ably issues an actual token' do
           auth_callback = Proc.new { subject }
           client_without_api_key = Ably::Rest::Client.new(default_options.merge(auth_callback: auth_callback))
-          client_without_api_key.auth.authorise
+          client_without_api_key.auth.authorize
           expect(client_without_api_key.auth.current_token_details.capability).to eql(capability)
         end
       end
@@ -1008,7 +1003,7 @@ describe Ably::Auth do
               auth.create_token_request(token_attributes)
             end
             client = Ably::Rest::Client.new(auth_callback: auth_callback, environment: environment, protocol: protocol)
-            client.auth.authorise
+            client.auth.authorize
           end
         end
       end
@@ -1202,5 +1197,44 @@ describe Ably::Auth do
         expect(auth).to be_using_basic_auth
       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
+      end
+
+      it 'returns a valid token (#RSA10l)' do
+        response = client.auth.authorise
+        expect(response).to be_a(Ably::Models::TokenDetails)
+      end
+    end
   end
 end