ably 0.7.6 → 0.8.0

data/spec/unit/models/token_request_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::TokenRequest do
+  subject { Ably::Models::TokenRequest }
+
+  it_behaves_like 'a model', with_simple_attributes: %w(key_name client_id nonce mac) do
+    let(:model_args) { [] }
+  end
+
+  context 'attributes' do
+    context '#capability' do
+      let(:capability) { { "value" => random_str } }
+      let(:capability_str) { JSON.dump(capability) }
+
+      subject { Ably::Models::TokenRequest.new({ capability: capability_str }) }
+
+      it 'retrieves attribute :capability as parsed JSON' do
+        expect(subject.capability).to eql(capability)
+      end
+    end
+
+    context "#timestamp" do
+      let(:time) { Time.now }
+
+      context 'with :timestamp option as milliseconds in constructor' do
+        subject { Ably::Models::TokenRequest.new(timestamp: time.to_i * 1000) }
+
+        it "retrieves attribute :timestamp as Time" do
+          expect(subject.timestamp).to be_a(Time)
+          expect(subject.timestamp.to_i).to eql(time.to_i)
+        end
+      end
+
+      context 'with :timestamp option as Time in constructor' do
+        subject { Ably::Models::TokenRequest.new(timestamp: time) }
+
+        it "retrieves attribute :timestamp as Time" do
+          expect(subject.timestamp).to be_a(Time)
+          expect(subject.timestamp.to_i).to eql(time.to_i)
+        end
+      end
+
+      context 'when converted to JSON' do
+        subject { Ably::Models::TokenRequest.new(timestamp: time) }
+
+        it "is in milliseconds since epoch" do
+          expect(JSON.parse(JSON.dump(subject))['timestamp']).to eql((time.to_f * 1000).round)
+        end
+      end
+    end
+
+    context "#ttl" do
+      let(:ttl) { 500 }
+
+      context 'with :ttl option as milliseconds in constructor' do
+        subject { Ably::Models::TokenRequest.new(ttl: ttl * 1000) }
+
+        it "retrieves attribute :ttl as seconds" do
+          expect(subject.ttl).to be_a(Integer)
+          expect(subject.ttl).to eql(ttl)
+        end
+      end
+
+      context 'when converted to JSON' do
+        subject { Ably::Models::TokenRequest.new(ttl: ttl * 1000) }
+
+        it "is in milliseconds since epoch" do
+          expect(JSON.parse(JSON.dump(subject))['ttl']).to eql(ttl * 1000)
+        end
+      end
+    end
+  end
+
+  context '==' do
+    let(:token_attributes) { { client_id: random_str } }
+
+    it 'is true when attributes are the same' do
+      new_token = -> { Ably::Models::TokenRequest.new(token_attributes) }
+      expect(new_token[]).to eq(new_token[])
+    end
+
+    it 'is false when attributes are not the same' do
+      expect(Ably::Models::TokenRequest.new(client_id: 1)).to_not eq(Ably::Models::TokenRequest.new(client_id: 2))
+    end
+
+    it 'is false when class type differs' do
+      expect(Ably::Models::TokenRequest.new(client_id: 1)).to_not eq(nil)
+    end
+  end
+
+  context 'TokenRequest conversion methods', :api_private do
+    context 'with a TokenRequest object' do
+      let(:token_request) { Ably::Models::TokenRequest.new(client_id: random_str) }
+
+      it 'returns the TokenRequest object' do
+        expect(Ably::Models::TokenRequest(token_request)).to eql(token_request)
+      end
+    end
+
+    context 'with a JSON object' do
+      let(:client_id) { random_str }
+      let(:token_request_json) { { client_id: client_id } }
+
+      it 'returns a new TokenRequest object from the JSON' do
+        expect(Ably::Models::TokenRequest(token_request_json).client_id).to eql(client_id)
+      end
+    end
+  end
+end

data/spec/unit/rest/client_spec.rb

@@ -40,7 +40,7 @@ describe Ably::Rest::Client do
       end
 
       context 'set to true' do
-        context 'without an key or token_id' do
+        context 'without an key or token' do
           let(:client_options) { { use_token_auth: true, key: true } }
 
           it 'fails as an key is required to issue tokens' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ably
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 0.8.0
 platform: ruby
 authors:
 - Lewis Marshall
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-17 00:00:00.000000000 Z
+date: 2015-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -257,7 +257,8 @@ files:
 - lib/ably/models/protocol_message.rb
 - lib/ably/models/stat.rb
 - lib/ably/models/stats_types.rb
-- lib/ably/models/token.rb
+- lib/ably/models/token_details.rb
+- lib/ably/models/token_request.rb
 - lib/ably/modules/ably.rb
 - lib/ably/modules/async_wrapper.rb
 - lib/ably/modules/channels_collection.rb
