ably 0.1.5 → 0.1.6

data/spec/unit/models/protocol_message_spec.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+require 'support/model_helper'
+
+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' 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) { SecureRandom.hex }
+
+    context 'Java naming' 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' 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' 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 '#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' 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' 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

data/spec/unit/{token_spec.rb → models/token_spec.rb}

@@ -1,38 +1,34 @@
 require "spec_helper"
 
-describe Ably::Token do
+describe Ably::Models::Token do
+  subject { Ably::Models::Token }
+
+  it_behaves_like 'a model', with_simple_attributes: %w(id capability client_id nonce) do
+    let(:model_args) { [] }
+  end
+
   context 'defaults' do
     let(:one_hour)          { 60 * 60 }
     let(:all_capabilities)  { { "*" => ["*"] } }
 
     it 'should default TTL to 1 hour' do
-      expect(Ably::Token::DEFAULTS[:ttl]).to eql(one_hour)
+      expect(Ably::Models::Token::DEFAULTS[:ttl]).to eql(one_hour)
     end
 
     it 'should default capability to all' do
-      expect(Ably::Token::DEFAULTS[:capability]).to eql(all_capabilities)
+      expect(Ably::Models::Token::DEFAULTS[:capability]).to eql(all_capabilities)
     end
 
     it 'should only have defaults for :ttl and :capability' do
-      expect(Ably::Token::DEFAULTS.keys).to contain_exactly(:ttl, :capability)
+      expect(Ably::Models::Token::DEFAULTS.keys).to contain_exactly(:ttl, :capability)
     end
   end
 
   context 'attributes' do
     let(:unique_value) { 'unique_value' }
 
-    %w(id capability client_id nonce).each do |attribute|
-      context "##{attribute}" do
-        subject { Ably::Token.new({ attribute.to_sym => unique_value }) }
-
-        it "retrieves attribute :#{attribute}" do
-          expect(subject.public_send(attribute)).to eql(unique_value)
-        end
-      end
-    end
-
     context '#key_id' do
-      subject { Ably::Token.new({ key: unique_value }) }
+      subject { Ably::Models::Token.new({ key: unique_value }) }
       it 'retrieves attribute :key' do
         expect(subject.key_id).to eql(unique_value)
       end
@@ -41,7 +37,7 @@ describe Ably::Token do
     { :issued_at => :issued_at, :expires_at => :expires }.each do |method_name, attribute|
       let(:time) { Time.now }
       context "##{method_name}" do
-        subject { Ably::Token.new({ attribute.to_sym => time.to_i }) }
+        subject { Ably::Models::Token.new({ attribute.to_sym => time.to_i }) }
 
         it "retrieves attribute :#{attribute} as Time" do
           expect(subject.public_send(method_name)).to be_a(Time)
@@ -51,10 +47,10 @@ describe Ably::Token do
     end
 
     context '#expired?' do
-      let(:expire_time) { Time.now + Ably::Token::TOKEN_EXPIRY_BUFFER }
+      let(:expire_time) { Time.now + Ably::Models::Token::TOKEN_EXPIRY_BUFFER }
 
       context 'once grace period buffer has passed' do
-        subject { Ably::Token.new(expires: expire_time - 1) }
+        subject { Ably::Models::Token.new(expires: expire_time - 1) }
 
         it 'is true' do
           expect(subject.expired?).to eql(true)
@@ -62,7 +58,7 @@ describe Ably::Token do
       end
 
       context 'within grace period buffer' do
-        subject { Ably::Token.new(expires: expire_time + 1) }
+        subject { Ably::Models::Token.new(expires: expire_time + 1) }
 
         it 'is false' do
           expect(subject.expired?).to eql(false)
@@ -75,16 +71,16 @@ describe Ably::Token do
     let(:token_attributes) { { id: 'unique' } }
 
     it 'is true when attributes are the same' do
-      new_token = -> { Ably::Token.new(token_attributes) }
+      new_token = -> { Ably::Models::Token.new(token_attributes) }
       expect(new_token[]).to eq(new_token[])
     end
 
     it 'is false when attributes are not the same' do
-      expect(Ably::Token.new(id: 1)).to_not eq(Ably::Token.new(id: 2))
+      expect(Ably::Models::Token.new(id: 1)).to_not eq(Ably::Models::Token.new(id: 2))
     end
 
     it 'is false when class type differs' do
-      expect(Ably::Token.new(id: 1)).to_not eq(nil)
+      expect(Ably::Models::Token.new(id: 1)).to_not eq(nil)
     end
   end
 end

data/spec/unit/modules/conversions_spec.rb

@@ -49,7 +49,7 @@ describe Ably::Modules::Conversions do
       let(:seconds) { Time.new.to_f }
 
       it 'converts to Time from milliseconds by default' do
-        expect(subject.as_time_from_epoch(millisecond).to_f).to be_within(0.001).of(time.to_f)
+        expect(subject.as_time_from_epoch(millisecond).to_f).to be_within(0.01).of(time.to_f)
       end
 
       it 'converts to Time from seconds' do

data/spec/unit/modules/event_emitter_spec.rb

@@ -16,16 +16,18 @@ describe Ably::Modules::EventEmitter do
 
   context 'event fan out' do
     specify do
-      expect(obj).to receive(:received_message).with(msg).twice
       2.times do
         subject.on(:message) { |msg| obj.received_message msg }
       end
+
+      expect(obj).to receive(:received_message).with(msg).twice
       subject.trigger :message, msg
     end
 
     it 'sends only messages to matching event names' do
-      expect(obj).to receive(:received_message).with(msg).once
       subject.on(:valid) { |msg| obj.received_message msg }
+
+      expect(obj).to receive(:received_message).with(msg).once
       subject.trigger :valid, msg
       subject.trigger :ignored, msg
       subject.trigger 'valid', msg
@@ -37,19 +39,49 @@ describe Ably::Modules::EventEmitter do
       end
 
       it 'calls the provided proc to coerce the event name' do
-        expect(obj).to receive(:received_message).with(msg).once
         subject.on('valid') { |msg| obj.received_message msg }
+
+        expect(obj).to receive(:received_message).with(msg).once
         subject.trigger :valid, msg
       end
     end
 
     context 'without coercion' do
       it 'only matches event names on type matches' do
-        expect(obj).to_not receive(:received_message).with(msg)
         subject.on('valid') { |msg| obj.received_message msg }
+
+        expect(obj).to_not receive(:received_message).with(msg)
         subject.trigger :valid, msg
       end
     end
+
+    context 'subscribe to multiple events' do
+      it 'with the same block' do
+        subject.on(:click, :hover) { |msg| obj.received_message msg }
+
+        expect(obj).to receive(:received_message).with(msg).twice
+
+        subject.trigger :click, msg
+        subject.trigger :hover, msg
+      end
+    end
+  end
+
+  context '#once' do
+    it 'calls the block the first time an event is emitted only' do
+      block_called = 0
+      subject.once('event') { block_called += 1 }
+      3.times { subject.trigger 'event', 'data' }
+      expect(block_called).to eql(1)
+    end
+
+    it 'does not remove other blocks after it is called' do
+      block_called = 0
+      subject.once('event') { block_called += 1 }
+      subject.on('event')   { block_called += 1 }
+      3.times { subject.trigger 'event', 'data' }
+      expect(block_called).to eql(4)
+    end
   end
 
   context '#off' do