ably 0.1.6 → 0.2.0

data/lib/ably/util/pub_sub.rb

@@ -19,6 +19,17 @@ module Ably::Util
   class PubSub
     include Ably::Modules::EventEmitter
 
+    # Ensure new PubSub object does not share class instance variables
+    def self.new(options = {})
+      Class.new(PubSub).allocate.tap do |pub_sub_object|
+        pub_sub_object.send(:initialize, options)
+      end
+    end
+
+    def inspect
+      "<#PubSub: @event_emitter_coerce_proc: #{self.class.event_emitter_coerce_proc.inspect}\n @callbacks: #{callbacks}>"
+    end
+
     def initialize(options = {})
       self.class.instance_eval do
         configure_event_emitter options

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = "0.1.6"
+  VERSION = '0.2.0'
 end

data/spec/acceptance/realtime/channel_spec.rb

@@ -8,13 +8,11 @@ describe Ably::Realtime::Channel do
     context "over #{protocol}" do
       let(:default_options) { { api_key: api_key, environment: environment, protocol: protocol } }
 
-      let(:client) do
-        Ably::Realtime::Client.new(default_options)
-      end
+      let(:client)       { Ably::Realtime::Client.new(default_options) }
       let(:channel_name) { SecureRandom.hex(2) }
-      let(:payload) { SecureRandom.hex(4) }
-      let(:channel) { client.channel(channel_name) }
-      let(:messages) { [] }
+      let(:payload)      { SecureRandom.hex(4) }
+      let(:channel)      { client.channel(channel_name) }
+      let(:messages)     { [] }
 
       it 'attaches to a channel' do
         run_reactor do
@@ -135,6 +133,66 @@ describe Ably::Realtime::Channel do
         end
       end
 
+      it 'opens many connections and then many channels simultaneously' do
+        run_reactor(15) do
+          count, connected_ids = 25, []
+
+          clients = count.times.map do
+            Ably::Realtime::Client.new(default_options)
+          end
+
+          channels_opened = 0
+          open_channels_on_clients = Proc.new do
+            5.times.each do |channel|
+              clients.each do |client|
+                client.channel("channel-#{channel}").attach do
+                  channels_opened += 1
+                  if channels_opened == clients.count * 5
+                    expect(channels_opened).to eql(clients.count * 5)
+                    stop_reactor
+                  end
+                end
+              end
+            end
+          end
+
+          clients.each do |client|
+            client.connection.on(:connected) do
+              connected_ids << client.connection.id
+
+              if connected_ids.count == 25
+                expect(connected_ids.uniq.count).to eql(25)
+                open_channels_on_clients.call
+              end
+            end
+          end
+        end
+      end
+
+      it 'opens many connections and attaches to channels before connected' do
+        run_reactor(15) do
+          count, connected_ids = 25, []
+
+          clients = count.times.map do
+            Ably::Realtime::Client.new(default_options)
+          end
+
+          channels_opened = 0
+
+          clients.each do |client|
+            5.times.each do |channel|
+              client.channel("channel-#{channel}").attach do
+                channels_opened += 1
+                if channels_opened == clients.count * 5
+                  expect(channels_opened).to eql(clients.count * 5)
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+      end
+
       context 'attach failure' do
         let(:restricted_client) do
           Ably::Realtime::Client.new(default_options.merge(api_key: restricted_api_key))
@@ -146,7 +204,7 @@ describe Ably::Realtime::Channel do
             restricted_channel.attach
             restricted_channel.on(:failed) do |error|
               expect(restricted_channel.state).to eq(:failed)
-              expect(error.status_code).to eq(401)
+              expect(error.status).to eq(401)
               stop_reactor
             end
           end

data/spec/acceptance/realtime/connection_spec.rb

@@ -3,19 +3,43 @@ require 'spec_helper'
 describe Ably::Realtime::Connection do
   include RSpec::EventMachine
 
-  [:msgpack, :json].each do |protocol|
+  let(:connection) { client.connection }
+
+  [:json, :msgpack].each do |protocol|
     context "over #{protocol}" do
+      let(:default_options) do
+        { api_key: api_key, environment: environment, protocol: protocol }
+      end
+
       let(:client) do
