ably 0.7.5 → 0.7.6

data/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/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_id' do
+      let(:client_options) { { key: 'appid.keyuid:keysecret', key_id: '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_id 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_id or key_secret are mutually exclusive/)
       end
     end
 
@@ -80,28 +80,39 @@ 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 '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' } }
 
-      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

data/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/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/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
@@ -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

data/spec/unit/auth_spec.rb

@@ -4,7 +4,7 @@ require 'shared/protocol_msgbus_behaviour'
 describe Ably::Auth do
   let(:client)    { double('client').as_null_object }
   let(:client_id) { nil }
-  let(:options)   { { api_key: 'appid.keyuid:keysecret', client_id: client_id } }
+  let(:options)   { { key: 'appid.keyuid:keysecret', client_id: client_id } }
 
   subject do
     Ably::Auth.new(client, options)

data/spec/unit/models/paginated_resource_spec.rb

@@ -5,7 +5,7 @@ describe Ably::Models::PaginatedResource do
   let(:paginated_resource_class) { Ably::Models::PaginatedResource }
   let(:headers) { Hash.new }
   let(:client) do
-    instance_double('Ably::Rest::Client', logger: true).tap do |client|
+    instance_double('Ably::Rest::Client', logger: Ably::Models::NilLogger.new).tap do |client|
       allow(client).to receive(:get).and_return(http_response)
     end
   end
@@ -27,57 +27,54 @@ describe Ably::Models::PaginatedResource do
   let(:first_paged_request) { paginated_resource_class.new(http_response, full_url, client, paginated_resource_options) }
   subject { first_paged_request }
 
-  it 'returns correct length from body' do
-    expect(subject.length).to eql(body.length)
-  end
-
-  it 'supports alias methods for length' do
-    expect(subject.count).to eql(subject.length)
-    expect(subject.size).to eql(subject.length)
-  end
-
-  it 'is Enumerable' do
-    expect(subject).to be_kind_of(Enumerable)
-  end
+  context '#items' do
+    it 'returns correct length from body' do
+      expect(subject.items.length).to eql(body.length)
+    end
 
-  it 'is iterable' do
-    expect(subject.map { |d| d }).to eql(body)
-  end
+    it 'is Enumerable' do
+      expect(subject.items).to be_kind_of(Enumerable)
+    end
 
-  context '#each' do
-    it 'returns an enumerator' do
-      expect(subject.each).to be_a(Enumerator)
+    it 'is iterable' do
+      expect(subject.items.map { |d| d }).to eql(body)
     end
 
-    it 'yields each item' do
-      items = []
-      subject.each do |item|
-        items << item
+    context '#each' do
+      it 'returns an enumerator' do
+        expect(subject.items.each).to be_a(Enumerator)
+      end
+
+      it 'yields each item' do
+        items = []
+        subject.items.each do |item|
+          items << item
+        end
+        expect(items).to eq(body)
       end
-      expect(items).to eq(body)
     end
-  end
 
-  it 'provides [] accessor method' do
-    expect(subject[0][:id]).to eql(body[0][:id])
-    expect(subject[1][:id]).to eql(body[1][:id])
-    expect(subject[2]).to be_nil
-  end
+    it 'provides [] accessor method' do
+      expect(subject.items[0][:id]).to eql(body[0][:id])
+      expect(subject.items[1][:id]).to eql(body[1][:id])
+      expect(subject.items[2]).to be_nil
+    end
 
-  specify '#first gets the first item in page' do
-    expect(subject.first[:id]).to eql(body[0][:id])
-  end
+    specify '#first gets the first item in page' do
+      expect(subject.items.first[:id]).to eql(body[0][:id])
+    end
 
-  specify '#last gets the last item in page' do
-    expect(subject.last[:id]).to eql(body[1][:id])
-  end
+    specify '#last gets the last item in page' do
+      expect(subject.items.last[:id]).to eql(body[1][:id])
+    end
 
-  context 'with coercion', :api_private do
-    let(:paginated_resource_options) { { coerce_into: 'OpenStruct' } }
+    context 'with coercion', :api_private do
+      let(:paginated_resource_options) { { coerce_into: 'OpenStruct' } }
 
-    it 'returns coerced objects' do
-      expect(subject.first).to be_a(OpenStruct)
-      expect(subject.first.id).to eql(body.first[:id])
+      it 'returns coerced objects' do
+        expect(subject.items.first).to be_a(OpenStruct)
+        expect(subject.items.first.id).to eql(body.first[:id])
+      end
     end
   end
 
@@ -90,7 +87,7 @@ describe Ably::Models::PaginatedResource do
       }
     end
     let(:paged_client) do
-      instance_double('Ably::Rest::Client', logger: true).tap do |client|
+      instance_double('Ably::Rest::Client', logger: Ably::Models::NilLogger.new).tap do |client|
         allow(client).to receive(:get).and_return(http_response_page2)
       end
     end
@@ -116,15 +113,15 @@ describe Ably::Models::PaginatedResource do
       end
 
       it 'calls the block for each resource after retrieving the resources' do
-        expect(subject[0][:added_attribute_from_block]).to eql("id:#{body[0][:id]}")
+        expect(subject.items[0][:added_attribute_from_block]).to eql("id:#{body[0][:id]}")
       end
 
       it 'calls the block for each resource on second page after retrieving the resources' do
