ably-rest 0.7.3 → 0.7.5

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

@@ -14,8 +14,8 @@ describe Ably::Realtime::Client, '#stats', :event_machine do
         end
       end
 
-      it 'should return a Deferrable object' do
-        expect(client.stats).to be_a(EventMachine::Deferrable)
+      it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
+        expect(client.stats).to be_a(Ably::Util::SafeDeferrable)
         stop_reactor
       end
     end

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

@@ -16,9 +16,9 @@ describe Ably::Realtime::Client, '#time', :event_machine do
         end
       end
 
-      it 'should return a deferrable object' do
+      it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
         run_reactor do
-          expect(client.time).to be_a(EventMachine::Deferrable)
+          expect(client.time).to be_a(Ably::Util::SafeDeferrable)
           stop_reactor
         end
       end

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

@@ -146,7 +146,7 @@ describe Ably::Auth do
 
       context 'with :auth_url option', :webmock do
         let(:auth_url)          { 'https://www.fictitious.com/get_token' }
-        let(:token_request)     { { id: key_id } }
+        let(:auth_url_response) { { id: key_id } }
         let(:token_response)    { { access_token: { } } }
         let(:query_params)      { nil }
         let(:headers)           { nil }
@@ -166,7 +166,7 @@ describe Ably::Auth do
           stub.with(:headers => headers) unless headers.nil?
           stub.to_return(
             :status => 201,
-            :body => token_request.to_json,
+            :body => auth_url_response.to_json,
             :headers => { 'Content-Type' => 'application/json' }
           )
         end
@@ -182,14 +182,18 @@ describe Ably::Auth do
             )
         end
 
-        context 'when response is valid' do
-          before { auth.request_token options }
+        context 'when response from :auth_url is a valid token request' do
+          let!(:token) { auth.request_token(options) }
 
           it 'requests a token from :auth_url using an HTTP GET request' do
             expect(request_token_stub).to have_been_requested
             expect(auth_url_request_stub).to have_been_requested
           end
 
+          it 'returns a valid token generated from the token request' do
+            expect(token).to be_a(Ably::Models::Token)
+          end
+
           context 'with :query_params' do
             let(:query_params) { { 'key' => random_str } }
 
@@ -216,6 +220,32 @@ describe Ably::Auth do
           end
         end
 
+        context 'when response from :auth_url is a token' do
+          let(:token_id) { 'J_0Tlg.D7AVZkdOZW-PqNNGvCSp38' }
+          let(:issued_at) { Time.now }
+          let(:expires) { Time.now + 60}
+          let(:capability) { {'foo'=>['publish']} }
+          let(:auth_url_response) do
+            {
+              'id' => token_id,
+              'key' => 'J_0Tlg.NxCRig',
+              'issued_at' => issued_at.to_i,
+              'expires' => expires.to_i,
+              'capability'=> capability
+            }
+          end
+
+          let!(:token) { auth.request_token(options) }
+
+          it 'returns a Token created from the token JSON' do
+            expect(request_token_stub).to_not have_been_requested
+            expect(token.id).to eql(token_id)
+            expect(token.expires_at).to be_within(1).of(expires)
+            expect(token.issued_at).to be_within(1).of(issued_at)
+            expect(token.capability.to_json).to eql(capability.to_json)
+          end
+        end
+
         context 'when response is invalid' do
           context '500' do
             let!(:auth_url_request_stub) do
@@ -240,10 +270,10 @@ describe Ably::Auth do
         end
       end
 
-      context 'with token_request_block' do
+      context 'with token_request_block that returns a token request' do
         let(:client_id) { random_str }
         let(:options) { { client_id: client_id } }
-        let!(:token) do
+        let!(:request_token) do
           auth.request_token(options) do |block_options|
             @block_called = true
             @block_options = block_options
@@ -257,7 +287,66 @@ describe Ably::Auth do
         end
 
         it 'uses the token request from the block when requesting a new token' do