-        Ably::Realtime::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+        Ably::Realtime::Client.new(default_options)
       end
 
-      subject { client.connection }
+      context 'with API key' do
+        it 'connects automatically' do
+          run_reactor do
+            connection.on(:connected) do
+              expect(connection.state).to eq(:connected)
+              expect(client.auth.auth_params[:key_id]).to_not be_nil
+              expect(client.auth.auth_params[:access_token]).to be_nil
+              stop_reactor
+            end
+          end
+        end
+      end
 
-      it 'connects automatically' do
-        run_reactor do
-          subject.on(:connected) do
-            expect(subject.state).to eq(:connected)
-            stop_reactor
+      context 'with client_id resulting in token auth' do
+        let(:default_options) do
+          { api_key: api_key, environment: environment, protocol: protocol, client_id: SecureRandom.hex, log_level: :debug }
+        end
+        it 'connects automatically' do
+          run_reactor do
+            connection.on(:connected) do
+              expect(connection.state).to eq(:connected)
+              expect(client.auth.auth_params[:access_token]).to_not be_nil
+              expect(client.auth.auth_params[:key_id]).to be_nil
+              stop_reactor
+            end
           end
         end
       end
@@ -32,7 +56,7 @@ describe Ably::Realtime::Connection do
 
           run_reactor do
             phases.each do |phase|
-              subject.on(phase) do
+              connection.on(phase) do
                 events_triggered << phase
                 test_expectation.call if events_triggered.length == phases.length
               end
@@ -41,24 +65,38 @@ describe Ably::Realtime::Connection do
         end
       end
 
-      skip '#closed disconnects and closes the connection once timeout is reached'
+      skip '#close disconnects, closes the connection immediately and changes the connection state to closed'
 
-      specify '#closed disconnects and closes the connection gracefully' do
+      specify '#close(graceful: true) gracefully waits for the server to close the connection' do
         run_reactor(8) do
-          subject.close
-          subject.on(:closed) do
-            expect(subject.state).to eq(:closed)
+          connection.close
+          connection.on(:closed) do
+            expect(connection.state).to eq(:closed)
             stop_reactor
           end
         end
       end
 
-      it 'receives a heart beat' do
-        run_reactor(20) do
-          subject.on(:connected) do
-            subject.__incoming_protocol_msgbus__.subscribe(:message) do |protocol_message|
-              if protocol_message.action == :heartbeat
-                expect(protocol_message.action).to eq(:heartbeat)
+      it 'echoes a heart beat with #ping' do
+        run_reactor do
+          connection.on(:connected) do
+            connection.ping do |time_elapsed|
+              expect(time_elapsed).to be > 0
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      skip 'connects, closes gracefully and reconnects on #connect'
+
+      it 'connects, closes the connection, and then reconnects with a new connection ID' do
+        run_reactor(15) do
+          connection.connect do
+            connection_id = connection.id
+            connection.close do
+              connection.connect do
+                expect(connection.id).to_not eql(connection_id)
                 stop_reactor
               end
             end
@@ -66,15 +104,73 @@ describe Ably::Realtime::Connection do
         end
       end
 
-      skip 'connects, closes gracefully and reconnects on #connect'
+      context 'failures' do
+        context 'with invalid app part of the key' do
+          let(:missing_key) { 'not_an_app.invalid_key_id:invalid_key_value' }
+          let(:client) do
+            Ably::Realtime::Client.new(default_options.merge(api_key: missing_key))
+          end
 
-      it 'connects, closes then connection when timeout is reaached and reconnects on #connect' do
+          it 'enters the failed state and returns a not found error' do
+            run_reactor do
+              connection.on(:failed) do |error|
+                expect(connection.state).to eq(:failed)
+                expect(error.status).to eq(404)
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'with invalid key ID part of the key' do
+          let(:invalid_key) { "#{app_id}.invalid_key_id:invalid_key_value" }
+          let(:client) do
+            Ably::Realtime::Client.new(default_options.merge(api_key: invalid_key))
+          end
+
+          it 'enters the failed state and returns an authorization error' do
+            run_reactor do
+              connection.on(:failed) do |error|
+                expect(connection.state).to eq(:failed)
+                expect(error.status).to eq(401)
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'with invalid WebSocket host' do
+          let(:client) do
+            Ably::Realtime::Client.new(default_options.merge(ws_host: 'non.existent.host'))
+          end
+
+          it 'enters the failed state and returns an authorization error' do
+            run_reactor do
+              connection.on(:failed) do |error|
+                expect(connection.state).to eq(:failed)
+                expect(error.code).to eq(80000)
+                expect(error.status).to be_nil
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
+
+      it 'opens many connections simultaneously' do
         run_reactor(15) do
