ably-rest 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27ef716f8df3e3ded4ffffdcdbfb94c018a30e74
-  data.tar.gz: 47d6e2d4b21491d1272c6c9d32b063e037d9c908
+  metadata.gz: 006c13b2408ff07c78159727a7e0bbd1a2eea9ab
+  data.tar.gz: 691848a554d61eb6c785cc7515f169e36bed8241
 SHA512:
-  metadata.gz: fe7dc932158f9bba9d026eab21b38820ab80ed6811c01140e4472e88dacaaed2d59f6e3965125e42e3b912cb4f47892bac2ed9ea3c66969f332a81bb6717c7bc
-  data.tar.gz: 2e826797df048e498f4c3083934df9219a42933d2286857fb1dd35c541730439bb4912220ddaa4032e7a2187fec5cf6e1cd5ae701262b89dde18a43f17e4b491
+  metadata.gz: 5ef3a684409bf54433d1c81b76da2555e6aa885dc547e4c11c8e4e94f24adf25c56cc84a2613f5d8b11c03294126a5b03b826a6a744820e1765b7eb4433eebf5
+  data.tar.gz: 562e4212388a59f3b53e699ff1933a1d02563b3c62af75370919c8dba10b984013e43a38bc73a33b364fe65952537d02d96eb77b30953e2c1df9d81382caf7fa

data/lib/submodules/ably-ruby/lib/ably/exceptions.rb

@@ -122,5 +122,8 @@ module Ably
     class ChannelInactive < BaseAblyException; end
 
     class IncompatibleClientId < BaseAblyException; end
+
+    # Token request has missing or invalid attributes
+    class InvalidTokenRequest < BaseAblyException; end
   end
 end

data/lib/submodules/ably-ruby/lib/ably/models/message.rb

@@ -1,3 +1,5 @@
+require 'ably/models/message_encoders/base'
+
 module Ably::Models
   # Convert messsage argument to a {Message} object and associate with a protocol message if provided
   #
@@ -43,6 +45,9 @@ module Ably::Models
     include Ably::Modules::ModelCommon
     include Ably::Modules::SafeDeferrable if defined?(Ably::Realtime)
 
+    # Statically register a default set of encoders for this class
+    Ably::Models::MessageEncoders.register_default_encoders self
+
     # {Message} initializer
     #
     # @param  attributes [Hash]             object with the underlying message detail key value attributes

data/lib/submodules/ably-ruby/lib/ably/models/message_encoders/base.rb

@@ -13,10 +13,11 @@ module Ably::Models::MessageEncoders
   # Base interface for an Ably Encoder
   #
   class Base
-    attr_reader :client
+    attr_reader :client, :options
 
-    def initialize(client)
+    def initialize(client, options = {})
       @client = client
+      @options = options
     end
 
     # #encode is called once before a message is sent to Ably
@@ -94,11 +95,26 @@ module Ably::Models::MessageEncoders
     end
   end
 
-  def self.register_default_encoders(client)
+  # @api private
+  def self.register_default_encoders(client, binary_protocol: false)
     client.register_encoder Ably::Models::MessageEncoders::Utf8
     client.register_encoder Ably::Models::MessageEncoders::Json
     client.register_encoder Ably::Models::MessageEncoders::Cipher
-    client.register_encoder Ably::Models::MessageEncoders::Base64
+    client.register_encoder Ably::Models::MessageEncoders::Base64, binary_protocol: binary_protocol
+  end
+
+  # @api private
+  def self.encoder_from(encoder, options)
+    encoder_klass = if encoder.kind_of?(String)
+      encoder.split('::').inject(Kernel) do |base, klass_name|
+        base.public_send(:const_get, klass_name)
+      end
+    else
+      encoder
+    end
+
+    raise "Encoder must inherit from `Ably::Models::MessageEncoders::Base`" unless encoder_klass.ancestors.include?(Ably::Models::MessageEncoders::Base)
+    encoder_klass.new(self, options)
   end
 end
 

data/lib/submodules/ably-ruby/lib/ably/models/message_encoders/base64.rb

@@ -34,7 +34,7 @@ module Ably::Models::MessageEncoders
     end
 
     def transport_protocol_text?
