ably 0.1.5 → 0.1.6

data/lib/ably/realtime/models/shared.rb

@@ -1,17 +0,0 @@
-module Ably::Realtime::Models
-  module Shared
-    include Ably::Modules::Conversions
-
-    # Provide a normal Hash accessor to the underlying raw message object
-    #
-    # @return [Object]
-    def [](key)
-      json[key]
-    end
-
-    def ==(other)
-      other.kind_of?(self.class) &&
-        json == other.json
-    end
-  end
-end

data/lib/ably/rest/models/message.rb

@@ -1,64 +0,0 @@
-module Ably::Rest::Models
-  # A Message object encapsulates an individual message published in Ably retrieved via Rest
-  class Message
-    include Ably::Modules::Conversions
-
-    def initialize(message)
-      @message = IdiomaticRubyWrapper(message.clone.freeze)
-    end
-
-    # Event name
-    #
-    # @return [String]
-    def name
-      json[:name]
-    end
-
-    # Payload
-    #
-    # @return [Object]
-    def data
-      json[:data]
-    end
-
-    # Client ID of the publisher of the message
-    #
-    # @return [String]
-    def client_id
-      json[:client_id]
-    end
-
-    # Timestamp when message was sent.  This property is populated by the sender.
-    #
-    # @return [Time]
-    def sender_timestamp
-      as_time_from_epoch(json[:timestamp]) if json[:timestamp]
-    end
-
-    # Unique message ID
-    #
-    # @return [String]
-    def message_id
-      json[:message_id]
-    end
-
-    # Provide a normal Hash accessor to the underlying raw message object
-    #
-    # @return [Object]
-    def [](key)
-      json[key]
-    end
-
-    # Raw message object
-    #
-    # @return [Hash]
-    def json
-      @message
-    end
-
-    def ==(other)
-      other.kind_of?(Message) &&
-        json == other.json
-    end
-  end
-end

data/lib/ably/rest/models/presence_message.rb

@@ -1,21 +0,0 @@
-require 'delegate'
-
-module Ably::Rest::Models
-  # A placeholder class representing a presence message
-  class PresenceMessage < Delegator
-    include Ably::Modules::Conversions
-
-    def initialize(json_object)
-      super
-      @json_object = IdiomaticRubyWrapper(json_object.clone.freeze, stop_at: [:client_data])
-    end
-
-    def __getobj__
-      @json_object
-    end
-
-    def __setobj__(obj)
-      @json_object = obj
-    end
-  end
-end

data/lib/ably/token.rb

@@ -1,80 +0,0 @@
-module Ably
-  # Authentication token issued by Ably in response to an token request
-  class Token
-    include Ably::Modules::Conversions
-
-    DEFAULTS = {
-      capability: { "*" => ["*"] },
-      ttl:        60 * 60 # 1 hour
-    }
-
-    # Buffer in seconds given to the use of a token prior to it being considered unusable
-    # For example, if buffer is 10s, the token can no longer be used for new requests 9s before it expires
-    TOKEN_EXPIRY_BUFFER = 5
-
-    def initialize(attributes)
-      @attributes = attributes.clone.freeze
-    end
-
-    # Unique token ID used to authenticate requests
-    #
-    # @return [String]
-    def id
-      attributes.fetch(:id)
-    end
-
-    # Key ID used to create this token
-    #
-    # @return [String]
-    def key_id
-      attributes.fetch(:key)
-    end
-
-    # Time the token was issued
-    #
-    # @return [Time]
-    def issued_at
-      as_time_from_epoch(attributes.fetch(:issued_at), granularity: :s)
-    end
-
-    # Time the token expires
-    #
-    # @return [Time]
-    def expires_at
-      as_time_from_epoch(attributes.fetch(:expires), granularity: :s)
-    end
-
-    # Capabilities assigned to this token
-    #
-    # @return [Hash]
-    def capability
-      attributes.fetch(:capability)
-    end
-
-    # Optioanl client ID assigned to this token
-    #
-    # @return [String]
-    def client_id
-      attributes.fetch(:client_id)
-    end
-
-    def nonce
-      attributes.fetch(:nonce)
-    end
-
-    def ==(other)
-      other.kind_of?(Token) &&
-        attributes == other.attributes
-    end
-
-    # Returns true if token is expired or about to expire
-    #
-    # @return [Boolean]
-    def expired?
-      expires_at < Time.now + TOKEN_EXPIRY_BUFFER
-    end
-
-    protected
-    attr_reader :attributes
-  end
-end

data/spec/unit/realtime/message_spec.rb

