ably 0.6.2 → 0.7.0

data/spec/acceptance/rest/message_spec.rb

@@ -1,221 +1,244 @@
+# encoding: utf-8
 require 'spec_helper'
 require 'securerandom'
 
-describe 'Ably::Rest Message' do
+describe Ably::Rest::Channel, 'messages' do
   include Ably::Modules::Conversions
 
-  [:msgpack, :json].each do |protocol|
-    context "over #{protocol}" do
-      let(:default_client_options) { { api_key: api_key, environment: environment, protocol: protocol } }
-      let(:client)                 { Ably::Rest::Client.new(default_client_options) }
-      let(:other_client)           { Ably::Rest::Client.new(default_client_options) }
-
-      describe 'encryption and encoding' do
-        let(:channel_name)      { "persisted:#{SecureRandom.hex(4)}" }
-        let(:cipher_options)    { { key: SecureRandom.hex(32) } }
-        let(:encrypted_channel) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
-
-        context 'encoding and decoding encrypted messages' do
-          shared_examples 'an Ably encrypter and decrypter' do |item, data|
-            let(:algorithm)      { data['algorithm'].upcase }
-            let(:mode)           { data['mode'].upcase }
-            let(:key_length)     { data['keylength'] }
-            let(:secret_key)     { Base64.decode64(data['key']) }
-            let(:iv)             { Base64.decode64(data['iv']) }
-
-            let(:cipher_options) { { key: secret_key, iv: iv, algorithm: algorithm, mode: mode, key_length: key_length } }
-
-            context 'publish & subscribe' do
-              let(:encoded)              { item['encoded'] }
-              let(:encoded_data)         { encoded['data'] }
-              let(:encoded_encoding)     { encoded['encoding'] }
-              let(:encoded_data_decoded) do
-                if encoded_encoding == 'json'
-                  JSON.parse(encoded_data)
-                elsif encoded_encoding == 'base64'
-                  Base64.decode64(encoded_data)
-                else
-                  encoded_data
-                end
-              end
-
-              let(:encrypted)              { item['encrypted'] }
-              let(:encrypted_data)         { encrypted['data'] }
-              let(:encrypted_encoding)     { encrypted['encoding'] }
-              let(:encrypted_data_decoded) do
-                if encrypted_encoding.match(%r{/base64$})
-                  Base64.decode64(encrypted_data)
-                else
-                  encrypted_data
-                end
-              end
-
-              it 'encrypts message automatically when published' do
-                expect(client).to receive(:post) do |path, message|
-                  if protocol == :json
-                    expect(message['encoding']).to eql(encrypted_encoding)
-                    expect(Base64.decode64(message['data'])).to eql(encrypted_data_decoded)
-                  else
-                    # Messages sent over binary protocol will not have Base64 encoded data
-                    expect(message['encoding']).to eql(encrypted_encoding.gsub(%r{/base64$}, ''))
-                    expect(message['data']).to eql(encrypted_data_decoded)
-                  end
-                end.and_return(double('Response', status: 201))
-
-                encrypted_channel.publish 'example', encoded_data_decoded
-              end
-
-              it 'sends and receives messages that are encrypted & decrypted by the Ably library' do
-                encrypted_channel.publish 'example', encoded_data_decoded
+  vary_by_protocol do
+    let(:default_client_options) { { api_key: api_key, environment: environment, protocol: protocol } }
+    let(:client_options)         { default_client_options }
+    let(:client)                 { Ably::Rest::Client.new(client_options) }
+    let(:other_client)           { Ably::Rest::Client.new(client_options) }
+    let(:channel)                { client.channel('test') }
+
+    context 'publishing with an ASCII_8BIT message name' do
+      let(:message_name) { random_str.encode(Encoding::ASCII_8BIT) }
+
+      it 'is converted into UTF_8' do
+        channel.publish message_name, 'example'
+        message = channel.history.first
+        expect(message.name.encoding).to eql(Encoding::UTF_8)
+        expect(message.name.encode(Encoding::ASCII_8BIT)).to eql(message_name)
+      end
+    end
 