-      !client.protocol_binary?
+      !options[:binary_protocol]
     end
   end
 end

data/lib/submodules/ably-ruby/lib/ably/models/presence_message.rb

@@ -52,6 +52,9 @@ module Ably::Models
       :update
     )
 
+    # Statically register a default set of encoders for this class
+    Ably::Models::MessageEncoders.register_default_encoders self
+
     # {PresenceMessage} initializer
     #
     # @param  attributes  [Hash]            object with the underlying presence message key value attributes

data/lib/submodules/ably-ruby/lib/ably/models/token_details.rb

@@ -73,7 +73,17 @@ module Ably::Models
     # @!attribute [r] capability
     # @return [Hash] Capabilities assigned to this token
     def capability
-      JSON.parse(attributes.fetch(:capability)) if attributes.has_key?(:capability)
+      if attributes.has_key?(:capability)
+        capability_val = attributes.fetch(:capability)
+        case capability_val
+        when Hash
+          capability_val
+        when Ably::Models::IdiomaticRubyWrapper
+          capability_val.as_json
+        else
+          JSON.parse(attributes.fetch(:capability))
+        end
+      end
     end
 
     # @!attribute [r] client_id

data/lib/submodules/ably-ruby/lib/ably/models/token_request.rb

@@ -42,7 +42,7 @@ module Ably::Models
     # @!attribute [r] key_name
     # @return [String] API key name of the key against which this request is made.  An API key is made up of an API key name and secret delimited by a +:+
     def key_name
-      attributes.fetch(:key_name)
+      attributes.fetch(:key_name) { raise Ably::Exceptions::InvalidTokenRequest, 'Key name is missing' }
     end
 
     # @!attribute [r] ttl
@@ -59,7 +59,16 @@ module Ably::Models
     #                the capability of the returned token will be the intersection of
     #                this capability with the capability of the issuing key.
     def capability
-      JSON.parse(attributes.fetch(:capability))
+      capability_val = attributes.fetch(:capability) { raise Ably::Exceptions::InvalidTokenRequest, 'Capability is missing' }
+
+      case capability_val
+      when Hash
+        capability_val
+      when Ably::Models::IdiomaticRubyWrapper
+        capability_val.as_json
+      else
+        JSON.parse(attributes.fetch(:capability))
+      end
     end
 
     # @!attribute [r] client_id
@@ -75,7 +84,8 @@ module Ably::Models
     #                token requests from being replayed.
     #                Timestamp when sent to Ably is in milliseconds.
     def timestamp
-      as_time_from_epoch(attributes.fetch(:timestamp), granularity: :ms)
+      timestamp_val = attributes.fetch(:timestamp) { raise Ably::Exceptions::InvalidTokenRequest, 'Timestamp is missing' }
+      as_time_from_epoch(timestamp_val, granularity: :ms)
     end
 
     # @!attribute [r] nonce
@@ -83,21 +93,21 @@ module Ably::Models
     #                   uniqueness of this request. Any subsequent request using the
     #                   same nonce will be rejected.
     def nonce
-      attributes.fetch(:nonce)
+      attributes.fetch(:nonce) { raise Ably::Exceptions::InvalidTokenRequest, 'Nonce is missing' }
     end
 
     # @!attribute [r] mac
     # @return [String]  the Message Authentication Code for this request. See the
     #                   {https://www.ably.io/documentation Ably Authentication documentation} for more details.
     def mac
-      attributes.fetch(:mac)
+      attributes.fetch(:mac) { raise Ably::Exceptions::InvalidTokenRequest, 'MAC is missing' }
     end
 
     # Requests that the token is always persisted
     # @api private
     #
     def persisted
-      attributes.fetch(:persisted)
+      attributes[:persisted]
     end
 
     # @!attribute [r] attributes

data/lib/submodules/ably-ruby/lib/ably/modules/encodeable.rb

@@ -10,20 +10,60 @@ module Ably::Modules
   # - A #raw_hash_object attribute that returns the original hash object used to create this object
   #
   module Encodeable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Return a Message or Presence object from the encoded JSON-like object, using the optional channel options
