ably 0.8.15 → 1.0.0

data/spec/unit/models/connection_state_change_spec.rb

@@ -6,7 +6,7 @@ describe Ably::Models::ConnectionStateChange do
 
   subject { Ably::Models::ConnectionStateChange }
 
-  context '#current' do
+  context '#current (#TA2)' do
     it 'is required' do
       expect { subject.new(previous: true) }.to raise_error ArgumentError
     end
@@ -16,7 +16,7 @@ describe Ably::Models::ConnectionStateChange do
     end
   end
 
-  context '#previous' do
+  context '#previous(#TA2)' do
     it 'is required' do
       expect { subject.new(current: true) }.to raise_error ArgumentError
     end
@@ -26,7 +26,18 @@ describe Ably::Models::ConnectionStateChange do
     end
   end
 
-  context '#retry_in' do
+  context '#event(#TA5)' do
+    it 'is not required' do
+      expect { subject.new(previous: true, current: true) }.to_not raise_error
+    end
+
+    it 'is an attribute' do
+      expect(subject.new(event: unique, current: true, previous: true).event).to eql(unique)
+    end
+  end
+
+
+  context '#retry_in (#TA2)' do
     it 'is not required' do
       expect { subject.new(previous: true, current: true) }.to_not raise_error
     end
@@ -36,7 +47,7 @@ describe Ably::Models::ConnectionStateChange do
     end
   end
 
-  context '#reason' do
+  context '#reason (#TA3)' do
     it 'is not required' do
       expect { subject.new(previous: true, current: true) }.to_not raise_error
     end

data/spec/unit/models/message_encoders/base64_spec.rb

@@ -57,8 +57,9 @@ describe Ably::Models::MessageEncoders::Base64 do
 
   context '#encode' do
     context 'over binary transport' do
+      subject { Ably::Models::MessageEncoders::Base64.new(client, binary_protocol: true) }
+
       before do
-        allow(client).to receive(:protocol_binary?).and_return(true)
         subject.encode message, {}
       end
 

data/spec/unit/models/message_spec.rb

@@ -25,6 +25,38 @@ describe Ably::Models::Message do
     end
   end
 
+  context '#extras (#TM2i)' do
+    let(:model) { subject.new({ extras: extras }, protocol_message: protocol_message) }
+
+    context 'when missing' do
+      let(:model) { subject.new({}, protocol_message: protocol_message) }
+      it 'is nil' do
+        expect(model.extras).to be_nil
+      end
+    end
+
+    context 'when a string' do
+      let(:extras) { 'string' }
+      it 'raises an exception' do
+        expect { model.extras }.to raise_error ArgumentError, /extras contains an unsupported type/
+      end
+    end
+
+    context 'when a Hash' do
+      let(:extras) { { key: 'value' } }
+      it 'contains a Hash Json object' do
+        expect(model.extras).to eq(extras)
+      end
+    end
+
+    context 'when a Json Array' do
+      let(:extras) { [{ 'key' => 'value' }] }
+      it 'contains a Json Array object' do
+        expect(model.extras).to eq(extras)
+      end
+    end
+  end
+
   context '#connection_id attribute' do
     let(:protocol_connection_id) { random_str }
     let(:protocol_message) { Ably::Models::ProtocolMessage.new('connectionId' => protocol_connection_id, action: 1, timestamp: protocol_message_timestamp) }
@@ -379,4 +411,125 @@ describe Ably::Models::Message do
       end
     end
   end
