ably 1.1.8 → 1.2.2

data/spec/acceptance/rest/channels_spec.rb

@@ -5,11 +5,11 @@ describe Ably::Rest::Channels do
   shared_examples 'a channel' do
     it 'returns a channel object' do
       expect(channel).to be_a Ably::Rest::Channel
-      expect(channel.name).to eql(channel_name)
+      expect(channel.name).to eq(channel_name)
     end
 
     it 'returns channel object and passes the provided options' do
-      expect(channel_with_options.options).to eql(options)
+      expect(channel_with_options.options.to_h).to eq(options)
     end
   end
 
@@ -32,12 +32,29 @@ describe Ably::Rest::Channels do
       it_behaves_like 'a channel'
     end
 
+    describe '#set_options (#RTL16)' do
+      let(:channel) { client.channel(channel_name) }
+
+      it "updates channel's options" do
+        expect { channel.options = options }.to change { channel.options.to_h }.from({}).to(options)
+      end
+
+      context 'when providing Ably::Models::ChannelOptions object' do
+        let(:options_object) { Ably::Models::ChannelOptions.new(options) }
+
+        it "updates channel's options" do
+          expect { channel.options =  options_object}.to change { channel.options.to_h }.from({}).to(options)
+        end
+      end
+    end
+
     describe 'accessing an existing channel object with different options' do
       let(:new_channel_options) { { encrypted: true } }
       let(:original_channel)    { client.channels.get(channel_name, options) }
 
       it 'overrides the existing channel options and returns the channel object (RSN3c)' do
-        expect(original_channel.options).to_not include(:encrypted)
+        expect(original_channel.options.to_h).to_not include(:encrypted)
+
         new_channel = client.channels.get(channel_name, new_channel_options)
         expect(new_channel).to be_a(Ably::Rest::Channel)
         expect(new_channel.options[:encrypted]).to eql(true)
@@ -48,10 +65,10 @@ describe Ably::Rest::Channels do
       let(:original_channel) { client.channels.get(channel_name, options) }
 
       it 'returns the existing channel without modifying the channel options' do
-        expect(original_channel.options).to eql(options)
+        expect(original_channel.options.to_h).to eq(options)
         new_channel = client.channels.get(channel_name)
         expect(new_channel).to be_a(Ably::Rest::Channel)
-        expect(original_channel.options).to eql(options)
+        expect(original_channel.options.to_h).to eq(options)
       end
     end
 

data/spec/acceptance/rest/client_spec.rb

@@ -1081,7 +1081,7 @@ describe Ably::Rest::Client do
     end
 
     context 'version headers', :webmock do
-      [nil, 'ably-ruby/1.1.1 ruby/1.9.3'].each do |agent|
+      [nil, 'ably-ruby/1.1.1 ruby/3.1.1'].each do |agent|
         context "with #{agent ? "custom #{agent}" : 'default'} agent" do
           let(:client_options) { default_options.merge(key: api_key, agent: agent) }
 
@@ -1097,7 +1097,7 @@ describe Ably::Rest::Client do
           it 'sends a protocol version and lib version header (#G4, #RSC7a, #RSC7b)' do
             client.channels.get('foo').publish("event")
             expect(publish_message_stub).to have_been_requested
-            expect(Ably::PROTOCOL_VERSION).to eql('1.1')
+            expect(Ably::PROTOCOL_VERSION).to eql('1.2')
           end
         end
       end
@@ -1231,7 +1231,7 @@ describe Ably::Rest::Client do
       end
     end
 
-    context 'request_id generation' do
+    context 'request_id generation (#RSC7c)' do
       context 'Timeout error' do
         context 'with option add_request_ids: true and no fallback hosts', :webmock, :prevent_log_stubbing do
           let(:custom_logger_object) { TestLogger.new }

data/spec/acceptance/rest/message_spec.rb

@@ -24,6 +24,57 @@ describe Ably::Rest::Channel, 'messages' do
       end
     end
 
