ably-rest 0.7.1 → 0.7.3

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

@@ -0,0 +1,386 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::PresenceMessage do
+  include Ably::Modules::Conversions
+
+  subject { Ably::Models::PresenceMessage }
+  let(:protocol_message_timestamp) { as_since_epoch(Time.now) }
+  let(:protocol_message) { Ably::Models::ProtocolMessage.new(action: 1, timestamp: protocol_message_timestamp) }
+
+  it_behaves_like 'a model', with_simple_attributes: %w(client_id data encoding) do
+    let(:model_args) { [protocol_message] }
+  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) }
+    let(:model_connection_id) { random_str }
+
+    context 'when this model has a connectionId attribute' do
+      context 'but no protocol message' do
+        let(:model) { subject.new('connectionId' => model_connection_id ) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to eql(model_connection_id)
+        end
+      end
+
+      context 'with a protocol message with a different connectionId' do
+        let(:model) { subject.new({ 'connectionId' => model_connection_id }, protocol_message) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to eql(model_connection_id)
+        end
+      end
+    end
+
+    context 'when this model has no connectionId attribute' do
+      context 'and no protocol message' do
+        let(:model) { subject.new({ }) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to be_nil
+        end
+      end
+
+      context 'with a protocol message with a connectionId' do
+        let(:model) { subject.new({ }, protocol_message) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to eql(protocol_connection_id)
+        end
+      end
+    end
+  end
+
+  context '#member_key attribute' do
+    let(:model) { subject.new(client_id: 'client_id', connection_id: 'connection_id') }
+
+    it 'is string in format connection_id:client_id' do
+      expect(model.member_key).to eql('connection_id:client_id')
+    end
+
+    context 'with the same client id across multiple connections' do
+      let(:connection_1) { subject.new({ client_id: 'same', connection_id: 'unique' }, protocol_message) }
+      let(:connection_2) { subject.new({ client_id: 'same', connection_id: 'different' }, protocol_message) }
+
+      it 'is unique' do
+        expect(connection_1.member_key).to_not eql(connection_2.member_key)
+      end
+    end
+
+    context 'with a single connection and different client_ids' do
+      let(:client_1) { subject.new({ client_id: 'unique', connection_id: 'same' }, protocol_message) }
+      let(:client_2) { subject.new({ client_id: 'different', connection_id: 'same' }, protocol_message) }
+
+      it 'is unique' do
+        expect(client_1.member_key).to_not eql(client_2.member_key)
+      end
+    end
+  end
+
+  context '#timestamp' do
+    let(:model) { subject.new({}, protocol_message) }
+    it 'retrieves attribute :timestamp as a Time object from ProtocolMessage' do
+      expect(model.timestamp).to be_a(Time)
+      expect(model.timestamp.to_i).to be_within(1).of(Time.now.to_i)
+    end
+  end
+
+  context 'Java naming', :api_private do
+    let(:model) { subject.new({ clientId: 'joe' }, protocol_message) }
+
+    it 'converts the attribute to ruby symbol naming convention' do
+      expect(model.client_id).to eql('joe')
+    end
+  end
+
+  context 'with action', :api_private do
+    context 'absent' do
+      let(:model) { subject.new({ action: 0 }, protocol_message) }
+
+      it 'provides action as an Enum' do
+        expect(model.action).to eq(:absent)
+      end
+    end
+
+    context 'enter' do
+      let(:model) { subject.new({ action: 2 }, protocol_message) }
+
+      it 'provides action as an Enum' do
+        expect(model.action).to eq(:enter)
+      end
+    end
+  end
+
+  context 'without action', :api_private do
+    let(:model) { subject.new({}, protocol_message) }
+
+    it 'raises an exception when accessed' do
+      expect { model.action }.to raise_error KeyError
+    end
+  end
+
+  context 'initialized with' do
+    %w(client_id connection_id encoding).each do |attribute|
+      context ":#{attribute}" do
+        let(:encoded_value)   { value.encode(encoding) }
+        let(:value)           { random_str }
+        let(:options)         { { attribute.to_sym => encoded_value } }
+        let(:model)           { subject.new(options, protocol_message) }
+        let(:model_attribute) { model.public_send(attribute) }
+
+        context 'as UTF_8 string' do
+          let(:encoding) { Encoding::UTF_8 }
+
+          it 'is permitted' do
+            expect(model_attribute).to eql(encoded_value)
+          end
+
+          it 'remains as UTF-8' do
+            expect(model_attribute.encoding).to eql(Encoding::UTF_8)
+          end
+        end
+
+        context 'as SHIFT_JIS string' do
+          let(:encoding) { Encoding::SHIFT_JIS }
+
+          it 'gets converted to UTF-8' do
+            expect(model_attribute.encoding).to eql(Encoding::UTF_8)
+          end
+
+          it 'is compatible with original encoding' do
+            expect(model_attribute.encode(encoding)).to eql(encoded_value)
+          end
+        end
+
+        context 'as ASCII_8BIT string' do
+          let(:encoding) { Encoding::ASCII_8BIT }
+
+          it 'gets converted to UTF-8' do
+            expect(model_attribute.encoding).to eql(Encoding::UTF_8)
+          end
+
+          it 'is compatible with original encoding' do
+            expect(model_attribute.encode(encoding)).to eql(encoded_value)
+          end
+        end
+
+        context 'as Integer' do
+          let(:encoded_value) { 1 }
+
+          it 'raises an argument error' do
+            expect { model_attribute }.to raise_error ArgumentError, /must be a String/
+          end
+        end
+
+        context 'as Nil' do
+          let(:encoded_value) { nil }
+
+          it 'is permitted' do
+            expect(model_attribute).to be_nil
+          end
+        end
+      end
+    end
+  end
+
+  context '#to_json', :api_private do
+    let(:json_object) { JSON.parse(model.to_json) }
+
+    context 'with valid data' do
+      let(:model) { subject.new({ action: 'enter', clientId: 'joe' }, protocol_message) }
+
+      it 'converts the attribute back to Java mixedCase notation using string keys' do
+        expect(json_object["clientId"]).to eql('joe')
+      end
+    end
+
+    context 'with invalid data' do
+      let(:model) { subject.new({ clientId: 'joe' }, protocol_message) }
+
+      it 'raises an exception' do
+        expect { model.to_json }.to raise_error KeyError, /cannot generate a valid Hash/
+      end
+    end
+
+    context 'with binary data' do
+      let(:data) { MessagePack.pack(random_str(32)) }
+      let(:model) { subject.new({ action: 'enter', data: data }, protocol_message) }
+
+      it 'encodes as Base64 so that it can be converted to UTF-8 automatically by JSON#dump' do
+        expect(json_object["data"]).to eql(::Base64.encode64(data))
+      end
+
+      it 'adds Base64 encoding' do
+        expect(json_object["encoding"]).to eql('base64')
+      end
+    end
+  end
+
+  context 'from REST request with embedded fields', :api_private do
+    let(:id) { random_str }
+    let(:message_time) { Time.now + 60 }
+    let(:timestamp) { as_since_epoch(message_time) }
+    let(:model) { subject.new(id: id, timestamp: timestamp) }
+
+    context 'with protocol message' do
+      specify '#id prefers embedded ID' do
+        expect(model.id).to eql(id)
+      end
+
+      specify '#timestamp prefers embedded timestamp' do
+        expect(model.timestamp.to_i).to be_within(1).of(message_time.to_i)
+      end
+    end
+
+    context 'without protocol message' do
+      specify '#id uses embedded ID' do
+        expect(model.id).to eql(id)
+      end
+
+      specify '#timestamp uses embedded timestamp' do
+        expect(model.timestamp.to_i).to be_within(1).of(message_time.to_i)
+      end
+    end
+  end
+
+  context 'part of ProtocolMessage', :api_private do
+    let(:ably_time) { Time.now + 5 }
+    let(:message_serial) { random_int_str(1_000_000) }
+    let(:connection_id) { random_str }
+
+    let(:presence_0_payload) { random_str(8) }
+    let(:presence_0_json) do
+      {
+        client_id: 'zero',
+        data: presence_0_payload
+      }
+    end
+    let(:presence_1_payload) { random_str(8) }
+    let(:presence_1_json) do
+      {
+        client_id: 'one',
+        data: presence_1_payload
+      }
+    end
+
+    let(:protocol_message_id) { random_str }
+    let(:protocol_message) do
+      Ably::Models::ProtocolMessage.new({
+        action: :message,
+        timestamp: ably_time.to_i,
+        msg_serial: message_serial,
+        id: protocol_message_id,
+        presence: [
+          presence_0_json, presence_1_json
+        ]
+      })
+    end
+
+    let(:presence_0) { protocol_message.presence.first }
+    let(:presence_1) { protocol_message.presence.last }
+
+    it 'should generate a message ID from the index, serial and connection id' do
+      expect(presence_0.id).to eql("#{protocol_message_id}:0")
+      expect(presence_1.id).to eql("#{protocol_message_id}:1")
+    end
+
+    it 'should not modify the data payload' do
+      expect(presence_0.data).to eql(presence_0_payload)
+      expect(presence_1.data).to eql(presence_1_payload)
+    end
+  end
+
+  context 'PresenceMessage conversion method', :api_private do
+    let(:json) { { client_id: 'test' } }
+
+    context 'with JSON' do
+      context 'without ProtocolMessage' do
+        subject { Ably::Models.PresenceMessage(json) }
+
+        it 'returns a PresenceMessage object' do
+          expect(subject).to be_a(Ably::Models::PresenceMessage)
+        end
+
+        it 'initializes with the JSON' do
+          expect(subject.client_id).to eql('test')
+        end
+
+        it 'raises an exception when accessing ProtocolMessage' do
+          expect { subject.protocol_message }.to raise_error RuntimeError
+        end
+
+        it 'has no ProtocolMessage' do
+          expect(subject.assigned_to_protocol_message?).to eql(false)
+        end
+      end
+
+      context 'with ProtocolMessage' do
+        subject { Ably::Models.PresenceMessage(json, protocol_message) }
+
+        it 'returns a PresenceMessage object' do
+          expect(subject).to be_a(Ably::Models::PresenceMessage)
+        end
+
+        it 'initializes with the JSON' do
+          expect(subject.client_id).to eql('test')
+        end
+
+        it 'provides access to ProtocolMessage' do
+          expect(subject.protocol_message).to eql(protocol_message)
+        end
+
+        it 'has a ProtocolMessage' do
+          expect(subject.assigned_to_protocol_message?).to eql(true)
+        end
+      end
+    end
+
+    context 'with another PresenceMessage' do
+      let(:message) { Ably::Models::PresenceMessage.new(json) }
+
+      context 'without ProtocolMessage' do
+        subject { Ably::Models.PresenceMessage(message) }
+
+        it 'returns a PresenceMessage object' do
+          expect(subject).to be_a(Ably::Models::PresenceMessage)
+        end
+
+        it 'initializes with the JSON' do
+          expect(subject.client_id).to eql('test')
+        end
+
+        it 'raises an exception when accessing ProtocolMessage' do
+          expect { subject.protocol_message }.to raise_error RuntimeError
+        end
+
+        it 'has no ProtocolMessage' do
+          expect(subject.assigned_to_protocol_message?).to eql(false)
+        end
+      end
+
+      context 'with ProtocolMessage' do
+        subject { Ably::Models.PresenceMessage(message, protocol_message) }
+
+        it 'returns a PresenceMessage object' do
+          expect(subject).to be_a(Ably::Models::PresenceMessage)
+        end
+
+        it 'initializes with the JSON' do
+          expect(subject.client_id).to eql('test')
+        end
+
+        it 'provides access to ProtocolMessage' do
+          expect(subject.protocol_message).to eql(protocol_message)
+        end
+
+        it 'has a ProtocolMessage' do
+          expect(subject.assigned_to_protocol_message?).to eql(true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,315 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::ProtocolMessage do
+  include Ably::Modules::Conversions
+  subject { Ably::Models::ProtocolMessage }
+
+  def new_protocol_message(options)
+    subject.new({ action: 1 }.merge(options))
+  end
+
+  it_behaves_like 'a model',
+    with_simple_attributes: %w(id channel channel_serial connection_id),
+    base_model_options: { action: 1 } do
+
+    let(:model_args) { [] }
+  end
+
+  context 'initializer action coercion', :api_private do
+    it 'ignores actions that are Integers' do
+      protocol_message = subject.new(action: 14)
+      expect(protocol_message.hash[:action]).to eql(14)
+    end
+
+    it 'converts actions to Integers if a symbol' do
+      protocol_message = subject.new(action: :message)
+      expect(protocol_message.hash[:action]).to eql(15)
+    end
+
+    it 'converts actions to Integers if a ACTION' do
+      protocol_message = subject.new(action: Ably::Models::ProtocolMessage::ACTION.Message)
+      expect(protocol_message.hash[:action]).to eql(15)
+    end
+
+    it 'raises an argument error if nil' do
+      expect { subject.new({}) }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'attributes' do
+    let(:unique_value) { random_str }
+
+    context 'Java naming', :api_private do
+      let(:protocol_message) { new_protocol_message(channelSerial: unique_value) }
+
+      it 'converts the attribute to ruby symbol naming convention' do
+        expect(protocol_message.channel_serial).to eql(unique_value)
+      end
+    end
+
+    context '#action', :api_private do
+      let(:protocol_message) { new_protocol_message(action: 14) }
+
+      it 'returns an Enum that behaves like a symbol' do
+        expect(protocol_message.action).to eq(:presence)
+      end
+
+      it 'returns an Enum that behaves like a Numeric' do
+        expect(protocol_message.action).to eq(14)
+      end
+
+      it 'returns an Enum that behaves like a String' do
+        expect(protocol_message.action).to eq('Presence')
+      end
+
+      it 'returns an Enum that matchdes the ACTION constant' do
+        expect(protocol_message.action).to eql(Ably::Models::ProtocolMessage::ACTION.Presence)
+      end
+    end
+
+    context '#timestamp' do
+      let(:protocol_message) { new_protocol_message(timestamp: as_since_epoch(Time.now)) }
+      it 'retrieves attribute :timestamp as Time object' do
+        expect(protocol_message.timestamp).to be_a(Time)
+        expect(protocol_message.timestamp.to_i).to be_within(1).of(Time.now.to_i)
+      end
+    end
+
+    context '#count' do
+      context 'when missing' do
+        let(:protocol_message) { new_protocol_message({}) }
+        it 'is 1' do
+          expect(protocol_message.count).to eql(1)
+        end
+      end
+
+      context 'when non numeric' do
+        let(:protocol_message) { new_protocol_message(count: 'A') }
+        it 'is 1' do
+          expect(protocol_message.count).to eql(1)
+        end
+      end
+
+      context 'when greater than 1' do
+        let(:protocol_message) { new_protocol_message(count: '666') }
+        it 'is the value of count' do
+          expect(protocol_message.count).to eql(666)
+        end
+      end
+    end
+
+    context '#message_serial' do
+      let(:protocol_message) { new_protocol_message(msg_serial: "55") }
+      it 'converts :msg_serial to an Integer' do
+        expect(protocol_message.message_serial).to be_a(Integer)
+        expect(protocol_message.message_serial).to eql(55)
+      end
+    end
+
+    context '#has_message_serial?' do
+      context 'without msg_serial' do
+        let(:protocol_message) { new_protocol_message({}) }
+
+        it 'returns false' do
+          expect(protocol_message.has_message_serial?).to eql(false)
+        end
+      end
+
+      context 'with msg_serial' do
+        let(:protocol_message) { new_protocol_message(msg_serial: "55") }
+
+        it 'returns true' do
+          expect(protocol_message.has_message_serial?).to eql(true)
+        end
+      end
+    end
+
+    context '#connection_serial' do
+      let(:protocol_message) { new_protocol_message(connection_serial: "55") }
+      it 'converts :connection_serial to an Integer' do
+        expect(protocol_message.connection_serial).to be_a(Integer)
+        expect(protocol_message.connection_serial).to eql(55)
+      end
+    end
+
+    context '#flags' do
+      context 'when nil' do
+        let(:protocol_message) { new_protocol_message({}) }
+
+        it 'is zero' do
+          expect(protocol_message.flags).to eql(0)
+        end
+      end
+
+      context 'when numeric' do
+        let(:protocol_message) { new_protocol_message(flags: '25') }
+
+        it 'is an Integer' do
+          expect(protocol_message.flags).to eql(25)
+        end
+      end
+
+      context 'when has_presence' 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
+      end
+
+      context 'when has another future flag' do
+        let(:protocol_message) { new_protocol_message(flags: 2) }
+
+        it '#has_presence_flag? is false' do
+          expect(protocol_message.has_presence_flag?).to be_falsey
+        end
+      end
+    end
+
+    context '#has_connection_serial?' do
+      context 'without connection_serial' do
+        let(:protocol_message) { new_protocol_message({}) }
+
+        it 'returns false' do
+          expect(protocol_message.has_connection_serial?).to eql(false)
+        end
+      end
+
+      context 'with connection_serial' do
+        let(:protocol_message) { new_protocol_message(connection_serial: "55") }
+
+        it 'returns true' do
+          expect(protocol_message.has_connection_serial?).to eql(true)
+        end
+      end
+    end
+
+    context '#serial' do
+      context 'with underlying msg_serial' do
+        let(:protocol_message) { new_protocol_message(msg_serial: "55") }
+        it 'converts :msg_serial to an Integer' do
+          expect(protocol_message.serial).to be_a(Integer)
+          expect(protocol_message.serial).to eql(55)
+        end
+      end
+
+      context 'with underlying connection_serial' do
+        let(:protocol_message) { new_protocol_message(connection_serial: "55") }
+        it 'converts :connection_serial to an Integer' do
+          expect(protocol_message.serial).to be_a(Integer)
+          expect(protocol_message.serial).to eql(55)
+        end
+      end
+
+      context 'with underlying connection_serial and msg_serial' do
+        let(:protocol_message) { new_protocol_message(connection_serial: "99", msg_serial: "11") }
+        it 'prefers connection_serial and converts :connection_serial to an Integer' do
+          expect(protocol_message.serial).to be_a(Integer)
+          expect(protocol_message.serial).to eql(99)
+        end
+      end
+    end
+
+    context '#has_serial?' do
+      context 'without msg_serial or connection_serial' do
+        let(:protocol_message) { new_protocol_message({}) }
+
+        it 'returns false' do
+          expect(protocol_message.has_serial?).to eql(false)
+        end
+      end
+
+      context 'with msg_serial' do
+        let(:protocol_message) { new_protocol_message(msg_serial: "55") }
+
+        it 'returns true' do
+          expect(protocol_message.has_serial?).to eql(true)
+        end
+      end
+
+      context 'with connection_serial' do
+        let(:protocol_message) { new_protocol_message(connection_serial: "55") }
+
+        it 'returns true' do
+          expect(protocol_message.has_serial?).to eql(true)
+        end
+      end
+    end
+
+    context '#error' do
+      context 'with no error attribute' do
+        let(:protocol_message) { new_protocol_message(action: 1) }
+
+        it 'returns nil' do
+          expect(protocol_message.error).to be_nil
+        end
+      end
+
+      context 'with nil error' do
+        let(:protocol_message) { new_protocol_message(error: nil) }
+
+        it 'returns nil' do
+          expect(protocol_message.error).to be_nil
+        end
+      end
+
+      context 'with error' do
+        let(:protocol_message) { new_protocol_message(error: { message: 'test_error' }) }
+
+        it 'returns a valid ErrorInfo object' do
+          expect(protocol_message.error).to be_a(Ably::Models::ErrorInfo)
+          expect(protocol_message.error.message).to eql('test_error')
+        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(: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] }) }
+
+      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)
+      end
+    end
+
+    context 'with missing msg_serial for ack message' do
+      let(:model) { new_protocol_message({ :action => message_action }) }
+
+      it 'it raises an exception' do
+        expect { model.to_json }.to raise_error TypeError, /msg_serial.*missing/
+      end
+    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) }) }
+
+      specify do
+        expect(json_object).to eql(JSON.parse("#{model}"))
+      end
+    end
+  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(: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')
+    end
+  end
+end