+      # @param message_object [Hash] JSON-like object representation of an encoded message
+      # @param channel_options [Hash] Channel options, currently reserved for Encryption options
+      # @yield [Ably::Exceptions::BaseAblyException] yields an Ably exception if decoding fails
+      # @return [Message,Presence]
+      def from_encoded(message_object, channel_options = {}, &error_block)
+        new(message_object).tap do |message|
+          message.decode(encoders, channel_options, &error_block)
+        end
+      end
+
+      # Return an Array of Message or Presence objects from the encoded Array of JSON-like objects, using the optional channel options
+      # @param message_objects [Array<Hash>] Array of JSON-like objects with encoded messages
+      # @param channel_options [Hash] Channel options, currently reserved for Encryption options
+      # @return [Array<Message,Presence>]
+      def from_encoded_array(message_object_array, channel_options = {})
+        Array(message_object_array).map do |message_object|
+          from_encoded(message_object, channel_options)
+        end
+      end
+
+      # Register an encoder for this object
+      # @api private
+      def register_encoder(encoder, options = {})
+        encoders << Ably::Models::MessageEncoders.encoder_from(encoder, options)
+      end
+
+      private
+      def encoders
+        @encoders ||= []
+      end
+    end
+
     # Encode a message using the channel options and register encoders for the client
-    # @param channel [Ably::Realtime::Channel]
+    # @param encoders [Array<Ably::Models::MessageEncoders::Base>] List of encoders to apply to the message
+    # @param channel_options [Hash] Channel options, currently reserved for Encryption options
     # @return [void]
     # @api private
-    def encode(channel)
-      apply_encoders :encode, channel
+    def encode(encoders, channel_options, &error_block)
+      apply_encoders :encode, encoders, channel_options, &error_block
     end
 
     # Decode a message using the channel options and registered encoders for the client
-    # @param channel [Ably::Realtime::Channel]
+    # @param encoders [Array<Ably::Models::MessageEncoders::Base>] List of encoders to apply to the message
+    # @param channel_options [Hash] Channel options, currently reserved for Encryption options
     # @return [void]
     # @api private
-    def decode(channel)
-      apply_encoders :decode, channel
+    def decode(encoders, channel_options, &error_block)
+      apply_encoders :decode, encoders, channel_options, &error_block
     end
 
     # The original encoding of this message when it was received as a raw message from the Ably service
@@ -44,7 +84,7 @@ module Ably::Modules
       end
     end
 
-    def apply_encoders(method, channel)
+    def apply_encoders(method, encoders, channel_options, &error_callback)
       max_encoding_length = 512
       message_attributes = attributes.dup
 
@@ -54,16 +94,15 @@ module Ably::Modules
         end
 
         previous_encoding = message_attributes[:encoding]
-        channel.client.encoders.each do |encoder|
-          encoder.send method, message_attributes, channel.options
+        encoders.each do |encoder|
+          encoder.send method, message_attributes, channel_options
         end
       end until previous_encoding == message_attributes[:encoding]
 
       set_attributes_object message_attributes
     rescue Ably::Exceptions::CipherError => cipher_error
-      if channel.respond_to?(:emit)
-        channel.client.logger.error "Encoder error #{cipher_error.code} trying to #{method} message: #{cipher_error.message}"
-        channel.emit :error, cipher_error
+      if block_given?
+        yield cipher_error, "Encoder error #{cipher_error.code} trying to #{method} message: #{cipher_error.message}"
       else
         raise cipher_error
       end

data/lib/submodules/ably-ruby/lib/ably/modules/model_common.rb

@@ -8,6 +8,10 @@ module Ably::Modules
     include Conversions
     include MessagePack
 
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
     # Provide a normal Hash accessor to the underlying raw message object
     #
     # @return [Object]
@@ -38,6 +42,19 @@ module Ably::Modules
       attributes.hash
     end
 
+    module ClassMethods
+      # Return a new instance of this object using the provided JSON-like object or JSON string
+      # @param [Hash, String] JSON-like object or JSON string
+      # @return a new instance o this object
+      def from_json(json_like_object)
+        if json_like_object.kind_of?(String)
+          new(JSON.parse(json_like_object))
+        else
+          new(json_like_object)
+        end
+      end
+    end
+
     private
     def ensure_utf8_string_for(attribute, value)
       if value

