ably 0.1.6 → 0.2.0

data/spec/acceptance/rest/base_spec.rb

@@ -1,12 +1,12 @@
-require "spec_helper"
-require "securerandom"
+require 'spec_helper'
+require 'securerandom'
 
-describe "REST" do
+describe 'REST' do
   let(:client) do
     Ably::Rest::Client.new(api_key: api_key, environment: environment)
   end
 
-  describe "protocol" do
+  describe 'protocol' do
     include Ably::Modules::Conversions
 
     let(:client_options) { {} }
@@ -71,8 +71,8 @@ describe "REST" do
     end
   end
 
-  describe "invalid requests in middleware" do
-    it "should raise an InvalidRequest exception with a valid message" do
+  describe 'invalid requests in middleware' do
+    it 'should raise an InvalidRequest exception with a valid message' do
       invalid_client = Ably::Rest::Client.new(api_key: 'appid.keyuid:keysecret', environment: environment)
       expect { invalid_client.channel('test').publish('foo', 'choo') }.to raise_error do |error|
         expect(error).to be_a(Ably::Exceptions::InvalidToken)
@@ -82,7 +82,7 @@ describe "REST" do
       end
     end
 
-    describe "server error with JSON response", webmock: true do
+    describe 'server error with JSON response', webmock: true do
       let(:error_response) { '{ "error": { "statusCode": 500, "code": 50000, "message": "Internal error" } }' }
 
       before do
@@ -90,18 +90,18 @@ describe "REST" do
           to_return(:status => 500, :body => error_response, :headers => { 'Content-Type' => 'application/json' })
       end
 
-      it "should raise a ServerError exception" do
+      it 'should raise a ServerError exception' do
         expect { client.time }.to raise_error(Ably::Exceptions::ServerError, /Internal error/)
       end
     end
 
-    describe "server error", webmock: true do
+    describe 'server error', webmock: true do
       before do
         stub_request(:get, "#{client.endpoint}/time").
         to_return(:status => 500, :headers => { 'Content-Type' => 'application/json' })
       end
 
-      it "should raise a ServerError exception" do
+      it 'should raise a ServerError exception' do
         expect { client.time }.to raise_error(Ably::Exceptions::ServerError, /Unknown/)
       end
     end

data/spec/acceptance/rest/channel_spec.rb

@@ -1,7 +1,7 @@
-require "spec_helper"
-require "securerandom"
+require 'spec_helper'
+require 'securerandom'
 
-describe "REST" do
+describe Ably::Rest::Channel do
   include Ably::Modules::Conversions
 
   [:msgpack, :json].each do |protocol|
@@ -10,44 +10,60 @@ describe "REST" do
         Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
       end
 
-      describe "publishing messages" do
-        let(:channel) { client.channel("test") }
-        let(:event)   { "foo" }
-        let(:message) { "woop!" }
+      describe 'publishing messages' do
+        let(:channel) { client.channel('test') }
+        let(:event)   { 'foo' }
+        let(:message) { 'woop!' }
 
-        it "should publish the message ok" do
+        it 'should publish the message ok' do
           expect(channel.publish(event, message)).to eql(true)
         end
       end
 
-      describe "fetching channel history" do
+      describe 'fetching channel history' do
         let(:channel) { client.channel("persisted:#{SecureRandom.hex(4)}") }
         let(:expected_history) do
           [
-            { :name => "test1", :data => "foo" },
-            { :name => "test2", :data => "bar" },
-            { :name => "test3", :data => "baz" }
+            { :name => 'test1', :data => 'foo' },
+            { :name => 'test2', :data => 'bar' },
+            { :name => 'test3', :data => 'baz' }
           ]
         end
+        let!(:before_published) { client.time }
 
         before(:each) do
           expected_history.each do |message|
-            channel.publish(message[:name], message[:data]) || raise("Unable to publish message")
+            channel.publish(message[:name], message[:data]) || raise('Unable to publish message')
           end
         end
 
