ably 0.7.6 → 0.8.0

data/spec/acceptance/rest/base_spec.rb

@@ -109,18 +109,18 @@ describe Ably::Rest do
     end
 
     describe 'token authentication failures', :webmock do
-      let(:token_1) { { id: random_str } }
-      let(:token_2) { { id: random_str } }
-      let(:channel) { 'channelname' }
+      let(:token_1) { { token: random_str } }
+      let(:token_2) { { token: random_str } }
+      let(:channel) { random_str }
 
       before do
         @token_requests = 0
         @publish_attempts = 0
 
-        stub_request(:post, "#{client.endpoint}/keys/#{key_id}/requestToken").to_return do
+        stub_request(:post, "#{client.endpoint}/keys/#{key_name}/requestToken").to_return do
           @token_requests += 1
           {
-            :body => { access_token: send("token_#{@token_requests}").merge(expires: Time.now.to_i + 3600) }.to_json,
+            :body => public_send("token_#{@token_requests}").merge(expires: (Time.now.to_i + 60) * 1000).to_json,
             :headers => { 'Content-Type' => 'application/json' }
           }
         end
@@ -143,7 +143,9 @@ describe Ably::Rest do
         it 'should automatically reissue a token' do
           client.channel(channel).publish('evt', 'msg')
           expect(@publish_attempts).to eql(1)
+          expect(@token_requests).to eql(1)
 
+          # Triggers an authentication 401 failure which should automatically request a new token
           client.channel(channel).publish('evt', 'msg')
           expect(@publish_attempts).to eql(3)
           expect(@token_requests).to eql(2)
@@ -151,7 +153,7 @@ describe Ably::Rest do
       end
 
       context 'when NOT auth#token_renewable?' do
-        let(:client) { Ably::Rest::Client.new(token_id: 'token ID cannot be used to create a new token', environment: environment, protocol: protocol) }
+        let(:client) { Ably::Rest::Client.new(token: 'token ID cannot be used to create a new token', environment: environment, protocol: protocol) }
 
         it 'should raise an InvalidToken exception' do
           client.channel(channel).publish('evt', 'msg')

data/spec/acceptance/rest/channel_spec.rb

@@ -93,15 +93,22 @@ describe Ably::Rest::Channel do
       let(:channel) { client.channel(channel_name) }
       let(:endpoint) do
         client.endpoint.tap do |client_end_point|
-          client_end_point.user = key_id
+          client_end_point.user = key_name
           client_end_point.password = key_secret
         end
       end
+      let(:default_options) do
+          {
+            direction: :backwards,
+            limit: 100
+          }
+        end
 
       [:start, :end].each do |option|
         describe ":#{option}", :webmock do
           let!(:history_stub) {
-            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/messages?#{option}=#{milliseconds}").
+            query_params = default_options.merge(option => milliseconds).map { |k, v| "#{k}=#{v}" }.join('&')
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/messages?#{query_params}").
               to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
           }
 

data/spec/acceptance/rest/client_spec.rb

@@ -12,14 +12,14 @@ describe Ably::Rest::Client do
 
     context '#initialize' do
       let(:client_id)     { random_str }
-      let(:token_request) { client.auth.create_token_request(key_id: key_id, key_secret: key_secret, client_id: client_id) }
+      let(:token_request) { client.auth.create_token_request(key_name: key_name, key_secret: key_secret, client_id: client_id) }
 
-      context 'with an auth block' do
-        let(:client) { Ably::Rest::Client.new(client_options) { token_request } }
+      context 'with a :auth_callback Proc' do
+        let(:client) { Ably::Rest::Client.new(client_options.merge(auth_callback: Proc.new { token_request })) }
 
-        it 'calls the block to get a new token' do
-          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(client_id)
+        it 'calls the auth Proc to get a new token' do
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token_details }
+          expect(client.auth.current_token_details.client_id).to eql(client_id)
         end
       end
 
@@ -32,19 +32,19 @@ describe Ably::Rest::Client do
         end
 
         it 'sends an HTTP request to the provided URL to get a new token' do
-          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(client_id)
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token_details }
+          expect(client.auth.current_token_details.client_id).to eql(client_id)
         end
       end
     end
 
     context 'using tokens' do
       let(:client) do