data/lib/submodules/ably-ruby/lib/ably/realtime/channel.rb

@@ -299,7 +299,10 @@ module Ably
 
       def setup_event_handlers
         __incoming_msgbus__.subscribe(:message) do |message|
-          message.decode self
+          message.decode(client.encoders, options) do |encode_error, error_message|
+            client.logger.error error_message
+            emit :error, encode_error
+          end
           emit_message message.name, message
         end
 
@@ -387,7 +390,10 @@ module Ably
 
       def create_message(message)
         Ably::Models::Message(message.dup).tap do |msg|
-          msg.encode self
+          msg.encode(client.encoders, options) do |encode_error, error_message|
+            client.logger.error error_message
+            emit :error, encode_error
+          end
         end
       end
 

data/lib/submodules/ably-ruby/lib/ably/realtime/presence.rb

@@ -346,7 +346,10 @@ module Ably::Realtime
       }
 
       Ably::Models::PresenceMessage.new(model, logger: logger).tap do |presence_message|
-        presence_message.encode self.channel
+        presence_message.encode(client.encoders, channel.options) do |encode_error, error_message|
+          client.logger.error error_message
+          emit :error, encode_error
+        end
       end
     end
 

data/lib/submodules/ably-ruby/lib/ably/realtime/presence/members_map.rb

@@ -165,7 +165,10 @@ module Ably::Realtime
 
       def setup_event_handlers
         presence.__incoming_msgbus__.subscribe(:presence, :sync) do |presence_message|
-          presence_message.decode channel
+          presence_message.decode(client.encoders, channel.options) do |encode_error, error_message|
+            client.logger.error error_message
+            channel.emit :error, encode_error
+          end
           update_members_and_emit_events presence_message
         end
 

data/lib/submodules/ably-ruby/lib/ably/rest/channel.rb

@@ -65,7 +65,7 @@ module Ably
 
         payload = messages.map do |message|
           Ably::Models::Message(message.dup).tap do |msg|
-            msg.encode self
+            msg.encode client.encoders, options
 
             next if msg.client_id.nil?
             if msg.client_id == '*'
@@ -134,7 +134,7 @@ module Ably
       end
 
       def decode_message(message)
-        message.decode self
+        message.decode client.encoders, options
       rescue Ably::Exceptions::CipherError, Ably::Exceptions::EncoderError => e
         client.logger.error "Decoding Error on channel '#{name}', message event name '#{message.name}'. #{e.class.name}: #{e.message}"
       end

data/lib/submodules/ably-ruby/lib/ably/rest/client.rb

@@ -346,18 +346,8 @@ module Ably
       # @return [void]
       #
       # @api private
-      def register_encoder(encoder)
-        encoder_klass = if encoder.kind_of?(String)
-          encoder.split('::').inject(Kernel) do |base, klass_name|
-            base.public_send(:const_get, klass_name)
-          end
-        else
-          encoder
-        end
-
-        raise "Encoder must inherit from `Ably::Models::MessageEncoders::Base`" unless encoder_klass.ancestors.include?(Ably::Models::MessageEncoders::Base)
-
-        encoders << encoder_klass.new(self)
+      def register_encoder(encoder, options = {})
+        encoders << Ably::Models::MessageEncoders.encoder_from(encoder, options)
       end
 
       # @!attribute [r] protocol_binary?
@@ -535,7 +525,7 @@ module Ably
       end
 
       def initialize_default_encoders
-        Ably::Models::MessageEncoders.register_default_encoders self
+        Ably::Models::MessageEncoders.register_default_encoders self, binary_protocol: protocol == :msgpack
       end
     end
   end

data/lib/submodules/ably-ruby/lib/ably/rest/presence.rb

@@ -88,7 +88,7 @@ module Ably
       end
 
       def decode_message(presence_message)
-        presence_message.decode channel
+        presence_message.decode client.encoders, channel.options
       rescue Ably::Exceptions::CipherError, Ably::Exceptions::EncoderError => e
         client.logger.error "Decoding Error on presence channel '#{channel.name}', presence message client_id '#{presence_message.client_id}'. #{e.class.name}: #{e.message}"
       end

data/lib/submodules/ably-ruby/lib/ably/version.rb

