ably 1.1.6 → 1.2.0

data/spec/acceptance/realtime/presence_spec.rb

@@ -498,7 +498,9 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         presence_client_one.enter do
-          presence_client_one.leave
+          EventMachine.add_timer(0.5) do
+            presence_client_one.leave
+          end
         end
       end
     end
@@ -705,7 +707,7 @@ describe Ably::Realtime::Presence, :event_machine do
 
     context '#sync_complete? and SYNC flags (#RTP1)' do
       context 'when attaching to a channel without any members present' do
-        it 'sync_complete? is true, there is no presence flag, and the presence channel is considered synced immediately (#RTP1)' do
+        xit 'sync_complete? is true, there is no presence flag, and the presence channel is considered synced immediately (#RTP1)' do
           flag_checked = false
 
           anonymous_client.connection.__incoming_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
@@ -1211,10 +1213,11 @@ describe Ably::Realtime::Presence, :event_machine do
             channel_client_one.attach do
               presence_client_one.subscribe(:enter) do
                 presence_client_one.unsubscribe :enter
-
-                expect(presence_client_one.members).to be_in_sync
-                expect(presence_client_one.members.send(:members).count).to eql(1)
-                presence_client_one.leave data
+                EventMachine.add_timer(0.5) do
+                  expect(presence_client_one.members).to be_in_sync
+                  expect(presence_client_one.members.send(:members).count).to eql(1)
+                  presence_client_one.leave data
+                end
               end
 
               presence_client_one.enter(enter_data) do
@@ -2137,16 +2140,18 @@ describe Ably::Realtime::Presence, :event_machine do
         end
 
         it 'emits an error when cipher does not match and presence data cannot be decoded' do
-          incompatible_encrypted_channel.attach do
+          incompatible_encrypted_channel.once(:attached) do
             expect(client_two.logger).to receive(:error) do |*args, &block|
               expect(args.concat([block ? block.call : nil]).join(',')).to match(/Cipher algorithm AES-128-CBC does not match/)
               stop_reactor
-            end
+            end.at_least(:once)
 
             encrypted_channel.attach do
               encrypted_channel.presence.enter data
             end
           end
+
+          incompatible_encrypted_channel.attach
         end
       end
     end
@@ -2522,156 +2527,6 @@ describe Ably::Realtime::Presence, :event_machine do
           client_one.connection.transport.__outgoing_protocol_msgbus__.unsubscribe
         end
 