@@ -356,7 +357,8 @@ files:
 - spec/unit/models/presence_message_spec.rb
 - spec/unit/models/protocol_message_spec.rb
 - spec/unit/models/stats_spec.rb
-- spec/unit/models/token_spec.rb
+- spec/unit/models/token_details_spec.rb
+- spec/unit/models/token_request_spec.rb
 - spec/unit/modules/async_wrapper_spec.rb
 - spec/unit/modules/conversions_spec.rb
 - spec/unit/modules/enum_spec.rb
@@ -449,7 +451,8 @@ test_files:
 - spec/unit/models/presence_message_spec.rb
 - spec/unit/models/protocol_message_spec.rb
 - spec/unit/models/stats_spec.rb
-- spec/unit/models/token_spec.rb
+- spec/unit/models/token_details_spec.rb
+- spec/unit/models/token_request_spec.rb
 - spec/unit/modules/async_wrapper_spec.rb
 - spec/unit/modules/conversions_spec.rb
 - spec/unit/modules/enum_spec.rb

data/lib/ably/models/token.rb

@@ -1,74 +0,0 @@
-module Ably::Models
-  # Authentication token issued by Ably in response to an token request
-  class Token
-    include Ably::Modules::ModelCommon
-
-    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)
-      @hash_object = IdiomaticRubyWrapper(attributes.clone.freeze)
-    end
-
-    # @!attribute [r] id
-    # @return [String] Unique token ID used to authenticate requests
-    def id
-      hash.fetch(:id)
-    end
-
-    # @!attribute [r] key_id
-    # @return [String] Key ID used to create this token
-    def key_id
-      hash.fetch(:key)
-    end
-
-    # @!attribute [r] issued_at
-    # @return [Time] Time the token was issued
-    def issued_at
-      as_time_from_epoch(hash.fetch(:issued_at), granularity: :s)
-    end
-
-    # @!attribute [r] expires_at
-    # @return [Time] Time the token expires
-    def expires_at
-      as_time_from_epoch(hash.fetch(:expires), granularity: :s)
-    end
-
-    # @!attribute [r] capability
-    # @return [Hash] Capabilities assigned to this token
-    def capability
-      hash.fetch(:capability)
-    end
-
-    # @!attribute [r] client_id
-    # @return [String] Optional client ID assigned to this token
-    def client_id
-      hash[:client_id]
-    end
-
-    # @!attribute [r] nonce
-    # @return [String] unique nonce used to generate Token and ensure token generation cannot be replayed
-    def nonce
-      hash.fetch(:nonce)
-    end
-
-    # Returns true if token is expired or about to expire
-    #
-    # @return [Boolean]
-    def expired?
-      expires_at < Time.now + TOKEN_EXPIRY_BUFFER
-    end
-
-    # @!attribute [r] hash
-    # @return [Hash] Access the token Hash object ruby'fied to use symbolized keys
-    def hash
-      @hash_object
-    end
-  end
-end

data/spec/unit/models/token_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-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::Models::Token::DEFAULTS[:ttl]).to eql(one_hour)
-    end
-
-    it 'should default capability to all' do
-      expect(Ably::Models::Token::DEFAULTS[:capability]).to eql(all_capabilities)
-    end
-
-    it 'should only have defaults for :ttl and :capability' do
-      expect(Ably::Models::Token::DEFAULTS.keys).to contain_exactly(:ttl, :capability)
-    end
-  end
-
-  context 'attributes' do
-    let(:unique_value) { 'unique_value' }
-
-    context '#key_id' do
-      subject { Ably::Models::Token.new({ key: unique_value }) }
-      it 'retrieves attribute :key' do
-        expect(subject.key_id).to eql(unique_value)
-      end
-    end
-
-    { :issued_at => :issued_at, :expires_at => :expires }.each do |method_name, attribute|
-      let(:time) { Time.now }
-      context "##{method_name}" do
-        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)
-          expect(subject.public_send(method_name).to_i).to eql(time.to_i)
-        end
-      end
-    end
-
-    context '#expired?' do
-      let(:expire_time) { Time.now + Ably::Models::Token::TOKEN_EXPIRY_BUFFER }
-
-      context 'once grace period buffer has passed' do
-        subject { Ably::Models::Token.new(expires: expire_time - 1) }
-
-        it 'is true' do
-          expect(subject.expired?).to eql(true)
-        end
-      end
-
-      context 'within grace period buffer' do
-        subject { Ably::Models::Token.new(expires: expire_time + 1) }
-
-        it 'is false' do
-          expect(subject.expired?).to eql(false)
-        end
-      end
-    end
-  end
-
-  context '==' do
-    let(:token_attributes) { { id: 'unique' } }
-
-    it 'is true when attributes are the same' do
-      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::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::Models::Token.new(id: 1)).to_not eq(nil)
-    end
-  end
-end