ably-rest 1.1.2 → 1.2.2

data/lib/submodules/ably-ruby/spec/unit/models/presence_message_spec.rb

@@ -220,6 +220,55 @@ describe Ably::Models::PresenceMessage do
     end
   end
 
+  describe '#size' do
+    let(:model) { subject.new({ action: 'enter', data: data, client_id: client_id }, protocol_message: protocol_message) }
+
+    context 'String (#TO3l8a)' do
+      let(:data) { 'example string data' }
+      let(:client_id) { '1' }
+
+      it 'should return 20 bytes' do
+        expect(model.size).to eq(20)
+      end
+    end
+
+    context 'Object (#TO3l8b)' do
+      let(:data) { Object.new }
+      let(:client_id) { '10' }
+
+      it 'should return 32 bytes' do
+        expect(model.size).to eq(32)
+      end
+    end
+
+    context 'Array (#TO3l8b)' do
+      let(:data) { [1, 'two', :three] }
+      let(:client_id) { '2' }
+
+      it 'should return 18 bytes' do
+        expect(model.size).to eq(18)
+      end
+    end
+
+    context 'extras (#TO3l8d)' do
+      let(:data) { { example: 'value', score: 1, hash: { test: true } } }
+      let(:client_id) { '3' }
+
+      it 'should return 51 bytes' do
+        expect(model.size).to eq(51)
+      end
+    end
+
+    context 'nil (#TO3l8e)' do
+      let(:data) { nil }
+      let(:client_id) { '4' }
+
+      it 'should return 1 bytes' do
+        expect(model.size).to eq(1)
+      end
+    end
+  end
+
   context 'from REST request with embedded fields', :api_private do
     let(:id) { random_str }
     let(:message_time) { Time.now + 60 }

data/lib/submodules/ably-ruby/spec/unit/models/protocol_message_spec.rb

@@ -10,9 +10,9 @@ describe Ably::Models::ProtocolMessage do
     subject.new({ action: 1 }.merge(options))
   end
 
-  # TR4n, TR4b, TR4c, TR4d, TR4e
+  # TR4n, TR4b, TR4c, TR4d
   it_behaves_like 'a model',
-    with_simple_attributes: %w(id channel channel_serial connection_id connection_key),
+    with_simple_attributes: %w(id channel channel_serial connection_id),
     base_model_options: { action: 1 } do
 
     let(:model_args) { [] }
@@ -176,6 +176,28 @@ describe Ably::Models::ProtocolMessage do
         end
       end
 
+      context 'when attach resumed flag' do
+        context 'flags is 34' do
+          let(:protocol_message) { new_protocol_message(flags: 34) }
+
+          it '#has_attach_resume_flag? is true' do
+            expect(protocol_message.has_attach_resume_flag?).to be_truthy
+          end
+
+          it '#has_attach_presence_flag? is false' do
+            expect(protocol_message.has_attach_presence_flag?).to be_falsey
+          end
+        end
+
+        context 'flags is 0' do
+          let(:protocol_message) { new_protocol_message(flags: 0) }
+
+          it 'should raise an exception if flags is a float number' do
+            expect(protocol_message.has_attach_resume_flag?).to be_falsy
+          end
+        end
+      end
+
       context 'when channel resumed and presence flags present' do
         let(:protocol_message) { new_protocol_message(flags: 5) }
 
@@ -201,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({}) }
@@ -308,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' }]) }
 
@@ -318,6 +378,54 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
+    context '#message_size (#TO3l8)' do
+      context 'on presence' do
+        let(:protocol_message) do
+          new_protocol_message(presence: [{ action: 1, data: 'test342343', client_id: 'sdf' }])
+        end
+
+        it 'should return 13 bytes (sum in bytes: data and client_id)' do
+          expect(protocol_message.message_size).to eq(13)
+        end
+      end
+
+      context 'on message' do
+        let(:protocol_message) do
+          new_protocol_message(messages: [{ action: 1, unknown: 'test', data: 'test342343', client_id: 'sdf', name: 'sf23ewrew', extras: { time: Time.now, time_zone: 'UTC' } }])
+        end
+
+        it 'should return 76 bytes (sum in bytes: data, client_id, name, extras)' do
+          expect(protocol_message.message_size).to eq(76)
+        end
+      end
+    end
+
+    context '#has_correct_message_size? (#TO3l8)' do
+      context 'on presence' do
+        it 'should return true when a message has correct size' do
+          protocol_message = new_protocol_message(presence: [{ action: 1, data: 'x' * 100 }])
+          expect(protocol_message.has_correct_message_size?).to eq(true)
+        end
+
+        it 'should return false when a message has not correct size' do
+          protocol_message = new_protocol_message(presence: [{ action: 1, data: 'x' * 65537 }])
+          expect(protocol_message.has_correct_message_size?).to eq(false)
+        end
+      end
+
+      context 'on message' do
+        it 'should return true when a message has correct size' do
+          protocol_message = new_protocol_message(messages: [{ name: 'x' * 100 }])
+          expect(protocol_message.has_correct_message_size?).to eq(true)
+        end
+
+        it 'should return false when a message has not correct size' do
+          protocol_message = new_protocol_message(messages: [{ name: 'x' * 65537 }])
+          expect(protocol_message.has_correct_message_size?).to eq(false)
+        end
+      end
+    end
+
     context '#connection_details (#TR4o)' do
       let(:connection_details) { protocol_message.connection_details }
 
