RTL21

lib/ably/models/message.rb

@@ -162,15 +162,15 @@ def delta_extras
       @delta_extras ||= DeltaExtras.new(attributes[:extras][:delta]).freeze
     end
 
+    def protocol_message_index
+      protocol_message.messages.map(&:object_id).index(self.object_id)
+    end
+
     private
     def raw_hash_object
       @raw_hash_object
     end
 
-    def protocol_message_index
-      protocol_message.messages.map(&:object_id).index(self.object_id)
-    end
-
     def set_attributes_object(new_attributes)
       @attributes = IdiomaticRubyWrapper(new_attributes.clone, stop_at: [:data, :extras])
     end

spec/unit/models/message_spec.rb

@@ -270,6 +270,20 @@
     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 }

spec/unit/models/protocol_message_spec.rb

@@ -330,6 +330,26 @@ def new_protocol_message(options)
       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 +463,23 @@ def new_protocol_message(options)
 
   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 +492,7 @@ def new_protocol_message(options)
     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 +501,18 @@ def new_protocol_message(options)
   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