-        Ably::Rest::Client.new(client_options) do
+        Ably::Rest::Client.new(client_options.merge(auth_callback: Proc.new do
           @request_index ||= 0
           @request_index += 1
           send("token_request_#{@request_index > 2 ? 'next' : @request_index}")
-        end
+        end))
       end
       let(:token_request_1) { client.auth.create_token_request(token_request_options.merge(client_id: random_str)) }
       let(:token_request_2) { client.auth.create_token_request(token_request_options.merge(client_id: random_str)) }
@@ -53,30 +53,30 @@ describe Ably::Rest::Client do
       let(:token_request_next) { client.auth.create_token_request(token_request_options.merge(client_id: random_str)) }
 
       context 'when expired' do
-        let(:token_request_options) { { key_id: key_id, key_secret: key_secret, ttl: Ably::Models::Token::TOKEN_EXPIRY_BUFFER } }
+        let(:token_request_options) { { key_name: key_name, key_secret: key_secret, ttl: Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER } }
 
         it 'creates a new token automatically when the old token expires' do
-          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(token_request_1['clientId'])
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token_details }
+          expect(client.auth.current_token_details.client_id).to eql(token_request_1.client_id)
 
           sleep 1
 
-          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(token_request_2['clientId'])
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token_details }
+          expect(client.auth.current_token_details.client_id).to eql(token_request_2.client_id)
         end
       end
 
       context 'when token has not expired' do
-        let(:token_request_options) { { key_id: key_id, key_secret: key_secret, ttl: 3600 } }
+        let(:token_request_options) { { key_name: key_name, key_secret: key_secret, ttl: 3600 } }
 
         it 'reuses the existing token for every request' do
-          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(token_request_1['clientId'])
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token_details }
+          expect(client.auth.current_token_details.client_id).to eql(token_request_1.client_id)
 
           sleep 1
 
-          expect { client.channel('channel_name').publish('event', 'message') }.to_not change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(token_request_1['clientId'])
+          expect { client.channel('channel_name').publish('event', 'message') }.to_not change { client.auth.current_token_details }
+          expect(client.auth.current_token_details.client_id).to eql(token_request_1.client_id)
         end
       end
     end
@@ -245,7 +245,7 @@ describe Ably::Rest::Client do
       end
 
       context 'that times out', :webmock do
-        let(:path) { '/keys/app_id.key_id/requestToken' }
+        let(:path) { '/keys/app_id.key_name/requestToken' }
         let!(:custom_host_request_stub) do
           stub_request(:post, "https://#{custom_host}#{path}").to_return do
             raise Faraday::TimeoutError.new('timeout error message')

data/spec/acceptance/rest/presence_spec.rb

@@ -124,11 +124,18 @@ describe Ably::Rest::Presence do
         let(:client) do
           Ably::Rest::Client.new(key: "#{user}:#{secret}")
         end
+        let(:default_options) do
+          {
+            direction: :backwards,
+            limit: 100
+          }
+        end
 
         [:start, :end].each do |option|
           describe ":#{option}", :webmock do
             let!(:history_stub) {
-              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?#{option}=#{milliseconds}").
+              query_params = default_options.merge(option => milliseconds).map { |k, v| "#{k}=#{v}" }.join('&')
+              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?#{query_params}").
                 to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
             }
 
@@ -225,7 +232,7 @@ describe Ably::Rest::Presence do
 
         context '#get' do
           let!(:get_stub)   {
-            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence").
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence?limit=100").
               to_return(:body => serialized_encoded_message, :headers => { 'Content-Type' => content_type })
           }
 
@@ -242,7 +249,7 @@ describe Ably::Rest::Presence do
 
         context '#history' do
           let!(:history_stub)   {
-            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history").
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?direction=backwards&limit=100").
               to_return(:body => serialized_encoded_message, :headers => { 'Content-Type' => content_type })
           }
 
@@ -272,7 +279,7 @@ describe Ably::Rest::Presence do
         context '#get' do
           let(:client_options) { default_options.merge(log_level: :fatal) }
           let!(:get_stub)   {
-            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence").
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence?limit=100").
               to_return(:body => serialized_encoded_message_with_invalid_encoding, :headers => { 'Content-Type' => content_type })
           }
           let(:presence_message) { presence.get.items.first }
