ably 0.8.4 → 0.8.5

data/spec/acceptance/realtime/connection_spec.rb

@@ -11,7 +11,7 @@ describe Ably::Realtime::Connection, :event_machine do
     end
 
     let(:client_options) { default_options }
-    let(:client)         { Ably::Realtime::Client.new(client_options) }
+    let(:client)         { auto_close Ably::Realtime::Client.new(client_options) }
 
     before(:example) do
       EventMachine.add_shutdown_hook do
@@ -29,7 +29,7 @@ describe Ably::Realtime::Connection, :event_machine do
 
       context 'with :auto_connect option set to false' do
         let(:client) do
-          Ably::Realtime::Client.new(default_options.merge(auto_connect: false))
+          auto_close Ably::Realtime::Client.new(default_options.merge(auto_connect: false))
         end
 
         it 'does not connect automatically' do
@@ -96,7 +96,7 @@ describe Ably::Realtime::Connection, :event_machine do
               stub_const 'Ably::Auth::TOKEN_DEFAULTS', Ably::Auth::TOKEN_DEFAULTS.merge(renew_token_buffer: 0)
 
               # Authorise synchronously to ensure token has been issued
-              client.auth.authorise_sync(token_params: { ttl: ttl })
+              client.auth.authorise_sync(ttl: ttl)
             end
 
             let(:original_renew_token_buffer) { @original_renew_token_buffer }
@@ -158,7 +158,7 @@ describe Ably::Realtime::Connection, :event_machine do
             context 'when connected with a valid non-expired token' do
               context 'that then expires following the connection being opened' do
                 let(:ttl)     { 5 }
-                let(:channel) { client.channel('test') }
+                let(:channel) { client.channel(random_str) }
 
                 context 'the server' do
                   it 'disconnects the client, and the client automatically renews the token and then reconnects', em_timeout: 15 do
@@ -204,7 +204,8 @@ describe Ably::Realtime::Connection, :event_machine do
 
             let!(:expired_token_details) do
               # Request a token synchronously
-              Ably::Realtime::Client.new(default_options).auth.request_token_sync(token_params: { ttl: 0.01 })
+              token_client = auto_close Ably::Realtime::Client.new(default_options)
+              token_client.auth.request_token_sync(ttl: 0.01)
             end
 
             context 'opening a new connection' do
@@ -270,8 +271,7 @@ describe Ably::Realtime::Connection, :event_machine do
       end
 
       it 'calls the Deferrable callback on success' do
-        connection.connect.callback do |connection|
-          expect(connection).to be_a(Ably::Realtime::Connection)
+        connection.connect.callback do
           expect(connection.state).to eq(:connected)
           stop_reactor
         end
@@ -306,7 +306,8 @@ describe Ably::Realtime::Connection, :event_machine do
       end
 
       describe 'once connected' do
-        let(:connection2) {  Ably::Realtime::Client.new(client_options).connection }
+        let(:client2)     { auto_close Ably::Realtime::Client.new(client_options) }
+        let(:connection2) { client2.connection }
 
         describe 'connection#id' do
           it 'is a string' do
@@ -436,7 +437,7 @@ describe Ably::Realtime::Connection, :event_machine do
 
       it 'calls the Deferrable callback on success' do
         connection.connect do
-          connection.close.callback do |connection|
+          connection.close.callback do
             expect(connection).to be_a(Ably::Realtime::Connection)
             expect(connection.state).to eq(:closed)
             stop_reactor
@@ -576,7 +577,7 @@ describe Ably::Realtime::Connection, :event_machine do
       let(:channel_name) { random_str }
       let(:channel) { client.channel(channel_name) }
       let(:publishing_client) do
-        Ably::Realtime::Client.new(client_options)
+        auto_close Ably::Realtime::Client.new(client_options)
       end
       let(:publishing_client_channel) { publishing_client.channel(channel_name) }
       let(:client_options) { default_options.merge(log_level: :fatal) }
@@ -594,9 +595,10 @@ describe Ably::Realtime::Connection, :event_machine do
         def self.available_states
           [:connecting, :connected, :disconnected, :suspended, :failed]
         end
-        let(:available_states) { self.class.available_states}
+        let(:available_states) { self.class.available_states }
         let(:states)           { Hash.new }
         let(:client_options)   { default_options.merge(log_level: :none) }