-          expect(token.client_id).to eql(client_id)
+          expect(request_token.client_id).to eql(client_id)
+        end
+      end
+
+      context 'with token_request_block that returns a token' do
+        let(:client_id)   { random_str }
+        let(:options)     { { client_id: client_id } }
+        let(:token_id)    { 'J_0Tlg.D7AVZkdOZW-PqNNGvCSp38' }
+        let(:issued_at)   { Time.now }
+        let(:expires)     { Time.now + 60}
+        let(:capability)  { {'foo'=>['publish']} }
+
+        let!(:request_token) do
+          auth.request_token(options) do |block_options|
+            @block_called = true
+            @block_options = block_options
+            {
+              'id' => token_id,
+              'key' => 'J_0Tlg.NxCRig',
+              'client_id' => client_id,
+              'issued_at' => issued_at.to_i,
+              'expires' => expires.to_i,
+              'capability'=> capability
+            }
+          end
+        end
+
+        it 'calls the block when authenticating to obtain the request token' do
+          expect(@block_called).to eql(true)
+          expect(@block_options).to include(options)
+        end
+
+        it 'uses the token request from the block when requesting a new token' do
+          expect(request_token).to be_a(Ably::Models::Token)
+          expect(request_token.id).to eql(token_id)
+          expect(request_token.client_id).to eql(client_id)
+          expect(request_token.expires_at).to be_within(1).of(expires)
+          expect(request_token.issued_at).to be_within(1).of(issued_at)
+          expect(request_token.capability.to_json).to eql(capability.to_json)
+        end
+      end
+
+      context 'persisted option', api_private: true do
+        context 'when set to true', api_private: true do
+          let(:options) { { persisted: true } }
+          let(:token) { auth.request_token(options) }
+
+          it 'returns a token with a short token ID that is used to look up the token details' do
+            expect(token.id.length).to be < 64
+            expect(token.id).to match(/^#{app_id}\.A/)
+          end
+        end
+
+        context 'when omitted', api_private: true do
+          let(:options) { { } }
+          let(:token) { auth.request_token(options) }
+
+          it 'returns a literal token' do
+            expect(token.id.length).to be > 64
+          end
         end
       end
     end

data/lib/submodules/ably-ruby/spec/shared/client_initializer_behaviour.rb

@@ -113,6 +113,14 @@ shared_examples 'a client initializer' do
       end
     end
 
+    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)
+      end
+    end
+
     context 'with token' do
       let(:client_options) { { token_id: 'token' } }
 

data/lib/submodules/ably-ruby/spec/shared/safe_deferrable_behaviour.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+shared_examples 'a safe Deferrable' do
+  let(:logger) { instance_double('Logger') }
+  let(:arguments) { [random_str] }
+  let(:errback_calls) { [] }
+  let(:success_calls) { [] }
+  let(:exception) { StandardError.new("Intentional error") }
+
+  before do
+    allow(subject).to receive(:logger).and_return(logger)
+  end
+
+  context '#errback' do
+    it 'adds a callback that is called when #fail is called' do
+      subject.errback do |*args|
+        expect(args).to eql(arguments)
+      end
+      subject.fail *arguments
+    end
+
+    it 'catches exceptions in the callback and logs the error to the logger' do
+      expect(subject.send(:logger)).to receive(:error).with(/#{exception.message}/)
+      subject.errback do
+        raise exception
+      end
+      subject.fail
+    end
+  end
+
+  context '#fail' do
+    it 'calls the callbacks defined with #errback, but not the ones added for success #callback' do
+      3.times do
+        subject.errback  { errback_calls << true }
+        subject.callback { success_calls << true }
+      end
+      subject.fail *arguments
+      expect(errback_calls.count).to eql(3)
+      expect(success_calls.count).to eql(0)
+    end
+  end
+
+  context '#callback' do
+    it 'adds a callback that is called when #succed is called' do
+      subject.callback do |*args|
+        expect(args).to eql(arguments)
+      end
+      subject.succeed *arguments
+    end
+
+    it 'catches exceptions in the callback and logs the error to the logger' do
+      expect(subject.send(:logger)).to receive(:error).with(/#{exception.message}/)
+      subject.callback do
+        raise exception
+      end
+      subject.succeed
+    end
+  end
+
+  context '#succeed' do
+    it 'calls the callbacks defined with #callback, but not the ones added for #errback' do
+      3.times do
+        subject.errback  { errback_calls << true }
+        subject.callback { success_calls << true }
+      end
+      subject.succeed *arguments
+      expect(success_calls.count).to eql(3)
+      expect(errback_calls.count).to eql(0)
+    end
+  end
+end

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

@@ -44,7 +44,7 @@ RSpec.configure do |config|
 
   config.after(:suite) do
     WebMock.disable!
-    TestApp.instance.delete
+    TestApp.instance.delete if TestApp.instance_variable_get('@singleton__instance__')
   end
 end
 

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

@@ -6,7 +6,7 @@ module RSpec
   module EventMachine
     extend self
 
-    DEFAULT_TIMEOUT = 10
+    DEFAULT_TIMEOUT = 15
 
     def run_reactor(timeout = DEFAULT_TIMEOUT)
       Timeout::timeout(timeout + 0.5) do

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

@@ -15,10 +15,10 @@ class TestApp
       {
         'name' => 'persisted:presence_fixtures',
         'presence' => [
-          { 'clientId' => 'client_bool',    'clientData' => 'true' },
-          { 'clientId' => 'client_int',     'clientData' => '24' },
-          { 'clientId' => 'client_string',  'clientData' => 'This is a string clientData payload' },
-          { 'clientId' => 'client_json',    'clientData' => '{ "test" => \'This is a JSONObject clientData payload\'}' }
+          { '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\'}' }
         ]
       }
     ]
@@ -79,7 +79,7 @@ class TestApp
   end
 
   def environment
-    'sandbox'
+    ENV['ABLY_ENV'] || 'sandbox'
   end
 
   def create_test_app
@@ -90,7 +90,12 @@ class TestApp
       'Content-Type' => 'application/json'
     }
 
