ably-rest 0.8.3 → 0.8.5

data/lib/submodules/ably-ruby/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,10 +181,14 @@ 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))
+          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)
+        end
+
         it 'will not echo messages to the client but will still broadcast messages to other connected clients', em_timeout: 10 do
           channel.attach do |echo_channel|
             no_echo_channel.attach do
@@ -196,13 +200,27 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
 
               echo_channel.subscribe('test_event') do |message|
                 expect(message.data).to eql(payload)
-                EventMachine.add_timer(1) do
+                EventMachine.add_timer(1.5) do
                   stop_reactor
                 end
               end
             end
           end
         end
+
+        it 'will not echo messages to the client from other REST clients publishing using that connection_ID', em_timeout: 10 do
+          skip 'Waiting on realtime#285 to be resolved'
+          no_echo_channel.attach do
+            no_echo_channel.subscribe('test_event') do |message|
+              fail "Message should not have been echoed back"
+            end
+
+            rest_client.channel(channel_name).publish('test_event', nil, connection_id: no_echo_client.connection.id)
+            EventMachine.add_timer(1.5) do
+              stop_reactor
+            end
+          end
+        end
       end
     end
 
@@ -257,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))
+        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' }
@@ -265,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
@@ -400,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
 
-          message_count.times do |index|
-            encrypted_channel_client2.publish index.to_s, "#{index}-#{data}"
+        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
+
+            encrypted_channel_client2.publish 'name', MessagePack.pack('data')
           end
         end
       end
@@ -432,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 } }
@@ -569,5 +594,103 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
         end
       end
     end
+
+    describe 'when message is published, the connection disconnects before the ACK is received, and the connection is resumed' do
+      let(:event_name)     { random_str }
+      let(:message_state)  { [] }
+      let(:connection)     { client.connection }
+      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
+        on_reconnected = Proc.new do
+          expect(message_state).to be_empty
+          EventMachine.add_timer(2) do
+            expect(message_state).to contain_exactly(:delivered)
+            # TODO: Uncomment once issue realtime#42 is resolved
+            # expect(msgs_received.length).to eql(1)
+            stop_reactor
+          end
+        end
+
+        connection.once(:connected) do
+          connection.transport.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+            if protocol_message.messages.find { |message| message.name == event_name }
+              EventMachine.add_timer(0.001) do
+                connection.transport.unbind # trigger failure
+                expect(message_state).to be_empty
+                connection.once :connected, &on_reconnected
+              end
+            end
+          end
+        end
+
+        channel.publish(event_name).tap do |deferrable|
+          deferrable.callback { message_state << :delivered }
+          deferrable.errback do
+            raise 'Message delivery should not fail'
+          end
+        end
+
+        channel.subscribe do |message|
+          msgs_received << message
+        end
+      end
+    end
+
+    describe 'when message is published, the connection disconnects before the ACK is received' do
+      let(:connection) { client.connection }
+      let(:event_name) { random_str }
+
+      describe 'the connection becomes suspended' do
+        let(:client_options) { default_options.merge(:log_level => :fatal) }
+
+        it 'calls the errback for all messages' do
+          connection.once(:connected) do
+            connection.transport.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+              if protocol_message.messages.find { |message| message.name == event_name }
+                EventMachine.add_timer(0.001) do
+                  connection.transition_state_machine :suspended
+                end
+              end
+            end
+          end
+
+          channel.publish(event_name).tap do |deferrable|
+            deferrable.callback do
+              raise 'Message delivery should not happen'
+            end
+            deferrable.errback do
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      describe 'the connection becomes failed' do
+        let(:client_options) { default_options.merge(:log_level => :none) }
+
+        it 'calls the errback for all messages' do
+          connection.once(:connected) do
+            connection.transport.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+              if protocol_message.messages.find { |message| message.name == event_name }
+                EventMachine.add_timer(0.001) do
+                  connection.transition_state_machine :failed, reason: RuntimeError.new
+                end
+              end
+            end
+          end
+
+          channel.publish(event_name).tap do |deferrable|
+            deferrable.callback do
+              raise 'Message delivery should not happen'
+            end
+            deferrable.errback do
+              stop_reactor
+            end
+          end
+        end
+      end
+    end
   end
 end