-          subject.connect do
-            connection_id = subject.id
-            subject.close do
-              subject.connect do
-                expect(subject.id).to_not eql(connection_id)
+          count, connected_ids = 25, []
+
+          clients = count.times.map do
+            Ably::Realtime::Client.new(default_options)
+          end
+
+          clients.each do |client|
+            client.connection.on(:connected) do
+              connected_ids << client.connection.id
+
+              if connected_ids.count == 25
+                expect(connected_ids.uniq.count).to eql(25)
                 stop_reactor
               end
             end

data/spec/acceptance/realtime/message_spec.rb

@@ -1,5 +1,7 @@
 require 'spec_helper'
 require 'securerandom'
+require 'json'
+require 'base64'
 
 describe 'Ably::Realtime::Channel Messages' do
   include RSpec::EventMachine
@@ -18,8 +20,8 @@ describe 'Ably::Realtime::Channel Messages' do
       let(:other_client_channel) { other_client.channel(channel_name) }
 
       let(:channel_name) { 'subscribe_send_text' }
-      let(:options) { { :protocol => :json } }
-      let(:payload) { 'Test message (subscribe_send_text)' }
+      let(:options)      { { :protocol => :json } }
+      let(:payload)      { 'Test message (subscribe_send_text)' }
 
       it 'sends a string message' do
         run_reactor do
@@ -52,7 +54,7 @@ describe 'Ably::Realtime::Channel Messages' do
         let(:no_echo_channel) { no_echo_client.channel(channel_name) }
 
         it 'sends a single message without a reply yet the messages is echoed on another normal connection' do
-          run_reactor do
+          run_reactor(10) do
             channel.attach do |echo_channel|
               no_echo_channel.attach do
                 no_echo_channel.publish 'test_event', payload
@@ -63,7 +65,9 @@ describe 'Ably::Realtime::Channel Messages' do
 
                 echo_channel.subscribe('test_event') do |message|
                   expect(message.data).to eql(payload)
-                  EventMachine.add_timer(1.5) { stop_reactor }
+                  EventMachine.add_timer(1) do
+                    stop_reactor
+                  end
                 end
               end
             end
@@ -72,9 +76,9 @@ describe 'Ably::Realtime::Channel Messages' do
       end
 
       context 'with multiple messages' do
-        let(:send_count) { 15 }
+        let(:send_count)     { 15 }
         let(:expected_echos) { send_count * 2 }
-        let(:channel_name) { SecureRandom.hex }
+        let(:channel_name)   { SecureRandom.hex }
         let(:echos) do
           { client: 0, other: 0 }
         end
@@ -82,37 +86,28 @@ describe 'Ably::Realtime::Channel Messages' do
           { client: 0, other: 0 }
         end
 
-        def expect_messages_to_be_echoed_on_both_connections
-          {
-            channel              => :client,
-            other_client_channel => :other
-          }.each do |target_channel, echo_key|
-            EventMachine.defer do
-              target_channel.subscribe('test_event') do |message|
-                echos[echo_key] += 1
-
-                if echos[:client] == expected_echos && echos[:other] == expected_echos
-                  # Wait briefly before doing the final check in case additional messages received
-                  EventMachine.add_timer(0.5) do
-                    expect(echos[:client]).to eql(expected_echos)
-                    expect(echos[:other]).to eql(expected_echos)
-                    expect(callbacks[:client]).to eql(send_count)
-                    expect(callbacks[:other]).to eql(send_count)
-                    stop_reactor
-                  end
+        it 'sends and receives the messages on both opened connections and calls the callbacks (expects twice number of messages due to local echos)' do
+          run_reactor(8) do
+            check_message_and_callback_counts = Proc.new do
+              if echos[:client] == expected_echos && echos[:other] == expected_echos
+                # Wait for message backlog to clear
+                EventMachine.add_timer(0.5) do
+                  expect(echos[:client]).to eql(expected_echos)
+                  expect(echos[:other]).to eql(expected_echos)
+
+                  expect(callbacks[:client]).to eql(send_count)
+                  expect(callbacks[:other]).to eql(send_count)
+
+                  EventMachine.stop
                 end
               end
             end