-        context 'and the resume flag is true' do
-          context 'and the presence flag is false' do
-            it 'does not send any presence events as the PresenceMap is in sync (#RTP5c1)' do
-              presence_client_one.enter
-              presence_client_one.subscribe(:enter) do
-                presence_client_one.unsubscribe :enter
-
-                client_one.connection.transport.__outgoing_protocol_msgbus__.subscribe do |message|
-                  raise "No presence state updates to Ably are expected. Message sent: #{message.to_json}" if client_one.connection.connected?
-                end
-
-                cripple_websocket_transport
-
-                fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                  action: attached_action,
-                  channel: channel_name,
-                  flags: resume_flag
-                )
-
-                EventMachine.add_timer(1) do
-                  presence_client_one.get do |members|
-                    expect(members.length).to eql(1)
-                    expect(presence_client_one.members.local_members.length).to eql(1)
-                    stop_reactor
-                  end
-                end
-              end
-            end
-          end
-
-          context 'and the presence flag is true' do
-            context 'and following the SYNC all local MemberMap members are present in the PresenceMap' do
-              it 'does nothing as MemberMap is in sync (#RTP5c2)' do
-                presence_client_one.enter
-                presence_client_one.subscribe(:enter) do
-                  presence_client_one.unsubscribe :enter
-
-                  expect(presence_client_one.members.length).to eql(1)
-                  expect(presence_client_one.members.local_members.length).to eql(1)
-
-                  presence_client_one.members.once(:in_sync) do
-                    presence_client_one.get do |members|
-                      expect(members.length).to eql(1)
-                      expect(presence_client_one.members.local_members.length).to eql(1)
-                      stop_reactor
-                    end
-                  end
-
-                  client_one.connection.transport.__outgoing_protocol_msgbus__.subscribe do |message|
-                    raise "No presence state updates to Ably are expected. Message sent: #{message.to_json}" if client_one.connection.connected?
-                  end
-
-                  cripple_websocket_transport
-
-                  fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                    action: attached_action,
-                    channel: channel_name,
-                    flags: resume_flag + presence_flag
-                  )
-
-                  fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                    action: sync_action,
-                    channel: channel_name,
-                    presence: presence_client_one.members.map(&:shallow_clone).map(&:as_json),
-                    channelSerial: nil # no further SYNC messages expected
-                  )
-                end
-              end
-            end
-
-            context 'and following the SYNC a local MemberMap member is not present in the PresenceMap' do
-              it 're-enters the missing members automatically (#RTP5c2)' do
-                sync_check_completed = false
-
-                presence_client_one.enter
-                presence_client_one.subscribe(:enter) do
-                  presence_client_one.unsubscribe :enter
-
-                  expect(presence_client_one.members.length).to eql(1)
-                  expect(presence_client_one.members.local_members.length).to eql(1)
-
-                  client_one.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |message|
-                    next if message.action == :close # ignore finalization of connection
-
-                    expect(message.action).to eq(:presence)
-                    presence_message = message.presence.first
-                    expect(presence_message.action).to eq(:enter)
-                    expect(presence_message.client_id).to eq(client_one.auth.client_id)
-
-                    presence_client_one.subscribe(:enter) do |message|
-                      expect(message.connection_id).to eql(client_one.connection.id)
-                      expect(message.client_id).to eq(client_one.auth.client_id)
-
-                      EventMachine.next_tick do
-                        expect(presence_client_one.members.length).to eql(2)
-                        expect(presence_client_one.members.local_members.length).to eql(1)
-                        expect(sync_check_completed).to be_truthy
-                        stop_reactor
-                      end
-                    end
-
-                    # Fabricate Ably sending back the Enter PresenceMessage to the client a short while after
-                    # ensuring the PresenceMap for a short period does not have this member as to be expected in reality
-                    EventMachine.add_timer(0.2) do
-                      connection_id = random_str
-                      fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                        action: presence_action,
-                        channel: channel_name,
-                        connectionId: client_one.connection.id,
-                        connectionSerial: 50,
-                        timestamp: as_since_epoch(Time.now),
-                        presence: [presence_message.shallow_clone(id: "#{client_one.connection.id}:0:0", timestamp: as_since_epoch(Time.now)).as_json]
-                      )
-                    end
-                  end
-
-                  presence_client_one.members.once(:in_sync) do
-                    # For a brief period, the client will have re-entered the missing members from the local_members
-                    # but the enter from Ably will have not been received, so at this point the local_members will be empty
-                    presence_client_one.get do |members|
-                      expect(members.length).to eql(1)
-                      expect(members.first.connection_id).to_not eql(client_one.connection.id)
-                      expect(presence_client_one.members.local_members.length).to eql(0)
-                      sync_check_completed = true
-                    end
-                  end
-
-                  cripple_websocket_transport
-
-                  fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                    action: attached_action,
-                    channel: channel_name,
-                    flags: resume_flag + presence_flag
-                  )
-
-                  # Complete the SYNC but without the member who was entered by this client
-                  connection_id = random_str
-                  fabricate_incoming_protocol_message Ably::Models::ProtocolMessage.new(
-                    action: sync_action,
-                    channel: channel_name,
-                    timestamp: as_since_epoch(Time.now),
-                    presence: [{ id: "#{connection_id}:0:0", action: present_action, connection_id: connection_id, client_id: random_str }],
-                    chanenlSerial: nil # no further SYNC messages expected
-                  )
-                end
-              end
-            end
-          end
-        end
-
         context 'and the resume flag is false' do
           context 'and the presence flag is false' do
             let(:member_data) { random_str }
@@ -2779,7 +2634,24 @@ describe Ably::Realtime::Presence, :event_machine do
       end
     end
 
-    context 'channel state side effects' do
+    context 'channel state side effects (RTP5)' do
+      context 'channel transitions to the ATTACHED state (RTP5b)' do
+        it 'all queued presence messages are sent' do
+          channel_client_one.on(:attached) do
+            client_one.connection.__outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+              if protocol_message.action == :presence
+                expect(protocol_message.action).to eq(:presence)
+                stop_reactor
+              end
+            end
+          end
+
+          presence_client_one.enter do
+            channel_client_one.attach
+          end
+        end
+      end
+
       context 'channel transitions to the FAILED state' do
         let(:anonymous_client) { auto_close Ably::Realtime::Client.new(client_options.merge(log_level: :fatal)) }
         let(:client_one)       { auto_close Ably::Realtime::Client.new(client_options.merge(client_id: client_one_id, log_level: :fatal)) }

data/spec/acceptance/rest/auth_spec.rb

@@ -1165,6 +1165,24 @@ describe Ably::Auth do
         end
       end
 