data/lib/submodules/ably-ruby/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/lib/submodules/ably-ruby/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) }
@@ -40,18 +40,29 @@ describe Ably::Realtime::Presence, :event_machine do
       end
 
       unless expected_state == :left
-        %w(detached failed).each do |state|
-          it "raise an exception if the channel is #{state}" do
-            setup_test(method_name, args, options) do
-              channel_client_one.attach do
-                channel_client_one.change_state state.to_sym
-                expect { presence_client_one.public_send(method_name, args) }.to raise_error Ably::Exceptions::InvalidStateChange, /Operation is not allowed when channel is in STATE.#{state}/i
+        it 'raise an exception if the channel is detached' do
+          setup_test(method_name, args, options) do
+            channel_client_one.attach do
+              channel_client_one.transition_state_machine :detaching
+              channel_client_one.once(:detached) do
+                expect { presence_client_one.public_send(method_name, args) }.to raise_error Ably::Exceptions::InvalidStateChange, /Operation is not allowed when channel is in STATE.detached/i
                 stop_reactor
               end
             end
           end
         end
 
+        it 'raise an exception if the channel is failed' do
+          setup_test(method_name, args, options) do
+            channel_client_one.attach do
+              channel_client_one.transition_state_machine :failed
+              expect(channel_client_one.state).to eq(:failed)
+              expect { presence_client_one.public_send(method_name, args) }.to raise_error Ably::Exceptions::InvalidStateChange, /Operation is not allowed when channel is in STATE.failed/i
+              stop_reactor
+            end
+          end
+        end
+
         it 'implicitly attaches the channel' do
           expect(channel_client_one).to_not be_attached
           presence_client_one.public_send(method_name, args) do
@@ -61,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
@@ -83,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
@@ -266,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
@@ -652,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 }
@@ -869,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 }
@@ -1061,16 +1071,25 @@ describe Ably::Realtime::Presence, :event_machine do
         presence_client_one.get { raise 'Intentional exception' }
       end
 
-      %w(detached failed).each do |state|
-        it "raise an exception if the channel is #{state}" do
-          channel_client_one.attach do
-            channel_client_one.change_state state.to_sym
-            expect { presence_client_one.get }.to raise_error Ably::Exceptions::InvalidStateChange, /Operation is not allowed when channel is in STATE.#{state}/i
+      it 'raise an exception if the channel is detached' do
+        channel_client_one.attach do
+          channel_client_one.transition_state_machine :detaching
+          channel_client_one.once(:detached) do
+            expect { presence_client_one.get }.to raise_error Ably::Exceptions::InvalidStateChange, /Operation is not allowed when channel is in STATE.detached/i
             stop_reactor
           end
         end
       end
 
+      it 'raise an exception if the channel is failed' do
+        channel_client_one.attach do
+          channel_client_one.transition_state_machine :failed
+          expect(channel_client_one.state).to eq(:failed)
+          expect { presence_client_one.get }.to raise_error Ably::Exceptions::InvalidStateChange, /Operation is not allowed when channel is in STATE.failed/i
+          stop_reactor
+        end
+      end
+
       context 'during a sync' do
         let(:pages) { 2 }
         let(:members_per_page) { 100 }
@@ -1120,8 +1139,8 @@ describe Ably::Realtime::Presence, :event_machine do
                   if protocol_message.action == :sync
                     # prevent any more SYNC messages coming through
                     client_two.connection.transport.__incoming_protocol_msgbus__.unsubscribe
-                    channel_client_two.change_state :detaching
-                    channel_client_two.change_state :detached
+                    channel_client_two.transition_state_machine :detaching
+                    channel_client_two.transition_state_machine :detached
                   end
                 end
               end
@@ -1380,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
@@ -1393,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)
@@ -1565,6 +1584,7 @@ describe Ably::Realtime::Presence, :event_machine do
     context 'connection failure mid-way through a large member sync' do
       let(:members_count) { 400 }
       let(:sync_pages_received) { [] }
+      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/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/lib/submodules/ably-ruby/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/lib/submodules/ably-ruby/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)