+        let(:channel)          { client.channel(random_str) }
 
         it 'is composed of connection key and serial that is kept up to date with each message ACK received' do
           connection.on(:connected) do
@@ -604,7 +606,7 @@ describe Ably::Realtime::Connection, :event_machine do
             expect(connection.key).to_not be_nil
             expect(connection.serial).to eql(expected_serial)
 
-            client.channel('test').attach do |channel|
+            channel.attach do
               channel.publish('event', 'data') do
                 expected_serial += 1 # attach message received
                 expect(connection.serial).to eql(expected_serial)
@@ -670,9 +672,10 @@ describe Ably::Realtime::Connection, :event_machine do
             end
 
             connection.once(:failed) do
-              recover_client = Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
+              recover_client = auto_close Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
               recover_client.connection.on(:connected) do
-                expect(recover_client.connection.key).to eql(previous_connection_key)
+                expect(recover_client.connection.key[/^\w{5,}-/, 0]).to_not be_nil
+                expect(recover_client.connection.key[/^\w{5,}-/, 0]).to eql(previous_connection_key[/^\w{5,}-/, 0])
                 expect(recover_client.connection.id).to eql(previous_connection_id)
                 stop_reactor
               end
@@ -685,7 +688,7 @@ describe Ably::Realtime::Connection, :event_machine do
             end
 
             connection.once(:failed) do
-              recover_client = Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
+              recover_client = auto_close Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
               recover_client.connection.on_resume do
                 raise 'Should not call the resume callback'
               end
@@ -701,14 +704,15 @@ describe Ably::Realtime::Connection, :event_machine do
             let(:client_options)   { default_options.merge(log_level: :none) }
 
             it 'recovers server-side queued messages' do
-              channel.attach do |message|
+              channel.attach do
                 connection.transition_state_machine! :failed
               end
 
               connection.on(:failed) do
                 publishing_client_channel.publish('event', 'message') do
-                  recover_client = Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
-                  recover_client.channel(channel_name).attach do |recover_client_channel|
+                  recover_client = auto_close Ably::Realtime::Client.new(default_options.merge(recover: client.connection.recovery_key))
+                  recover_client_channel = recover_client.channel(channel_name)
+                  recover_client_channel.attach do
                     recover_client_channel.subscribe('event') do |message|
                       expect(message.data).to eql('message')
                       stop_reactor
@@ -737,9 +741,9 @@ describe Ably::Realtime::Connection, :event_machine do
           it 'emits a fatal error on the connection object, sets the #error_reason and disconnects' do
             connection.once(:error) do |error|
               expect(connection.state).to eq(:failed)
-              expect(error.message).to match(/Invalid connection key/)
-              expect(connection.error_reason.message).to match(/Invalid connection key/)
-              expect(connection.error_reason.code).to eql(40006)
+              expect(error.message).to match(/Invalid connectionKey/i)
+              expect(connection.error_reason.message).to match(/Invalid connectionKey/i)
+              expect(connection.error_reason.code).to eql(80018)
               expect(connection.error_reason).to eql(error)
               stop_reactor
             end
@@ -747,13 +751,13 @@ describe Ably::Realtime::Connection, :event_machine do
         end
 
         context 'with expired (missing) value sent to server' do
-          let(:client_options) { default_options.merge(recover: '0123456789abcdef:0', log_level: :fatal) }
+          let(:client_options) { default_options.merge(recover: 'wVIsgTHAB1UvXh7z-1991d8586:0', log_level: :fatal) }
 
           it 'emits an error on the connection object, sets the #error_reason, yet will connect anyway' do
             connection.once(:error) do |error|
               expect(connection.state).to eq(:connected)
-              expect(error.message).to match(/Invalid connection key/i)
-              expect(connection.error_reason.message).to match(/Invalid connection key/i)
+              expect(error.message).to match(/Unable to recover connection/i)
+              expect(connection.error_reason.message).to match(/Unable to recover connection/i)
               expect(connection.error_reason.code).to eql(80008)
               expect(connection.error_reason).to eql(error)
               stop_reactor
@@ -1046,7 +1050,7 @@ describe Ably::Realtime::Connection, :event_machine do
         end
 
         context 'retry_in' do
-          let(:client_options) { default_options.merge(log_level: :debug) }
+          let(:client_options) { default_options.merge(log_level: :error) }
 
           it 'is nil when a retry is not required' do
             connection.on(:connected) do |connection_state_change|
