ably-rest 0.7.1 → 0.7.3

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

@@ -0,0 +1,185 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'base64'
+
+describe Ably::Models::MessageEncoders do
+  let(:default_client_options) { { api_key: api_key, environment: environment } }
+  let(:client)                 { Ably::Rest::Client.new(default_client_options.merge(protocol: protocol)) }
+  let(:channel_options)        { {} }
+  let(:channel)                { client.channel('test', channel_options) }
+  let(:response)               { instance_double('Faraday::Response', status: 201) }
+
+  let(:cipher_params)          { { key: random_str, algorithm: 'aes', mode: 'cbc', key_length: 128 } }
+  let(:crypto)                 { Ably::Util::Crypto.new(cipher_params) }
+
+  let(:utf_8_data)             { random_str.encode(Encoding::UTF_8) }
+  let(:binary_data)            { MessagePack.pack(random_str).encode(Encoding::ASCII_8BIT) }
+  let(:json_data)              { { 'key' => random_str } }
+
+  after do
+    channel.publish 'event', published_data
+  end
+
+  def on_publish
+    expect(client).to receive(:post) do |url, message|
+      yield(message['encoding'], message['data'])
+    end.and_return(response)
+  end
+
+  def decrypted(payload, options = {})
+    payload = Base64.decode64(payload) if options[:base64]
+    crypto.decrypt(payload)
+  end
+
+  context 'with binary transport protocol' do
+    let(:protocol) { :msgpack }
+
+    context 'without encryption' do
+      context 'with UTF-8 data' do
+        let(:published_data) { utf_8_data }
+
+        it 'does not apply any encoding' do
+          on_publish do |encoding, encoded_data|
+            expect(encoding).to be_nil
+            expect(encoded_data).to eql(published_data)
+          end
+        end
+      end
+
+      context 'with binary data' do
+        let(:published_data) { binary_data }
+
+        it 'does not apply any encoding' do
+          on_publish do |encoding, encoded_data|
+            expect(encoding).to be_nil
+            expect(encoded_data).to eql(published_data)
+          end
+        end
+      end
+
+      context 'with JSON data' do
+        let(:published_data) { json_data }
+
+        it 'stringifies the JSON and sets the encoding attribute to "json"' do
+          on_publish do |encoding, encoded_data|
+            expect(encoding).to eql('json')
+            expect(encoded_data).to eql(JSON.dump(published_data))
+          end
+        end
+      end
+    end
+
+    context 'with encryption' do
+      let(:channel_options) { { encrypted: true, cipher_params: cipher_params } }
+
+      context 'with UTF-8 data' do
+        let(:published_data) { utf_8_data }
+
+        it 'applies utf-8 and cipher encoding and sets the encoding attribute to "utf-8/cipher+aes-128-cbc"' do
+          on_publish do |encoding, encoded_data|
+            expect(encoding).to eql('utf-8/cipher+aes-128-cbc')
+            expect(decrypted(encoded_data)).to eql(published_data)
+          end
+        end
+      end
+
+      context 'with binary data' do
+        let(:published_data) { binary_data }
+
+        it 'applies cipher encoding and sets the encoding attribute to "cipher+aes-128-cbc"' do
+          on_publish do |encoding, encoded_data|
+            expect(encoding).to eql('cipher+aes-128-cbc')
+            expect(decrypted(encoded_data)).to eql(published_data)
+          end
+        end
+      end
+
+      context 'with JSON data' do
+        let(:published_data) { json_data }
+
+        it 'applies json, utf-8 and cipher encoding and sets the encoding attribute to "json/utf-8/cipher+aes-128-cbc"' do
+          on_publish do |encoding, encoded_data|
+            expect(encoding).to eql('json/utf-8/cipher+aes-128-cbc')
+            expect(decrypted(encoded_data)).to eql(JSON.dump(published_data))
+          end
+        end
+      end
+    end
+  end
+
+  context 'with text transport protocol' do
+    let(:protocol) { :json }
+
+    context 'without encryption' do
+      context 'with UTF-8 data' do
+        let(:published_data) { utf_8_data }
+
+        it 'does not apply any encoding' do
+          on_publish do |encoding, encoded_data|
+            expect(encoding).to be_nil
+            expect(encoded_data).to eql(published_data)
+          end
+        end
+      end
+
+      context 'with binary data' do
+        let(:published_data) { binary_data }
+
+        it 'applies a base64 encoding and sets the encoding attribute to "base64"' do
+          on_publish do |encoding, encoded_data|
+            expect(encoding).to eql('base64')
+            expect(Base64.decode64(encoded_data)).to eql(published_data)
+          end
+        end
+      end
+
+      context 'with JSON data' do
+        let(:published_data) { json_data }
+
+        it 'stringifies the JSON and sets the encoding attribute to "json"' do
+          on_publish do |encoding, encoded_data|
+            expect(encoding).to eql('json')
+            expect(encoded_data).to eql(JSON.dump(published_data))
+          end
+        end
+      end
+    end
+
+    context 'with encryption' do
+      let(:channel_options) { { encrypted: true, cipher_params: cipher_params } }
+
+      context 'with UTF-8 data' do
+        let(:published_data) { utf_8_data }
+
+        it 'applies utf-8, cipher and base64 encodings and sets the encoding attribute to "utf-8/cipher+aes-128-cbc/base64"' do
+          on_publish do |encoding, encoded_data|
+            expect(encoding).to eql('utf-8/cipher+aes-128-cbc/base64')
+            expect(decrypted(encoded_data, base64: true)).to eql(published_data)
+          end
+        end
+      end
+
+      context 'with binary data' do
+        let(:published_data) { binary_data }
+
+        it 'applies cipher and base64 encoding and sets the encoding attribute to "utf-8/cipher+aes-128-cbc/base64"' do
+          on_publish do |encoding, encoded_data|
+            expect(encoding).to eql('cipher+aes-128-cbc/base64')
+            expect(decrypted(encoded_data, base64: true)).to eql(published_data)
+          end
+        end
+      end
+
+      context 'with JSON data' do
+        let(:published_data) { json_data }
+
+        it 'applies json, utf-8, cipher and base64 encoding and sets the encoding attribute to "json/utf-8/cipher+aes-128-cbc/base64"' do
+          on_publish do |encoding, encoded_data|
+            expect(encoding).to eql('json/utf-8/cipher+aes-128-cbc/base64')
+            expect(decrypted(encoded_data, base64: true)).to eql(JSON.dump(published_data))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,247 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'securerandom'
+
+describe Ably::Rest::Channel, 'messages' do
+  include Ably::Modules::Conversions
+
+  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
+
+    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
+
+          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 retrieves messages that are encrypted & decrypted by the Ably library' do
+            encrypted_channel.publish 'example', encoded_data_decoded
+
+            message = encrypted_channel.history.first
+            expect(message.data).to eql(encoded_data_decoded)
+            expect(message.encoding).to be_nil
+          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
+          end
+        end
+
+        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
+
+        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
+
+        context 'when publishing lots of messages' do
+          let(:data) { MessagePack.pack({ 'key' => random_str }) }
+          let(:message_count) { 20 }
+
+          it 'encrypts on #publish and decrypts on #history' do
+            message_count.times do |index|
+              encrypted_channel.publish index.to_s, "#{index}-#{data}"
+            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 '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) }
+
+          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)}"
+
+            specify "delivers a #{payload_description} payload to the receiver" do
+              encrypted_channel.publish 'example', payload
+
+              message = other_client_channel.history.first
+              expect(message.data).to eql(payload)
+              expect(message.encoding).to be_nil
+            end
+          end
+        end
+
+        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' => random_str }) }
+
+          it 'does not attempt to decrypt the message' do
+            unencrypted_channel.publish 'example', payload
+
+            message = other_client_encrypted_channel.history.first
+            expect(message.data).to eql(payload)
+            expect(message.encoding).to be_nil
+          end
+        end
+
+        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 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' => random_str }) }
+
+          before do
+            encrypted_channel_client1.publish 'example', payload
+          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 '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(: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' => random_str }) }
+
+          before do
+            encrypted_channel_client1.publish 'example', payload
+          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 '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
+    end
+  end
+end

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