-        it "should return all the history for the channel" do
+        it 'should return all the history for the channel' do
           actual_history = channel.history
 
           expect(actual_history.size).to eql(3)
 
           expected_history.each do |message|
-            expect(actual_history).to include(Ably::Models::Message.new(message))
-            expect(actual_history.map(&:hash)).to include(message)
+            message_name, message_data = message[:name], message[:data]
+            matching_message = actual_history.find { |message| message.name == message_name && message.data == message_data }
+            expect(matching_message).to be_a(Ably::Models::Message)
           end
         end
 
-        it "should return paged history" do
+        context 'timestamps' do
+          it 'should be greater than the time before the messages were published' do
+            channel.history.each do |message|
+              expect(before_published.to_f).to be < message.timestamp.to_f
+            end
+          end
+        end
+
+        it 'should return messages with unique IDs' do
+          message_ids = channel.history.map(&:id).compact
+          expect(message_ids.count).to eql(3)
+          expect(message_ids.uniq.count).to eql(3)
+        end
+
+        it 'should return paged history' do
           page_1 = channel.history(limit: 1)
           page_2 = page_1.next_page
           page_3 = page_2.next_page
@@ -71,7 +87,7 @@ describe "REST" do
         end
       end
 
-      describe "options" do
+      describe 'history options' do
         let(:channel_name) { "persisted:#{SecureRandom.hex(4)}" }
         let(:channel) { client.channel(channel_name) }
         let(:endpoint) do
@@ -82,7 +98,7 @@ describe "REST" do
         end
 
         [:start, :end].each do |option|
-          describe ":{option}", webmock: true do
+          describe ":#{option}", webmock: true do
             let!(:history_stub) {
               stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/messages?live=true&#{option}=#{milliseconds}").
                 to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })

data/spec/acceptance/rest/channels_spec.rb

@@ -1,5 +1,5 @@
-require "spec_helper"
-require "securerandom"
+require 'spec_helper'
+require 'securerandom'
 
 describe Ably::Rest::Channels do
   [:msgpack, :json].each do |protocol|
@@ -10,30 +10,30 @@ describe Ably::Rest::Channels do
       let(:channel_name) { SecureRandom.hex }
       let(:options) { { key: 'value' } }
 
-      shared_examples "a channel" do
-        it "should access a channel" do
+      shared_examples 'a channel' do
+        it 'should access a channel' do
           expect(channel).to be_a Ably::Rest::Channel
           expect(channel.name).to eql(channel_name)
         end
 
-        it "should allow options to be set on a channel" do
+        it 'should allow options to be set on a channel' do
           expect(channel_with_options.options).to eql(options)
         end
       end
 
-      describe "using shortcut method on client" do
+      describe 'using shortcut method on client' do
         let(:channel) { client.channel(channel_name) }
         let(:channel_with_options) { client.channel(channel_name, options) }
         it_behaves_like 'a channel'
       end
 
-      describe "using documented .get method on client.channels" do
+      describe 'using documented .get method on client.channels' do
         let(:channel) { client.channels.get(channel_name) }
         let(:channel_with_options) { client.channels.get(channel_name, options) }
         it_behaves_like 'a channel'
       end
 
-      describe "using undocumented [] method on client.channels" do
+      describe 'using undocumented [] method on client.channels' do
         let(:channel) { client.channels[channel_name] }
         let(:channel_with_options) { client.channels[channel_name, options] }
         it_behaves_like 'a channel'

data/spec/acceptance/rest/message_spec.rb

