ably 0.8.15 → 1.0.0

data/spec/acceptance/rest/base_spec.rb

@@ -137,7 +137,7 @@ describe Ably::Rest do
 
       context 'when auth#token_renewable?' do
         before do
-          client.auth.authorise
+          client.auth.authorize
         end
 
         it 'should automatically reissue a token' do

data/spec/acceptance/rest/channel_spec.rb

@@ -84,7 +84,7 @@ describe Ably::Rest::Channel do
 
       context 'without adequate permissions on the channel' do
         let(:capability)     { { onlyChannel: ['subscribe'] } }
-        let(:client_options) { default_options.merge(use_token_auth: true, token_params: { capability: capability }) }
+        let(:client_options) { default_options.merge(use_token_auth: true, default_token_params: { capability: capability }) }
 
         it 'raises a permission error when publishing' do
           expect { channel.publish(name, data) }.to raise_error(Ably::Exceptions::UnauthorizedRequest, /not permitted/)
@@ -375,7 +375,6 @@ describe Ably::Rest::Channel do
             query_params = default_history_options
             .merge(option => milliseconds).map { |k, v| "#{k}=#{v}" }.join('&')
             stub_request(:get, "#{endpoint}/channels/#{Addressable::URI.encode(channel_name)}/messages?#{query_params}").
-              with(basic_auth: [key_name, key_secret]).
               to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
           }
 

data/spec/acceptance/rest/client_spec.rb

@@ -51,6 +51,14 @@ describe Ably::Rest::Client do
         end
       end
 
+      context 'with a non string :client_id' do
+        let(:client) { Ably::Rest::Client.new(client_options.merge(key: api_key, client_id: 1)) }
+
+        it 'raises an ArgumentError' do
+          expect { client.auth }.to raise_error ArgumentError, /client_id.*String/
+        end
+      end
+
       context 'with an invalid wildcard "*" :client_id' do
         it 'raises an exception' do
           expect { Ably::Rest::Client.new(client_options.merge(key: api_key, client_id: '*')) }.to raise_error ArgumentError
@@ -70,6 +78,21 @@ describe Ably::Rest::Client do
         end
       end
 
+      context 'with :default_token_params' do
+        let(:client) do
+          Ably::Rest::Client.new(client_options.merge(
+            default_token_params: { client_id: 'bob' },
+            use_token_auth: true,
+            key: api_key
+          ))
+        end
+
+        it 'overides the default token params (#TO3j11)' do
+          client.auth.authorize
+          expect(client.auth.client_id).to eql('bob')
+        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 })) }
         let(:token_request) { client.auth.create_token_request({}, key_name: key_name, key_secret: key_secret) }
@@ -112,7 +135,6 @@ describe Ably::Rest::Client do
 
           let!(:get_message_history_stub) do
             stub_request(:get, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}/channels/#{channel_name}/messages?#{history_querystring}").
-              with(basic_auth: [key_name, key_secret]).
               to_return(body: [], headers: { 'Content-Type' => 'application/json' })
           end
 
@@ -273,7 +295,7 @@ describe Ably::Rest::Client do
       context 'configured' do
         let(:client_options) { default_options.merge(key: api_key, environment: 'production') }
 
-        it 'should make connection attempts to A.ably-realtime.com, B.ably-realtime.com, C.ably-realtime.com, D.ably-realtime.com, E.ably-realtime.com' do
+        it 'should make connection attempts to A.ably-realtime.com, B.ably-realtime.com, C.ably-realtime.com, D.ably-realtime.com, E.ably-realtime.com (#RSC15a)' do
           hosts = []
           5.times do
             hosts << client.fallback_connection.host
@@ -282,12 +304,10 @@ describe Ably::Rest::Client do
         end
       end
 
-      context 'when environment is NOT production' do
+      context 'when environment is NOT production (#RSC15b)' do
         let(:client_options) { default_options.merge(environment: 'sandbox', key: api_key) }
         let!(:default_host_request_stub) do
-          stub_request(:post, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}#{path}").
-            with(basic_auth: [key_name, key_secret]).
-            to_return do
+          stub_request(:post, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
             raise Faraday::TimeoutError.new('timeout error message')
           end
         end
@@ -307,7 +327,8 @@ describe Ably::Rest::Client do
             environment: nil,
             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: :error
           )
         end
 