-        page_1_first_id = subject[0][:id]
-        next_page = subject.next_page
+        page_1_first_id = subject.items[0][:id]
+        next_page = subject.next
 
-        expect(next_page[0][:added_attribute_from_block]).to eql("id:#{body_page2[0][:id]}")
-        expect(next_page[0][:id]).to_not eql(page_1_first_id)
+        expect(next_page.items[0][:added_attribute_from_block]).to eql("id:#{body_page2[0][:id]}")
+        expect(next_page.items[0][:id]).to_not eql(page_1_first_id)
       end
     end
 
@@ -136,17 +133,17 @@ describe Ably::Models::PaginatedResource do
           paginated_resource_class.new(http_response, full_url, paged_client, async_blocking_operations: true)
         end
 
-        context '#next_page' do
+        context '#next' do
           it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
             run_reactor do
-              expect(subject.next_page).to be_a(Ably::Util::SafeDeferrable)
+              expect(subject.next).to be_a(Ably::Util::SafeDeferrable)
               stop_reactor
             end
           end
 
           it 'allows a success callback block to be added' do
             run_reactor do
-              subject.next_page do |paginated_resource|
+              subject.next do |paginated_resource|
                 expect(paginated_resource).to be_a(Ably::Models::PaginatedResource)
                 stop_reactor
               end
@@ -154,11 +151,11 @@ describe Ably::Models::PaginatedResource do
           end
         end
 
-        context '#first_page' do
+        context '#first' do
           it 'calls the errback callback when first page headers are missing' do
             run_reactor do
-              subject.next_page do |paginated_resource|
-                deferrable = subject.first_page
+              subject.next do |paginated_resource|
+                deferrable = subject.first
                 deferrable.errback do |error|
                   expect(error).to be_a(Ably::Exceptions::InvalidPageError)
                   stop_reactor
@@ -173,23 +170,27 @@ describe Ably::Models::PaginatedResource do
 
   context 'with non paged http response' do
     it 'is the first page' do
-      expect(subject).to be_first_page
+      expect(subject).to be_first
     end
 
     it 'is the last page' do
-      expect(subject).to be_last_page
+      expect(subject).to be_last
+    end
+
+    it 'does not have next page' do
+      expect(subject).to_not have_next
     end
 
     it 'does not support pagination' do
       expect(subject.supports_pagination?).to_not eql(true)
     end
 
-    it 'raises an exception when accessing next page' do
-      expect { subject.next_page }.to raise_error Ably::Exceptions::InvalidPageError, /Paging header link next/
+    it 'returns nil when accessing next page' do
+      expect(subject.next).to be_nil
     end
 
-    it 'raises an exception when accessing first page' do
-      expect { subject.first_page }.to raise_error Ably::Exceptions::InvalidPageError, /Paging header link first/
+    it 'returns nil when accessing first page' do
+      expect(subject.first).to be_nil
     end
   end
 
@@ -207,11 +208,15 @@ describe Ably::Models::PaginatedResource do
     end
 
     it 'is the first page' do
-      expect(subject).to be_first_page
+      expect(subject).to be_first
+    end
+
+    it 'has next page' do
+      expect(subject).to have_next
     end
 
     it 'is not the last page' do
-      expect(subject).to_not be_last_page
+      expect(subject).to_not be_last
     end
 
     it 'supports pagination' do
@@ -236,7 +241,7 @@ describe Ably::Models::PaginatedResource do
           headers: next_headers
         })
       end
-      let(:subject) { first_paged_request.next_page }
+      let(:subject) { first_paged_request.next }
 
       before do
         expect(client).to receive(:get).with("#{base_url}/history?index=1").and_return(next_http_response).once
@@ -247,39 +252,43 @@ describe Ably::Models::PaginatedResource do
       end
 
       it 'retrieves the next page of results' do
-        expect(subject.length).to eql(next_body.length)
-        expect(subject[0][:id]).to eql(next_body[0][:id])
+        expect(subject.items.length).to eql(next_body.length)
+        expect(subject.items[0][:id]).to eql(next_body[0][:id])
       end
 
       it 'is not the first page' do
-        expect(subject).to_not be_first_page
+        expect(subject).to_not be_first
+      end
+
+      it 'does not have a next page' do
+        expect(subject).to_not have_next
       end
 
       it 'is the last page' do
-        expect(subject).to be_last_page
+        expect(subject).to be_last
       end
 
-      it 'raises an exception if trying to access the last page when it is the last page' do
-        expect(subject).to be_last_page
-        expect { subject.next_page }.to raise_error Ably::Exceptions::InvalidPageError, /There are no more pages/
+      it 'returns nil when trying to access the last page when it is the last page' do
+        expect(subject).to be_last
+        expect(subject.next).to be_nil
       end
 
       context 'and then first page' do
         before do
           expect(client).to receive(:get).with("#{base_url}/history?index=0").and_return(http_response).once
         end
-        subject { first_paged_request.next_page.first_page }
+        subject { first_paged_request.next.first }
 
         it 'returns a PaginatedResource' do
           expect(subject).to be_a(paginated_resource_class)
         end
 
         it 'retrieves the first page of results' do
-          expect(subject.length).to eql(body.length)
+          expect(subject.items.length).to eql(body.length)
         end
 
         it 'is the first page' do
-          expect(subject).to be_first_page
+          expect(subject).to be_first
         end
       end
     end