+    context 'a single Message object (#RSL1a)' do
+      let(:name) { random_str }
+      let(:data) { random_str }
+      let(:message) { Ably::Models::Message.new(name: name, data: data) }
+
+      it 'publishes the message' do
+        channel.publish(message)
+        expect(channel.history.items.length).to eql(1)
+        message = channel.history.items.first
+        expect(message.name).to eq(name)
+        expect(message.data).to eq(data)
+      end
+    end
+
+    context 'an array of Message objects (#RSL1a)' do
+      let(:data) { random_str }
+      let(:message1) { Ably::Models::Message.new(name: random_str, data: data) }
+      let(:message2) { Ably::Models::Message.new(name: random_str, data: data) }
+      let(:message3) { Ably::Models::Message.new(name: random_str, data: data) }
+
+      it 'publishes three messages' do
+        channel.publish([message1, message2, message3])
+        expect(channel.history.items.length).to eql(3)
+      end
+    end
+
+    context 'an array of hashes (#RSL1a)' do
+      let(:data) { random_str }
+      let(:message1) { { name: random_str, data: data } }
+      let(:message2) { { name: random_str, data: data } }
+      let(:message3) { { name: random_str, data: data } }
+
+      it 'publishes three messages' do
+        channel.publish([message1, message2, message3])
+        expect(channel.history.items.length).to eql(3)
+      end
+    end
+
+    context 'a name with data payload (#RSL1a, #RSL1b)' do
+      let(:name) { random_str }
+      let(:data) { random_str }
+
+      it 'publishes the message' do
+        channel.publish(name, data)
+        expect(channel.history.items.length).to eql(1)
+        message = channel.history.items.first
+        expect(message.name).to eq(name)
+        expect(message.data).to eq(data)
+      end
+    end
+
     context 'with supported data payload content type' do
       context 'JSON Object (Hash)' do
         let(:data) { { 'Hash' => 'true' } }
@@ -153,13 +204,20 @@ describe Ably::Rest::Channel, 'messages' do
         end
       end
 
-      specify 'idempotent publishing is disabled by default with 1.1 (#TO3n)' do
+      specify 'idempotent publishing is disabled by default with <= 1.1 (#TO3n)' do
+        stub_const 'Ably::PROTOCOL_VERSION', '1.0'
+        client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
+        expect(client.idempotent_rest_publishing).to be_falsey
+        stub_const 'Ably::PROTOCOL_VERSION', '1.1'
         client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
         expect(client.idempotent_rest_publishing).to be_falsey
       end
 
-      specify 'idempotent publishing is enabled by default with 1.2 (#TO3n)' do
-        stub_const 'Ably::VERSION', '1.2.0'
+      specify 'idempotent publishing is enabled by default with >= 1.2 (#TO3n)' do
+        stub_const 'Ably::PROTOCOL_VERSION', '1.2'
+        client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
+        expect(client.idempotent_rest_publishing).to be_truthy
+        stub_const 'Ably::PROTOCOL_VERSION', '1.3'
         client = Ably::Rest::Client.new(key: api_key, protocol: protocol)
         expect(client.idempotent_rest_publishing).to be_truthy
       end

data/spec/lib/unit/models/channel_options_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Ably::Models::ChannelOptions do
+  let(:modes) { nil }
+  let(:params) { {} }
+  let(:options) { described_class.new(modes: modes, params: params) }
+
+  describe '#modes_to_flags' do
+    let(:modes) { %w[publish subscribe presence_subscribe] }
+
+    subject(:protocol_message) do
+      Ably::Models::ProtocolMessage.new(action: Ably::Models::ProtocolMessage::ACTION.Attach, flags: options.modes_to_flags)
+    end
+
+    it 'converts modes to ProtocolMessage#flags correctly' do
+      expect(protocol_message.has_attach_publish_flag?).to eq(true)
+      expect(protocol_message.has_attach_subscribe_flag?).to eq(true)
+      expect(protocol_message.has_attach_presence_subscribe_flag?).to eq(true)
+
+      expect(protocol_message.has_attach_resume_flag?).to eq(false)
+      expect(protocol_message.has_attach_presence_flag?).to eq(false)
+    end
+  end
+
+  describe '#set_modes_from_flags' do
+    let(:subscribe_flag) { 262144 }
+
+    it 'converts flags to ChannelOptions#modes correctly' do
+      result = options.set_modes_from_flags(subscribe_flag)
+
+      expect(result).to eq(options.modes)
+      expect(options.modes.map(&:to_sym)).to eq(%i[subscribe])
+    end
+  end
+
+    describe '#set_params' do
+      let(:previous_params) { { example_attribute: 1 } }
+      let(:new_params) { { new_attribute: 1 } }
+      let(:params) { previous_params }
+
+      it 'should be able to overwrite attributes' do
+        expect { options.set_params(new_params) }.to \
+          change { options.params }.from(previous_params).to(new_params)
+      end
+
+      it 'should be able to make params empty' do # (1)
+        expect { options.set_params({}) }.to change { options.params }.from(previous_params).to({})
+      end
+    end
+end