@@ -0,0 +1,224 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe 'Ably::Rest Message' 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
+
+                message = encrypted_channel.history.first
+                expect(message.data).to eql(encoded_data_decoded)
+                expect(message.encoding).to be_nil
+              end
+            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' 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' do
+            data = JSON.parse(File.read(File.join(resources_root, 'crypto-data-256.json')))
+            add_tests_for_data data
+          end
+
+          context 'multiple messages' do
+            let(:data) { MessagePack.pack({ 'key' => SecureRandom.hex }) }
+            let(:message_count) { 20 }
+
+            it 'encrypt and decrypt messages' 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 "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) }
+
+            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 '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) }
+
+            let(:payload) { MessagePack.pack({ 'key' => SecureRandom.hex }) }
+
+            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 '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) }
+
+            let(:payload) { MessagePack.pack({ 'key' => SecureRandom.hex }) }
+
+            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
+
+              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 '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/
+            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) }
+
+            let(:payload) { MessagePack.pack({ 'key' => SecureRandom.hex }) }
+
+            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
+
+              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 '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/
+            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) }
+
+            let(:payload) { MessagePack.pack({ 'key' => SecureRandom.hex }) }
+
+            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
+
+              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 '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/
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/rest/presence_spec.rb

@@ -1,7 +1,7 @@
-require "spec_helper"
-require "securerandom"
+require 'spec_helper'
+require 'securerandom'
 
-describe "REST" do
+describe Ably::Rest::Presence do
   include Ably::Modules::Conversions
 
   [:msgpack, :json].each do |protocol|
@@ -12,54 +12,73 @@ describe "REST" do
 
       let(:fixtures) do
         TestApp::APP_SPEC['channels'].first['presence'].map do |fixture|
-          IdiomaticRubyWrapper(fixture, stop_at: [:client_data])
+          IdiomaticRubyWrapper(fixture, stop_at: [:data])
         end
       end
 
-      describe "fetching presence" do
-        let(:channel) { client.channel("persisted:presence_fixtures") }
+      describe '#get presence' 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' 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.client_data).to eq(fixture[:client_data])
+            expect(presence_message.data).to eq(fixture[:data])
           end
         end
       end
 
-      describe "presence history" do
-        let(:channel) { client.channel("persisted:presence_fixtures") }
-        let(:history) { channel.presence.history }
+      describe 'presence #history' do
+        let(:channel) { client.channel('persisted:presence_fixtures') }
+        let(:presence_history) { channel.presence.history }
 
-        it "returns recent presence activity" do
-          expect(history.size).to eql(4)
+        it 'returns recent presence activity' do
+          expect(presence_history.size).to eql(4)
 
           fixtures.each do |fixture|
-            presence_message = history.find { |client| client.client_id == fixture['clientId'] }
-            expect(presence_message.client_data).to eq(fixture[:client_data])
+            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 }
-          let(:paged_history_forward) { channel.presence.history(limit: page_size, direction: :forwards) }
 
-          it "returns recent presence activity with options passsed to Ably" do
-            expect(paged_history_forward).to be_a(Ably::Models::PaginatedResource)
-            expect(paged_history_forward.size).to eql(2)
+          context 'forwards' do
+            let(:presence_history) { channel.presence.history(direction: :forwards) }
+            let(:paged_history_forward) { channel.presence.history(limit: page_size, direction: :forwards) }
 
-            next_page = paged_history_forward.next_page
+            it 'returns recent presence activity with options passed to Ably' do
+              expect(paged_history_forward).to be_a(Ably::Models::PaginatedResource)
+              expect(paged_history_forward.size).to eql(2)
 
-            expect(paged_history_forward.first.id).to eql(history.last.id)
-            expect(next_page.first.id).to eql(history[page_size].id)
+              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 '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
+              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
 
-      describe "options" do
+      describe 'options' do
         let(:channel_name) { "persisted:#{SecureRandom.hex(4)}" }
         let(:presence) { client.channel(channel_name).presence }
         let(:user) { 'appid.keyuid' }
@@ -106,6 +125,123 @@ describe "REST" do
           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)
+        end
+
+        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(: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?live=true").
+                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!(: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 })
+            }
+
+            after do
+              expect(get_stub).to have_been_requested
+            end
+
+            it 'raises a cipher error' do
+              expect { presence.get }.to raise_error Ably::Exceptions::CipherError
+            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 })
+            }
+
+            after do
+              expect(history_stub).to have_been_requested
+            end
+
+            it 'raises a cipher error' do
+              expect { presence.history }.to raise_error Ably::Exceptions::CipherError
+            end
+          end
+        end
+      end
     end
   end
 end