-                message = encrypted_channel.history.first
-                expect(message.data).to eql(encoded_data_decoded)
-                expect(message.encoding).to be_nil
-              end
+    describe 'encryption and encoding' do
+      let(:channel_name)      { "persisted:#{random_str}" }
+      let(:cipher_options)    { { key: random_str(32) } }
+      let(:encrypted_channel) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+
+      context 'with #publish and #history' do
+        shared_examples 'an Ably encrypter and decrypter' do |item, data|
+          let(:algorithm)      { data['algorithm'].upcase }
+          let(:mode)           { data['mode'].upcase }
+          let(:key_length)     { data['keylength'] }
+          let(:secret_key)     { Base64.decode64(data['key']) }
+          let(:iv)             { Base64.decode64(data['iv']) }
+
+          let(:cipher_options) { { key: secret_key, iv: iv, algorithm: algorithm, mode: mode, key_length: key_length } }
+
+          let(:encoded)              { item['encoded'] }
+          let(:encoded_data)         { encoded['data'] }
+          let(:encoded_encoding)     { encoded['encoding'] }
+          let(:encoded_data_decoded) do
+            if encoded_encoding == 'json'
+              JSON.parse(encoded_data)
+            elsif encoded_encoding == 'base64'
+              Base64.decode64(encoded_data)
+            else
+              encoded_data
             end
           end
 
-          resources_root = File.expand_path('../../../resources', __FILE__)
-
-          def self.add_tests_for_data(data)
-            data['items'].each_with_index do |item, index|
-              context "item #{index} with encrypted encoding #{item['encrypted']['encoding']}" do
-                it_behaves_like 'an Ably encrypter and decrypter', item, data
-              end
+          let(:encrypted)              { item['encrypted'] }
+          let(:encrypted_data)         { encrypted['data'] }
+          let(:encrypted_encoding)     { encrypted['encoding'] }
+          let(:encrypted_data_decoded) do
+            if encrypted_encoding.match(%r{/base64$})
+              Base64.decode64(encrypted_data)
+            else
+              encrypted_data
             end
           end
 
-          context 'with AES-128-CBC' do
-            data = JSON.parse(File.read(File.join(resources_root, 'crypto-data-128.json')))
-            add_tests_for_data data
-          end
+          it 'encrypts message automatically when published' do
+            expect(client).to receive(:post) do |path, message|
+              if protocol == :json
+                expect(message['encoding']).to eql(encrypted_encoding)
+                expect(Base64.decode64(message['data'])).to eql(encrypted_data_decoded)
+              else
+                # Messages sent over binary protocol will not have Base64 encoded data
+                expect(message['encoding']).to eql(encrypted_encoding.gsub(%r{/base64$}, ''))
+                expect(message['data']).to eql(encrypted_data_decoded)
+              end
+            end.and_return(double('Response', status: 201))
 
-          context 'with AES-256-CBC' do
-            data = JSON.parse(File.read(File.join(resources_root, 'crypto-data-256.json')))
-            add_tests_for_data data
+            encrypted_channel.publish 'example', encoded_data_decoded
           end
 
-          context 'multiple messages' do
-            let(:data) { MessagePack.pack({ 'key' => SecureRandom.hex }) }
-            let(:message_count) { 20 }
+          it 'sends and retrieves messages that are encrypted & decrypted by the Ably library' do
+            encrypted_channel.publish 'example', encoded_data_decoded
 
-            it 'encrypt and decrypt messages' do
-              message_count.times do |index|
-                encrypted_channel.publish index.to_s, "#{index}-#{data}"
-              end
+            message = encrypted_channel.history.first
+            expect(message.data).to eql(encoded_data_decoded)
+            expect(message.encoding).to be_nil
+          end
+        end
 
-              messages = encrypted_channel.history
+        resources_root = File.expand_path('../../../resources', __FILE__)
 