data/spec/run_parallel_tests

@@ -11,13 +11,8 @@ DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )"
 bundle exec rspec "${DIR}/unit"
 unit_status=$?
 
-if ruby -v | grep -e "1.9"; then
-  # Output with test ID is not supported with this old version of RSpec
-  # So it will be jumbled sadly for 1.9.*
-  bundle exec parallel_rspec "${DIR}/acceptance"
-else
-  bundle exec parallel_rspec "${DIR}/acceptance" --prefix-output-with-test-env-number
-fi
+bundle exec parallel_rspec "${DIR}/acceptance" --prefix-output-with-test-env-number
+
 acceptance_status=$?
 
 if [ $unit_status -ne 0 ]; then

data/spec/unit/logger_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Ably::Logger do
+describe Ably::Logger, :prevent_log_stubbing do
   let(:rest_client) do
     instance_double('Ably::Rest::Client')
   end
@@ -18,14 +18,10 @@ describe Ably::Logger do
 
   context 'internals', :api_private do
     it 'delegates to the default Logger object' do
-      received = false
       expect(subject.logger).to be_a(::Logger)
-      allow_any_instance_of(::Logger).to receive(:warn) do |*args, &block|
-        expect(args.concat([block ? block.call : nil]).join(',')).to match(/message/)
-        received = true
-      end
+      expect(subject.logger).to receive(:warn).with('message')
+
       subject.warn 'message'
-      expect(received).to be_truthy
     end
 
     context 'formatter' do
@@ -136,18 +132,14 @@ describe Ably::Logger do
       end
 
       it 'delegates log messages to logger', :api_private do
-        received = false
-        allow(custom_logger_object).to receive(:fatal) do |*args, &block|
-          expect(args.concat([block ? block.call : nil]).join(',')).to match(/message/)
-          received = true
-        end
+        expect(custom_logger_object).to receive(:fatal).with('message')
+
         subject.fatal 'message'
-        expect(received).to be_truthy
       end
     end
   end
 
-  context 'with blocks', :prevent_log_stubbing do
+  context 'with blocks' do
     it 'does not call the block unless the log level is met' do
       log_level_blocks = []
       subject.warn { log_level_blocks << :warn }

data/spec/unit/models/channel_details_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::ChannelDetails do
+  subject { Ably::Models::ChannelDetails(channel_id: 'channel-id-123-xyz', name: 'name', status: { isActive: 'true', occupancy: { metrics: { connections: 1, presence_connections: 2, presence_members: 2, presence_subscribers: 5, publishers: 7, subscribers: 9 } } }) }
+
+  describe '#channel_id' do
+    it 'should return channel id' do
+      expect(subject.channel_id).to eq('channel-id-123-xyz')
+    end
+  end
+
+  describe '#name' do
+    it 'should return name' do
+      expect(subject.name).to eq('name')
+    end
+  end
+
+  describe '#status' do
+    it 'should return status' do
+      expect(subject.status).to be_a(Ably::Models::ChannelStatus)
+      expect(subject.status.occupancy.metrics.connections).to eq(1)
+      expect(subject.status.occupancy.metrics.presence_connections).to eq(2)
+      expect(subject.status.occupancy.metrics.presence_members).to eq(2)
+      expect(subject.status.occupancy.metrics.presence_subscribers).to eq(5)
+      expect(subject.status.occupancy.metrics.publishers).to eq(7)
+      expect(subject.status.occupancy.metrics.subscribers).to eq(9)
+    end
+  end
+end