@@ -1061,7 +1065,7 @@ describe Ably::Realtime::Connection, :event_machine do
                 expect(connection_state_change.retry_in).to eql(0)
                 stop_reactor
               end
-              EventMachine.add_timer(0.001) { connection.transport.unbind }
+              EventMachine.add_timer(0.005) { connection.transport.unbind }
             end
           end
 
@@ -1082,7 +1086,7 @@ describe Ably::Realtime::Connection, :event_machine do
                   expect(connection_state_change.retry_in).to be > 0
                   stop_reactor
                 end
-                EventMachine.add_timer(0.001) { connection.transport.unbind }
+                EventMachine.add_timer(0.005) { connection.transport.unbind }
               end
               connection.transport.unbind
             end

data/spec/acceptance/realtime/message_spec.rb

@@ -9,12 +9,12 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
     let(:default_options) { options.merge(key: api_key, environment: environment, protocol: protocol) }
     let(:client_options)  { default_options }
     let(:client) do
-      Ably::Realtime::Client.new(client_options)
+      auto_close Ably::Realtime::Client.new(client_options)
     end
     let(:channel) { client.channel(channel_name) }
 
     let(:other_client) do
-      Ably::Realtime::Client.new(client_options)
+      auto_close Ably::Realtime::Client.new(client_options)
     end
     let(:other_client_channel) { other_client.channel(channel_name) }
 
@@ -181,12 +181,12 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
 
       context 'with :echo_messages option set to false' do
         let(:no_echo_client) do
-          Ably::Realtime::Client.new(default_options.merge(echo_messages: false, log_level: :debug))
+          auto_close Ably::Realtime::Client.new(default_options.merge(echo_messages: false))
         end
         let(:no_echo_channel) { no_echo_client.channel(channel_name) }
 
         let(:rest_client) do
-          Ably::Rest::Client.new(default_options.merge(log_level: :debug))
+          Ably::Rest::Client.new(default_options)
         end
 
         it 'will not echo messages to the client but will still broadcast messages to other connected clients', em_timeout: 10 do
@@ -275,7 +275,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
 
     context 'without suitable publishing permissions' do
       let(:restricted_client) do
-        Ably::Realtime::Client.new(options.merge(key: restricted_api_key, environment: environment, protocol: protocol, :log_level => :error))
+        auto_close Ably::Realtime::Client.new(options.merge(key: restricted_api_key, environment: environment, protocol: protocol, :log_level => :error))
       end
       let(:restricted_channel) { restricted_client.channel("cansubscribe:example") }
       let(:payload)            { 'Test message without permission to publish' }
@@ -283,8 +283,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       it 'calls the error callback' do
         restricted_channel.attach do
           deferrable = restricted_channel.publish('test_event', payload)
-          deferrable.errback do |message, error|
-            expect(message.data).to eql(payload)
+          deferrable.errback do |error|
             expect(error.status).to eql(401)
             stop_reactor
           end
@@ -418,31 +417,39 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
         let(:encrypted_channel_client1) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
         let(:encrypted_channel_client2) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
 
-        let(:data) { MessagePack.pack({ 'key' => random_str }) }
+        let(:data) { { 'key' => random_str } }
         let(:message_count) { 50 }
 
         it 'encrypts and decrypts all messages' do
-          messages_received = {
-            decrypted: 0,
-            encrypted: 0
-          }
+          messages_received = []
 
-          encrypted_channel_client2.attach do
-            encrypted_channel_client2.subscribe do |message|
-              expect(message.data).to eql("#{message.name}-#{data}")
+          encrypted_channel_client1.attach do
+            encrypted_channel_client1.subscribe do |message|
+              expect(message.data).to eql(MessagePack.pack(data.merge(index: message.name.to_i)))
               expect(message.encoding).to be_nil
-              messages_received[:decrypted] += 1
-              stop_reactor if messages_received[:decrypted] == message_count
+              messages_received << message
+              stop_reactor if messages_received.count == message_count
             end
 
-            encrypted_channel_client1.__incoming_msgbus__.subscribe(:message) do |message|
-              expect(message['encoding']).to match(/cipher\+/)
-              messages_received[:encrypted] += 1
+            message_count.times do |index|
+              encrypted_channel_client2.publish index.to_s, MessagePack.pack(data.merge(index: index))
             end
           end