-              expect(messages.count).to eql(message_count)
-              messages.each do |message|
-                expect(message.data).to eql("#{message.name}-#{data}")
-                expect(message.encoding).to be_nil
-              end
+        def self.add_tests_for_data(data)
+          data['items'].each_with_index do |item, index|
+            context "item #{index} with encrypted encoding #{item['encrypted']['encoding']}" do
+              it_behaves_like 'an Ably encrypter and decrypter', item, data
             end
           end
+        end
 
-          context "sending using protocol #{protocol} and retrieving with a different protocol" do
-            let(:other_protocol)       { protocol == :msgpack ? :json : :msgpack }
-            let(:other_client)         { Ably::Rest::Client.new(default_client_options.merge(protocol: other_protocol)) }
-            let(:other_client_channel) {  other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+        context 'with AES-128-CBC using crypto-data-128.json fixtures' do
+          data = JSON.parse(File.read(File.join(resources_root, 'crypto-data-128.json')))
+          add_tests_for_data data
+        end
 
-            before do
-              expect(other_client.protocol_binary?).to_not eql(client.protocol_binary?)
-            end
+        context 'with AES-256-CBC using crypto-data-256.json fixtures' do
+          data = JSON.parse(File.read(File.join(resources_root, 'crypto-data-256.json')))
+          add_tests_for_data data
+        end
 
-            [MessagePack.pack({ 'key' => SecureRandom.hex }), '€ unicode', { 'key' => SecureRandom.hex }].each do |payload|
-              payload_description = "#{payload.class}#{" #{payload.encoding}" if payload.kind_of?(String)}"
+        context 'when publishing lots of messages' do
+          let(:data) { MessagePack.pack({ 'key' => random_str }) }
+          let(:message_count) { 20 }
 
-              specify "delivers a #{payload_description} payload to the receiver" do
-                encrypted_channel.publish 'example', payload
+          it 'encrypts on #publish and decrypts on #history' do
+            message_count.times do |index|
+              encrypted_channel.publish index.to_s, "#{index}-#{data}"
+            end
 
-                message = other_client_channel.history.first
-                expect(message.data).to eql(payload)
-                expect(message.encoding).to be_nil
-              end
+            messages = encrypted_channel.history
+
+            expect(messages.count).to eql(message_count)
+            messages.each do |message|
+              expect(message.data).to eql("#{message.name}-#{data}")
+              expect(message.encoding).to be_nil
             end
           end
+        end
 
-          context 'publishing on an unencrypted channel and retrieving on an encrypted channel' do
-            let(:unencrypted_channel)            { client.channel(channel_name) }
-            let(:other_client_encrypted_channel) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+        context 'when retrieving #history with a different protocol' do
+          let(:other_protocol)       { protocol == :msgpack ? :json : :msgpack }
+          let(:other_client)         { Ably::Rest::Client.new(default_client_options.merge(protocol: other_protocol)) }
+          let(:other_client_channel) {  other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
 
-            let(:payload) { MessagePack.pack({ 'key' => SecureRandom.hex }) }
+          before do
+            expect(other_client.protocol_binary?).to_not eql(client.protocol_binary?)
+          end
+
+          [MessagePack.pack({ 'key' => SecureRandom.hex }), 'ã unicode', { 'key' => SecureRandom.hex }].each do |payload|
+            payload_description = "#{payload.class}#{" #{payload.encoding}" if payload.kind_of?(String)}"
 
-            it 'does not attempt to decrypt the message' do
-              unencrypted_channel.publish 'example', payload
+            specify "delivers a #{payload_description} payload to the receiver" do
+              encrypted_channel.publish 'example', payload
 
-              message = other_client_encrypted_channel.history.first
+              message = other_client_channel.history.first
               expect(message.data).to eql(payload)
               expect(message.encoding).to be_nil
             end
           end
+        end
 
-          context 'publishing on an encrypted channel and retrieving on an unencrypted channel' do
-            let(:encrypted_channel)                { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
-            let(:other_client_unencrypted_channel) { other_client.channel(channel_name) }
+        context 'when publishing on an unencrypted channel and retrieving with #history on an encrypted channel' do
+          let(:unencrypted_channel)            { client.channel(channel_name) }
+          let(:other_client_encrypted_channel) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
 
-            let(:payload) { MessagePack.pack({ 'key' => SecureRandom.hex }) }
+          let(:payload) { MessagePack.pack({ 'key' => random_str }) }
 
-            skip 'delivers the message but still encrypted' do
-              # TODO: Decide if we should raise an exception or allow the message through
-              encrypted_channel.publish 'example', payload
+          it 'does not attempt to decrypt the message' do
+            unencrypted_channel.publish 'example', payload
 
-              message = other_client_unencrypted_channel.history.first
-              expect(message.data).to_not eql(payload)
-              expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
-            end
+            message = other_client_encrypted_channel.history.first
+            expect(message.data).to eql(payload)
+            expect(message.encoding).to be_nil
+          end
+        end
 
-            it 'triggers a Cipher exception' do
-              encrypted_channel.publish 'example', payload
-              expect { other_client_unencrypted_channel.history }.to raise_error Ably::Exceptions::CipherError, /Message cannot be decrypted/
+        context 'when publishing on an encrypted channel and retrieving with #history on an unencrypted channel' do
+          let(:client_options)                   { default_client_options.merge(log_level: :fatal) }
+          let(:cipher_options)                   { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+          let(:encrypted_channel)                { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+          let(:other_client_unencrypted_channel) { other_client.channel(channel_name) }
+
+          let(:payload) { MessagePack.pack({ 'key' => random_str }) }
+
+          before do
+            encrypted_channel.publish 'example', payload
+          end
+
+          it 'retrieves the message that remains encrypted with an encrypted encoding attribute' do
+            message = other_client_unencrypted_channel.history.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/)
             end
+            other_client_unencrypted_channel.history
           end
+        end
 
-          context 'publishing on an encrypted channel and subscribing with a different algorithm on another client' do
-            let(:cipher_options_client1)    { { key: SecureRandom.hex(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-            let(:encrypted_channel_client1) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client1) }
-            let(:cipher_options_client2)    { { key: SecureRandom.hex(32), algorithm: 'aes', mode: 'cbc', key_length: 128 } }
-            let(:encrypted_channel_client2) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client2) }
+        context 'publishing on an encrypted channel and retrieving #history with a different algorithm on another client' do
+          let(:client_options)            { default_client_options.merge(log_level: :fatal) }
+          let(:cipher_options_client1)    { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+          let(:encrypted_channel_client1) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client1) }
+          let(:cipher_options_client2)    { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 128 } }
+          let(:encrypted_channel_client2) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client2) }
 
