ably-rest 1.0.5 → 1.1.3

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Realtime::Push, :event_machine do
+  vary_by_protocol do
+    let(:default_options) { { key: api_key, environment: environment, protocol: protocol} }
+    let(:client_options)  { default_options }
+    let(:client) do
+      Ably::Realtime::Client.new(client_options)
+    end
+    subject { client.push }
+
+    describe '#activate' do
+      it 'raises an unsupported exception' do
+        expect { subject.activate('foo') }.to raise_error(Ably::Exceptions::PushNotificationsNotSupported)
+        stop_reactor
+      end
+    end
+
+    describe '#deactivate' do
+      it 'raises an unsupported exception' do
+        expect { subject.deactivate('foo') }.to raise_error(Ably::Exceptions::PushNotificationsNotSupported)
+        stop_reactor
+      end
+    end
+  end
+end

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

@@ -472,7 +472,7 @@ describe Ably::Auth do
           end
 
           let(:auth_callback) do
-            Proc.new do |token_params_arg|
+            lambda do |token_params_arg|
               @block_called = true
               @block_params = token_params_arg
               {
@@ -486,7 +486,7 @@ describe Ably::Auth do
             end
           end
 
-          it 'calls the Proc when authenticating to obtain the request token' do
+          it 'calls the lambda when authenticating to obtain the request token' do
             expect(@block_called).to eql(true)
             expect(@block_params).to include(token_params)
           end
@@ -517,7 +517,7 @@ describe Ably::Auth do
           let(:client_id)   { random_str }
 
           let!(:token_details) do
-            auth.request_token({}, auth_callback: Proc.new do |block_options|
+            auth.request_token({}, auth_callback: lambda do |token_params|
               auth.create_token_request(client_id: client_id)
             end)
           end
@@ -533,7 +533,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: lambda do |token_params|
               token
             end)
           end
@@ -689,7 +689,7 @@ describe Ably::Auth do
 
       context 'AuthOptions argument' do
         let(:token_ttl) { 2 }
-        let(:auth_callback) { Proc.new do
+        let(:auth_callback) { lambda do |token_params|
           auth.create_token_request(ttl: token_ttl)
         end }
         let(:default_auth_options) { { auth_callback: auth_callback } }
@@ -717,7 +717,7 @@ describe Ably::Auth do
         end
 
         it 'updates Auth#options attribute with an immutable hash' do
-          auth.authorize(nil, auth_callback: Proc.new { '1231232.12321:12321312' })
+          auth.authorize(nil, auth_callback: lambda { |token_params| '1231232.12321:12321312' })
           expect { auth.options['key_name'] = 'new_name' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
         end
 
@@ -758,22 +758,23 @@ describe Ably::Auth do
       end
 
       it 'updates the persisted auth options that are then used for subsequent authorize requests' do
-        expect(auth.options[:authUrl]).to be_nil
-        auth.authorize({}, authUrl: 'http://foo.com')
-        expect(auth.options[:authUrl]).to eql('http://foo.com')
+        auth_url = "https://echo.ably.io/?type=text&body=#{auth.request_token.token}"
+        expect(auth.options[:auth_url]).to be_nil
+        auth.authorize({}, auth_url: auth_url)
+        expect(auth.options[:auth_url]).to eql(auth_url)
       end
 
-      context 'with a Proc for the :auth_callback option' do
+      context 'with a lambda for the :auth_callback option' do
         let(:client_id) { random_str }
         let!(:token) do
-          auth.authorize({}, auth_callback: Proc.new do
+          auth.authorize({}, auth_callback: lambda do |token_params|
             @block_called ||= 0
             @block_called += 1
             auth.create_token_request(client_id: client_id)
           end)
         end
 
-        it 'calls the Proc' do
+        it 'calls the lambda' do
           expect(@block_called).to eql(1)
         end
 
@@ -782,7 +783,7 @@ describe Ably::Auth do
         end
 
         context 'for every subsequent #request_token' do
-          context 'without a :auth_callback Proc' do
+          context 'without a :auth_callback lambda' do
             it 'calls the originally provided block' do
               auth.request_token
               expect(@block_called).to eql(2)
@@ -790,8 +791,8 @@ describe Ably::Auth do
           end
 
           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 })
+            it 'does not call the originally provided lambda and calls the new #request_token :auth_callback lambda' do
+              auth.request_token({}, auth_callback: lambda { |token_params| @request_block_called = true; auth.create_token_request })
               expect(@block_called).to eql(1)
               expect(@request_block_called).to eql(true)
             end
@@ -800,7 +801,7 @@ describe Ably::Auth do
       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
+        context 'and a lambda 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
@@ -811,13 +812,13 @@ describe Ably::Auth do
 
           let(:token_client)   { Ably::Rest::Client.new(default_options.merge(key: api_key, default_token_params: { ttl: 3 })) }
           let(:client_options) {
-            default_options.merge(token: token_client.auth.request_token.token, auth_callback: Proc.new do
+            default_options.merge(token: token_client.auth.request_token.token, auth_callback: lambda do |token_params|
               @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
+          it 'calls the lambda once the token has expired and the new token is used' do
             client.stats
             expect(@block_called).to eql(0)
             sleep 3.5
@@ -829,7 +830,7 @@ describe Ably::Auth do
 
       context 'with an explicit ClientOptions client_id' do
         let(:client_id)       { random_str }
-        let(:client_options)  { default_options.merge(auth_callback: Proc.new { auth_token_object }, client_id: client_id) }
+        let(:client_options)  { default_options.merge(auth_callback: lambda { |token_params| auth_token_object }, client_id: client_id) }
         let(:auth_client)     { Ably::Rest::Client.new(default_options.merge(key: api_key, client_id: 'invalid')) }
 
         context 'and an incompatible client_id in a TokenDetails object passed to the auth callback' do
@@ -871,7 +872,7 @@ describe Ably::Auth do
       end
 
       it 'returns a TokenRequest that can be passed to a client that can use it for authentication without an API key' do
-        auth_callback = Proc.new { subject }
+        auth_callback = proc { |token_params| 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.authorize }.to_not raise_error
@@ -932,7 +933,7 @@ describe Ably::Auth do
         end
 
         it 'uses these capabilities when Ably issues an actual token' do
-          auth_callback = Proc.new { subject }
+          auth_callback = lambda { |token_params| subject }
           client_without_api_key = Ably::Rest::Client.new(default_options.merge(auth_callback: auth_callback))
           client_without_api_key.auth.authorize
           expect(client_without_api_key.auth.current_token_details.capability).to eql(capability)
@@ -1041,7 +1042,7 @@ describe Ably::Auth do
           end
 
           it 'is valid when used for authentication' do
-            auth_callback = Proc.new do
+            auth_callback = lambda do |callback|
               auth.create_token_request(token_attributes)
             end
             client = Ably::Rest::Client.new(auth_callback: auth_callback, environment: environment, protocol: protocol)
@@ -1324,36 +1325,9 @@ describe Ably::Auth do
       end
     end
 
-    context 'deprecated #authorise' do
+    context 'deprecated #authorise', :prevent_log_stubbing do
       let(:client_options)  { default_options.merge(key: api_key, logger: custom_logger_object, use_token_auth: true) }
-      let(:custom_logger) do
-        Class.new do
-          def initialize
-            @messages = []
-          end
-
-          [:fatal, :error, :warn, :info, :debug].each do |severity|
-            define_method severity do |message, &block|
-              message_val = [message]
-              message_val << block.call if block
-
-              @messages << [severity, message_val.compact.join(' ')]
-            end
-          end
-
-          def logs
-            @messages
-          end
-
-          def level
-            1
-          end
-
-          def level=(new_level)
-          end
-        end
-      end
-      let(:custom_logger_object) { custom_logger.new }
+      let(:custom_logger_object) { TestLogger.new }
 
       it 'logs a deprecation warning (#RSA10l)' do
         client.auth.authorise
@@ -1365,5 +1339,42 @@ describe Ably::Auth do
         expect(response).to be_a(Ably::Models::TokenDetails)
       end
     end
+
+    # RSC1, RSC1a, RSA3c, RSA3d
+    context 'when using JWT' do
+      let(:auth_url) { 'https://echo.ably.io/createJWT' }
+      let(:token) { Faraday.get("#{auth_url}?keyName=#{key_name}&keySecret=#{key_secret}").body }
+      let(:client) { Ably::Rest::Client.new(token: token, environment: environment, protocol: protocol) }
+
+      it 'authenticates correctly using the JWT token generated by the echo server' do
+        expect(client.stats).to_not be_nil()
+      end
+
+      context 'when the JWT embeds an Ably token' do
+        let(:token) { Faraday.post(auth_url, { keyName: key_name, keySecret: key_secret, jwtType: :embedded }).body }
+
+        it 'authenticates correctly using the embedded token' do
+          expect(client.stats).to_not be_nil()
+        end
+
+        context 'and the requested token is encrypted' do
+          let(:token) { Faraday.post(auth_url, { keyName: key_name, keySecret: key_secret, jwtType: :embedded, encrypted: 1 }).body }
+
+          it 'authenticates correctly using the embedded token' do
+            expect(client.stats).to_not be_nil()
+          end
+        end
+      end
+
+      # RSA4f, RSA8c
+      context 'when the token requested is returned with application/jwt content type' do
+        let(:auth_rest_client) { Ably::Rest::Client.new(default_options.merge(key: api_key)) }
+        let(:auth_params) { { keyName: key_name, keySecret: key_secret, returnType: 'jwt' } }
+        let(:token) { auth_rest_client.auth.request_token({ }, { auth_url: auth_url, auth_params: auth_params }).token }
+        it 'authenticates correctly and pulls stats' do
+          expect(client.stats).to_not be_nil()
+        end
+      end
+    end
   end
 end

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

@@ -7,7 +7,7 @@ describe Ably::Rest do
 
     let(:client_options) { {} }
     let(:client) do
-      Ably::Rest::Client.new(client_options.merge(key: 'appid.keyuid:keysecret'))
+      Ably::Rest::Client.new(client_options.merge(key: 'appid.keyuid:keysecret', log_retries_as_info: true))
     end
 
     let(:now) { Time.now - 1000 }
@@ -67,7 +67,7 @@ describe Ably::Rest do
 
   vary_by_protocol do
     let(:client) do
-      Ably::Rest::Client.new(key: api_key, environment: environment, protocol: protocol)
+      Ably::Rest::Client.new(key: api_key, environment: environment, protocol: protocol, log_retries_as_info: true)
     end
 
     describe 'failed requests' do

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

@@ -40,7 +40,7 @@ describe Ably::Rest::Channel do
 
         it 'publishes the message without a client_id' do
           expect(client).to receive(:post).
-            with("/channels/#{channel_name}/publish", hash_excluding(client_id: client_id)).
+            with("/channels/#{channel_name}/publish", hash_excluding(client_id: client_id), {}).
             and_return(double('response', status: 201))
 
           expect(channel.publish(name, data)).to eql(true)
@@ -82,6 +82,44 @@ describe Ably::Rest::Channel do
         end
       end
 
+      context 'with a Message object' do
+        let(:name) { random_str }
+
+        let(:message) do
+          Ably::Models::Message(name: name, data: data)
+        end
+
+        it 'publishes the message' do
+          expect(client).to receive(:post).once.and_call_original
+          expect(channel.publish(message)).to eql(true)
+          expect(channel.history.items.first.name).to eql(name)
+        end
+      end
+
+      context 'with a Message object and query params' do
+        let(:message) do
+          Ably::Models::Message(name: name, data: data)
+        end
+
+        it 'should fail to publish the message (RSL1l1)' do
+          expect(client).to receive(:post).once.and_call_original
+          expect { channel.publish(message, { _forceNack: 'true' }) }.to raise_error(Ably::Exceptions::InvalidRequest, /40099/)
+        end
+      end
+
+      context 'with Messages and query params' do
+        let(:messages) do
+          10.times.map do |index|
+            { name: index.to_s, data: { "index" => index + 10 } }
+          end
+        end
+
+        it 'should fail to publish the message (RSL1l1)' do
+          expect(client).to receive(:post).once.and_call_original
+          expect { channel.publish(messages, { _forceNack: 'true' }) }.to raise_error(Ably::Exceptions::InvalidRequest, /40099/)
+        end
+      end
+
       context 'without adequate permissions on the channel' do
         let(:capability)     { { onlyChannel: ['subscribe'] } }
         let(:client_options) { default_options.merge(use_token_auth: true, default_token_params: { capability: capability }) }
@@ -96,7 +134,7 @@ describe Ably::Rest::Channel do
           let(:data) { random_str }
 
           it 'publishes the message without a name attribute in the payload' do
-            expect(client).to receive(:post).with(anything, { "data" => data }).once.and_call_original
+            expect(client).to receive(:post).with(anything, { "data" => data }, {}).once.and_call_original
             expect(channel.publish(nil, data)).to eql(true)
             expect(channel.history.items.first.name).to be_nil
             expect(channel.history.items.first.data).to eql(data)
@@ -107,7 +145,7 @@ describe Ably::Rest::Channel do
           let(:name) { random_str }
 
           it 'publishes the message without a data attribute in the payload' do
-            expect(client).to receive(:post).with(anything, { "name" => name }).once.and_call_original
+            expect(client).to receive(:post).with(anything, { "name" => name }, {}).once.and_call_original
             expect(channel.publish(name)).to eql(true)
             expect(channel.history.items.first.name).to eql(name)
             expect(channel.history.items.first.data).to be_nil
@@ -118,7 +156,7 @@ describe Ably::Rest::Channel do
           let(:name) { random_str }
 
           it 'publishes the message without any attributes in the payload' do
-            expect(client).to receive(:post).with(anything, {}).once.and_call_original
+            expect(client).to receive(:post).with(anything, {}, {}).once.and_call_original
             expect(channel.publish(nil)).to eql(true)
             expect(channel.history.items.first.name).to be_nil
             expect(channel.history.items.first.data).to be_nil
@@ -275,6 +313,43 @@ describe Ably::Rest::Channel do
           end
         end
       end
+
+      context 'with a frozen message event name' do
+        let(:event_name) { random_str.freeze }
+
+        it 'succeeds and publishes with an implicit client_id' do
+          channel.publish([name: event_name])
+          channel.publish(event_name)
+
+          if !(RUBY_VERSION.match(/^1\./) || RUBY_VERSION.match(/^2\.[012]/))
+            channel.publish(+'foo-bar') # new style freeze, see https://github.com/ably/ably-ruby/issues/132
+          else
+            channel.publish('foo-bar'.freeze) # new + style not supported until Ruby 2.3
+          end
+
+          channel.history do |messages|
+            expect(messages.length).to eql(3)
+            expect(messages.first.name).to eql(event_name)
+            expect(messages[1].name).to eql(event_name)
+            expect(messages.last.name).to eql('foo-bar')
+          end
+        end
+      end
+
+      context 'with a frozen payload' do
+        let(:payload) { { foo: random_str.freeze }.freeze }
+
+        it 'succeeds and publishes with an implicit client_id' do
+          channel.publish([data: payload])
+          channel.publish(nil, payload)
+
+          channel.history do |messages|
+            expect(messages.length).to eql(2)
+            expect(messages.first.data).to eql(payload)
+            expect(messages.last.data).to eql(payload)
+          end
+        end
+      end
     end
 
     describe '#history' do

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

@@ -60,5 +60,11 @@ describe Ably::Rest::Channels do
       let(:channel_with_options) { client.channels[channel_name, options] }
       it_behaves_like 'a channel'
     end
+
+    describe 'using a frozen channel name' do
+      let(:channel) { client.channels[channel_name.freeze] }
+      let(:channel_with_options) { client.channels[channel_name.freeze, options] }
+      it_behaves_like 'a channel'
+    end
   end
 end

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

@@ -4,7 +4,7 @@ require 'webrick'
 
 describe Ably::Rest::Client do
   vary_by_protocol do
-    let(:default_options) { { environment: environment, protocol: protocol } }
+    let(:default_options) { { environment: environment, protocol: protocol, log_retries_as_info: true } }
     let(:client_options)  { default_options }
 
     let(:client) { Ably::Rest::Client.new(client_options) }
@@ -27,6 +27,19 @@ describe Ably::Rest::Client do
         end
       end
 
+      context 'with an invalid API key' do
+        let(:client) { Ably::Rest::Client.new(client_options.merge(key: 'app.key:secret', log_level: :fatal)) }
+
+        it 'logs an entry with a help href url matching the code #TI5' do
+          begin
+            client.channels.get('foo').publish('test')
+            raise 'Expected Ably::Exceptions::ResourceMissing'
+          rescue Ably::Exceptions::ResourceMissing => err
+            expect err.to_s.match(%r{https://help.ably.io/error/40400})
+          end
+        end
+      end
+
       context 'with an explicit string :token' do
         let(:client) { Ably::Rest::Client.new(client_options.merge(token: random_str)) }
 
@@ -65,10 +78,10 @@ describe Ably::Rest::Client do
         end
       end
 
-      context 'with an :auth_callback Proc' do
-        let(:client) { Ably::Rest::Client.new(client_options.merge(auth_callback: Proc.new { token_request })) }
+      context 'with an :auth_callback lambda' do
+        let(:client) { Ably::Rest::Client.new(client_options.merge(auth_callback: lambda { |token_params| token_request })) }
 
-        it 'calls the auth Proc to get a new token' do
+        it 'calls the auth lambda to get a new token' do
           expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token_details }
           expect(client.auth.current_token_details.client_id).to eql(client_id)
         end
@@ -93,8 +106,8 @@ describe Ably::Rest::Client do
         end
       end
 
-      context 'with an :auth_callback Proc (clientId provided in library options instead of as a token_request param)' do
-        let(:client) { Ably::Rest::Client.new(client_options.merge(client_id: client_id, auth_callback: Proc.new { token_request })) }
+      context 'with an :auth_callback lambda (clientId provided in library options instead of as a token_request param)' do
+        let(:client) { Ably::Rest::Client.new(client_options.merge(client_id: client_id, auth_callback: lambda { |token_params| token_request })) }
         let(:token_request) { client.auth.create_token_request({}, key_name: key_name, key_secret: key_secret) }
 
         it 'correctly sets the clientId on the token' do
@@ -178,7 +191,7 @@ describe Ably::Rest::Client do
 
     context 'using tokens' do
       let(:client) do
-        Ably::Rest::Client.new(client_options.merge(auth_callback: Proc.new do
+        Ably::Rest::Client.new(client_options.merge(auth_callback: lambda do |token_params|
           @request_index ||= 0
           @request_index += 1
           send("token_request_#{@request_index > 2 ? 'next' : @request_index}")
@@ -290,7 +303,7 @@ describe Ably::Rest::Client do
 
     context 'fallback hosts', :webmock do
       let(:path)           { '/channels/test/publish' }
-      let(:publish_block)  { proc { client.channel('test').publish('event', 'data') } }
+      let(:publish_block)  { lambda { client.channel('test').publish('event', 'data') } }
 
       context 'configured' do
         let(:client_options) { default_options.merge(key: api_key, environment: 'production') }
@@ -321,7 +334,7 @@ describe Ably::Rest::Client do
         let(:custom_hosts)       { %w(A.ably-realtime.com B.ably-realtime.com) }
         let(:max_retry_count)    { 2 }
         let(:max_retry_duration) { 0.5 }
-        let(:fallback_block)     { Proc.new { raise Faraday::SSLError.new('ssl error message') } }
+        let(:fallback_block)     { proc { raise Faraday::SSLError.new('ssl error message') } }
         let(:client_options) do
           default_options.merge(
             environment: nil,
@@ -454,7 +467,7 @@ describe Ably::Rest::Client do
         context 'and server returns a 50x error' do
           let(:status) { 502 }
           let(:fallback_block) do
-            Proc.new do
+            proc do
               {
                 headers: { 'Content-Type' => 'text/html' },
                 status: status
@@ -478,7 +491,7 @@ describe Ably::Rest::Client do
         let(:custom_hosts)       { %w(A.foo.com B.foo.com) }
         let(:max_retry_count)    { 2 }
         let(:max_retry_duration) { 0.5 }
-        let(:fallback_block)     { Proc.new { raise Faraday::SSLError.new('ssl error message') } }
+        let(:fallback_block)     { proc { raise Faraday::SSLError.new('ssl error message') } }
         let(:production_options) do
           default_options.merge(
             environment: nil,
@@ -490,7 +503,7 @@ describe Ably::Rest::Client do
 
         let(:status) { 502 }
         let(:fallback_block) do
-          Proc.new do
+          proc do
             {
               headers: { 'Content-Type' => 'text/html' },
               status: status
@@ -547,28 +560,36 @@ describe Ably::Rest::Client do
           context 'and timing out the primary host' do
             before do
               @web_server = WEBrick::HTTPServer.new(:Port => port, :SSLEnable => false, :AccessLog => [], Logger: WEBrick::Log.new("/dev/null"))
-              @web_server.mount_proc "/channels/#{channel_name}/publish" do |req, res|
-                if req.header["host"].first.include?(primary_host)
-                  @primary_host_requested = true
-                  sleep request_timeout + 0.5
-                else
-                  @fallback_request_count ||= 0
-                  @fallback_request_count += 1
-                  if @fallback_request_count <= fail_fallback_request_count
+            request_handler = lambda do |result_body|
+                lambda do |req, res|
+                  host = req.header["host"].first
+                  if host.include?(primary_host)
+                    @primary_host_request_count ||= 0
+                    @primary_host_request_count += 1
                     sleep request_timeout + 0.5
                   else
-                    res.status = 200
-                    res['Content-Type'] = 'application/json'
-                    res.body = '{}'
+                    @fallback_request_count ||= 0
+                    @fallback_request_count += 1
+                    @fallback_hosts_tried ||= []
+                    @fallback_hosts_tried.push(host)
+                    if @fallback_request_count <= fail_fallback_request_count
+                      sleep request_timeout + 0.5
+                    else
+                      res.status = 200
+                      res['Content-Type'] = 'application/json'
+                      res.body = result_body
+                    end
                   end
                 end
               end
+              @web_server.mount_proc "/time", &request_handler.call('[1000000000000]')
+              @web_server.mount_proc "/channels/#{channel_name}/publish", &request_handler.call('{}')
               Thread.new do
                 @web_server.start
               end
             end
 
-            context 'with request timeout less than max_retry_duration' do
+            context 'POST with request timeout less than max_retry_duration' do
               let(:client_options) do
                 default_options.merge(
                   rest_host: primary_host,
@@ -577,20 +598,44 @@ describe Ably::Rest::Client do
                   port: port,
                   tls: false,
                   http_request_timeout: request_timeout,
-                  max_retry_duration: request_timeout * 3,
+                  http_max_retry_duration: request_timeout * 2.5,
                   log_level: :error
                 )
               end
               let(:fail_fallback_request_count) { 1 }
 
-              it 'tries one of the fallback hosts (#RSC15d)' do
+              it 'tries the primary host, then both fallback hosts (#RSC15d)' do
                 client.channel(channel_name).publish('event', 'data')
-                expect(@primary_host_requested).to be_truthy
+                expect(@primary_host_request_count).to eql(1)
+                expect(@fallback_request_count).to eql(2)
+                expect(@fallback_hosts_tried.uniq.length).to eql(2)
+              end
+            end
+
+            context 'GET with request timeout less than max_retry_duration' do
+              let(:client_options) do
+                default_options.merge(
+                  rest_host: primary_host,
+                  fallback_hosts: fallbacks,
+                  token: 'fake.token',
+                  port: port,
+                  tls: false,
+                  http_request_timeout: request_timeout,
+                  http_max_retry_duration: request_timeout * 2.5,
+                  log_level: :error
+                )
+              end
+              let(:fail_fallback_request_count) { 1 }
+
+              it 'tries the primary host, then both fallback hosts (#RSC15d)' do
+                client.time
+                expect(@primary_host_request_count).to eql(1)
                 expect(@fallback_request_count).to eql(2)
+                expect(@fallback_hosts_tried.uniq.length).to eql(2)
               end
             end
 
-            context 'with request timeout less than max_retry_duration' do
+            context 'POST with request timeout more than max_retry_duration' do
               let(:client_options) do
                 default_options.merge(
                   rest_host: primary_host,
@@ -599,18 +644,41 @@ describe Ably::Rest::Client do
                   port: port,
                   tls: false,
                   http_request_timeout: request_timeout,
-                  max_retry_duration: request_timeout / 2,
+                  http_max_retry_duration: request_timeout / 2,
                   log_level: :error
                 )
               end
               let(:fail_fallback_request_count) { 0 }
 
-              it 'tries one of the fallback hosts (#RSC15d)' do
-                client.channel(channel_name).publish('event', 'data')
-                expect(@primary_host_requested).to be_truthy
-                expect(@fallback_request_count).to eql(1)
+              it 'does not try any fallback hosts (#RSC15d)' do
+                expect { client.channel(channel_name).publish('event', 'data') }.to raise_error Ably::Exceptions::ConnectionTimeout
+                expect(@primary_host_request_count).to eql(1)
+                expect(@fallback_request_count).to be_nil
               end
             end
+
+            context 'GET with request timeout more than max_retry_duration' do
+              let(:client_options) do
+                default_options.merge(
+                  rest_host: primary_host,
+                  fallback_hosts: fallbacks,
+                  token: 'fake.token',
+                  port: port,
+                  tls: false,
+                  http_request_timeout: request_timeout,
+                  http_max_retry_duration: request_timeout / 2,
+                  log_level: :error
+                )
+              end
+              let(:fail_fallback_request_count) { 0 }
+
+              it 'does not try any fallback hosts (#RSC15d)' do
+                expect { client.time }.to raise_error Ably::Exceptions::ConnectionTimeout
+                expect(@primary_host_request_count).to eql(1)
+                expect(@fallback_request_count).to be_nil
+              end
+            end
+
           end
 
           context 'and failing the primary host' do
@@ -655,6 +723,109 @@ describe Ably::Rest::Client do
               expect(@fallback_request_count).to eql(2)
             end
           end
+
+          context 'to fail the primary host, allow a fallback to succeed, then later trigger a fallback to the primary host (#RSC15f)' do
+            before do
+              @request_count = 0
+              @primary_host_request_count = 0
+              @web_server = WEBrick::HTTPServer.new(:Port => port, :SSLEnable => false, :AccessLog => [], Logger: WEBrick::Log.new("/dev/null"))
+              @web_server.mount_proc "/channels/#{channel_name}/publish" do |req, res|
+                @request_count += 1
+                if req.header["host"].first.include?(primary_host)
+                  @primary_host_request_count += 1
+                  # Fail all requests to the primary host so that a fallback is used
+                  # Except request 6 which should suceed and clear the fallback host preference
+                  if @request_count == 6
+                    res.status = 200
+                    res['Content-Type'] = 'application/json'
+                    res.body = '{}'
+                  else
+                    res.status = 500
+                  end
+                else
+                  # Fail the second request (first failed fallback of first request)
+                  # Fail the third request on the previously succeeded fallback host to trigger an attempt on the primary host
+                  if [2, 5].include?(@request_count)
+                    res.status = 500
+                  else
+                    res.status = 200
+                    res['Content-Type'] = 'application/json'
+                    res.body = '{}'
+                  end
+                end
+              end
+
+              Thread.new do
+                @web_server.start
+              end
+            end
+
+            let(:client_options) do
+              default_options.merge(
+                rest_host: primary_host,
+                fallback_hosts: fallbacks,
+                token: 'fake.token',
+                port: port,
+                tls: false,
+                log_level: :error
+              ).merge(additional_client_options)
+            end
+
+            let (:additional_client_options) { {} }
+
+            it 'succeeds and remembers fallback host preferences across requests' do
+              # Send a request, expect primary endpoint to fail, one fallback to fail, second fallback to succeed
+              client.channel(channel_name).publish('event', 'data')
+              expect(@request_count).to eql(3)
+              expect(fallbacks).to include(client.using_preferred_fallback_host?)
+              successfull_fallback = client.using_preferred_fallback_host?
+              expect(@primary_host_request_count).to eql(1)
+
+              # Send another request, which should go straight to the fallback as it succeeded previously
+              client.channel(channel_name).publish('event', 'data')
+              expect(@request_count).to eql(4)
+              expect(successfull_fallback).to eql(client.using_preferred_fallback_host?)
+              expect(@primary_host_request_count).to eql(1)
+
+              # A subsequent request should fail to the fallback, go the primary host and succeed
+              client.channel(channel_name).publish('event', 'data')
+              expect(@request_count).to eql(6)
+              expect(client.using_preferred_fallback_host?).to be_falsey
+              expect(@primary_host_request_count).to eql(2)
+
+              # A subsequent request will fail on the primary endpoint, and we expect the fallback to be used again
+              client.channel(channel_name).publish('event', 'data')
+              expect(@request_count).to eql(8)
+              expect(fallbacks).to include(client.using_preferred_fallback_host?)
+              successfull_fallback = client.using_preferred_fallback_host?
+              expect(@primary_host_request_count).to eql(3)
+
+              # Send another request, which should go straight to the fallback as it succeeded previously
+              client.channel(channel_name).publish('event', 'data')
+              expect(@request_count).to eql(9)
+              expect(successfull_fallback).to eql(client.using_preferred_fallback_host?)
+              expect(@primary_host_request_count).to eql(3)
+            end
+
+            context 'with custom :fallback_retry_timeout' do
+              let (:additional_client_options) { { fallback_retry_timeout: 5 } }
+
+              it 'stops using the preferred fallback after this time' do
+                # Send a request, expect primary endpoint to fail, one fallback to fail, second fallback to succeed
+                client.channel(channel_name).publish('event', 'data')
+                expect(@request_count).to eql(3)
+                expect(fallbacks).to include(client.using_preferred_fallback_host?)
+                expect(@primary_host_request_count).to eql(1)
+
+                # Wait for the preferred fallback cache to expire
+                sleep 5
+
+                # Send another request, which should go straight to the primary host again as fallback host is expired
+                client.channel(channel_name).publish('event', 'data')
+                expect(@primary_host_request_count).to eql(2)
+              end
+            end
+          end
         end
       end
 
@@ -662,20 +833,21 @@ describe Ably::Rest::Client do
         let(:custom_hosts)       { %w(A.foo.com B.foo.com) }
         let(:max_retry_count)    { 2 }
         let(:max_retry_duration) { 0.5 }
-        let(:fallback_block)     { Proc.new { raise Faraday::SSLError.new('ssl error message') } }
+        let(:fallback_block)     { proc { raise Faraday::SSLError.new('ssl error message') } }
         let(:env)                { 'custom-env' }
         let(:production_options) do
           default_options.merge(
             environment: env,
             key: api_key,
             http_max_retry_duration: max_retry_duration,
-            http_max_retry_count: max_retry_count
+            http_max_retry_count: max_retry_count,
+            log_level: :fatal,
           )
         end
 
         let(:status) { 502 }
         let(:fallback_block) do
-          Proc.new do
+          proc do
             {
               headers: { 'Content-Type' => 'text/html' },
               status: status
@@ -696,7 +868,7 @@ describe Ably::Rest::Client do
           end
 
           let(:client_options) {
-            production_options.merge(fallback_hosts: custom_hosts, log_level: :error)
+            production_options.merge(fallback_hosts: custom_hosts, log_level: :fatal)
           }
 
           it 'attempts the fallback hosts as this is not an authentication failure' do
@@ -709,7 +881,7 @@ describe Ably::Rest::Client do
 
         context 'with an empty array of fallback hosts provided (#RSC15b, #TO3k6)' do
           let(:client_options) {
-            production_options.merge(fallback_hosts: [])
+            production_options.merge(fallback_hosts: [], log_level: :fatal)
           }
 
           it 'does not attempt the fallback hosts as this is an authentication failure' do
@@ -734,7 +906,7 @@ describe Ably::Rest::Client do
           end
 
           let(:client_options) {
-            production_options.merge(fallback_hosts: custom_hosts, log_level: :error)
+            production_options.merge(fallback_hosts: custom_hosts, log_level: :fatal)
           }
 
           it 'attempts the default fallback hosts as this is an authentication failure' do
@@ -911,7 +1083,7 @@ describe Ably::Rest::Client do
           it 'sends a protocol version and lib version header (#G4, #RSC7a, #RSC7b)' do
             client.channels.get('foo').publish("event")
             expect(publish_message_stub).to have_been_requested
-            expect(Ably::PROTOCOL_VERSION).to eql('1.0')
+            expect(Ably::PROTOCOL_VERSION).to eql('1.1')
           end
         end
       end
@@ -962,36 +1134,10 @@ describe Ably::Rest::Client do
 
     context 'request_id generation' do
       context 'Timeout error' do
-        context 'with request_id', :webmock do
-          let(:custom_logger) do
-            Class.new do
-              def initialize
-                @messages = []
-              end
-
-              [:fatal, :error, :warn, :info, :debug].each do |severity|
-                define_method severity do |message, &block|
-                  message_val = [message]
-                  message_val << block.call if block
-
-                  @messages << [severity, message_val.compact.join(' ')]
-                end
-              end
-
-              def logs
-                @messages
-              end
-
-              def level
-                1
-              end
-
-              def level=(new_level)
-              end
-            end
-          end
-          let(:custom_logger_object) { custom_logger.new }
+        context 'with option add_request_ids: true', :webmock, :prevent_log_stubbing do
+          let(:custom_logger_object) { TestLogger.new }
           let(:client_options) { default_options.merge(key: api_key, logger: custom_logger_object, add_request_ids: true) }
+
           before do
             @request_id = nil
             stub_request(:get, Addressable::Template.new("#{client.endpoint}/time{?request_id}")).with do |request|
@@ -1000,15 +1146,64 @@ describe Ably::Rest::Client do
               raise Faraday::TimeoutError.new('timeout error message')
             end
           end
+
           it 'has an error with the same request_id of the request' do
-            expect{ client.time }.to raise_error(Ably::Exceptions::ConnectionTimeout, /#{@request_id}/)
+            expect { client.time }.to raise_error(Ably::Exceptions::ConnectionTimeout, /#{@request_id}/)
+            expect(@request_id).to be_a(String)
+            expect(@request_id).to_not be_empty
             expect(custom_logger_object.logs.find { |severity, message| message.match(/#{@request_id}/i)} ).to_not be_nil
           end
         end
 
-        context 'when specifying fallback hosts', :webmock do
-          let(:client_options) { { key: api_key, fallback_hosts_use_default: true, add_request_ids: true } }
+        context 'with option add_request_ids: true and REST operations with a message body' do
+          let(:client_options) { default_options.merge({ key: api_key, add_request_ids: true }) }
+          let(:channel_name) { random_str }
+          let(:channel) { client.channels.get(channel_name) }
+
+          context 'with mocks to inspect the params', :webmock do
+            before do
+              stub_request(:post, Addressable::Template.new("#{client.endpoint}/channels/#{channel_name}/publish{?request_id}")).
+                with do |request|
+                  @request_id = request.uri.query_values['request_id']
+                end.to_return(:status => 200, :body => [], :headers => { 'Content-Type' => 'application/json' })
+            end
+
+            context 'with a single publish' do
+              it 'succeeds and sends the request_id as a param' do
+                channel.publish('name', { body: random_str })
+                expect(@request_id.to_s).to_not be_empty
+              end
+            end
+
+            context 'with an array publish' do
+              it 'succeeds and sends the request_id as a param' do
+                channel.publish([{ body: random_str }, { body: random_str }])
+                expect(@request_id.to_s).to_not be_empty
+              end
+            end
+          end
+
+          context 'without mocks to ensure the requests are accepted' do
+            context 'with a single publish' do
+              it 'succeeds and sends the request_id as a param' do
+                channel.publish('name', { body: random_str })
+                expect(channel.history.items.length).to eql(1)
+              end
+            end
+
+            context 'with an array publish' do
+              it 'succeeds and sends the request_id as a param' do
+                channel.publish([{ body: random_str }, { body: random_str }])
+                expect(channel.history.items.length).to eql(2)
+              end
+            end
+          end
+        end
+
+        context 'option add_request_ids: true and specified fallback hosts', :webmock do
+          let(:client_options) { { key: api_key, fallback_hosts_use_default: true, add_request_ids: true, log_level: :error, log_retries_as_info: true } }
           let(:requests)       { [] }
+
           before do
             @request_id = nil
             hosts = Ably::FALLBACK_HOSTS + ['rest.ably.io']
@@ -1021,8 +1216,11 @@ describe Ably::Rest::Client do
               end
             end
           end
-          it 'request_id is the same across retries' do
+
+          specify 'request_id is the same across retries' do
             expect{ client.time }.to raise_error(Ably::Exceptions::ConnectionTimeout, /#{@request_id}/)
+            expect(@request_id).to be_a(String)
+            expect(@request_id).to_not be_empty
             expect(requests.uniq.count).to eql(1)
             expect(requests.uniq.first).to eql(@request_id)
           end
@@ -1030,6 +1228,7 @@ describe Ably::Rest::Client do
 
         context 'without request_id' do
           let(:client_options) { default_options.merge(key: api_key, http_request_timeout: 0) }
+
           it 'does not include request_id in ConnectionTimeout error' do
             begin
               client.stats
@@ -1038,10 +1237,11 @@ describe Ably::Rest::Client do
             end
           end
         end
-      end 
+      end
 
       context 'UnauthorizedRequest nonce error' do
         let(:token_params) { { nonce: "samenonce_#{protocol}", timestamp:  Time.now.to_i } }
+
         it 'includes request_id in UnauthorizedRequest error due to replayed nonce' do
           client1 = Ably::Rest::Client.new(default_options.merge(key: api_key))
           client2 = Ably::Rest::Client.new(default_options.merge(key: api_key, add_request_ids: true))
@@ -1054,5 +1254,49 @@ describe Ably::Rest::Client do
         end
       end
     end
+
+    context 'failed request logging', :prevent_log_stubbing do
+      let(:custom_logger) { TestLogger.new }
+      let(:client_options) { default_options.merge(key: api_key, logger: custom_logger, log_retries_as_info: false) }
+
+      it 'is absent when requests do not fail' do
+        client.time
+        expect(custom_logger.logs(min_severity: :warn)).to be_empty
+      end
+
+      context 'with the first request failing' do
+        let(:client_options) do
+          default_options.merge(
+            rest_host: 'non.existent.domain.local',
+            fallback_hosts: [[environment, Ably::Rest::Client::DOMAIN].join('-')],
+            key: api_key,
+            logger: custom_logger,
+            log_retries_as_info: false)
+        end
+
+        it 'is present with success message when requests do not actually fail' do
+          client.time
+          expect(custom_logger.logs(min_severity: :warn).select { |severity, msg| msg.match(/Retry/) }.length).to eql(1)
+          expect(custom_logger.logs(min_severity: :warn).select { |severity, msg| msg.match(/SUCCEEDED/) }.length).to eql(1)
+        end
+      end
+
+      context 'with all requests failing' do
+        let(:client_options) do
+          default_options.merge(
+            rest_host: 'non.existent.domain.local',
+            fallback_hosts: ['non2.existent.domain.local'],
+            key: api_key,
+            logger: custom_logger,
+            log_retries_as_info: false)
+        end
+
+        it 'is present when all requests fail' do
+          expect { client.time }.to raise_error(Ably::Exceptions::ConnectionError)
+          expect(custom_logger.logs(min_severity: :warn).select { |severity, msg| msg.match(/Retry/) }.length).to be >= 2
+          expect(custom_logger.logs(min_severity: :error).select { |severity, msg| msg.match(/FAILED/) }.length).to eql(1)
+        end
+      end
+    end
   end
 end