ably-rest 0.7.5 → 0.8.1

data/lib/submodules/ably-ruby/spec/acceptance/rest/stats_spec.rb

@@ -9,17 +9,17 @@ describe Ably::Rest::Client, '#stats' do
 
   STATS_FIXTURES = [
     {
-      intervalId: Ably::Models::Stat.to_interval_id(LAST_INTERVAL - 120, :minute),
+      intervalId: Ably::Models::Stats.to_interval_id(LAST_INTERVAL - 120, :minute),
       inbound:  { realtime: { messages: { count: 50, data: 5000 } } },
       outbound: { realtime: { messages: { count: 20, data: 2000 } } }
     },
     {
-      intervalId: Ably::Models::Stat.to_interval_id(LAST_INTERVAL - 60, :minute),
+      intervalId: Ably::Models::Stats.to_interval_id(LAST_INTERVAL - 60, :minute),
       inbound:  { realtime: { messages: { count: 60, data: 6000 } } },
       outbound: { realtime: { messages: { count: 10, data: 1000 } } }
     },
     {
-      intervalId: Ably::Models::Stat.to_interval_id(LAST_INTERVAL, :minute),
+      intervalId: Ably::Models::Stats.to_interval_id(LAST_INTERVAL, :minute),
       inbound:       { realtime: { messages: { count: 70, data: 7000 } } },
       outbound:      { realtime: { messages: { count: 40, data: 4000 } } },
       persisted:     { presence: { count: 20, data: 2000 } },
@@ -36,7 +36,7 @@ describe Ably::Rest::Client, '#stats' do
   end
 
   vary_by_protocol do
-    let(:client) {  Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol) }
+    let(:client) {  Ably::Rest::Client.new(key: api_key, environment: environment, protocol: protocol) }
 
     describe 'fetching application stats' do
       context 'by minute' do
@@ -44,56 +44,61 @@ 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(:stat)    { subject.first}
+          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
-            expect(subject.count).to eql(1)
+            expect(subject.items.count).to eql(1)
+          end
+
+          it 'returns zero value for any missing metrics' do
+            expect(stat.channels.refused).to eql(0)
+            expect(stat.outbound.webhook.all.count).to eql(0)
           end
 
           it 'returns all aggregated message data' do
-            expect(stat.all[:messages][:count]).to eql(70 + 40) # inbound + outbound
-            expect(stat.all[:messages][:data]).to eql(7000 + 4000) # inbound + outbound
+            expect(stat.all.messages.count).to eql(70 + 40) # inbound + outbound
+            expect(stat.all.messages.data).to eql(7000 + 4000) # inbound + outbound
           end
 
           it 'returns inbound realtime all data' do
-            expect(stat.inbound[:realtime][:all][:count]).to eql(70)
-            expect(stat.inbound[:realtime][:all][:data]).to eql(7000)
+            expect(stat.inbound.realtime.all.count).to eql(70)
+            expect(stat.inbound.realtime.all.data).to eql(7000)
           end
 
           it 'returns inbound realtime message data' do
-            expect(stat.inbound[:realtime][:messages][:count]).to eql(70)
-            expect(stat.inbound[:realtime][:messages][:data]).to eql(7000)
+            expect(stat.inbound.realtime.messages.count).to eql(70)
+            expect(stat.inbound.realtime.messages.data).to eql(7000)
           end
 
           it 'returns outbound realtime all data' do
-            expect(stat.outbound[:realtime][:all][:count]).to eql(40)
-            expect(stat.outbound[:realtime][:all][:data]).to eql(4000)
+            expect(stat.outbound.realtime.all.count).to eql(40)
+            expect(stat.outbound.realtime.all.data).to eql(4000)
           end
 
           it 'returns persisted presence all data' do
-            expect(stat.persisted[:all][:count]).to eql(20)
-            expect(stat.persisted[:all][:data]).to eql(2000)
+            expect(stat.persisted.all.count).to eql(20)
+            expect(stat.persisted.all.data).to eql(2000)
           end
 
           it 'returns connections all data' do
-            expect(stat.connections[:tls][:peak]).to eql(20)
-            expect(stat.connections[:tls][:opened]).to eql(10)
+            expect(stat.connections.tls.peak).to eql(20)
+            expect(stat.connections.tls.opened).to eql(10)
           end
 
           it 'returns channels all data' do
-            expect(stat.channels[:peak]).to eql(50)
-            expect(stat.channels[:opened]).to eql(30)
+            expect(stat.channels.peak).to eql(50)
+            expect(stat.channels.opened).to eql(30)
           end
 
           it 'returns api_requests data' do
-            expect(stat.api_requests[:succeeded]).to eql(50)
-            expect(stat.api_requests[:failed]).to eql(10)
+            expect(stat.api_requests.succeeded).to eql(50)
+            expect(stat.api_requests.failed).to eql(10)
           end
 
           it 'returns token_requests data' do
-            expect(stat.token_requests[:succeeded]).to eql(60)
-            expect(stat.token_requests[:failed]).to eql(20)
+            expect(stat.token_requests.succeeded).to eql(60)
+            expect(stat.token_requests.failed).to eql(20)
           end
 
           it 'returns stat objects with #interval_granularity equal to :minute' do
@@ -111,43 +116,43 @@ 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(:stat)           { subject.first}
+          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
-            expect(stat.inbound[:realtime][:all][:count]).to eql(first_inbound_realtime_count)
+            expect(stat.inbound.realtime.all.count).to eql(first_inbound_realtime_count)
           end
 
           it 'returns 3 pages of stats' do
-            expect(subject).to be_first_page
-            expect(subject).to_not be_last_page
-            page3 = subject.next_page.next_page
-            expect(page3).to be_last_page
-            expect(page3.first.inbound[:realtime][:all][:count]).to eql(last_inbound_realtime_count)
+            expect(subject).to be_first
+            expect(subject).to_not be_last
+            page3 = subject.next.next
+            expect(page3).to be_last
+            expect(page3.items.first.inbound.realtime.all.count).to eql(last_inbound_realtime_count)
           end
         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(:stat)           { subject.first}
+          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
-            expect(stat.inbound[:realtime][:all][:count]).to eql(last_inbound_realtime_count)
+            expect(stat.inbound.realtime.all.count).to eql(last_inbound_realtime_count)
           end
 
           it 'returns 3 pages of stats' do
-            expect(subject).to be_first_page
-            expect(subject).to_not be_last_page
-            page3 = subject.next_page.next_page
-            expect(page3.first.inbound[:realtime][:all][:count]).to eql(first_inbound_realtime_count)
+            expect(subject).to be_first
+            expect(subject).to_not be_last
+            page3 = subject.next.next
+            expect(page3.items.first.inbound.realtime.all.count).to eql(first_inbound_realtime_count)
           end
         end
       end
 
       [: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(:stat)    { subject.first }
+          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|
               sum + fixture[:inbound][:realtime][:messages][:count] + fixture[:outbound][:realtime][:messages][:count]
@@ -160,10 +165,10 @@ describe Ably::Rest::Client, '#stats' do
           end
 
           it 'should aggregate the stats for that period' do
-            expect(subject.count).to eql(1)
+            expect(subject.items.count).to eql(1)
 
-            expect(stat.all[:messages][:count]).to eql(aggregate_messages_count)
-            expect(stat.all[:messages][:data]).to eql(aggregate_messages_data)
+            expect(stat.all.messages.count).to eql(aggregate_messages_count)
+            expect(stat.all.messages.data).to eql(aggregate_messages_data)
           end
         end
       end

data/lib/submodules/ably-ruby/spec/acceptance/rest/time_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Ably::Rest::Client, '#time' do
   vary_by_protocol do
     let(:client) do
-      Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+      Ably::Rest::Client.new(key: api_key, environment: environment, protocol: protocol)
     end
 
     describe 'fetching the service time' do

data/lib/submodules/ably-ruby/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/lib/submodules/ably-ruby/spec/shared/client_initializer_behaviour.rb

@@ -26,7 +26,7 @@ shared_examples 'a client initializer' do
       let(:client_options) { Hash.new }
 
       it 'raises an exception' do
-        expect { subject }.to raise_error(ArgumentError, /api_key is missing/)
+        expect { subject }.to raise_error(ArgumentError, /key is missing/)
       end
     end
 
@@ -38,35 +38,35 @@ shared_examples 'a client initializer' do
       end
     end
 
-    context 'api_key: "invalid"' do
-      let(:client_options) { { api_key: 'invalid' } }
+    context 'key: "invalid"' do
+      let(:client_options) { { key: 'invalid' } }
 
       it 'raises an exception' do
-        expect { subject }.to raise_error(ArgumentError, /api_key is invalid/)
+        expect { subject }.to raise_error(ArgumentError, /key is invalid/)
       end
     end
 
-    context 'api_key: "invalid:asdad"' do
-      let(:client_options) { { api_key: 'invalid:asdad' } }
+    context 'key: "invalid:asdad"' do
+      let(:client_options) { { key: 'invalid:asdad' } }
 
       it 'raises an exception' do
-        expect { subject }.to raise_error(ArgumentError, /api_key is invalid/)
+        expect { subject }.to raise_error(ArgumentError, /key is invalid/)
       end
     end
 
-    context 'api_key and key_id' do
-      let(:client_options) { { api_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, /api_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
 
-    context 'api_key and key_secret' do
-      let(:client_options) { { api_key: 'appid.keyuid:keysecret', key_secret: 'invalid' } }
+    context 'key and key_secret' do
+      let(:client_options) { { key: 'appid.keyuid:keysecret', key_secret: 'invalid' } }
 
       it 'raises an exception' do
-        expect { subject }.to raise_error(ArgumentError, /api_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
 
@@ -80,32 +80,32 @@ shared_examples 'a client initializer' do
   end
 
   context 'with valid arguments' do
-    let(:default_options) { { api_key: 'appid.keyuid:keysecret' } }
+    let(:default_options) { { key: 'appid.keyuid:keysecret' } }
     let(:client_options)  { default_options }
 
-    context 'api_key only' do
+    context 'key only' do
       it 'connects to the Ably service' do
         expect { subject }.to_not raise_error
       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 api_key' do
-        expect(subject.auth.api_key).to eql('id:secret')
+      it 'constructs an key' do
+        expect(subject.auth.key).to eql('id:secret')
       end
     end
 
     context 'with a string key instead of options hash' do
       let(:client_options) { 'app.key:secret' }
 
-      it 'sets the api_key' do
-        expect(subject.auth.api_key).to eql(client_options)
+      it 'sets the key' 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
@@ -116,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_id' do
-        expect(subject.auth.token_id).to eql('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' do
+        expect(subject.auth.token).to eql('token')
       end
     end
 

data/lib/submodules/ably-ruby/spec/spec_helper.rb

@@ -4,6 +4,9 @@ def console(message)
   puts "\033[31m[#{Time.now.strftime('%H:%M:%S.%L')}]\033[0m \033[33m#{message}\033[0m"
 end
 
+require 'coveralls'
+Coveralls.wear!
+
 require 'webmock/rspec'
 
 require 'ably'

data/lib/submodules/ably-ruby/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/lib/submodules/ably-ruby/spec/support/markdown_spec_formatter.rb

@@ -24,7 +24,7 @@ module Ably
       def start(notification)
         puts "\n\e[33m --> Creating SPEC.md <--\e[0m\n"
         scope = if defined?(Ably::Realtime)
-          'Real-time & REST'
+          'Realtime & REST'
         else
           'REST'
         end

data/lib/submodules/ably-ruby/spec/support/test_app.rb

@@ -1,28 +1,15 @@
 require 'singleton'
 
 class TestApp
-  APP_SPEC = {
-    'keys' => [
-      {},
-      {
-        'capability' => '{ "cansubscribe:*":["subscribe"], "canpublish:*":["publish"], "canpublish:andpresence":["presence","publish"] }'
-      }
-    ],
-    'namespaces' => [
-      { 'id' => 'persisted', 'persisted' => true }
-    ],
-    'channels' => [
-      {
-        'name' => 'persisted:presence_fixtures',
-        'presence' => [
-          { 'clientId' => 'client_bool',    'data' => 'true' },
-          { 'clientId' => 'client_int',     'data' => '24' },
-          { 'clientId' => 'client_string',  'data' => 'This is a string clientData payload' },
-          { 'clientId' => 'client_json',    'data' => '{ "test" => \'This is a JSONObject clientData payload\'}' }
-        ]
-      }
-    ]
-  }
+  TEST_RESOURCES_PATH = File.expand_path('../../../lib/submodules/ably-common/test-resources', __FILE__)
+
+  # App configuration for test app
+  # See https://github.com/ably/ably-common/blob/master/test-resources/test-app-setup.json
+  APP_SPEC = JSON.parse(File.read(File.join(TEST_RESOURCES_PATH, 'test-app-setup.json')))['post_apps']
+
+  # Cipher details used for client_encoded presence data in test app
+  # See https://github.com/ably/ably-common/blob/master/test-resources/test-app-setup.json
+  APP_SPEC_CIPHER = JSON.parse(File.read(File.join(TEST_RESOURCES_PATH, 'test-app-setup.json')))['cipher']
 
   # If an app has already been created and we need a new app, create a new test app
   # This is sometimes needed when a test needs to be isolated from any other tests
@@ -40,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
@@ -107,13 +94,13 @@ class TestApp
   end
 
   def create_test_stats(stats)
-    client = Ably::Rest::Client.new(api_key: api_key, environment: environment)
+    client = Ably::Rest::Client.new(key: api_key, environment: environment)
     response = client.post('/stats', stats)
     raise "Could not create stats fixtures.  Ably responded with status #{response.status}\n#{response.body}" unless (200..299).include?(response.status)
   end
 
   private
   def sandbox_client
-    @sandbox_client ||= Ably::Rest::Client.new(api_key: 'app.key:secret', tls: true, environment: environment)
+    @sandbox_client ||= Ably::Rest::Client.new(key: 'app.key:secret', tls: true, environment: environment)
   end
 end