+
+  context '#from_encoded (#TM3)' do
+    context 'with no encoding' do
+      let(:message_data) do
+        { name: 'name', data: 'data-string' }
+      end
+      let(:from_encoded) { subject.from_encoded(message_data) }
+
+      it 'returns a message object' do
+        expect(from_encoded).to be_a(Ably::Models::Message)
+        expect(from_encoded.name).to eql('name')
+        expect(from_encoded.data).to eql('data-string')
+        expect(from_encoded.encoding).to be_nil
+      end
+
+      context 'with a block' do
+        it 'does not call the block' do
+          block_called = false
+          subject.from_encoded(message_data) do |exception, message|
+            block_called = true
+          end
+          expect(block_called).to be_falsey
+        end
+      end
+    end
+
+    context 'with an encoding' do
+      let(:hash_data)           { { 'key' => 'value', 'key2' => 123 } }
+      let(:message_data) do
+        { name: 'name', data: JSON.dump(hash_data), encoding: 'json' }
+      end
+      let(:from_encoded) { subject.from_encoded(message_data) }
+
+      it 'returns a message object' do
+        expect(from_encoded).to be_a(Ably::Models::Message)
+        expect(from_encoded.name).to eql('name')
+        expect(from_encoded.data).to eql(hash_data)
+        expect(from_encoded.encoding).to be_nil
+      end
+    end
+
+    context 'with a custom encoding' do
+      let(:hash_data)           { { 'key' => 'value', 'key2' => 123 } }
+      let(:message_data) do
+        { name: 'name', data: JSON.dump(hash_data), encoding: 'foo/json' }
+      end
+      let(:from_encoded) { subject.from_encoded(message_data) }
+
+      it 'returns a message object with the residual incompatible transforms left in the encoding property' do
+        expect(from_encoded).to be_a(Ably::Models::Message)
+        expect(from_encoded.name).to eql('name')
+        expect(from_encoded.data).to eql(hash_data)
+        expect(from_encoded.encoding).to eql('foo')
+      end
+    end
+
+    context 'with a Cipher encoding' do
+      let(:hash_data)           { { 'key' => 'value', 'key2' => 123 } }
+      let(:cipher_params)       { { key: Ably::Util::Crypto.generate_random_key(128), algorithm: 'aes', mode: 'cbc', key_length: 128 } }
+      let(:crypto)              { Ably::Util::Crypto.new(cipher_params) }
+      let(:payload)             { random_str }
+      let(:message_data) do
+        { name: 'name', data: crypto.encrypt(payload), encoding: 'utf-8/cipher+aes-128-cbc' }
+      end
+      let(:channel_options)     { { cipher: cipher_params } }
+      let(:from_encoded)        { subject.from_encoded(message_data, channel_options) }
+
+      it 'returns a message object with the residual incompatible transforms left in the encoding property' do
+        expect(from_encoded).to be_a(Ably::Models::Message)
+        expect(from_encoded.name).to eql('name')
+        expect(from_encoded.data).to eql(payload)
+        expect(from_encoded.encoding).to be_nil
+      end
+    end
+
+    context 'with invalid Cipher encoding' do
+      let(:hash_data)           { { 'key' => 'value', 'key2' => 123 } }
+      let(:cipher_params)       { { key: Ably::Util::Crypto.generate_random_key(128), algorithm: 'aes', mode: 'cbc', key_length: 128 } }
+      let(:unencryped_payload)  { random_str }
+      let(:message_data) do
+        { name: 'name', data: unencryped_payload, encoding: 'utf-8/cipher+aes-128-cbc' }
+      end
+      let(:channel_options)     { { cipher: cipher_params } }
+
+      context 'without a block' do
+        it 'raises an exception' do
+          expect { subject.from_encoded(message_data, channel_options) }.to raise_exception(Ably::Exceptions::CipherError)
+        end
+      end
+
+      context 'with a block' do
+        it 'calls the block with the exception' do
+          block_called = false
+          subject.from_encoded(message_data, channel_options) do |exception, message|
+            expect(exception).to be_a(Ably::Exceptions::CipherError)
+            block_called = true
+          end
+          expect(block_called).to be_truthy
+        end
+      end
+    end
+  end
+
+  context '#from_encoded_array (#TM3)' do
+    context 'with no encoding' do
+      let(:message_data) do
+        [{ name: 'name1', data: 'data-string' }, { name: 'name2', data: 'data-string' }]
+      end
+      let(:from_encoded) { subject.from_encoded_array(message_data) }
+
+      it 'returns an Array of message objects' do
+        first = from_encoded.first
+        expect(first).to be_a(Ably::Models::Message)
+        expect(first.name).to eql('name1')
+        expect(first.data).to eql('data-string')
+        expect(first.encoding).to be_nil
+        last = from_encoded.last
+        expect(last.name).to eql('name2')
+      end
+    end
+  end
 end

data/spec/unit/models/presence_message_spec.rb