+        end
+
+        it 'receives raw messages with the correct encoding' do
+          encrypted_channel_client1.attach do
+            client.connection.__incoming_protocol_msgbus__.unsubscribe # remove all listeners
+            client.connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+              if protocol_message.action == Ably::Models::ProtocolMessage::ACTION.Message
+                protocol_message.messages.each do |message|
+                  expect(message['encoding']).to match(/cipher\+/)
+                end
+                stop_reactor
+              end
+            end
 
-          message_count.times do |index|
-            encrypted_channel_client2.publish index.to_s, "#{index}-#{data}"
+            encrypted_channel_client2.publish 'name', MessagePack.pack('data')
           end
         end
       end
@@ -450,7 +457,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       context 'subscribing with a different transport protocol' do
         let(:other_protocol) { protocol == :msgpack ? :json : :msgpack }
         let(:other_client) do
-          Ably::Realtime::Client.new(default_options.merge(protocol: other_protocol))
+          auto_close Ably::Realtime::Client.new(default_options.merge(protocol: other_protocol))
         end
 
         let(:cipher_options)            { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
@@ -592,7 +599,7 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       let(:event_name)     { random_str }
       let(:message_state)  { [] }
       let(:connection)     { client.connection }
-      let(:client_options) { default_options.merge(:log_level => :debug) }
+      let(:client_options) { default_options.merge(:log_level => :none) }
       let(:msgs_received)  { [] }
 
       it 'publishes the message again, later receives the ACK and only one message is ever received from Ably' do

data/spec/acceptance/realtime/presence_history_spec.rb

@@ -7,11 +7,11 @@ describe Ably::Realtime::Presence, 'history', :event_machine do
 
     let(:channel_name)        { "persisted:#{random_str(2)}" }
 
-    let(:client_one)          { Ably::Realtime::Client.new(default_options.merge(client_id: random_str)) }
+    let(:client_one)          { auto_close Ably::Realtime::Client.new(default_options.merge(client_id: random_str)) }
     let(:channel_client_one)  { client_one.channel(channel_name) }
     let(:presence_client_one) { channel_client_one.presence }
 
-    let(:client_two)          { Ably::Realtime::Client.new(default_options.merge(client_id: random_str)) }
+    let(:client_two)          { auto_close Ably::Realtime::Client.new(default_options.merge(client_id: random_str)) }
     let(:channel_client_two)  { client_two.channel(channel_name) }
     let(:presence_client_two) { channel_client_two.presence }
 

data/spec/acceptance/realtime/presence_spec.rb

@@ -8,9 +8,9 @@ describe Ably::Realtime::Presence, :event_machine do
     let(:default_options) { { key: api_key, environment: environment, protocol: protocol } }
     let(:client_options)  { default_options }
 
-    let(:anonymous_client) { Ably::Realtime::Client.new(client_options) }
-    let(:client_one)       { Ably::Realtime::Client.new(client_options.merge(client_id: random_str)) }
-    let(:client_two)       { Ably::Realtime::Client.new(client_options.merge(client_id: random_str)) }
+    let(:anonymous_client) { auto_close Ably::Realtime::Client.new(client_options) }
+    let(:client_one)       { auto_close Ably::Realtime::Client.new(client_options.merge(client_id: random_str)) }
+    let(:client_two)       { auto_close Ably::Realtime::Client.new(client_options.merge(client_id: random_str)) }
 
     let(:channel_name)              { "presence-#{random_str(4)}" }
     let(:channel_anonymous_client)  { anonymous_client.channel(channel_name) }
@@ -72,7 +72,7 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         context 'when :queue_messages client option is false' do
-          let(:client_one) { Ably::Realtime::Client.new(default_options.merge(queue_messages: false, client_id: random_str)) }
+          let(:client_one) { auto_close Ably::Realtime::Client.new(default_options.merge(queue_messages: false, client_id: random_str)) }
 
           context 'and connection state initialized' do
             it 'raises an exception' do
@@ -94,7 +94,7 @@ describe Ably::Realtime::Presence, :event_machine do
           end
 
           context 'and connection state disconnected' do
-            let(:client_one) { Ably::Realtime::Client.new(default_options.merge(queue_messages: false, client_id: random_str, :log_level => :error)) }
+            let(:client_one) { auto_close Ably::Realtime::Client.new(default_options.merge(queue_messages: false, client_id: random_str, :log_level => :error)) }
 
             it 'raises an exception' do
               client_one.connection.once(:connected) do
@@ -277,8 +277,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
               presence_client_one.public_send(method_name, args).tap do |deferrable|
                 deferrable.callback { raise 'Should not succeed' }
-                deferrable.errback do |presence, error|
-                  expect(presence).to be_a(Ably::Realtime::Presence)
+                deferrable.errback do |error|
                   expect(error).to be_kind_of(Ably::Exceptions::BaseAblyException)
                   stop_reactor
                 end
@@ -663,7 +662,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
       context 'without necessary capabilities to join presence' do
         let(:restricted_client) do
-          Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
+          auto_close Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
         end
         let(:restricted_channel)  { restricted_client.channel("cansubscribe:channel") }
         let(:restricted_presence) { restricted_channel.presence }
@@ -880,7 +879,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
         context 'without necessary capabilities to enter on behalf of another client' do
           let(:restricted_client) do
-            Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
+            auto_close Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
           end
           let(:restricted_channel)  { restricted_client.channel("cansubscribe:channel") }
           let(:restricted_presence) { restricted_channel.presence }
@@ -1400,7 +1399,7 @@ describe Ably::Realtime::Presence, :event_machine do
       let(:client_id)   { random_str.encode(Encoding::ASCII_8BIT) }
 
       context 'in connection set up' do
-        let(:client_one)  { Ably::Realtime::Client.new(default_options.merge(client_id: client_id)) }
+        let(:client_one)  { auto_close Ably::Realtime::Client.new(default_options.merge(client_id: client_id)) }
 
         it 'is converted into UTF_8' do
           presence_client_one.enter
@@ -1413,7 +1412,7 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       context 'in channel options' do
-        let(:client_one)  { Ably::Realtime::Client.new(default_options) }
+        let(:client_one)  { auto_close Ably::Realtime::Client.new(default_options) }
 
         it 'is converted into UTF_8' do
           presence_client_one.enter(client_id: client_id)

data/spec/acceptance/realtime/stats_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Ably::Realtime::Client, '#stats', :event_machine do
   vary_by_protocol do
     let(:client) do
-      Ably::Realtime::Client.new(key: api_key, environment: environment, protocol: protocol)
+      auto_close Ably::Realtime::Client.new(key: api_key, environment: environment, protocol: protocol)
     end
 
     describe 'fetching stats' do

data/spec/acceptance/realtime/time_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Ably::Realtime::Client, '#time', :event_machine do
   vary_by_protocol do
     let(:client) do
-      Ably::Realtime::Client.new(key: api_key, environment: environment, protocol: protocol)
+      auto_close Ably::Realtime::Client.new(key: api_key, environment: environment, protocol: protocol)
     end
 
     describe 'fetching the service time' do

data/spec/acceptance/rest/auth_spec.rb

@@ -27,7 +27,7 @@ describe Ably::Auth do
 
   vary_by_protocol do
     let(:default_options) { { environment: environment, protocol: protocol } }
-    let(:client_options) { default_options.merge(key: api_key) }
+    let(:client_options)  { default_options.merge(key: api_key) }
     let(:client) do
       Ably::Rest::Client.new(client_options)
     end
@@ -66,10 +66,10 @@ describe Ably::Auth do
       let(:capability) { { :foo => ['publish'] } }
 
       let(:token_details) do
-        auth.request_token(token_params: {
+        auth.request_token(
           ttl:        ttl,
           capability: capability
-        })
+        )
       end
 
       it 'creates a TokenRequest automatically and sends it to Ably to obtain a token', webmock: true do
@@ -112,7 +112,7 @@ describe Ably::Auth do
               )
           end
 