-    @attributes = JSON.parse(Faraday.post(url, APP_SPEC.to_json, headers).body)
+    response = Faraday.post(url, APP_SPEC.to_json, headers)
+    raise "Could not create test app.  Ably responded with status #{response.status}\n#{response.body}" unless (200..299).include?(response.status)
+
+    @attributes = JSON.parse(response.body)
+
+    puts "Test app '#{app_id}' created in #{environment} environment"
   end
 
   def host
@@ -103,7 +108,8 @@ class TestApp
 
   def create_test_stats(stats)
     client = Ably::Rest::Client.new(api_key: api_key, environment: environment)
-    client.post('/stats', stats)
+    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

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

@@ -1,9 +1,10 @@
 # encoding: utf-8
-require 'spec_helper'
-require 'shared/model_behaviour'
 require 'base64'
 require 'msgpack'
 
+require 'spec_helper'
+require 'shared/model_behaviour'
+
 describe Ably::Models::Message do
   include Ably::Modules::Conversions
 
@@ -12,11 +13,11 @@ describe Ably::Models::Message do
   let(:protocol_message) { Ably::Models::ProtocolMessage.new(action: 1, timestamp: protocol_message_timestamp) }
 
   it_behaves_like 'a model', with_simple_attributes: %w(name client_id data encoding) do
-    let(:model_args) { [protocol_message] }
+    let(:model_args) { [protocol_message: protocol_message] }
   end
 
   context '#timestamp' do
-    let(:model) { subject.new({}, protocol_message) }
+    let(:model) { subject.new({}, protocol_message: protocol_message) }
 
     it 'retrieves attribute :timestamp as Time object from ProtocolMessage' do
       expect(model.timestamp).to be_a(Time)
@@ -39,7 +40,7 @@ describe Ably::Models::Message do
       end
 
       context 'with a protocol message with a different connectionId' do
-        let(:model) { subject.new({ 'connectionId' => model_connection_id }, protocol_message) }
+        let(:model) { subject.new({ 'connectionId' => model_connection_id }, protocol_message: protocol_message) }
 
         it 'uses the model value' do
           expect(model.connection_id).to eql(model_connection_id)
@@ -57,7 +58,7 @@ describe Ably::Models::Message do
       end
 
       context 'with a protocol message with a connectionId' do
-        let(:model) { subject.new({ }, protocol_message) }
+        let(:model) { subject.new({ }, protocol_message: protocol_message) }
 
         it 'uses the model value' do
           expect(model.connection_id).to eql(protocol_connection_id)
@@ -67,7 +68,7 @@ describe Ably::Models::Message do
   end
 
   context 'Java naming', :api_private do