+      context 'when token does not expire' do
+        let(:client_options) { default_options.merge(use_token_auth: true, key: api_key, query_time: true) }
+        let(:channel) { client.channels.get(random_str) }
+
+        context 'for the next 2 hours' do
+          let(:local_time) { Time.now - 2 * 60 * 60 }
+
+          before { allow(Time).to receive(:now).and_return(local_time) }
+
+          it 'should not request for the new token (#RSA4b1)' do
+            expect { channel.publish 'event' }.to change { auth.current_token_details }
+            expect do
+              expect { channel.publish 'event' }.not_to change { auth.current_token_details }
+            end.not_to change { auth.current_token_details.expires }
+          end
+        end
+      end
+
       context 'when :client_id is provided in a token' do
         let(:client_id) { '123' }
         let(:token) do

data/spec/acceptance/rest/channel_spec.rb

@@ -5,11 +5,13 @@ describe Ably::Rest::Channel do
   include Ably::Modules::Conversions
 
   vary_by_protocol do
-    let(:default_options) { { key: api_key, environment: environment, protocol: protocol} }
+    let(:default_options) { { key: api_key, environment: environment, protocol: protocol, max_frame_size: max_frame_size, max_message_size: max_message_size, idempotent_rest_publishing: false } }
     let(:client_options)  { default_options }
     let(:client) do
       Ably::Rest::Client.new(client_options)
     end
+    let(:max_message_size) { nil }
+    let(:max_frame_size) { nil }
 
     describe '#publish' do
       let(:channel_name) { random_str }
@@ -60,6 +62,9 @@ describe Ably::Rest::Channel do
         end
 
         it 'publishes an array of messages in one HTTP request' do
+          expect(client.max_message_size).to eq(Ably::Rest::Client::MAX_MESSAGE_SIZE)
+          expect(messages.sum(&:size) < Ably::Rest::Client::MAX_MESSAGE_SIZE).to eq(true)
+
           expect(client).to receive(:post).once.and_call_original
           expect(channel.publish(messages)).to eql(true)
           expect(channel.history.items.map(&:name)).to match_array(messages.map { |message| message[:name] })
@@ -68,17 +73,78 @@ describe Ably::Rest::Channel do
       end
 
       context 'with an array of Message objects' do
-        let(:messages) do
-          10.times.map do |index|
-            Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 })
+        context 'when max_message_size and max_frame_size is not set' do
+          before do
+            expect(client.max_message_size).to eq(Ably::Rest::Client::MAX_MESSAGE_SIZE)
+            expect(client.max_frame_size).to eq(Ably::Rest::Client::MAX_FRAME_SIZE)
+          end
+
+          context 'and messages size (130 bytes) is smaller than the max_message_size' do
+            let(:messages) do
+              10.times.map do |index|
+                Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 })
+              end
+            end
+
+            it 'publishes an array of messages in one HTTP request' do
+              expect(messages.sum &:size).to eq(130)
+              expect(client).to receive(:post).once.and_call_original
+              expect(channel.publish(messages)).to eql(true)
+              expect(channel.history.items.map(&:name)).to match_array(messages.map(&:name))
+              expect(channel.history.items.map(&:data)).to match_array(messages.map(&:data))
+            end
+          end
+
+          context 'and messages size (177784 bytes) is bigger than the max_message_size' do
+            let(:messages) do
+              10000.times.map do |index|
+                Ably::Models::Message(name: index.to_s, data: { "index" => index + 1 })
+              end
+            end
+
+            it 'should not publish and raise Ably::Exceptions::MaxMessageSizeExceeded' do
+              expect(messages.sum &:size).to eq(177784)
+              expect { channel.publish(messages) }.to raise_error(Ably::Exceptions::MaxMessageSizeExceeded)
+            end
           end
         end
 