@@ -316,21 +337,21 @@ describe Ably::Rest::Client do
         end
 
         let!(:first_fallback_request_stub) do
-          stub_request(:post, "https://#{custom_hosts[0]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
+          stub_request(:post, "https://#{custom_hosts[0]}#{path}").to_return(&fallback_block)
         end
 
         let!(:second_fallback_request_stub) do
-          stub_request(:post, "https://#{custom_hosts[1]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
+          stub_request(:post, "https://#{custom_hosts[1]}#{path}").to_return(&fallback_block)
         end
 
         context 'and connection times out' do
           let!(:default_host_request_stub) do
-            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return do
+            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
               raise Faraday::TimeoutError.new('timeout error message')
             end
           end
 
-          it "tries fallback hosts #{http_defaults.fetch(:max_retry_count)} times" do
+          it "tries fallback hosts #{http_defaults.fetch(:max_retry_count)} times (#RSC15b, #RSC15b)" do
             expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionError, /ssl error message/
             expect(default_host_request_stub).to have_been_requested
             expect(first_fallback_request_stub).to have_been_requested
@@ -339,7 +360,7 @@ describe Ably::Rest::Client do
 
           context "and the total request time exeeds #{http_defaults.fetch(:max_retry_duration)} seconds" do
             let!(:default_host_request_stub) do
-              stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return do
+              stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
                 sleep max_retry_duration * 1.5
                 raise Faraday::TimeoutError.new('timeout error message')
               end
@@ -356,7 +377,7 @@ describe Ably::Rest::Client do
 
         context 'and connection fails' do
           let!(:default_host_request_stub) do
-            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return do
+            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
               raise Faraday::ConnectionFailed.new('connection failure error message')
             end
           end
@@ -369,10 +390,47 @@ describe Ably::Rest::Client do
           end
         end
 
+        context 'and first request to primary endpoint fails' do
+          let(:client_options) do
+            default_options.merge(
+              environment: nil,
+              key: api_key,
+              http_max_retry_duration: max_retry_duration,
+              http_max_retry_count: max_retry_count,
+              log_level: :error
+            )
+          end
+          let(:requests) { [] }
+          let!(:default_host_request_stub) do
+            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
+              requests << true
+              if requests.count == 1
+                raise Faraday::ConnectionFailed.new('connection failure error message')
+              else
+                {
+                  headers: { 'Content-Type' => 'application/json' },
+                  status: 200,
+                  body: {}.to_json
+                }
+              end
+            end
+          end
+
+          it "tries a fallback host, and for the next request tries the primary endpoint again (#RSC15e)" do
+            expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionError, /ssl error message/
+            expect(default_host_request_stub).to have_been_requested
+            expect(first_fallback_request_stub).to have_been_requested
+            expect(requests.count).to eql(1)
+
+            publish_block.call
+            expect(requests.count).to eql(2)
+          end
+        end
+
         context 'and basic authentication fails' do
           let(:status) { 401 }
           let!(:default_host_request_stub) do
-            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return(
+            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").to_return(
               headers: { 'Content-Type' => 'application/json' },
               status: status,
               body: {
@@ -404,10 +462,10 @@ describe Ably::Rest::Client do
             end
           end
           let!(:default_host_request_stub) do
-            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
+            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").to_return(&fallback_block)
           end
 
-          it 'attempts the fallback hosts as this is an authentication failure' do
+          it 'attempts the fallback hosts as this is an authentication failure (#RSC15d)' do
             expect { publish_block.call }.to raise_error(Ably::Exceptions::ServerError)
             expect(default_host_request_stub).to have_been_requested
             expect(first_fallback_request_stub).to have_been_requested
@@ -440,23 +498,23 @@ describe Ably::Rest::Client do
           end
         end
         let!(:default_host_request_stub) do
-          stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
+          stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").to_return(&fallback_block)
         end
 
         context 'with custom fallback hosts provided' do
           let!(:first_fallback_request_stub) do
-            stub_request(:post, "https://#{custom_hosts[0]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
+            stub_request(:post, "https://#{custom_hosts[0]}#{path}").to_return(&fallback_block)
           end
 
           let!(:second_fallback_request_stub) do
-            stub_request(:post, "https://#{custom_hosts[1]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
+            stub_request(:post, "https://#{custom_hosts[1]}#{path}").to_return(&fallback_block)
           end
 
           let(:client_options) {
             production_options.merge(fallback_hosts: custom_hosts, log_level: :error)
           }
 
-          it 'attempts the fallback hosts as this is an authentication failure (#RSC15b, #TO3k6)' do
+          it 'attempts the fallback hosts as this is an authentication failure (#RSC15b, #RSC15a, #TO3k6)' do
             expect { publish_block.call }.to raise_error(Ably::Exceptions::ServerError)
             expect(default_host_request_stub).to have_been_requested
             expect(first_fallback_request_stub).to have_been_requested
@@ -464,7 +522,7 @@ describe Ably::Rest::Client do
           end
         end
 
-        context 'with an empty array of fallback hosts provided (#RSC15b, #TO3k6)' do
+        context 'with an empty array of fallback hosts provided (#RSC15b, #RSC15a, #TO3k6)' do
           let(:client_options) {
             production_options.merge(fallback_hosts: [])
           }
@@ -488,7 +546,7 @@ describe Ably::Rest::Client do
 
           context 'and timing out the primary host' do
             before do
-              @web_server = WEBrick::HTTPServer.new(:Port => port, :SSLEnable => false)
+              @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
@@ -525,7 +583,7 @@ describe Ably::Rest::Client do
               end
               let(:fail_fallback_request_count) { 1 }
 
-              it 'tries one of the fallback hosts' do
+              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(2)
@@ -541,12 +599,13 @@ describe Ably::Rest::Client do
                   port: port,
                   tls: false,
                   http_request_timeout: request_timeout,
-                  max_retry_duration: request_timeout / 2
+                  max_retry_duration: request_timeout / 2,
+                  log_level: :error
                 )
               end
               let(:fail_fallback_request_count) { 0 }
 
-              it 'tries one of the fallback hosts' do
+              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)
@@ -556,7 +615,7 @@ describe Ably::Rest::Client do
 
           context 'and failing the primary host' do
             before do
-              @web_server = WEBrick::HTTPServer.new(:Port => port, :SSLEnable => false)
+              @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
@@ -584,7 +643,8 @@ describe Ably::Rest::Client do
                 fallback_hosts: fallbacks,
                 token: 'fake.token',
                 port: port,
-                tls: false
+                tls: false,
+                log_level: :error
               )
             end
             let(:fail_fallback_request_count) { 1 }
@@ -623,23 +683,23 @@ describe Ably::Rest::Client do
           end
         end
         let!(:default_host_request_stub) do
-          stub_request(:post, "https://#{env}-#{Ably::Rest::Client::DOMAIN}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
+          stub_request(:post, "https://#{env}-#{Ably::Rest::Client::DOMAIN}#{path}").to_return(&fallback_block)
         end
 
         context 'with custom fallback hosts provided (#RSC15b, #TO3k6)' do
           let!(:first_fallback_request_stub) do
-            stub_request(:post, "https://#{custom_hosts[0]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
+            stub_request(:post, "https://#{custom_hosts[0]}#{path}").to_return(&fallback_block)
           end
 
           let!(:second_fallback_request_stub) do
-            stub_request(:post, "https://#{custom_hosts[1]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
+            stub_request(:post, "https://#{custom_hosts[1]}#{path}").to_return(&fallback_block)
           end
 
           let(:client_options) {
-            production_options.merge(fallback_hosts: custom_hosts)
+            production_options.merge(fallback_hosts: custom_hosts, log_level: :error)
           }
 
-          it 'attempts the fallback hosts as this is an authentication failure' do
+          it 'attempts the fallback hosts as this is not an authentication failure' do
             expect { publish_block.call }.to raise_error(Ably::Exceptions::ServerError)
             expect(default_host_request_stub).to have_been_requested
             expect(first_fallback_request_stub).to have_been_requested
@@ -665,20 +725,16 @@ describe Ably::Rest::Client do
             stub_const 'Ably::FALLBACK_HOSTS', custom_hosts
           end
 
-          let(:client_options) {
-            production_options.merge(fallback_hosts_use_default: true)
-          }
-
           let!(:first_fallback_request_stub) do
-            stub_request(:post, "https://#{Ably::FALLBACK_HOSTS[0]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
+            stub_request(:post, "https://#{Ably::FALLBACK_HOSTS[0]}#{path}").to_return(&fallback_block)
           end
 
           let!(:second_fallback_request_stub) do
-            stub_request(:post, "https://#{Ably::FALLBACK_HOSTS[1]}#{path}").with(basic_auth: [key_name, key_secret]).to_return(&fallback_block)
+            stub_request(:post, "https://#{Ably::FALLBACK_HOSTS[1]}#{path}").to_return(&fallback_block)
           end
 
           let(:client_options) {
-            production_options.merge(fallback_hosts: custom_hosts)
+            production_options.merge(fallback_hosts: custom_hosts, log_level: :error)
           }
 
           it 'attempts the default fallback hosts as this is an authentication failure' do
@@ -705,7 +761,7 @@ describe Ably::Rest::Client do
           let(:path) { '/channels/test/publish' }
 
           let!(:custom_host_request_stub) do
-            stub_request(:post, "https://#{custom_host}#{path}").with(basic_auth: [key_name, key_secret]).to_return do
+            stub_request(:post, "https://#{custom_host}#{path}").to_return do
               raise Faraday::ConnectionFailed.new('connection failure error message')
             end
           end
@@ -762,16 +818,16 @@ describe Ably::Rest::Client do
           expect(client.http_defaults[:open_timeout]).to eql(4)
         end
 
-        specify '#http_request_timeout is 15s' do
-          expect(client.http_defaults[:request_timeout]).to eql(15)
+        specify '#http_request_timeout is 10s' do
+          expect(client.http_defaults[:request_timeout]).to eql(10)
         end
 
         specify '#http_max_retry_count is 3' do
           expect(client.http_defaults[:max_retry_count]).to eql(3)
         end
 
-        specify '#http_max_retry_duration is 10s' do
-          expect(client.http_defaults[:max_retry_duration]).to eql(10)
+        specify '#http_max_retry_duration is 15s' do
+          expect(client.http_defaults[:max_retry_duration]).to eql(15)
         end
       end
 
@@ -844,18 +900,18 @@ describe Ably::Rest::Client do
             lib << Ably::VERSION
 
 
-            stub_request(:post, "#{client.endpoint.to_s.gsub('://', "://")}/channels/foo/publish").
+            stub_request(:post, "#{client.endpoint}/channels/foo/publish").
               with(headers: {
                 'X-Ably-Version' => Ably::PROTOCOL_VERSION,
                 'X-Ably-Lib' => lib.join('-')
               }).
-              with(basic_auth: [key_name, key_secret]).
               to_return(status: 201, body: '{}', headers: { 'Content-Type' => 'application/json' })
           end
 
-          it 'sends a protocol version and lib version header' 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')
           end
         end
       end
@@ -886,7 +942,7 @@ describe Ably::Rest::Client do
 
           it 'provides paging' do
             10.times do
-              client.request(:post, "/channels/#{channel_name}/publish", {}, { 'name': 'test' })
+              client.request(:post, "/channels/#{channel_name}/publish", {}, { 'name' => 'test' })
             end
             response = client.request(:get, "/channels/#{channel_name}/messages", { limit: 2 })
             expect(response.items.length).to eql(2)

data/spec/acceptance/rest/message_spec.rb

@@ -61,6 +61,33 @@ describe Ably::Rest::Channel, 'messages' do
       end
     end
 
+    context 'with supported extra payload content type (#RSL1h, #RSL6a2)' do
+      context 'JSON Object (Hash)' do
+        let(:data) { { 'push' => { 'title' => 'Testing' } } }
+
+        it 'is encoded and decoded to the same hash' do
+          channel.publish 'event', {}, extras: data
+          expect(channel.history.items.first.extras).to eql(data)
+        end
+      end
+
+      context 'JSON Array' do
+        let(:data) { { 'push' => [ nil, true, false, 55, 'string', { 'Hash' => true }, ['array'] ] } }
+
+        it 'is encoded and decoded to the same Array' do
+          channel.publish 'event', {}, extras: data
+          expect(channel.history.items.first.extras).to eql(data)
+        end
+      end
+
+      context 'nil' do
+        it 'is encoded and decoded to the same Array' do
+          channel.publish 'event', {}, extras: nil
+          expect(channel.history.items.first.extras).to be_nil
+        end
+      end
+    end
+
     context 'with unsupported data payload content type' do
       context 'Integer' do
         let(:data) { 1 }
@@ -134,7 +161,7 @@ describe Ably::Rest::Channel, 'messages' do
             end
           end
 
-          it 'encrypts message automatically when published' do
+          it 'encrypts message automatically when published (#RTL7d)' do
             expect(client).to receive(:post) do |path, message|
               if protocol == :json
                 expect(message['encoding']).to eql(encrypted_encoding)
@@ -149,7 +176,7 @@ describe Ably::Rest::Channel, 'messages' do
             encrypted_channel.publish 'example', encoded_data_decoded
           end
 
-          it 'sends and retrieves messages that are encrypted & decrypted by the Ably library' do
+          it 'sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)' do
             encrypted_channel.publish 'example', encoded_data_decoded
 
             message = encrypted_channel.history.items.first
@@ -168,12 +195,12 @@ describe Ably::Rest::Channel, 'messages' do
           end
         end
 
-        context 'with AES-128-CBC using crypto-data-128.json fixtures' do
+        context 'with AES-128-CBC using crypto-data-128.json fixtures (#RTL7d)' do
           data = JSON.parse(File.read(File.join(resources_root, 'crypto-data-128.json')))
           add_tests_for_data data
         end
 
-        context 'with AES-256-CBC using crypto-data-256.json fixtures' do
+        context 'with AES-256-CBC using crypto-data-256.json fixtures (#RTL7d)' do
           data = JSON.parse(File.read(File.join(resources_root, 'crypto-data-256.json')))
           add_tests_for_data data
         end
@@ -246,21 +273,21 @@ describe Ably::Rest::Channel, 'messages' do
             encrypted_channel.publish 'example', payload
           end
 
-          it 'retrieves the message that remains encrypted with an encrypted encoding attribute' do
+          it 'retrieves the message that remains encrypted with an encrypted encoding attribute (#RTL7e)' do
             message = other_client_unencrypted_channel.history.items.first
             expect(message.data).to_not eql(payload)
             expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
           end
 
-          it 'logs a Cipher exception' do
-            expect(other_client.logger).to receive(:error) do |message|
-              expect(message).to match(/Message cannot be decrypted/)
+          it 'logs a Cipher exception (#RTL7e)' do
+            expect(other_client.logger).to receive(:error) do |*args, &block|
+              expect(args.concat([block ? block.call : nil]).join(',')).to match(/Message cannot be decrypted/)
             end
             other_client_unencrypted_channel.history
           end
         end
 
-        context 'publishing on an encrypted channel and retrieving #history with a different algorithm on another client' do
+        context 'publishing on an encrypted channel and retrieving #history with a different algorithm on another client (#RTL7e)' do
           let(:client_options)            { default_client_options.merge(log_level: :fatal) }
           let(:cipher_options_client1)    { { key: Ably::Util::Crypto.generate_random_key(256), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
           let(:encrypted_channel_client1) { client.channel(channel_name, cipher: cipher_options_client1) }
@@ -273,15 +300,15 @@ describe Ably::Rest::Channel, 'messages' do
             encrypted_channel_client1.publish 'example', payload
           end
 
-          it 'retrieves the message that remains encrypted with an encrypted encoding attribute' do
+          it 'retrieves the message that remains encrypted with an encrypted encoding attribute (#RTL7e)' do
             message = encrypted_channel_client2.history.items.first
             expect(message.data).to_not eql(payload)
             expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
           end
 
-          it 'logs a Cipher exception' do
-            expect(other_client.logger).to receive(:error) do |message|
-              expect(message).to match(/Cipher algorithm [\w-]+ does not match/)
+          it 'logs a Cipher exception (#RTL7e)' do
+            expect(other_client.logger).to receive(:error) do |*args, &block|
+              expect(args.concat([block ? block.call : nil]).join(',')).to match(/Cipher algorithm [\w-]+ does not match/)
             end
             encrypted_channel_client2.history
           end
@@ -307,8 +334,8 @@ describe Ably::Rest::Channel, 'messages' do
           end
 
           it 'logs a Cipher exception' do
-            expect(other_client.logger).to receive(:error) do |message|
-              expect(message).to match(/CipherError decrypting data/)
+            expect(other_client.logger).to receive(:error) do |*args, &block|
+              expect(args.concat([block ? block.call : nil]).join(',')).to match(/CipherError decrypting data/)
             end
             encrypted_channel_client2.history
           end