@@ -0,0 +1,292 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Rest::Presence do
+  include Ably::Modules::Conversions
+
+  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
+
+    context 'tested against presence fixture data set up in test app' do
+      describe '#get' 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
+          reload_test_app
+        end
+
+        let(:channel) { client.channel('persisted:presence_fixtures') }
+        let(:presence) { channel.presence.get }
+
+        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
+
+        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 '#history' 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
+          reload_test_app
+        end
+
+        let(:channel) { client.channel('persisted:presence_fixtures') }
+        let(:presence_history) { channel.presence.history }
+
+        it 'returns recent presence activity' do
+          expect(presence_history.size).to eql(4)
+
+          fixtures.each do |fixture|
+            presence_message = presence_history.find { |client| client.client_id == fixture['clientId'] }
+            expect(presence_message.data).to eq(fixture[:data])
+          end
+        end
+
+        context 'with options' do
+          let(:page_size) { 2 }
+
+          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 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)
+
+              next_page = paged_history_forward.next_page
+
+              expect(paged_history_forward.first.id).to eql(presence_history.first.id)
+              expect(next_page.first.id).to eql(presence_history[page_size].id)
+            end
+          end
+
+          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 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)
+
+              next_page = paged_history_backward.next_page
+
+              expect(paged_history_backward.first.id).to eql(presence_history.first.id)
+              expect(next_page.first.id).to eql(presence_history[page_size].id)
+            end
+          end
+        end
+      end
+    end
+
+    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) { 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(api_key: "#{user}:#{secret}")
+        end
+
+        [:start, :end].each do |option|
+          describe ":#{option}", :webmock do
+            let!(:history_stub) {
+              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?#{option}=#{milliseconds}").
+                to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
+            }
+
+            before do
+              presence.history(options)
+            end
+
+            context 'with milliseconds since epoch value' do
+              let(:milliseconds) { as_since_epoch(Time.now) }
+              let(:options) { { option => milliseconds } }
+
+              it 'uses this value in the history request' do
+                expect(history_stub).to have_been_requested
+              end
+            end
+
+            context 'with Time object value' do
+              let(:time) { Time.now }
+              let(:milliseconds) { as_since_epoch(time) }
+              let(:options) { { option => time } }
+
+              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 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(:crypto)          { Ably::Util::Crypto.new(cipher_options) }
+
+      let(:content_type) do
+        if protocol == :msgpack
+          'application/x-msgpack'
+        else
+          'application/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 })
+          }
+
+          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
+        end
+
+        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
+
+          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
+        end
+
+        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
+
+          it 'returns the messages still encoded' do
+            expect(presence_message.encoding).to match(/cipher\+aes-128-cbc/)
+          end
+
+          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(: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
+
+          it 'returns the messages still encoded' do
+            expect(presence_message.encoding).to match(/cipher\+aes-128-cbc/)
+          end
+
+          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
+    end
+  end
+end