@@ -296,7 +303,7 @@ describe Ably::Rest::Presence do
         context '#history' do
           let(:client_options) { default_options.merge(log_level: :fatal) }
           let!(:history_stub)   {
-            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history").
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?direction=backwards&limit=100").
               to_return(:body => serialized_encoded_message_with_invalid_encoding, :headers => { 'Content-Type' => content_type })
           }
           let(:presence_message) { presence.history.items.first }

data/spec/acceptance/rest/stats_spec.rb

@@ -44,7 +44,7 @@ describe Ably::Rest::Client, '#stats' do
         let(:last_inbound_realtime_count)  { STATS_FIXTURES.last[:inbound][:realtime][:messages][:count] }
 
         context 'with :from set to last interval and :limit set to 1' do
-          let(:subject) { client.stats(start: as_since_epoch(LAST_INTERVAL), by: :minute, limit: 1) }
+          let(:subject) { client.stats(start: as_since_epoch(LAST_INTERVAL), end: LAST_INTERVAL, unit: :minute, limit: 1) }
           let(:stat)    { subject.items.first }
 
           it 'retrieves only one stat' do
@@ -116,7 +116,7 @@ describe Ably::Rest::Client, '#stats' do
 
         context 'with :start set to first interval, :limit set to 1 and direction :forwards' do
           let(:first_interval) { LAST_INTERVAL - 120 }
-          let(:subject)        { client.stats(start: as_since_epoch(first_interval), by: :minute, direction: :forwards, limit: 1) }
+          let(:subject)        { client.stats(start: as_since_epoch(first_interval), end: LAST_INTERVAL, unit: :minute, direction: :forwards, limit: 1) }
           let(:stat)           { subject.items.first }
 
           it 'returns the first interval stats as stats are provided forwards from :start' do
@@ -133,7 +133,7 @@ describe Ably::Rest::Client, '#stats' do
         end
 
         context 'with :end set to last interval, :limit set to 1 and direction :backwards' do
-          let(:subject)        { client.stats(:end => as_since_epoch(LAST_INTERVAL), by: :minute, direction: :backwards, limit: 1) }
+          let(:subject)        { client.stats(:end => as_since_epoch(LAST_INTERVAL), end: LAST_INTERVAL, unit: :minute, direction: :backwards, limit: 1) }
           let(:stat)           { subject.items.first }
 
           it 'returns the 3rd interval stats first as stats are provided backwards from :end' do
@@ -151,7 +151,7 @@ describe Ably::Rest::Client, '#stats' do
 
       [:hour, :day, :month].each do |interval|
         context "by #{interval}" do
-          let(:subject) { client.stats(start: as_since_epoch(LAST_INTERVAL), by: interval, direction: 'forwards', limit: 1) }
+          let(:subject) { client.stats(start: as_since_epoch(LAST_INTERVAL), end: LAST_INTERVAL, unit: interval, direction: 'forwards', limit: 1) }
           let(:stat)    { subject.items.first }
           let(:aggregate_messages_count) do
             STATS_FIXTURES.inject(0) do |sum, fixture|

data/spec/rspec_config.rb

@@ -32,8 +32,9 @@ RSpec.configure do |config|
   config.before(:example, :webmock) do
     allow(TestApp).to receive(:instance).and_return(instance_double('TestApp',
       app_id: 'app_id',
-      key_id: 'app_id.key_id',
-      api_key: 'app_id.key_id:secret',
+      key_name: 'app_id.key_name',
+      key_secret: 'secret',
+      api_key: 'app_id.key_name:secret',
       environment: 'sandbox'
     ))
     WebMock.enable!

data/spec/shared/client_initializer_behaviour.rb

@@ -54,11 +54,11 @@ shared_examples 'a client initializer' do
       end
     end
 
-    context 'key and key_id' do
-      let(:client_options) { { key: 'appid.keyuid:keysecret', key_id: 'invalid' } }
+    context 'key and key_name' do
+      let(:client_options) { { key: 'appid.keyuid:keysecret', key_name: 'invalid' } }
 
       it 'raises an exception' do