@@ -369,41 +477,27 @@ describe Ably::Models::ProtocolMessage do
         end
       end
     end
-
-    context '#connection_key (#TR4e)' do
-      context 'existing only in #connection_details.connection_key' do
-        let(:protocol_message) { new_protocol_message(connectionDetails: { connectionKey: 'key' }) }
-
-        it 'is returned' do
-          expect(protocol_message.connection_key).to eql('key')
-        end
-      end
-
-      context 'existing in both #connection_key and #connection_details.connection_key' do
-        let(:protocol_message) { new_protocol_message(connectionKey: 'deprecated', connectionDetails: { connectionKey: 'key' }) }
-
-        it 'returns #connection_details.connection_key as #connection_key will be deprecated > 0.8' do
-          expect(protocol_message.connection_key).to eql('key')
-        end
-      end
-    end
   end
 
   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
 
@@ -416,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}"))
@@ -425,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/lib/submodules/ably-ruby/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/lib/submodules/ably-ruby/spec/unit/realtime/channel_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 require 'shared/protocol_msgbus_behaviour'
 
 describe Ably::Realtime::Channel do
-  let(:client)       { double('client').as_null_object }
+  let(:client)       { Ably::Realtime::Client.new(token: 'valid') }
   let(:channel_name) { 'test' }
 
   subject do
@@ -68,9 +68,10 @@ describe Ably::Realtime::Channel do
 
   describe '#publish name argument' do
     let(:encoded_value) { random_str.encode(encoding) }
-    let(:message) { instance_double('Ably::Models::Message', client_id: nil) }
+    let(:message) { instance_double('Ably::Models::Message', client_id: nil, size: 0) }
 
     before do
+      allow(subject).to receive(:enqueue_messages_on_connection).and_return(message)
       allow(subject).to receive(:create_message).and_return(message)
       allow(subject).to receive(:attach).and_return(:true)
     end

data/lib/submodules/ably-ruby/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' 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' 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' do
+        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

data/lib/submodules/ably-ruby/spec/unit/realtime/client_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 require 'shared/client_initializer_behaviour'
 
 describe Ably::Realtime::Client do
-  subject do
+  subject(:realtime_client) do
     Ably::Realtime::Client.new(client_options)
   end
 
@@ -15,28 +15,41 @@ describe Ably::Realtime::Client do
     it 'passes on the options to the initializer' do
       rest_client = instance_double('Ably::Rest::Client', auth: instance_double('Ably::Auth'), options: client_options, environment: 'production', use_tls?: true, custom_tls_port: nil)
       expect(Ably::Rest::Client).to receive(:new).with(hash_including(client_options)).and_return(rest_client)
-      subject
+      realtime_client
     end
 
     context 'for attribute' do
       [:environment, :use_tls?, :log_level, :custom_host].each do |attribute|
         specify "##{attribute}" do
-          expect(subject.rest_client).to receive(attribute)
-          subject.public_send attribute
+          expect(realtime_client.rest_client).to receive(attribute)
+          realtime_client.public_send attribute
         end
       end
     end
   end
 
+  context 'when :transport_params option is passed' do
+    let(:expected_transport_params) do
+      { 'heartbeats' => 'true', 'v' => '1.0', 'extra_param' => 'extra_param' }
+    end
+    let(:client_options) do
+      { key: 'appid.keyuid:keysecret', transport_params: { heartbeats: true, v: 1.0, extra_param: 'extra_param'} }
+    end
+
+    it 'converts options to strings' do
+      expect(realtime_client.transport_params).to eq(expected_transport_params)
+    end
+  end
+
   context 'push' do
     let(:client_options) { { key: 'appid.keyuid:keysecret' } }
 
     specify '#device is not supported and raises an exception' do
-      expect { subject.device }.to raise_error Ably::Exceptions::PushNotificationsNotSupported
+      expect { realtime_client.device }.to raise_error Ably::Exceptions::PushNotificationsNotSupported
     end
 
     specify '#push returns a Push object' do