-            let(:payload) { MessagePack.pack({ 'key' => SecureRandom.hex }) }
+          let(:payload) { MessagePack.pack({ 'key' => random_str }) }
 
-            skip 'delivers the message but still encrypted' do
-              # TODO: Decide if we should raise an exception or allow the message through
-              encrypted_channel.publish 'example', payload
+          before do
+            encrypted_channel_client1.publish 'example', payload
+          end
 
-              message = other_client_unencrypted_channel.history.first
-              expect(message.data).to_not eql(payload)
-              expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
-            end
+          it 'retrieves the message that remains encrypted with an encrypted encoding attribute' do
+            message = encrypted_channel_client2.history.first
+            expect(message.data).to_not eql(payload)
+            expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
+          end
 
-            it 'triggers a Cipher exception' do
-              encrypted_channel_client1.publish 'example', payload
-              expect { encrypted_channel_client2.history }.to raise_error Ably::Exceptions::CipherError, /Cipher algorithm [\w\d-]+ does not match/
+          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/)
             end
+            encrypted_channel_client2.history
           end
+        end
 
-          context 'publishing on an encrypted channel and subscribing with a different key on another client' do
-            let(:cipher_options_client1)    { { key: SecureRandom.hex(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-            let(:encrypted_channel_client1) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client1) }
-            let(:cipher_options_client2)    { { key: SecureRandom.hex(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-            let(:encrypted_channel_client2) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client2) }
+        context 'publishing on an encrypted channel and subscribing with a different key on another client' do
+          let(:client_options)            { default_client_options.merge(log_level: :fatal) }
+          let(:cipher_options_client1)    { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+          let(:encrypted_channel_client1) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client1) }
+          let(:cipher_options_client2)    { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+          let(:encrypted_channel_client2) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options_client2) }
 