-          before { auth.request_token token_params: token_params }
+          before { auth.request_token token_params }
 
           it "overrides default and uses camelCase notation for attributes" do
             expect(request_token_stub).to have_been_requested
@@ -126,7 +126,7 @@ describe Ably::Auth do
         let(:nonce)         { random_str }
         let(:auth_options)  { { key: "#{key_name}:#{key_secret}" } }
         let(:token_params)  { { nonce: nonce, timestamp: Time.now } }
-        let(:token_request) { auth.create_token_request(auth_options, token_params) }
+        let(:token_request) { auth.create_token_request(token_params, auth_options) }
         let(:mac) do
           hmac_for(token_request, key_secret)
         end
@@ -142,7 +142,7 @@ describe Ably::Auth do
               :headers => { 'Content-Type' => content_type })
         end
 
-        let!(:token) { auth.request_token(auth_options, token_params) }
+        let!(:token) { auth.request_token(token_params, auth_options) }
 
         specify 'key_name is used in request and signing uses key_secret' do
           expect(request_token_stub).to have_been_requested
@@ -156,7 +156,7 @@ describe Ably::Auth do
 
         let(:auth_options)  { { key_name: key_name, key_secret: key_secret } }
         let(:token_params)  { { nonce: nonce, timestamp: Time.now } }