data/spec/unit/models/channel_metrics_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::ChannelMetrics do
+  subject { Ably::Models::ChannelMetrics(connections: 1, presence_connections: 2, presence_members: 2, presence_subscribers: 5, publishers: 7, subscribers: 9) }
+
+  describe '#connections' do
+    it 'should return integer' do
+      expect(subject.connections).to eq(1)
+    end
+  end
+
+  describe '#presence_connections' do
+    it 'should return integer' do
+      expect(subject.presence_connections).to eq(2)
+    end
+  end
+
+  describe '#presence_members' do
+    it 'should return integer' do
+      expect(subject.presence_members).to eq(2)
+    end
+  end
+
+  describe '#presence_subscribers' do
+    it 'should return integer' do
+      expect(subject.presence_subscribers).to eq(5)
+    end
+  end
+
+  describe '#publishers' do
+    it 'should return integer' do
+      expect(subject.publishers).to eq(7)
+    end
+  end
+
+  describe '#subscribers' do
+    it 'should return integer' do
+      expect(subject.subscribers).to eq(9)
+    end
+  end
+end

data/spec/unit/models/channel_occupancy_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::ChannelOccupancy do
+  subject { Ably::Models::ChannelOccupancy({ metrics: { connections: 1, presence_connections: 2, presence_members: 2, presence_subscribers: 5, publishers: 7, subscribers: 9 } }) }
+
+  describe '#metrics' do
+    it 'should return attributes' do
+      expect(subject.metrics.connections).to eq(1)
+      expect(subject.metrics.presence_connections).to eq(2)
+      expect(subject.metrics.presence_members).to eq(2)
+      expect(subject.metrics.presence_subscribers).to eq(5)
+      expect(subject.metrics.publishers).to eq(7)
+      expect(subject.metrics.subscribers).to eq(9)
+    end
+  end
+end

data/spec/unit/models/channel_status_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::ChannelStatus do
+  subject { Ably::Models::ChannelStatus({ isActive: 'true', occupancy: { metrics: { connections: 1, presence_connections: 2, presence_members: 2, presence_subscribers: 5, publishers: 7, subscribers: 9 } } }) }
+
+  describe '#is_active' do
+    context 'when occupancy is active' do
+      subject { Ably::Models::ChannelStatus({ isActive: true, occupancy: { metrics: { connections: 1, presence_connections: 2, presence_members: 2, presence_subscribers: 5, publishers: 7, subscribers: 9 } } }) }
+
+      it 'should return true' do
+        expect(subject.is_active).to eq(true)
+      end
+    end
+
+    context 'when occupancy is not active' do
+      subject { Ably::Models::ChannelStatus({ isActive: false, occupancy: { metrics: { connections: 1, presence_connections: 2, presence_members: 2, presence_subscribers: 5, publishers: 7, subscribers: 9 } } }) }
+
+      it 'should return false' do
+        expect(subject.is_active).to eq(false)
+      end
+    end
+  end
+
+  describe '#occupancy' do
+    it 'should return occupancy object' do
+      expect(subject.occupancy).to be_a(Ably::Models::ChannelOccupancy)
+      expect(subject.occupancy.metrics.connections).to eq(1)
+      expect(subject.occupancy.metrics.presence_connections).to eq(2)
+      expect(subject.occupancy.metrics.presence_members).to eq(2)
+      expect(subject.occupancy.metrics.presence_subscribers).to eq(5)
+      expect(subject.occupancy.metrics.publishers).to eq(7)
+      expect(subject.occupancy.metrics.subscribers).to eq(9)
+    end
+  end
+end

data/spec/unit/models/message_spec.rb

@@ -270,6 +270,20 @@ describe Ably::Models::Message do
     end
   end
 
+  describe '#protocol_message_index (#RTL21)' do
+    let(:messages) { [{ name: 'test1' }, { name: 'test2' }, { name: 'test3' }] }
+
+    let(:protocol_message) do
+      Ably::Models::ProtocolMessage.new({ action: 1 }.merge(messages: messages))
+    end
+
+    it 'should return correct protocol_message_index' do
+      expect(protocol_message.messages[0].protocol_message_index).to eq(0)
+      expect(protocol_message.messages[1].protocol_message_index).to eq(1)
+      expect(protocol_message.messages[2].protocol_message_index).to eq(2)
+    end
+  end
+
   context 'from REST request with embedded fields', :api_private do
     let(:id)                  { random_str }
     let(:protocol_message_id) { random_str }

data/spec/unit/models/protocol_message_spec.rb