@@ -383,4 +383,196 @@ describe Ably::Models::PresenceMessage do
       end
     end
   end
+
+
+  context '#from_encoded (#TP4)' do
+    context 'with no encoding' do
+      let(:message_data) do
+        { action: 2, data: 'data-string' }
+      end
+      let(:from_encoded) { subject.from_encoded(message_data) }
+
+      it 'returns a presence message object' do
+        expect(from_encoded).to be_a(Ably::Models::PresenceMessage)
+        expect(from_encoded.action).to eq(:enter)
+        expect(from_encoded.data).to eql('data-string')
+        expect(from_encoded.encoding).to be_nil
+      end
+
+      context 'with a block' do
+        it 'does not call the block' do
+          block_called = false
+          subject.from_encoded(message_data) do |exception, message|
+            block_called = true
+          end
+          expect(block_called).to be_falsey
+        end
+      end
+    end
+
+    context 'with an encoding' do
+      let(:hash_data)           { { 'key' => 'value', 'key2' => 123 } }
+      let(:message_data) do
+        { action: 'leave', data: JSON.dump(hash_data), encoding: 'json' }
+      end
+      let(:from_encoded) { subject.from_encoded(message_data) }
+
+      it 'returns a presence message object' do
+        expect(from_encoded).to be_a(Ably::Models::PresenceMessage)
+        expect(from_encoded.action).to eq(:leave)
+        expect(from_encoded.data).to eql(hash_data)
+        expect(from_encoded.encoding).to be_nil
+      end
+    end
+
+    context 'with a custom encoding' do
+      let(:hash_data)           { { 'key' => 'value', 'key2' => 123 } }
+      let(:message_data) do
+        { action: 1, data: JSON.dump(hash_data), encoding: 'foo/json' }
+      end
+      let(:from_encoded) { subject.from_encoded(message_data) }
+
+      it 'returns a presence message object with the residual incompatible transforms left in the encoding property' do
+        expect(from_encoded).to be_a(Ably::Models::PresenceMessage)
+        expect(from_encoded.action).to eq(1)
+        expect(from_encoded.data).to eql(hash_data)
+        expect(from_encoded.encoding).to eql('foo')
+      end
+    end
+
+    context 'with a Cipher encoding' do
+      let(:hash_data)           { { 'key' => 'value', 'key2' => 123 } }
+      let(:cipher_params)       { { key: Ably::Util::Crypto.generate_random_key(128), algorithm: 'aes', mode: 'cbc', key_length: 128 } }
+      let(:crypto)              { Ably::Util::Crypto.new(cipher_params) }
+      let(:payload)             { random_str }
+      let(:message_data) do
+        { action: 1, data: crypto.encrypt(payload), encoding: 'utf-8/cipher+aes-128-cbc' }
+      end
+      let(:channel_options)     { { cipher: cipher_params } }
+      let(:from_encoded)        { subject.from_encoded(message_data, channel_options) }
+
+      it 'returns a presence message object with the residual incompatible transforms left in the encoding property' do
+        expect(from_encoded).to be_a(Ably::Models::PresenceMessage)
+        expect(from_encoded.data).to eql(payload)
+        expect(from_encoded.encoding).to be_nil
+      end
+    end
+
+    context 'with invalid Cipher encoding' do
+      let(:hash_data)           { { 'key' => 'value', 'key2' => 123 } }
+      let(:cipher_params)       { { key: Ably::Util::Crypto.generate_random_key(128), algorithm: 'aes', mode: 'cbc', key_length: 128 } }
+      let(:unencryped_payload)  { random_str }
+      let(:message_data) do
+        { action: 1, data: unencryped_payload, encoding: 'utf-8/cipher+aes-128-cbc' }
+      end
+      let(:channel_options)     { { cipher: cipher_params } }
+
+      context 'without a block' do
+        it 'raises an exception' do
+          expect { subject.from_encoded(message_data, channel_options) }.to raise_exception(Ably::Exceptions::CipherError)
+        end
+      end
+
+      context 'with a block' do
+        it 'calls the block with the exception' do
+          block_called = false
+          subject.from_encoded(message_data, channel_options) do |exception, message|
+            expect(exception).to be_a(Ably::Exceptions::CipherError)
+            block_called = true
+          end
+          expect(block_called).to be_truthy
+        end
+      end
+    end
+  end
+
+  context '#from_encoded_array (#TP4)' do
+    context 'with no encoding' do
+      let(:message_data) do
+        [{ action: 1, data: 'data-string' }, { action: 2, data: 'data-string' }]
+      end
+      let(:from_encoded) { subject.from_encoded_array(message_data) }
+
+      it 'returns an Array of presence message objects' do
+        first = from_encoded.first
+        expect(first).to be_a(Ably::Models::PresenceMessage)
+        expect(first.action).to eq(1)
+        expect(first.data).to eql('data-string')
+        expect(first.encoding).to be_nil
+        last = from_encoded.last
+        expect(last.action).to eq(:enter)
+      end
+    end
+  end
+
+  context '#shallow_clone' do
+    context 'with inherited attributes from ProtocolMessage' do
+      let(:protocol_message) {
+        Ably::Models::ProtocolMessage.new('id' => 'fooId', 'connectionId' => protocol_connection_id, 'action' =>  1, 'timestamp' => protocol_message_timestamp)
+      }
+      let(:protocol_connection_id) { random_str }
+      let(:model) { subject.new({ 'action' => 2 }, protocol_message: protocol_message) }
+
+      it 'creates a duplicate of the message without any ProtocolMessage dependency' do
+        clone = model.shallow_clone
+        expect(clone.id).to match(/fooId/)
+        expect(clone.connection_id).to eql(protocol_connection_id)
+        expect(as_since_epoch(clone.timestamp)).to eq(protocol_message_timestamp)
+        expect(clone.action).to eq(2)
+      end
+    end
+
+    context 'with embedded attributes for all fields' do
+      let(:message_timestamp) { as_since_epoch(Time.now) + 100 }
+      let(:connection_id) { random_str }
+      let(:model) { subject.new({ 'action' => 3, 'id' => 'fooId', 'connectionId' => connection_id, 'timestamp' => message_timestamp }) }
+
+      it 'creates a duplicate of the message without any ProtocolMessage dependency' do
+        clone = model.shallow_clone
+        expect(clone.id).to eql('fooId')
+        expect(clone.connection_id).to eql(connection_id)
+        expect(as_since_epoch(clone.timestamp)).to eq(message_timestamp)
+        expect(clone.action).to eq(3)
+      end
+    end
+
+    context 'with new attributes passed in to the method' do
+      let(:protocol_message) {
+        Ably::Models::ProtocolMessage.new('id' => 'fooId', 'connectionId' => protocol_connection_id, 'action' =>  1, 'timestamp' => protocol_message_timestamp)
+      }
+      let(:protocol_connection_id) { random_str }
+      let(:model) { subject.new({ 'action' => 2 }, protocol_message: protocol_message) }
+
+      it 'creates a duplicate of the message without any ProtocolMessage dependency' do
+        clone = model.shallow_clone(id: 'newId', action: 1, timestamp: protocol_message_timestamp + 1000)
+        expect(clone.id).to match(/newId/)
+        expect(clone.connection_id).to eql(protocol_connection_id)
+        expect(as_since_epoch(clone.timestamp)).to eq(protocol_message_timestamp + 1000)
+        expect(clone.action).to eq(1)
+      end
+
+      context 'with an invalid ProtocolMessage (missing an ID)' do
+        let(:protocol_message) {
+          Ably::Models::ProtocolMessage.new('connectionId' => protocol_connection_id, 'action' =>  1, 'timestamp' => protocol_message_timestamp)
+        }
+        it 'allows an ID to be passed in to the shallow clone that takes precedence' do
+          clone = model.shallow_clone(id: 'newId', action: 1, timestamp: protocol_message_timestamp + 1000)
+          expect(clone.id).to match(/newId/)
+        end
+      end
+
+      context 'with mixing of cases' do
+        it 'resolves case issues and can use camelCase or snake_case' do
+          clone = model.shallow_clone(connectionId: 'camelCaseSym')
+          expect(clone.connection_id).to match(/camelCaseSym/)
+
+          clone = model.shallow_clone('connectionId' => 'camelCaseStr')
+          expect(clone.connection_id).to match(/camelCaseStr/)
+
+          clone = model.shallow_clone(connection_id: 'snake_case_sym')
+          expect(clone.connection_id).to match(/snake_case_sym/)
+        end
+      end
+    end
+  end
 end