-        let(:token_request) { auth.create_token_request(auth_options, token_params) }
+        let(:token_request) { auth.create_token_request(token_params, auth_options) }
         let(:mac) do
           hmac_for(token_request, key_secret)
         end
@@ -172,7 +172,7 @@ describe Ably::Auth do
               :headers => { 'Content-Type' => content_type })
         end
 
-        let!(:token) { auth.request_token(auth_options, token_params) }
+        let!(:token) { auth.request_token(token_params, auth_options) }
 
         specify 'key_name is used in request and signing uses key_secret' do
           expect(request_token_stub).to have_been_requested
@@ -184,7 +184,7 @@ describe Ably::Auth do
 
         it 'queries the server for the time' do
           expect(client).to receive(:time).and_call_original
-          auth.request_token(options)
+          auth.request_token({}, options)
         end
       end
 
@@ -193,7 +193,7 @@ describe Ably::Auth do
 
         it 'does not query the server for the time' do
           expect(client).to_not receive(:time)
-          auth.request_token(options)
+          auth.request_token({}, options)
         end
       end
 
@@ -237,7 +237,7 @@ describe Ably::Auth do
         end
 
         context 'when response from :auth_url is a valid token request' do
-          let!(:token) { auth.request_token(auth_options) }
+          let!(:token) { auth.request_token({}, auth_options) }
 
           it 'requests a token from :auth_url using an HTTP GET request' do
             expect(request_token_stub).to have_been_requested
@@ -290,7 +290,7 @@ describe Ably::Auth do
             }.to_json
           end
 
-          let!(:token_details) { auth.request_token(auth_options) }
+          let!(:token_details) { auth.request_token({}, auth_options) }
 
           it 'returns TokenDetails created from the token JSON' do
             expect(auth_url_request_stub).to have_been_requested
@@ -308,7 +308,7 @@ describe Ably::Auth do
           let(:auth_url_content_type) { 'text/plain' }
           let(:auth_url_response) { token }
 
-          let!(:token_details) { auth.request_token(auth_options) }
+          let!(:token_details) { auth.request_token({}, auth_options) }
 
           it 'returns TokenDetails created from the token JSON' do
             expect(auth_url_request_stub).to have_been_requested
@@ -325,7 +325,7 @@ describe Ably::Auth do
             end
 
             it 'raises ServerError' do
-              expect { auth.request_token auth_options }.to raise_error(Ably::Exceptions::ServerError)
+              expect { auth.request_token({}, auth_options) }.to raise_error(Ably::Exceptions::ServerError)
             end
           end
 
@@ -336,7 +336,7 @@ describe Ably::Auth do
             end
 
             it 'raises InvalidResponseBody' do
-              expect { auth.request_token auth_options }.to raise_error(Ably::Exceptions::InvalidResponseBody)
+              expect { auth.request_token({}, auth_options) }.to raise_error(Ably::Exceptions::InvalidResponseBody)
             end
           end
         end
@@ -350,12 +350,12 @@ describe Ably::Auth do
             Proc.new do |token_params_arg|
               @block_called = true
               expect(token_params_arg).to eq(token_params)
-              auth.create_token_request(token_params: { client_id: client_id })
+              auth.create_token_request(client_id: client_id)
             end
           end
           let(:token_params) { { ttl: ttl } }
           let!(:request_token) do
-            auth.request_token(auth_callback: auth_callback, token_params: token_params)
+            auth.request_token(token_params, auth_callback: auth_callback)
           end
 
           it 'calls the Proc with token_params when authenticating to obtain the request token' do
@@ -369,7 +369,7 @@ describe Ably::Auth do
 
         context 'that returns a TokenDetails JSON object' do
           let(:client_id)   { random_str }