@@ -223,6 +223,24 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
+    context '#params (#RTL4k1)' do
+      let(:params) do
+        { foo: :bar }
+      end
+
+      context 'when present' do
+        specify do
+          expect(new_protocol_message({ params: params }).params).to eq(params)
+        end
+      end
+
+      context 'when empty' do
+        specify do
+          expect(new_protocol_message({}).params).to eq({})
+        end
+      end
+    end
+
     context '#has_connection_serial?' do
       context 'without connection_serial' do
         let(:protocol_message) { new_protocol_message({}) }
@@ -330,6 +348,26 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
+    context '#messages (#RTL21)' do
+      let(:protocol_message) do
+        new_protocol_message(messages: [{ name: 'test1' }, { name: 'test2' }, { name: 'test3' }])
+      end
+
+      before do
+        message = Ably::Models::Message(name: 'test4')
+        message.assign_to_protocol_message(protocol_message)
+        protocol_message.add_message(message)
+      end
+
+      it 'contains Message objects in ascending order' do
+        expect(protocol_message.messages.count).to eql(4)
+        protocol_message.messages.each_with_index do |message, index|
+          expect(message.protocol_message_index).to eql(index)
+          expect(message.name).to include('test')
+        end
+      end
+    end
+
     context '#presence (#TR4l)' do
       let(:protocol_message) { new_protocol_message(presence: [{ action: 1, data: 'test' }]) }
 
@@ -443,19 +481,23 @@ describe Ably::Models::ProtocolMessage do
 
   context '#to_json', :api_private do
     let(:json_object) { JSON.parse(model.to_json) }