@@ -1,117 +0,0 @@
-require 'spec_helper'
-require 'support/model_helper'
-
-describe Ably::Realtime::Models::Message do
-  include Ably::Modules::Conversions
-
-  subject { Ably::Realtime::Models::Message }
-  let(:protocol_message) { Ably::Realtime::Models::ProtocolMessage.new(action: 1) }
-
-  it_behaves_like 'a realtime model', with_simple_attributes: %w(name client_id data) do
-    let(:model_args) { [protocol_message] }
-  end
-
-  context '#sender_timestamp' do
-    let(:model) { subject.new({ timestamp: as_since_epoch(Time.now) }, protocol_message) }
-    it 'retrieves attribute :sender_timestamp' do
-      expect(model.sender_timestamp).to be_a(Time)
-      expect(model.sender_timestamp.to_i).to be_within(1).of(Time.now.to_i)
-    end
-  end
-
-  context 'Java naming' 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 '#to_json' do
-    let(:json_object) { JSON.parse(model.to_json) }
-
-    context 'with valid data' do
-      let(:model) { subject.new({ name: 'test', 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
-
-      it 'autofills a missing timestamp for all messages' do
-        expect(json_object["timestamp"].to_i).to be_within(50).of(as_since_epoch(Time.now))
-      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 RuntimeError, /cannot generate valid JSON/
-      end
-    end
-  end
-
-  context 'part of ProtocolMessage' do
-    let(:ably_time) { Time.now + 5 }
-    let(:sender_time_0) { Time.now - 5 }
-    let(:sender_time_1) { Time.now - 3 }
-    let(:message_serial) { SecureRandom.random_number(1_000_000) }
-    let(:connection_id) { SecureRandom.hex }
-
-    let(:message_0_payload) do
-      {
-        'string_key' => 'string_value',
-        1 => 2,
-        true => false
-      }
-    end
-
-    let(:message_0_json) do
-      {
-        timestamp: sender_time_0,
-        name: 'zero',
-        data: message_0_payload
-      }
-    end
-
-    let(:message_1_json) do
-      {
-        timestamp: sender_time_1,
-        name: 'one',
-        data: 'simple string'
-      }
-    end
-
-    let(:protocol_message) do
-      Ably::Realtime::Models::ProtocolMessage.new({
-        timestamp: ably_time.to_i,
-        msg_serial: message_serial,
-        connection_id: connection_id,
-        messages: [
-          message_0_json, message_1_json
-        ]
-      })
-    end
-
-    let(:message_0) { protocol_message.messages.first }
-    let(:message_1) { protocol_message.messages.last }
-
-    it 'should generate a message ID from the index, serial and connection id' do
-      expect(message_0.message_id).to eql("#{connection_id}:#{message_serial}:0")
-      expect(message_1.message_id).to eql("#{connection_id}:#{message_serial}:1")
-    end
-
-    it 'should not modify the data payload' do
-      expect(message_0.data['string_key']).to eql('string_value')
-      expect(message_0.data[1]).to eql(2)
-      expect(message_0.data[true]).to eql(false)
-      expect(message_0.data).to eql(message_0_payload)
-
-      expect(message_1.data).to eql('simple string')
-    end
-
-    it 'should not allow changes to the payload' do
-      expect { message_0.data["test"] = true }.to raise_error RuntimeError, /can't modify frozen Hash/
-    end
-  end
-end

data/spec/unit/realtime/protocol_message_spec.rb

@@ -1,172 +0,0 @@
-require 'spec_helper'
-require 'support/model_helper'
-
-describe Ably::Realtime::Models::ProtocolMessage do
-  include Ably::Modules::Conversions
-  subject { Ably::Realtime::Models::ProtocolMessage }
-
-  it_behaves_like 'a realtime model',
-    with_simple_attributes: %w(channel channel_serial connection_id connection_serial) do
-
-    let(:model_args) { [] }
-  end
-
-  context 'attributes' do
-    let(:unique_value) { SecureRandom.hex }
-
-    context 'Java naming' do
-      let(:protocol_message) { subject.new(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) { subject.new(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::Realtime::Models::ProtocolMessage::ACTION.Presence)
-      end
-    end
-
-    context '#timestamp' do
-      let(:protocol_message) { subject.new(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 '#message_serial' do
-      let(:protocol_message) { subject.new(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 '#count' do
-      context 'when missing' do
-        let(:protocol_message) { subject.new({}) }
-        it 'is 1' do
-          expect(protocol_message.count).to eql(1)
-        end
-      end
-
-      context 'when non numeric' do
-        let(:protocol_message) { subject.new(count: 'A') }
-        it 'is 1' do
-          expect(protocol_message.count).to eql(1)
-        end
-      end
-
-      context 'when greater than 1' do
-        let(:protocol_message) { subject.new(count: '666') }
-        it 'is the value of count' do
-          expect(protocol_message.count).to eql(666)
-        end
-      end
-    end
-
-    context '#has_message_serial?' do
-      context 'without msg_serial' do
-        let(:protocol_message) { subject.new({}) }
-
-        it 'returns false' do
-          expect(protocol_message.has_message_serial?).to eql(false)
-        end
-      end
-
-      context 'with msg_serial' do
-        let(:protocol_message) { subject.new(msg_serial: "55") }
-
-        it 'returns true' do
-          expect(protocol_message.has_message_serial?).to eql(true)
-        end
-      end
-    end
-
-    context '#error' do
-      context 'with no error attribute' do
-        let(:protocol_message) { subject.new(action: 1) }
-
-        it 'returns nil' do
-          expect(protocol_message.error).to be_nil
-        end
-      end
-
-      context 'with nil error' do
-        let(:protocol_message) { subject.new(error: nil) }
-
-        it 'returns nil' do
-          expect(protocol_message.error).to be_nil
-        end
-      end
-
-      context 'with error' do
-        let(:protocol_message) { subject.new(error: { message: 'test_error' }) }
-
-        it 'returns a valid ErrorInfo object' do
-          expect(protocol_message.error).to be_a(Ably::Realtime::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::Realtime::Models::ProtocolMessage::ACTION.Attached }
-    let(:message_action) { Ably::Realtime::Models::ProtocolMessage::ACTION.Message }
-
-    context 'with valid data' do
-      let(:model) { subject.new({ :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 invalid name data' do
-      let(:model) { subject.new({ clientId: 'joe' }) }
-
-      it 'it raises an exception' do
-        expect { model.to_json }.to raise_error KeyError, /Action '' is not supported by ProtocolMessage/
-      end
-    end
-
-    context 'with missing msg_serial for ack message' do
-      let(:model) { subject.new({ :action => message_action }) }
-
-      it 'it raises an exception' do
-        expect { model.to_json }.to raise_error TypeError, /msg_serial is missing/
-      end
-    end
-
-    context 'is aliased by #to_s' do
-      let(:model) { subject.new({ :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
-end