-          let(:options)     { { client_id: client_id } }
+          let(:token_params){ { client_id: client_id } }
           let(:token)       { 'J_0Tlg.D7AVZkdOZW-PqNNGvCSp38' }
           let(:issued)      { Time.now }
           let(:expires)     { Time.now + 60}
@@ -377,7 +377,7 @@ describe Ably::Auth do
           let(:capability_str) { JSON.dump(capability) }
 
           let!(:token_details) do
-            auth.request_token(auth_callback: Proc.new do |token_params_arg|
+            auth.request_token(token_params, auth_callback: Proc.new do |token_params_arg|
               @block_called = true
               @block_params = token_params_arg
               {
@@ -388,12 +388,12 @@ describe Ably::Auth do
                 'expires' => expires.to_i * 1000,
                 'capability'=> capability_str
               }
-            end, token_params: options)
+            end)
           end
 
           it 'calls the Proc when authenticating to obtain the request token' do
             expect(@block_called).to eql(true)
-            expect(@block_params).to include(options)
+            expect(@block_params).to include(token_params)
           end
 
           it 'uses the token request returned from the callback when requesting a new token' do
@@ -410,10 +410,8 @@ describe Ably::Auth do
           let(:client_id)   { random_str }
 
           let!(:token_details) do
-            auth.request_token(auth_callback: Proc.new do |block_options|
-              auth.create_token_request(token_params: {
-                client_id: client_id
-              })
+            auth.request_token({}, auth_callback: Proc.new do |block_options|
+              auth.create_token_request(client_id: client_id)
             end)
           end
 
@@ -428,7 +426,7 @@ describe Ably::Auth do
           let(:token) { second_client.auth.request_token.token }
 
           let!(:token_details) do
-            auth.request_token(auth_callback: Proc.new do |block_options|
+            auth.request_token({}, auth_callback: Proc.new do |block_options|
               token
             end)
           end
@@ -440,10 +438,9 @@ describe Ably::Auth do
         end
       end
 
-      context 'persisted option', api_private: true do
+      context 'persisted option of token params', api_private: true do
         context 'when set to true', api_private: true do
-          let(:options) { { persisted: true } }
-          let(:token_details) { auth.request_token(token_params: options) }
+          let(:token_details) { auth.request_token(persisted: true) }
 
           it 'returns a token with a short token ID that is used to look up the token details' do
             expect(token_details.token.length).to be < 64
@@ -462,7 +459,7 @@ describe Ably::Auth do
 
       context 'with auth_option :client_id' do
         let(:client_id) { random_str }
-        let(:token_details) { auth.request_token(client_id: client_id) }
+        let(:token_details) { auth.request_token({}, client_id: client_id) }
 
         it 'returns a token with the client_id' do
           expect(token_details.client_id).to eql(client_id)
@@ -471,7 +468,7 @@ describe Ably::Auth do
 
       context 'with token_param :client_id' do
         let(:client_id) { random_str }
-        let(:token_details) { auth.request_token(token_params: { client_id: client_id }) }
+        let(:token_details) { auth.request_token(client_id: client_id) }
 
         it 'returns a token with the client_id' do
           expect(token_details.client_id).to eql(client_id)
@@ -495,8 +492,8 @@ describe Ably::Auth do
         end
 
         it 'passes all auth_options and token_params to #request_token' do
-          expect(auth).to receive(:request_token).with(auth_options, token_params)
-          auth.authorise auth_options, token_params
+          expect(auth).to receive(:request_token).with(token_params, auth_options)
+          auth.authorise token_params, auth_options
         end
 
         it 'returns a valid token' do
@@ -526,20 +523,26 @@ describe Ably::Auth do
         end
 
         it 'issues a new token if option :force => true' do
-          expect { auth.authorise(force: true) }.to change { auth.current_token_details }
+          expect { auth.authorise({}, force: true) }.to change { auth.current_token_details }
         end
       end
 
-      it 'updates the persisted auth options that are then used for subsequent authorise requests' do
-        expect(auth.options[:ttl]).to_not eql(26)
+      it 'updates the persisted token params that are then used for subsequent authorise requests' do
+        expect(auth.token_params[:ttl]).to_not eql(26)
         auth.authorise(ttl: 26)
-        expect(auth.options[:ttl]).to eql(26)
+        expect(auth.token_params[:ttl]).to eql(26)
+      end
+
+      it 'updates the persisted token params that are then used for subsequent authorise requests' do
+        expect(auth.options[:query_time]).to_not eql(true)
+        auth.authorise({}, query_time: true)
+        expect(auth.options[:query_time]).to eql(true)
       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.authorise({}, auth_callback: Proc.new do
             @block_called ||= 0
             @block_called += 1
             auth.create_token_request(client_id: client_id)
@@ -564,13 +567,41 @@ describe Ably::Auth do
 
           context 'with a provided block' do
             it 'does not call the originally provided Proc and calls the new #request_token :auth_callback Proc' do
-              auth.request_token(auth_callback: Proc.new { @request_block_called = true; auth.create_token_request })
+              auth.request_token({}, auth_callback: Proc.new { @request_block_called = true; auth.create_token_request })
               expect(@block_called).to eql(1)
               expect(@request_block_called).to eql(true)
             end
           end
         end
       end
+
+      context 'with an explicit token string that expires' do
+        context 'and a Proc for the :auth_callback option to provide a means to renew the token' do
+          before do
+            # Ensure a soon to expire token is not treated as expired
+            stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', 0
+            old_token_defaults = Ably::Auth::TOKEN_DEFAULTS
+            stub_const 'Ably::Auth::TOKEN_DEFAULTS', old_token_defaults.merge(renew_token_buffer: 0)
+          end
+
+          let(:token_client)   { Ably::Rest::Client.new(default_options.merge(key: api_key, token_params: { ttl: 3 })) }
+          let(:client_options) {
+            default_options.merge(token: token_client.auth.request_token.token, auth_callback: Proc.new do
+              @block_called ||= 0
+              @block_called += 1
+              token_client.auth.create_token_request
+            end)
+          }
+
+          it 'calls the Proc once the token has expired and the new token is used' do
+            client.stats
+            expect(@block_called).to be_nil
+            sleep 3.5
+            expect { client.stats }.to change { client.auth.current_token_details }
+            expect(@block_called).to eql(1)
+          end
+        end
+      end
     end
 
     describe '#create_token_request' do
@@ -578,7 +609,7 @@ describe Ably::Auth do
       let(:capability)   { { "foo" => ["publish"] } }
       let(:token_params) { Hash.new }
 
-      subject { auth.create_token_request(token_params: token_params) }
+      subject { auth.create_token_request(token_params) }
 
       it 'returns a TokenRequest object' do
         expect(subject).to be_a(Ably::Models::TokenRequest)
@@ -666,11 +697,11 @@ describe Ably::Auth do
         let(:client) { Ably::Rest::Client.new(auth_url: 'http://example.com', protocol: protocol) }
 
         it 'should raise an exception if key secret is missing' do
-          expect { auth.create_token_request(key_name: 'name') }.to raise_error Ably::Exceptions::TokenRequestFailed
+          expect { auth.create_token_request({}, key_name: 'name') }.to raise_error Ably::Exceptions::TokenRequestFailed
         end
 
         it 'should raise an exception if key name is missing' do
-          expect { auth.create_token_request(key_secret: 'secret') }.to raise_error Ably::Exceptions::TokenRequestFailed
+          expect { auth.create_token_request({}, key_secret: 'secret') }.to raise_error Ably::Exceptions::TokenRequestFailed
         end
       end
 
@@ -679,7 +710,7 @@ describe Ably::Auth do
           let(:time)         { Time.now - 30 }
           let(:auth_options) { { query_time: true } }
 
-          subject { auth.create_token_request(auth_options) }
+          subject { auth.create_token_request({}, auth_options) }
 
           it 'queries the server for the timestamp' do
             expect(client).to receive(:time).and_return(time)
@@ -733,10 +764,10 @@ describe Ably::Auth do
       describe 'with :token option' do
         let(:ttl) { 60 * 60 }
         let(:token_details) do
-          auth.request_token(token_params: {
+          auth.request_token(
             ttl:        ttl,
             capability: capability
-          })
+          )
         end
         let(:token) { token_details.token }
         let(:token_auth_client) do
@@ -756,7 +787,7 @@ describe Ably::Auth do
         end
 
         it 'fails if timestamp is invalid' do
-          expect { auth.request_token(token_params: { timestamp: Time.now - 180 }) }.to raise_error do |error|
+          expect { auth.request_token(timestamp: Time.now - 180) }.to raise_error do |error|
             expect(error).to be_a(Ably::Exceptions::InvalidRequest)
             expect(error.status).to eql(401)
             expect(error.code).to eql(40101)