-    let(:message) { { 'name' => 'event', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
+    let(:message1) { { 'name' => 'event1', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
+    let(:message2) { { 'name' => 'event2', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
+    let(:message3) { { 'name' => 'event3', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
     let(:attached_action) { Ably::Models::ProtocolMessage::ACTION.Attached }
     let(:message_action) { Ably::Models::ProtocolMessage::ACTION.Message }
 
     context 'with valid data' do
-      let(:model) { new_protocol_message({ :action => attached_action, :channelSerial => 'unique', messages: [message] }) }
+      let(:model) { new_protocol_message({ :action => attached_action, :channelSerial => 'unique', messages: [message1, message2, message3] }) }
 
       it 'converts the attribute back to Java mixedCase notation using string keys' do
         expect(json_object["channelSerial"]).to eql('unique')
       end
 
       it 'populates the messages' do
-        expect(json_object["messages"].first).to include(message)
+        expect(json_object["messages"][0]).to include(message1)
+        expect(json_object["messages"][1]).to include(message2)
+        expect(json_object["messages"][2]).to include(message3)
       end
     end
 
@@ -468,7 +510,7 @@ describe Ably::Models::ProtocolMessage do
     end
 
     context 'is aliased by #to_s' do
-      let(:model) { new_protocol_message({ :action => attached_action, :channelSerial => 'unique', messages: [message], :timestamp => as_since_epoch(Time.now) }) }
+      let(:model) { new_protocol_message({ :action => attached_action, :channelSerial => 'unique', messages: [message1, message2, message3], :timestamp => as_since_epoch(Time.now) }) }
 
       specify do
         expect(json_object).to eql(JSON.parse("#{model}"))
@@ -477,14 +519,18 @@ describe Ably::Models::ProtocolMessage do
   end
 
   context '#to_msgpack', :api_private do
-    let(:model)    { new_protocol_message({ :connectionSerial => 'unique', messages: [message] }) }
-    let(:message)  { { 'name' => 'event', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
+    let(:model)    { new_protocol_message({ :connectionSerial => 'unique', messages: [message1, message2, message3] }) }
+    let(:message1)  { { 'name' => 'event1', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
+    let(:message2)  { { 'name' => 'event2', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
+    let(:message3)  { { 'name' => 'event3', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
     let(:packed)   { model.to_msgpack }
     let(:unpacked) { MessagePack.unpack(packed) }
 
     it 'returns a unpackable msgpack object' do
       expect(unpacked['connectionSerial']).to eq('unique')
-      expect(unpacked['messages'][0]['name']).to eq('event')
+      expect(unpacked['messages'][0]['name']).to eq('event1')
+      expect(unpacked['messages'][1]['name']).to eq('event2')
+      expect(unpacked['messages'][2]['name']).to eq('event3')
     end
   end
 end

data/spec/unit/models/token_details_spec.rb

@@ -80,6 +80,20 @@ describe Ably::Models::TokenDetails do
           expect(subject.expired?).to eql(false)
         end
       end
+
+      context 'with :from attribute' do
+        subject { Ably::Models::TokenDetails.new(expires: expire_time) }
+
+        let(:server_offset_time) { 2 * 60 * 60 } # 2 hours
+
+        it 'is false' do
+          expect(subject.expired?(from: (Time.now - server_offset_time))).to eql(false)
+        end
+
+        it 'is true' do
+          expect(subject.expired?(from: Time.now)).to eql(true)
+        end
+      end
     end
   end
 

data/spec/unit/realtime/channels_spec.rb

@@ -3,39 +3,77 @@ require 'spec_helper'
 
 describe Ably::Realtime::Channels do
   let(:connection) { instance_double('Ably::Realtime::Connection', unsafe_on: true, on_resume: true) }
-  let(:client) { instance_double('Ably::Realtime::Client', connection: connection, client_id: 'clientId') }
+  let(:client) do
+    instance_double('Ably::Realtime::Client', connection: connection, client_id: 'clientId', logger: double('logger').as_null_object)
+  end
   let(:channel_name) { 'unique' }
-  let(:options) { { 'bizarre' => 'value' } }
+  let(:options) do
+    { params: { bizarre: 'value' } }
+  end
 
   subject { Ably::Realtime::Channels.new(client) }
 
   context 'creating channels' do
     context '#get' do
-      it 'creates a channel if it does not exist (RSN3a)' do
-        expect(Ably::Realtime::Channel).to receive(:new).with(client, channel_name, options)
-        subject.get(channel_name, options)
+      context "when channel doesn't exist" do
+        shared_examples 'creates a channel' do
+          it 'creates a channel (RTS3a)' do
+            expect(Ably::Realtime::Channel).to receive(:new).with(client, channel_name, channel_options)
+            subject.get(channel_name, channel_options)
+          end
+        end
+
+        describe 'hash' do
+          let(:channel_options) { options }
+          it { expect(channel_options).to be_a(Hash) }
+
+          include_examples 'creates a channel'
+        end
+
+        describe 'ChannelOptions object' do
+          let(:channel_options) { Ably::Models::ChannelOptions.new(options) }
+          it { expect(channel_options).to be_a(Ably::Models::ChannelOptions) }
+
+          include_examples 'creates a channel'
+        end
       end
 
       context 'when an existing channel exists' do
-        it 'will reuse a channel object if it exists (RSN3a)' do
-          channel = subject.get(channel_name, options)
-          expect(channel).to be_a(Ably::Realtime::Channel)
-          expect(subject.get(channel_name, options).object_id).to eql(channel.object_id)
+        shared_examples 'reuse a channel object if it exists' do
+          it 'will reuse a channel object if it exists (RTS3a)' do
+            channel = subject.get(channel_name, channel_options)
+            expect(channel).to be_a(Ably::Realtime::Channel)
+            expect(subject.get(channel_name, channel_options).object_id).to eql(channel.object_id)
+          end
+        end
+
+        describe 'hash' do
+          let(:channel_options) { options }
+          it { expect(channel_options).to be_a(Hash) }
+
+          include_examples 'reuse a channel object if it exists'
+        end
+
+        describe 'ChannelOptions object' do
+          let(:channel_options) { Ably::Models::ChannelOptions.new(options) }
+          it { expect(channel_options).to be_a(Ably::Models::ChannelOptions) }
+
+          include_examples 'reuse a channel object if it exists'
         end
 
         it 'will update the options on the channel if provided (RSN3c)' do
           channel = subject.get(channel_name, options)
-          expect(channel.options).to eql(options)
-          expect(channel.options).to_not include(:encrypted)
+          expect(channel.options.to_h).to eq(options)
+          expect(channel.options.to_h).to_not include(:encrypted)
           subject.get(channel_name, encrypted: true)
-          expect(channel.options[:encrypted]).to eql(true)
+          expect(channel.options[:encrypted]).to eq(true)
         end
 
         it 'will leave the options intact on the channel if not provided' do
           channel = subject.get(channel_name, options)
-          expect(channel.options).to eql(options)
+          expect(channel.options.to_h).to eq(options)
           subject.get(channel_name)
-          expect(channel.options).to eql(options)
+          expect(channel.options.to_h).to eq(options)
         end
       end
     end