@@ -1,5 +1,5 @@
 module Ably
-  VERSION = '0.9.1'
+  VERSION = '0.9.2'
   PROTOCOL_VERSION = '0.9'
 
   # Allow a variant to be configured for all instances of this client library

data/lib/submodules/ably-ruby/spec/acceptance/realtime/channel_spec.rb

@@ -367,11 +367,11 @@ describe Ably::Realtime::Channel, :event_machine do
             # All 3 messages should be batched into a single Protocol Message by the client library
             # message.id = "{protocol_message.id}:{protocol_message_index}"
             # Check that all messages share the same protocol_message.id
-            message_id = messages.map { |msg| msg.id.split(':')[0] }
+            message_id = messages.map { |msg| msg.id.split(':')[0...-1].join(':') }
             expect(message_id.uniq.count).to eql(1)
 
             # Check that messages use index 0,1,2 in the ID
-            message_indexes = messages.map { |msg| msg.id.split(':')[1] }
+            message_indexes = messages.map { |msg| msg.id.split(':').last }
             expect(message_indexes).to include("0", "1", "2")
             stop_reactor
           end

data/lib/submodules/ably-ruby/spec/acceptance/realtime/presence_spec.rb

@@ -1226,11 +1226,11 @@ describe Ably::Realtime::Presence, :event_machine do
         let(:client_options)      { default_options.merge(log_level: :none) }
 
         def connect_members_deferrables
-          (members_per_page * pages + 1).times.map do |index|
+          (members_per_page * pages + 1).times.map do |mem_index|
             # rate limit to 10 per second
             EventMachine::DefaultDeferrable.new.tap do |deferrable|
-              EventMachine.add_timer(index / 10) do
-                presence_client_one.enter_client("client:#{index}").tap do |enter_deferrable|
+              EventMachine.add_timer(mem_index/10) do
+                presence_client_one.enter_client("client:#{mem_index}").tap do |enter_deferrable|
                   enter_deferrable.callback { |*args| deferrable.succeed *args }
                   enter_deferrable.errback { |*args| deferrable.fail *args }
                 end

data/lib/submodules/ably-ruby/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/lib/submodules/ably-ruby/spec/unit/models/message_spec.rb

@@ -379,4 +379,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/lib/submodules/ably-ruby/spec/unit/models/presence_message_spec.rb

@@ -383,4 +383,125 @@ 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
 end

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

@@ -146,4 +146,79 @@ describe Ably::Models::TokenDetails do
       end
     end
   end
+
+  context 'from_json (TD7)' do
+    let(:issued_time) { Time.now }
+    let(:expires_time) { Time.now + 24*60*60 }
+    let(:capabilities) { { '*' => ['publish'] } }
+
+    context 'with Ruby idiomatic Hash object' do
+      subject { Ably::Models::TokenDetails.from_json(token_details_object) }
+
+      let(:token_details_object) do
+        {
+          token: 'val1',
+          key_name: 'val2',
+          issued: issued_time.to_i * 1000,
+          expires: expires_time.to_i * 1000,
+          capability: capabilities,
+          client_id: 'val3'
+        }
+      end
+
+      it 'returns a valid TokenDetails object' do
+        expect(subject.token).to eql('val1')
+        expect(subject.key_name).to eql('val2')
+        expect(subject.issued.to_f).to be_within(1).of(issued_time.to_f)
+        expect(subject.expires.to_f).to be_within(1).of(expires_time.to_f)
+        expect(subject.capability).to eql(capabilities)
+        expect(subject.client_id).to eql('val3')
+      end
+    end
+
+    context 'with JSON-like object' do
+      subject { Ably::Models::TokenDetails.from_json(token_details_object) }
+
+      let(:token_details_object) do
+        {
+          'keyName' => 'val2',
+          'issued' => issued_time.to_i * 1000,
+          'expires' => expires_time.to_i * 1000,
+          'capability' => JSON.dump(capabilities),
+          'clientId' => 'val3'
+        }
+      end
+
+      it 'returns a valid TokenDetails object' do
+        expect(subject.token).to be_nil
+        expect(subject.key_name).to eql('val2')
+        expect(subject.issued.to_f).to be_within(1).of(issued_time.to_f)
+        expect(subject.expires.to_f).to be_within(1).of(expires_time.to_f)
+        expect(subject.capability).to eql(capabilities)
+        expect(subject.client_id).to eql('val3')
+      end
+    end
+
+    context 'with JSON string' do
+      subject { Ably::Models::TokenDetails.from_json(JSON.dump(token_details_object)) }
+
+      let(:token_details_object) do
+        {
+          'keyName' => 'val2',
+          'issued' => issued_time.to_i * 1000,
+          'expires' => expires_time.to_i * 1000,
+          'clientId' => 'val3'
+        }
+      end
+
+      it 'returns a valid TokenDetails object' do
+        expect(subject.token).to be_nil
+        expect(subject.key_name).to eql('val2')
+        expect(subject.issued.to_f).to be_within(1).of(issued_time.to_f)
+        expect(subject.expires.to_f).to be_within(1).of(expires_time.to_f)
+        expect(subject.capability).to be_nil
+        expect(subject.client_id).to eql('val3')
+      end
+    end
+  end
 end

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