-    let(:model) { subject.new({ clientId: 'joe' }, protocol_message) }
+    let(:model) { subject.new({ clientId: 'joe' }, protocol_message: protocol_message) }
 
     it 'converts the attribute to ruby symbol naming convention' do
       expect(model.client_id).to eql('joe')
@@ -80,7 +81,7 @@ describe Ably::Models::Message do
         let(:encoded_value)   { value.encode(encoding) }
         let(:value)           { random_str }
         let(:options)         { { attribute.to_sym => encoded_value } }
-        let(:model)           { subject.new(options, protocol_message) }
+        let(:model)           { subject.new(options, protocol_message: protocol_message) }
         let(:model_attribute) { model.public_send(attribute) }
 
         context 'as UTF_8 string' do
@@ -142,7 +143,7 @@ describe Ably::Models::Message do
     let(:json_object) { JSON.parse(model.to_json) }
 
     context 'with valid data' do
-      let(:model) { subject.new({ name: 'test', clientId: 'joe' }, protocol_message) }
+      let(:model) { subject.new({ name: 'test', clientId: 'joe' }, protocol_message: protocol_message) }
 
       it 'converts the attribute back to Java mixedCase notation using string keys' do
         expect(json_object["clientId"]).to eql('joe')
@@ -150,7 +151,7 @@ describe Ably::Models::Message do
     end
 
     context 'with invalid data' do
-      let(:model) { subject.new({ clientId: 'joe' }, protocol_message) }
+      let(:model) { subject.new({ clientId: 'joe' }, protocol_message: protocol_message) }
 
       it 'raises an exception' do
         expect { model.to_json }.to raise_error RuntimeError, /cannot generate a valid Hash/
@@ -159,7 +160,7 @@ describe Ably::Models::Message do
 
     context 'with binary data' do
       let(:data) { MessagePack.pack(random_str(32)) }
-      let(:model) { subject.new({ name: 'test', data: data }, protocol_message) }
+      let(:model) { subject.new({ name: 'test', data: data }, protocol_message: protocol_message) }
 
       it 'encodes as Base64 so that it can be converted to UTF-8 automatically by JSON#dump' do
         expect(json_object["data"]).to eql(::Base64.encode64(data))
@@ -188,7 +189,7 @@ describe Ably::Models::Message do
     end
 
     context 'with protocol message' do
-      let(:model) { subject.new({ id: id, timestamp: message_timestamp }, protocol_message) }
+      let(:model) { subject.new({ id: id, timestamp: message_timestamp }, protocol_message: protocol_message) }
 
       specify '#id prefers embedded ID' do
         expect(model.id).to eql(id)
@@ -322,7 +323,7 @@ describe Ably::Models::Message do
       end
 
       context 'with ProtocolMessage' do
-        subject { Ably::Models.Message(json, protocol_message) }
+        subject { Ably::Models.Message(json, protocol_message: protocol_message) }
 
         it 'returns a Message object' do
           expect(subject).to be_a(Ably::Models::Message)
@@ -366,7 +367,7 @@ describe Ably::Models::Message do
       end
 
       context 'with ProtocolMessage' do
-        subject { Ably::Models.Message(message, protocol_message) }
+        subject { Ably::Models.Message(message, protocol_message: protocol_message) }
 
         it 'returns a Message object' do
           expect(subject).to be_a(Ably::Models::Message)

data/lib/submodules/ably-ruby/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').tap do |client|
+    instance_double('Ably::Rest::Client', logger: true).tap do |client|
       allow(client).to receive(:get).and_return(http_response)
     end
   end
@@ -90,7 +90,7 @@ describe Ably::Models::PaginatedResource do
       }
     end
     let(:paged_client) do
-      instance_double('Ably::Rest::Client').tap do |client|
+      instance_double('Ably::Rest::Client', logger: true).tap do |client|
         allow(client).to receive(:get).and_return(http_response_page2)
       end
     end
@@ -137,9 +137,9 @@ describe Ably::Models::PaginatedResource do
         end
 
         context '#next_page' do
-          it 'returns a deferrable object' do
+          it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
             run_reactor do
-              expect(subject.next_page).to be_a(EventMachine::Deferrable)
+              expect(subject.next_page).to be_a(Ably::Util::SafeDeferrable)
               stop_reactor
             end
           end