-            let(:payload) { MessagePack.pack({ 'key' => SecureRandom.hex }) }
+          let(:payload) { MessagePack.pack({ 'key' => random_str }) }
 
-            skip 'delivers the message but still encrypted' do
-              # TODO: Decide if we should raise an exception or allow the message through
-              encrypted_channel.publish 'example', payload
+          before do
+            encrypted_channel_client1.publish 'example', payload
+          end
 
-              message = other_client_unencrypted_channel.history.first
-              expect(message.data).to_not eql(payload)
-              expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
-            end
+          it 'retrieves the message that remains encrypted with an encrypted encoding attribute' do
+            message = encrypted_channel_client2.history.first
+            expect(message.data).to_not eql(payload)
+            expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
+          end
 
-            it 'triggers a Cipher exception' do
-              encrypted_channel_client1.publish 'example', payload
-              expect { encrypted_channel_client2.history }.to raise_error Ably::Exceptions::CipherError, /CipherError decrypting data/
+          it 'logs a Cipher exception' do
+            expect(other_client.logger).to receive(:error) do |message|
+              expect(message).to match(/CipherError decrypting data/)
             end
+            encrypted_channel_client2.history
           end
         end
       end

data/spec/acceptance/rest/presence_spec.rb

@@ -1,38 +1,57 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'securerandom'
 
 describe Ably::Rest::Presence do
   include Ably::Modules::Conversions
 
-  [:msgpack, :json].each do |protocol|
-    context "over #{protocol}" do
-      let(:client) do
-        Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+  vary_by_protocol do
+    let(:default_options) { { api_key: api_key, environment: environment, protocol: protocol } }
+    let(:client_options) { default_options }
+    let(:client) do
+      Ably::Rest::Client.new(client_options)
+    end
+
+    let(:fixtures) do
+      TestApp::APP_SPEC['channels'].first['presence'].map do |fixture|
+        IdiomaticRubyWrapper(fixture, stop_at: [:data])
       end
+    end
 
-      let(:fixtures) do
-        TestApp::APP_SPEC['channels'].first['presence'].map do |fixture|
-          IdiomaticRubyWrapper(fixture, stop_at: [:data])
-        end
+    context 'tested against presence fixture data set up in test app' do
+      before(:context) do
+        # When this test is run as a part of a test suite, the presence data injected in the test app may have expired
+        WebMock.disable!
+        TestApp.reload
       end
 
-      describe '#get presence' do
+      describe '#get' do
         let(:channel) { client.channel('persisted:presence_fixtures') }
         let(:presence) { channel.presence.get }
 
-        it 'returns current members on the channel' do
+        it 'returns current members on the channel with their action set to :present' do
           expect(presence.size).to eql(4)
 
           fixtures.each do |fixture|
             presence_message = presence.find { |client| client.client_id == fixture[:client_id] }
             expect(presence_message.data).to eq(fixture[:data])
+            expect(presence_message.action).to eq(:present)
           end
         end
 
-        skip 'with options'
+        context 'with :limit option' do
+          let(:page_size) { 2 }
+          let(:presence)  { channel.presence.get(limit: page_size) }
+
+          it 'returns a paged response limiting number of members per page' do
+            expect(presence.size).to eql(2)
+            next_page = presence.next_page
+            expect(next_page.size).to eql(2)
+            expect(next_page).to be_last_page
+          end
+        end
       end
 