-        expect { subject }.to raise_error(ArgumentError, /key and key_id or key_secret are mutually exclusive/)
+        expect { subject }.to raise_error(ArgumentError, /key and key_name or key_secret are mutually exclusive/)
       end
     end
 
@@ -66,7 +66,7 @@ shared_examples 'a client initializer' do
       let(:client_options) { { key: 'appid.keyuid:keysecret', key_secret: 'invalid' } }
 
       it 'raises an exception' do
-        expect { subject }.to raise_error(ArgumentError, /key and key_id or key_secret are mutually exclusive/)
+        expect { subject }.to raise_error(ArgumentError, /key and key_name or key_secret are mutually exclusive/)
       end
     end
 
@@ -89,19 +89,8 @@ shared_examples 'a client initializer' do
       end
     end
 
-    context 'with legacy :api_key only' do
-      let(:default_options) { { api_key: 'api_key_id.keyuid:keysecret' } }
-      it 'connects to the Ably service' do
-        expect { subject }.to_not raise_error
-      end
-
-      it 'sets the Auth#key' do
-        expect(subject.auth.key).to eql('api_key_id.keyuid:keysecret')
-      end
-    end
-
-    context 'key_id and key_secret' do
-      let(:client_options) { { key_id: 'id', key_secret: 'secret' } }
+    context 'key_name and key_secret', api_private: true do
+      let(:client_options) { { key_name: 'id', key_secret: 'secret' } }
 
       it 'constructs an key' do
         expect(subject.auth.key).to eql('id:secret')
@@ -115,8 +104,8 @@ shared_examples 'a client initializer' do
         expect(subject.auth.key).to eql(client_options)
       end
 
-      it 'sets the key_id' do
-        expect(subject.auth.key_id).to eql('app.key')
+      it 'sets the key_name' do
+        expect(subject.auth.key_name).to eql('app.key')
       end
 
       it 'sets the key_secret' do
@@ -127,16 +116,24 @@ shared_examples 'a client initializer' do
     context 'with a string token key instead of options hash' do
       let(:client_options) { 'app.kjhkasjhdsakdh127g7g1271' }
 
-      it 'sets the token_id' do
-        expect(subject.auth.token_id).to eql(client_options)
+      it 'sets the token' do
+        expect(subject.auth.token).to eql(client_options)
       end
     end
 
     context 'with token' do
-      let(:client_options) { { token_id: 'token' } }
+      let(:client_options) { { token: 'token' } }
+
+      it 'sets the token' do
+        expect(subject.auth.token).to eql('token')
+      end
+    end
+
+    context 'with token_details' do
+      let(:client_options) { { token_details: Ably::Models::TokenDetails.new(token: 'token') } }
 
-      it 'sets the token_id' do
-        expect(subject.auth.token_id).to eql('token')
+      it 'sets the token' do
+        expect(subject.auth.token).to eql('token')
       end
     end
 

data/spec/support/api_helper.rb

@@ -5,12 +5,12 @@ module ApiHelper
     TestApp.instance.app_id
   end
 
-  def key_id
-    TestApp.instance.key_id
+  def key_name
+    TestApp.instance.key_name
   end
 
   def key_secret
-    api_key.split(':')[1]
+    TestApp.instance.key_secret
   end
 
   def api_key

data/spec/support/test_app.rb

@@ -27,31 +27,31 @@ class TestApp
   end
 
   def app_id
-    @attributes["appId"]
+    @attributes.fetch('appId')
   end
 
   def key
-    @attributes["keys"].first
+    @attributes.fetch('keys').first
   end
 
   def restricted_key
-    @attributes["keys"][1]
+    @attributes.fetch('keys')[1]
   end
 
-  def key_id
-    "#{app_id}.#{key['id']}"
+  def key_name
+    key.fetch('keyName')
   end
 
-  def key_value
-    key['value']
+  def key_secret
+    key.fetch('keySecret')
   end
 
   def api_key
-    "#{key_id}:#{key_value}"
+    key.fetch('keyStr')
   end
 
   def restricted_api_key
-    "#{app_id}.#{restricted_key['id']}:#{restricted_key['value']}"
+    restricted_key.fetch('keyStr')
   end
 
   def delete