-          end
-        end
 
-        it 'sends and receives the messages on both opened connections (4 x send count due to local echos) and calls the callbacks' do
-          run_reactor(10) do
-            channel.attach
-            other_client_channel.attach
+            published = false
+            attach_callback = Proc.new do
+              next if published
 
-            channel.on(:attached) do
-              other_client_channel.on(:attached) do
+              if channel.attached? && other_client_channel.attached?
                 send_count.times do |index|
                   channel.publish('test_event', "#{index}: #{payload}") do
                     callbacks[:client] += 1
@@ -121,9 +116,22 @@ describe 'Ably::Realtime::Channel Messages' do
                     callbacks[:other] += 1
                   end
                 end
-                expect_messages_to_be_echoed_on_both_connections
+
+                published = true
               end
             end
+
+            channel.subscribe('test_event') do |message|
+              echos[:client] += 1
+              check_message_and_callback_counts.call
+            end
+            other_client_channel.subscribe('test_event') do |message|
+              echos[:other] += 1
+              check_message_and_callback_counts.call
+            end
+
+            channel.attach &attach_callback
+            other_client_channel.attach &attach_callback
           end
         end
       end
@@ -133,7 +141,7 @@ describe 'Ably::Realtime::Channel Messages' do
           Ably::Realtime::Client.new(options.merge(api_key: restricted_api_key, environment: environment, protocol: protocol))
         end
         let(:restricted_channel) { restricted_client.channel("cansubscribe:example") }
-        let(:payload) { 'Test message without permission to publish' }
+        let(:payload)            { 'Test message without permission to publish' }
 
         it 'calls the error callback' do
           run_reactor do
@@ -153,6 +161,283 @@ describe 'Ably::Realtime::Channel Messages' do
           end
         end
       end