-      describe 'presence #history' do
+      describe '#history' do
         let(:channel) { client.channel('persisted:presence_fixtures') }
         let(:presence_history) { channel.presence.history }
 
@@ -48,11 +67,11 @@ describe Ably::Rest::Presence do
         context 'with options' do
           let(:page_size) { 2 }
 
-          context 'forwards' do
+          context 'direction: :forwards' do
             let(:presence_history) { channel.presence.history(direction: :forwards) }
             let(:paged_history_forward) { channel.presence.history(limit: page_size, direction: :forwards) }
 
-            it 'returns recent presence activity with options passed to Ably' do
+            it 'returns recent presence activity forwards with most recent history last' do
               expect(paged_history_forward).to be_a(Ably::Models::PaginatedResource)
               expect(paged_history_forward.size).to eql(2)
 
@@ -63,11 +82,11 @@ describe Ably::Rest::Presence do
             end
           end
 
-          context 'backwards' do
+          context 'direction: :backwards' do
             let(:presence_history) { channel.presence.history(direction: :backwards) }
             let(:paged_history_backward) { channel.presence.history(limit: page_size, direction: :backwards) }
 
-            it 'returns recent presence activity with options passed to Ably' do
+            it 'returns recent presence activity backwards with most recent history first' do
               expect(paged_history_backward).to be_a(Ably::Models::PaginatedResource)
               expect(paged_history_backward.size).to eql(2)
 
@@ -79,12 +98,14 @@ describe Ably::Rest::Presence do
           end
         end
       end
+    end
 
-      describe 'options' do
-        let(:channel_name) { "persisted:#{SecureRandom.hex(4)}" }
+    describe '#history' do
+      context 'with time range options' do
+        let(:channel_name) { "persisted:#{random_str(4)}" }
         let(:presence) { client.channel(channel_name).presence }
         let(:user) { 'appid.keyuid' }
-        let(:secret) { SecureRandom.hex(8) }
+        let(:secret) { random_str(8) }
         let(:endpoint) do
           client.endpoint.tap do |client_end_point|
             client_end_point.user = user
@@ -96,9 +117,9 @@ describe Ably::Rest::Presence do
         end
 
         [:start, :end].each do |option|
-          describe ":{option}", webmock: true do
+          describe ":#{option}", :webmock do
             let!(:history_stub) {
-              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?live=true&#{option}=#{milliseconds}").
+              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?#{option}=#{milliseconds}").
                 to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
             }
 
@@ -106,141 +127,159 @@ describe Ably::Rest::Presence do
               presence.history(options)
             end
 
-            context 'with milliseconds since epoch' do
+            context 'with milliseconds since epoch value' do
               let(:milliseconds) { as_since_epoch(Time.now) }
               let(:options) { { option => milliseconds } }
 
-              specify 'are left unchanged' do
+              it 'uses this value in the history request' do
                 expect(history_stub).to have_been_requested
               end
             end
 
-            context 'with Time' do
+            context 'with Time object value' do
               let(:time) { Time.now }
               let(:milliseconds) { as_since_epoch(time) }
               let(:options) { { option => time } }
 
-              specify 'are left unchanged' do
+              it 'converts the value to milliseconds since epoch in the hisotry request' do
                 expect(history_stub).to have_been_requested
               end
             end
           end
         end
       end
+    end
 
-      describe 'decoding', webmock: true do
-        let(:user) { 'appid.keyuid' }
-        let(:secret) { SecureRandom.hex(8) }
-        let(:endpoint) do
-          client.endpoint.tap do |client_end_point|
-            client_end_point.user = user
-            client_end_point.password = secret
-          end
-        end
-        let(:client) do
-          Ably::Rest::Client.new(api_key: "#{user}:#{secret}", environment: environment, protocol: protocol)
+    describe 'decoding', :webmock do
+      let(:user) { 'appid.keyuid' }
+      let(:secret) { random_str(8) }
+      let(:endpoint) do
+        client.endpoint.tap do |client_end_point|
+          client_end_point.user = user
+          client_end_point.password = secret
         end