data/spec/unit/models/protocol_message_spec.rb

@@ -10,6 +10,7 @@ describe Ably::Models::ProtocolMessage do
     subject.new({ action: 1 }.merge(options))
   end
 
+  # TR4n, TR4b, TR4c, TR4d, TR4e
   it_behaves_like 'a model',
     with_simple_attributes: %w(id channel channel_serial connection_id connection_key),
     base_model_options: { action: 1 } do
@@ -134,7 +135,7 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
-    context '#flags' do
+    context '#flags (#TR4i)' do
       context 'when nil' do
         let(:protocol_message) { new_protocol_message({}) }
 
@@ -151,12 +152,40 @@ describe Ably::Models::ProtocolMessage do
         end
       end
 
-      context 'when has_presence' do
+      context 'when presence flag present' do
         let(:protocol_message) { new_protocol_message(flags: 1) }
 
         it '#has_presence_flag? is true' do
           expect(protocol_message.has_presence_flag?).to be_truthy
         end
+
+        it '#has_channel_resumed_flag? is false' do
+          expect(protocol_message.has_channel_resumed_flag?).to be_falsey
+        end
+      end
+
+      context 'when channel resumed flag present' do
+        let(:protocol_message) { new_protocol_message(flags: 4) }
+
+        it '#has_channel_resumed_flag? is true' do
+          expect(protocol_message.has_channel_resumed_flag?).to be_truthy
+        end
+
+        it '#has_presence_flag? is false' do
+          expect(protocol_message.has_presence_flag?).to be_falsey
+        end
+      end
+
+      context 'when channel resumed and presence flags present' do
+        let(:protocol_message) { new_protocol_message(flags: 5) }
+
+        it '#has_channel_resumed_flag? is true' do
+          expect(protocol_message.has_channel_resumed_flag?).to be_truthy
+        end
+
+        it '#has_presence_flag? is true' do
+          expect(protocol_message.has_presence_flag?).to be_truthy
+        end
       end
 
       context 'when has another future flag' do