+
+      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
+
+            let(:encrypted_channel) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+
+            it 'encrypts message automatically when published' do
+              run_reactor do
+                encrypted_channel.__incoming_msgbus__.unsubscribe # remove all subscribe callbacks that could decrypt the message
+
+                encrypted_channel.__incoming_msgbus__.subscribe(:message) do |message|
+                  if protocol == :json
+                    expect(message['encoding']).to eql(encrypted_encoding)
+                    expect(message['data']).to eql(encrypted_data)
+                  else
+                    # Messages received 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
+                  stop_reactor
+                end
+
+                encrypted_channel.publish 'example', encoded_data_decoded
+              end
+            end
+
+            it 'sends and receives messages that are encrypted & decrypted by the Ably library' do
+              run_reactor do
+                encrypted_channel.publish 'example', encoded_data_decoded
+                encrypted_channel.subscribe do |message|
+                  expect(message.data).to eql(encoded_data_decoded)
+                  expect(message.encoding).to be_nil
+                  stop_reactor
+                end
+              end
+            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 sends from one client to another' do
+          let(:cipher_options)            { { key: SecureRandom.hex(32) } }
+          let(:encrypted_channel_client1) { client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+          let(:encrypted_channel_client2) { other_client.channel(channel_name, encrypted: true, cipher_params: cipher_options) }
+
+          let(:data) { MessagePack.pack({ 'key' => SecureRandom.hex }) }
+          let(:message_count) { 50 }
+
+          it 'encrypt and decrypt messages' do
+            messages_received = {
+              decrypted: 0,
+              encrypted: 0
+            }
+
+            run_reactor do
+              encrypted_channel_client2.attach do
+                encrypted_channel_client2.subscribe do |message|
+                  expect(message.data).to eql("#{message.name}-#{data}")
+                  expect(message.encoding).to be_nil
+                  messages_received[:decrypted] += 1
+                  stop_reactor if messages_received[:decrypted] == message_count
+                end
+
+                encrypted_channel_client1.__incoming_msgbus__.subscribe(:message) do |message|
+                  expect(message['encoding']).to match(/cipher\+/)
+                  messages_received[:encrypted] += 1
+                end
+              end
+
+              message_count.times do |index|
+                encrypted_channel_client2.publish index.to_s, "#{index}-#{data}"
+              end
+            end
+          end
+        end
+
+        context "sending using protocol #{protocol} and subscribing with a different protocol" do
+          let(:other_protocol) { protocol == :msgpack ? :json : :msgpack }
+          let(:other_client) do
+            Ably::Realtime::Client.new(default_options.merge(protocol: other_protocol))
+          end
+
+          let(:cipher_options)            { { 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) }
+          let(:encrypted_channel_client2) { 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
+              run_reactor do
+                encrypted_channel_client1.publish 'example', payload
+                encrypted_channel_client2.subscribe do |message|
+                  expect(message.data).to eql(payload)
+                  expect(message.encoding).to be_nil
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+
+        context 'publishing on an unencrypted channel and subscribing on an encrypted channel with another client' do
+          let(:cipher_options)              { { key: SecureRandom.hex(32), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
+          let(:unencrypted_channel_client1) { client.channel(channel_name) }
+          let(:encrypted_channel_client2)   { 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
+            run_reactor do
+              unencrypted_channel_client1.publish 'example', payload
+              encrypted_channel_client2.subscribe do |message|
+                expect(message.data).to eql(payload)
+                expect(message.encoding).to be_nil
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context 'publishing on an encrypted channel and subscribing on an unencrypted channel with another client' do
+          let(:cipher_options)              { { 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) }
+          let(:unencrypted_channel_client2) { other_client.channel(channel_name) }
+
+          let(:payload) { MessagePack.pack({ 'key' => SecureRandom.hex }) }
+
+          it 'delivers the message but still encrypted' do
+            run_reactor do
+              encrypted_channel_client1.publish 'example', payload
+              unencrypted_channel_client2.subscribe do |message|
+                expect(message.data).to_not eql(payload)
+                expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
+                stop_reactor
+              end
+            end
+          end
+
+          it 'triggers a Cipher error on the channel' do
+            run_reactor do
+              unencrypted_channel_client2.attach do
+                encrypted_channel_client1.publish 'example', payload
+                unencrypted_channel_client2.on(:error) do |error|
+                  expect(error).to be_a(Ably::Exceptions::CipherError)
+                  expect(error.code).to eql(92001)
+                  expect(error.message).to match(/Message cannot be decrypted/)
+                  stop_reactor
+                end
+              end
+            end
+          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 }) }
+
+          it 'delivers the message but still encrypted' do
+            run_reactor do
+              encrypted_channel_client1.publish 'example', payload
+              encrypted_channel_client2.subscribe do |message|
+                expect(message.data).to_not eql(payload)
+                expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
+                stop_reactor
+              end
+            end
+          end
+
+          it 'triggers a Cipher error on the channel' do
+            run_reactor do
+              encrypted_channel_client2.attach do
+                encrypted_channel_client1.publish 'example', payload
+                encrypted_channel_client2.on(:error) do |error|
+                  expect(error).to be_a(Ably::Exceptions::CipherError)
+                  expect(error.code).to eql(92002)
+                  expect(error.message).to match(/Cipher algorithm [\w\d-]+ does not match/)
+                  stop_reactor
+                end
+              end
+            end
+          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 }) }
+
+          it 'delivers the message but still encrypted' do
+            run_reactor do
+              encrypted_channel_client1.publish 'example', payload
+              encrypted_channel_client2.subscribe do |message|
+                expect(message.data).to_not eql(payload)
+                expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
+                stop_reactor
+              end
+            end
+          end
+
+          it 'triggers a Cipher error on the channel' do
+            run_reactor do
+              encrypted_channel_client2.attach do
+                encrypted_channel_client1.publish 'example', payload
+                encrypted_channel_client2.on(:error) do |error|
+                  expect(error).to be_a(Ably::Exceptions::CipherError)
+                  expect(error.code).to eql(92003)
+                  expect(error.message).to match(/CipherError decrypting data/)
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+      end
     end
   end
 end