+      end
+      let(:client) do
+        Ably::Rest::Client.new(client_options.merge(api_key: "#{user}:#{secret}"))
+      end
+
+      let(:data)            { random_str(32) }
+      let(:channel_name)    { "persisted:#{random_str(4)}" }
+      let(:cipher_options)  { { key: random_str(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+      let(:presence)        { client.channel(channel_name, encrypted: true, cipher_params: cipher_options).presence }
 
-        let(:data)            { SecureRandom.hex(32) }
-        let(:channel_name)    { "persisted:#{SecureRandom.hex(4)}" }
-        let(:cipher_options)  { { key: SecureRandom.hex(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
-        let(:presence)        { client.channel(channel_name, encrypted: true, cipher_params: cipher_options).presence }
+      let(:crypto)          { Ably::Util::Crypto.new(cipher_options) }
 
-        let(:crypto)          { Ably::Util::Crypto.new(cipher_options) }
+      let(:content_type) do
+        if protocol == :msgpack
+          'application/x-msgpack'
+        else
+          'application/json'
+        end
+      end
 
-        let(:content_type) do
+      context 'valid decodeable content' do
+        let(:serialized_encoded_message) do
           if protocol == :msgpack
-            'application/x-msgpack'
+            msg = Ably::Models::PresenceMessage.new({ action: :enter, data: crypto.encrypt(data), encoding: 'utf-8/cipher+aes-256-cbc' })
+            MessagePack.pack([msg.as_json])
           else
-            'application/json'
+            msg = Ably::Models::PresenceMessage.new({ action: :enter, data: Base64.encode64(crypto.encrypt(data)), encoding: 'utf-8/cipher+aes-256-cbc/base64' })
+            [msg].to_json
           end
         end
 
-        context 'valid decodeable content' do
-          let(:serialized_encoded_message) do
-            if protocol == :msgpack
-              msg = Ably::Models::PresenceMessage.new({ action: :enter, data: crypto.encrypt(data), encoding: 'utf-8/cipher+aes-256-cbc' })
-              MessagePack.pack([msg.as_json])
-            else
-              msg = Ably::Models::PresenceMessage.new({ action: :enter, data: Base64.encode64(crypto.encrypt(data)), encoding: 'utf-8/cipher+aes-256-cbc/base64' })
-              [msg].to_json
-            end
-          end
+        context '#get' do
+          let!(:get_stub)   {
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence").
+              to_return(:body => serialized_encoded_message, :headers => { 'Content-Type' => content_type })
+          }
 
-          context '#get' do
-            let!(:get_stub)   {
-              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence").
-                to_return(:body => serialized_encoded_message, :headers => { 'Content-Type' => content_type })
-            }
-
-            after do
-              expect(get_stub).to have_been_requested
-            end
+          after do
+            expect(get_stub).to have_been_requested
+          end
 
-            it 'automaticaly decodes presence messages' do
-              present = presence.get
-              expect(present.first.encoding).to be_nil
-              expect(present.first.data).to eql(data)
-            end
+          it 'automaticaly decodes presence messages' do
+            present = presence.get
+            expect(present.first.encoding).to be_nil
+            expect(present.first.data).to eql(data)
           end
+        end
 
-          context '#history' do
-            let!(:history_stub)   {
-              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?live=true").
-                to_return(:body => serialized_encoded_message, :headers => { 'Content-Type' => content_type })
-            }
+        context '#history' do
+          let!(:history_stub)   {
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history").
+              to_return(:body => serialized_encoded_message, :headers => { 'Content-Type' => content_type })
+          }
 
-            after do
-              expect(history_stub).to have_been_requested
-            end
+          after do
+            expect(history_stub).to have_been_requested
+          end
 
-            it 'automaticaly decodes presence messages' do
-              history = presence.history
-              expect(history.first.encoding).to be_nil
-              expect(history.first.data).to eql(data)
-            end
+          it 'automaticaly decodes presence messages' do
+            history = presence.history
+            expect(history.first.encoding).to be_nil
+            expect(history.first.data).to eql(data)
           end
         end
+      end
 
-        context 'invalid data' do
-          let(:serialized_encoded_message_with_invalid_encoding) do
-            if protocol == :msgpack
-              msg = Ably::Models::PresenceMessage.new({ action: :enter, data: crypto.encrypt(data), encoding: 'utf-8/cipher+aes-128-cbc' })
-              MessagePack.pack([msg.as_json])
-            else
-              msg = Ably::Models::PresenceMessage.new({ action: :enter, data: Base64.encode64(crypto.encrypt(data)), encoding: 'utf-8/cipher+aes-128-cbc/base64' })
-              [msg].to_json
-            end
+      context 'invalid data' do
+        let(:serialized_encoded_message_with_invalid_encoding) do
+          if protocol == :msgpack
+            msg = Ably::Models::PresenceMessage.new({ action: :enter, data: crypto.encrypt(data), encoding: 'utf-8/cipher+aes-128-cbc' })
+            MessagePack.pack([msg.as_json])
+          else
+            msg = Ably::Models::PresenceMessage.new({ action: :enter, data: Base64.encode64(crypto.encrypt(data)), encoding: 'utf-8/cipher+aes-128-cbc/base64' })
+            [msg].to_json
           end
+        end
 
-          context '#get' do
-            let!(:get_stub)   {
-              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence").
-                to_return(:body => serialized_encoded_message_with_invalid_encoding, :headers => { 'Content-Type' => content_type })
-            }
+        context '#get' do
+          let(:client_options) { default_options.merge(log_level: :fatal) }
+          let!(:get_stub)   {
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence").
+              to_return(:body => serialized_encoded_message_with_invalid_encoding, :headers => { 'Content-Type' => content_type })
+          }
+          let(:presence_message) { presence.get.first }
 
-            after do
-              expect(get_stub).to have_been_requested
-            end
+          after do
+            expect(get_stub).to have_been_requested
+          end
+
+          it 'returns the messages still encoded' do
+            expect(presence_message.encoding).to match(/cipher\+aes-128-cbc/)
+          end
 
-            it 'raises a cipher error' do
-              expect { presence.get }.to raise_error Ably::Exceptions::CipherError
+          it 'logs a cipher error' do
+            expect(client.logger).to receive(:error) do |message|
+              expect(message).to match(/Cipher algorithm [\w-]+ does not match/)
             end
+            presence.get
           end
+        end
 
-          context '#history' do
-            let!(:history_stub)   {
-              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?live=true").
-                to_return(:body => serialized_encoded_message_with_invalid_encoding, :headers => { 'Content-Type' => content_type })
-            }
+        context '#history' do
+          let(:client_options) { default_options.merge(log_level: :fatal) }
+          let!(:history_stub)   {
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history").
+              to_return(:body => serialized_encoded_message_with_invalid_encoding, :headers => { 'Content-Type' => content_type })
+          }
+          let(:presence_message) { presence.history.first }
 
-            after do
-              expect(history_stub).to have_been_requested
-            end
+          after do
+            expect(history_stub).to have_been_requested
+          end
+
+          it 'returns the messages still encoded' do
+            expect(presence_message.encoding).to match(/cipher\+aes-128-cbc/)
+          end
 
-            it 'raises a cipher error' do
-              expect { presence.history }.to raise_error Ably::Exceptions::CipherError
+          it 'logs a cipher error' do
+            expect(client.logger).to receive(:error) do |message|
+              expect(message).to match(/Cipher algorithm [\w-]+ does not match/)
             end
+            presence.history
           end
         end
       end