@@ -107,4 +107,78 @@ describe Ably::Models::TokenRequest do
       end
     end
   end
+
+  context 'from_json (TE6)' do
+    let(:timestamp) { Time.now }
+    let(:capabilities) { { '*' => ['publish'] } }
+    let(:ttl_seconds) { 60 * 1000 }
+
+    context 'with Ruby idiomatic Hash object' do
+      subject { Ably::Models::TokenRequest.from_json(token_request_object) }
+
+      let(:token_request_object) do
+        {
+          nonce: 'val1',
+          key_name: 'val2',
+          ttl: ttl_seconds * 1000,
+          timestamp: timestamp.to_i * 1000,
+          capability: capabilities,
+          client_id: 'val3'
+        }
+      end
+
+      it 'returns a valid TokenRequest object' do
+        expect(subject.nonce).to eql('val1')
+        expect(subject.key_name).to eql('val2')
+        expect(subject.timestamp.to_f).to be_within(1).of(timestamp.to_f)
+        expect(subject.ttl).to eql(ttl_seconds)
+        expect(subject.capability).to eql(capabilities)
+        expect(subject.client_id).to eql('val3')
+      end
+    end
+
+    context 'with JSON-like object' do
+      subject { Ably::Models::TokenRequest.from_json(token_request_object) }
+
+      let(:token_request_object) do
+        {
+          'keyName' => 'val2',
+          'ttl' => ttl_seconds * 1000,
+          'timestamp' => timestamp.to_i * 1000,
+          'clientId' => 'val3'
+        }
+      end
+
+      it 'returns a valid TokenRequest object' do
+        expect { subject.nonce }.to raise_error(Ably::Exceptions::InvalidTokenRequest)
+        expect(subject.key_name).to eql('val2')
+        expect(subject.timestamp.to_f).to be_within(1).of(timestamp.to_f)
+        expect(subject.ttl).to eql(ttl_seconds)
+        expect { subject.capability }.to raise_error(Ably::Exceptions::InvalidTokenRequest)
+        expect(subject.client_id).to eql('val3')
+      end
+    end
+
+    context 'with JSON string' do
+      subject { Ably::Models::TokenRequest.from_json(JSON.dump(token_request_object)) }
+
+      let(:token_request_object) do
+        {
+          'nonce' => 'val1',
+          'ttl' => ttl_seconds * 1000,
+          'capability' => JSON.dump(capabilities),
+          'clientId' => 'val3'
+        }
+      end
+
+      it 'returns a valid TokenRequest object' do
+        expect(subject.nonce).to eql('val1')
+        expect { subject.key_name }.to raise_error(Ably::Exceptions::InvalidTokenRequest)
+        expect { subject.timestamp }.to raise_error(Ably::Exceptions::InvalidTokenRequest)
+        expect(subject.ttl).to eql(ttl_seconds)
+        expect(subject.capability).to eql(capabilities)
+        expect(subject.client_id).to eql('val3')
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ably-rest
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - Matthew O'Riordan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-02 00:00:00.000000000 Z
+date: 2016-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -405,7 +405,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: A Ruby REST only client library for ably.io realtime messaging