-        it 'publishes an array of messages in one HTTP request' do
-          expect(client).to receive(:post).once.and_call_original
-          expect(channel.publish(messages)).to eql(true)
-          expect(channel.history.items.map(&:name)).to match_array(messages.map(&:name))
-          expect(channel.history.items.map(&:data)).to match_array(messages.map(&:data))
+        context 'when max_message_size is 655 bytes' do
+          let(:max_message_size) { 655 }
+
+          before do
+            expect(client.max_message_size).to eq(max_message_size)
+            expect(client.max_frame_size).to eq(Ably::Rest::Client::MAX_FRAME_SIZE)
+          end
+
+          context 'and messages size (130 bytes) is smaller than the max_message_size' do
+            let(:messages) do
+              10.times.map do |index|
+                Ably::Models::Message(name: index.to_s, data: { "index" => index + 10 })
+              end
+            end
+
+            it 'publishes an array of messages in one HTTP request' do
+              expect(messages.sum &:size).to eq(130)
+              expect(client).to receive(:post).once.and_call_original
+              expect(channel.publish(messages)).to eql(true)
+              expect(channel.history.items.map(&:name)).to match_array(messages.map(&:name))
+              expect(channel.history.items.map(&:data)).to match_array(messages.map(&:data))
+            end
+          end
+
+          context 'and messages size (177784 bytes) is bigger than the max_message_size' do
+            let(:messages) do
+              10000.times.map do |index|
+                Ably::Models::Message(name: index.to_s, data: { "index" => index + 1 })
+              end
+            end
+
+            it 'should not publish and raise Ably::Exceptions::MaxMessageSizeExceeded' do
+              expect(messages.sum &:size).to eq(177784)
+              expect { channel.publish(messages) }.to raise_error(Ably::Exceptions::MaxMessageSizeExceeded)
+            end
+          end
         end
       end
 
@@ -350,6 +416,15 @@ describe Ably::Rest::Channel do
           end
         end
       end
+
+      context 'message size is exceeded (#TO3l8)' do
+        let(:data) { 101.times.map { { data: 'x' * 655 } } }
+
+        it 'should raise Ably::Exceptions::MaxMessageSizeExceeded exception' do
+          expect { channel.publish([ data: data ]) }.to \
+            raise_error(Ably::Exceptions::MaxMessageSizeExceeded)
+        end
+      end
     end
 
     describe '#history' do

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' do
-        expect(original_channel.options).to_not include(:encrypted)
+      it 'overrides the existing channel options and returns the channel object (RSN3c)' do
+        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,29 +1081,15 @@ describe Ably::Rest::Client do
     end
 
     context 'version headers', :webmock do
-      [nil, 'foo'].each do |variant|
-        context "with variant #{variant ? variant : 'none'}" do
-          if variant
-            before do
-              Ably.lib_variant = variant
-            end
+      [nil, 'ably-ruby/1.1.1 ruby/1.9.3'].each do |agent|
+        context "with #{agent ? "custom #{agent}" : 'default'} agent" do
+          let(:client_options) { default_options.merge(key: api_key, agent: agent) }
 
-            after do
-              Ably.lib_variant = nil
-            end
-          end
-
-          let(:client_options) { default_options.merge(key: api_key) }
           let!(:publish_message_stub) do
-            lib = ['ruby']
-            lib << variant if variant
-            lib << Ably::VERSION
-
-
             stub_request(:post, "#{client.endpoint}/channels/foo/publish").
               with(headers: {
                 'X-Ably-Version' => Ably::PROTOCOL_VERSION,
-                'X-Ably-Lib' => lib.join('-')
+                'Ably-Agent' => agent || Ably::AGENT
               }).
               to_return(status: 201, body: '{}', headers: { 'Content-Type' => 'application/json' })
           end
@@ -1111,13 +1097,13 @@ 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
     end
 
-    context '#request (#RSC19*)' do
+    context '#request (#RSC19*, #TO3l9)' do
       let(:client_options) { default_options.merge(key: api_key) }
       let(:device_id) { random_str }
       let(:endpoint) { client.endpoint }
@@ -1172,6 +1158,12 @@ describe Ably::Rest::Client do
 
           expect(response).to be_success
         end
+
+        it 'raises an exception once body size in bytes exceeded' do
+          expect {
+            client.request(:post, endpoint, {}, { content: 'x' * Ably::Rest::Client::MAX_FRAME_SIZE })
+          }.to raise_error(Ably::Exceptions::MaxFrameSizeExceeded)
+        end
       end
 
       context 'delete', :webmock do
@@ -1201,6 +1193,12 @@ describe Ably::Rest::Client do
 
           expect(response).to be_success
         end
+
+        it 'raises an exception once body size in bytes exceeded' do
+          expect {
+            client.request(:patch, endpoint, {}, { content: 'x' * Ably::Rest::Client::MAX_FRAME_SIZE })
+          }.to raise_error(Ably::Exceptions::MaxFrameSizeExceeded)
+        end
       end
 
       context 'put', :webmock do
@@ -1224,10 +1222,16 @@ describe Ably::Rest::Client do
 
           expect(response).to be_success
         end
+
+        it 'raises an exception once body size in bytes exceeded' do
+          expect {
+            client.request(:put, endpoint, {}, { content: 'x' * Ably::Rest::Client::MAX_FRAME_SIZE })
+          }.to raise_error(Ably::Exceptions::MaxFrameSizeExceeded)
+        end
       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