@@ -165,6 +194,10 @@ describe Ably::Models::ProtocolMessage do
         it '#has_presence_flag? is false' do
           expect(protocol_message.has_presence_flag?).to be_falsey
         end
+
+        it '#has_backlog_flag? is true' do
+          expect(protocol_message.has_backlog_flag?).to be_truthy
+        end
       end
     end
 
@@ -265,7 +298,7 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
-    context '#messages' do
+    context '#messages (#TR4k)' do
       let(:protocol_message) { new_protocol_message(messages: [{ name: 'test' }]) }
 
       it 'contains Message objects' do
@@ -275,7 +308,7 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
-    context '#presence' do
+    context '#presence (#TR4l)' do
       let(:protocol_message) { new_protocol_message(presence: [{ action: 1, data: 'test' }]) }
 
       it 'contains PresenceMessage objects' do
@@ -285,7 +318,7 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
-    context '#connection_details' do
+    context '#connection_details (#TR4o)' do
       let(:connection_details) { protocol_message.connection_details }
 
       context 'with a JSON value' do
@@ -312,7 +345,32 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
-    context '#connection_key' do
+    context '#auth (#TR4p)' do
+      let(:auth) { protocol_message.auth }
+
+      context 'with a JSON value' do
+        let(:protocol_message) { new_protocol_message(auth: { accesstoken: 'foo' }) }
+
+        it 'contains a AuthDetails object' do
+          expect(auth).to be_a(Ably::Models::AuthDetails)
+        end
+
+        it 'contains the attributes from the JSON auth details' do
+          expect(auth.access_token).to eql('foo')
+        end
+      end
+
+      context 'without a JSON value' do
+        let(:protocol_message) { new_protocol_message({}) }
+
+        it 'contains an empty AuthDetails object' do
+          expect(auth).to be_a(Ably::Models::AuthDetails)
+          expect(auth.access_token).to eql(nil)
+        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' }) }