data/spec/unit/auth_spec.rb

@@ -65,4 +65,21 @@ describe Ably::Auth do
       end
     end
   end
+
+  context 'defaults' do
+    let(:one_hour)          { 60 * 60 }
+    let(:all_capabilities)  { { "*" => ["*"] } }
+
+    it 'should default TTL to 1 hour' do
+      expect(Ably::Auth::TOKEN_DEFAULTS.fetch(:ttl)).to eql(one_hour)
+    end
+
+    it 'should default capability to all' do
+      expect(Ably::Auth::TOKEN_DEFAULTS.fetch(:capability)).to eql(all_capabilities)
+    end
+
+    it 'should only have defaults for :ttl and :capability' do
+      expect(Ably::Auth::TOKEN_DEFAULTS.keys).to contain_exactly(:ttl, :capability)
+    end
+  end
 end

data/spec/unit/models/token_details_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::TokenDetails do
+  include Ably::Modules::Conversions
+
+  subject { Ably::Models::TokenDetails }
+
+  it_behaves_like 'a model', with_simple_attributes: %w(token key_name client_id) do
+    let(:model_args) { [] }
+  end
+
+
+  context 'attributes' do
+    let(:capability) { { "value" => random_str } }
+    let(:capability_str) { JSON.dump(capability) }
+
+    context '#capability' do
+      subject { Ably::Models::TokenDetails.new({ capability: capability_str }) }
+
+      it 'retrieves attribute :capability as parsed JSON' do
+        expect(subject.capability).to eql(capability)
+      end
+    end
+
+    { :issued => :issued, :expires => :expires }.each do |method_name, attribute|
+      let(:time) { Time.now }
+      context "##{method_name} with :#{method_name} option as milliseconds in constructor" do
+        subject { Ably::Models::TokenDetails.new({ attribute.to_sym => time.to_i * 1000 }) }
+
+        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
+
+      context "##{method_name} with :#{method_name} option as a Time in constructor" do
+        subject { Ably::Models::TokenDetails.new({ attribute.to_sym => time }) }
+
+        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
+
+      context "##{method_name} when converted to JSON" do
+        subject { Ably::Models::TokenDetails.new({ attribute.to_sym => time }) }
+
+        it 'is in milliseconds' do
+          expect(JSON.parse(JSON.dump(subject))[convert_to_mixed_case(attribute)]).to eql((time.to_f * 1000).round)
+        end
+      end
+    end
+
+    context '#expired?' do
+      let(:expire_time) { Time.now + Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER }
+
+      context 'once grace period buffer has passed' do
+        subject { Ably::Models::TokenDetails.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::TokenDetails.new(expires: expire_time + 1) }
+
+        it 'is false' do
+          expect(subject.expired?).to eql(false)
+        end
+      end
+    end
+  end
+
+  context '==' do
+    let(:token_attributes) { { token: 'unique' } }
+
+    it 'is true when attributes are the same' do
+      new_token = -> { Ably::Models::TokenDetails.new(token_attributes) }
+      expect(new_token[]).to eq(new_token[])
+    end
+
+    it 'is false when attributes are not the same' do
+      expect(Ably::Models::TokenDetails.new(token: 1)).to_not eq(Ably::Models::TokenDetails.new(token: 2))
+    end
+
+    it 'is false when class type differs' do
+      expect(Ably::Models::TokenDetails.new(token: 1)).to_not eq(nil)
+    end
+  end
+
+  context 'TokenDetails conversion methods', :api_private do
+    context 'with a TokenDetails object' do
+      let(:token_details) { Ably::Models::TokenDetails.new(client_id: random_str) }
+
+      it 'returns the TokenDetails object' do
+        expect(Ably::Models::TokenDetails(token_details)).to eql(token_details)
+      end
+    end
+
+    context 'with a JSON object' do
+      let(:client_id) { random_str }
+      let(:token_details_json) { { client_id: client_id } }
+
+      it 'returns a new TokenDetails object from the JSON' do
+        expect(Ably::Models::TokenDetails(token_details_json).client_id).to eql(client_id)
+      end
+    end
+  end
+end