-      expect(subject.push).to be_a(Ably::Realtime::Push)
+      expect(realtime_client.push).to be_a(Ably::Realtime::Push)
     end
   end
 

data/lib/submodules/ably-ruby/spec/unit/realtime/incoming_message_dispatcher_spec.rb

@@ -32,5 +32,43 @@ describe Ably::Realtime::Client::IncomingMessageDispatcher, :api_private do
       expect(subject).to receive_message_chain(:logger, :warn)
       msgbus.publish :protocol_message, Ably::Models::ProtocolMessage.new(:action => :attached, channel: 'unknown')
     end
+
+    context 'TO3l8' do
+      context 'on action presence' do
+        let(:presence) { 101.times.map { { data: 'x' * 655 } } }
+
+        let(:protocol_message) do
+          Ably::Models::ProtocolMessage.new(action: :presence, channel: 'default', presence: presence, connection_serial: 123123123)
+        end
+
+        it 'should raise a protocol error when message size exceeded 65536 bytes' do
+          allow(connection).to receive(:serial).and_return(12312312)
+          allow(subject).to receive(:update_connection_recovery_info)
+          allow(subject).to receive_message_chain(:logger, :debug)
+          allow(subject).to receive_message_chain(:logger, :warn)
+          expect(subject).to receive_message_chain(:logger, :fatal)
+
+          msgbus.publish :protocol_message, protocol_message
+        end
+      end
+
+      context 'on action message' do
+        let(:messages) { 101.times.map { { data: 'x' * 655 } } }
+
+        let(:protocol_message) do
+          Ably::Models::ProtocolMessage.new(action: :message, channel: 'default', messages: messages, connection_serial: 123123123)
+        end
+
+        it 'should raise a protocol error when message size exceeded 65536 bytes' do
+          allow(connection).to receive(:serial).and_return(12312312)
+          allow(subject).to receive(:update_connection_recovery_info)
+          allow(subject).to receive_message_chain(:logger, :debug)
+          allow(subject).to receive_message_chain(:logger, :warn)
+          expect(subject).to receive_message_chain(:logger, :fatal)
+
+          msgbus.publish :protocol_message, protocol_message
+        end
+      end
+    end
   end
 end

data/lib/submodules/ably-ruby/spec/unit/rest/channel_spec.rb

@@ -7,10 +7,11 @@ describe Ably::Rest::Channel do
       'Ably::Rest::Client',
       encoders: [],
       post: instance_double('Faraday::Response', status: 201),
-      idempotent_rest_publishing: false,
+      idempotent_rest_publishing: false, max_message_size: max_message_size
     )
   end
   let(:channel_name) { 'unique' }
+  let(:max_message_size) { nil }
 
   subject { Ably::Rest::Channel.new(client, channel_name) }
 
@@ -126,5 +127,47 @@ describe Ably::Rest::Channel do
         expect { subject.publish(encoded_value, 'data') }.to raise_error ArgumentError, /must be a String/
       end
     end
+
+    context 'max message size exceeded' do
+      context 'when max_message_size is nil' do
+        context 'and a message size is 65537 bytes' do
+          it 'should raise Ably::Exceptions::MaxMessageSizeExceeded' do
+            expect { subject.publish('x' * 65537, 'data') }.to raise_error Ably::Exceptions::MaxMessageSizeExceeded
+          end
+        end
+      end
+
+      context 'when max_message_size is 65536 bytes' do
+        let(:max_message_size) { 65536 }
+
+        context 'and a message size is 65537 bytes' do
+          it 'should raise Ably::Exceptions::MaxMessageSizeExceeded' do
+            expect { subject.publish('x' * 65537, 'data') }.to raise_error Ably::Exceptions::MaxMessageSizeExceeded
+          end
+        end
+
+        context 'and a message size is 10 bytes' do
+          it 'should send a message' do
+            expect(subject.publish('x' * 10, 'data')).to eq(true)
+          end
+        end
+      end
+
+      context 'when max_message_size is 10 bytes' do
+        let(:max_message_size) { 10 }
+
+        context 'and a message size is 11 bytes' do
+          it 'should raise Ably::Exceptions::MaxMessageSizeExceeded' do
+            expect { subject.publish('x' * 11, 'data') }.to raise_error Ably::Exceptions::MaxMessageSizeExceeded
+          end
+        end
+
+        context 'and a message size is 2 bytes' do
+          it 'should send a message' do
+            expect(subject.publish('x' * 2, 'data')).to eq(true)
+          end
+        end
+      end
+    end
   end
 end