ably-rest 0.9.3 → 1.0.0

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

@@ -61,6 +61,33 @@ describe Ably::Rest::Channel, 'messages' do
       end
     end
 
+    context 'with supported extra payload content type (#RSL1h, #RSL6a2)' do
+      context 'JSON Object (Hash)' do
+        let(:data) { { 'push' => { 'title' => 'Testing' } } }
+
+        it 'is encoded and decoded to the same hash' do
+          channel.publish 'event', {}, extras: data
+          expect(channel.history.items.first.extras).to eql(data)
+        end
+      end
+
+      context 'JSON Array' do
+        let(:data) { { 'push' => [ nil, true, false, 55, 'string', { 'Hash' => true }, ['array'] ] } }
+
+        it 'is encoded and decoded to the same Array' do
+          channel.publish 'event', {}, extras: data
+          expect(channel.history.items.first.extras).to eql(data)
+        end
+      end
+
+      context 'nil' do
+        it 'is encoded and decoded to the same Array' do
+          channel.publish 'event', {}, extras: nil
+          expect(channel.history.items.first.extras).to be_nil
+        end
+      end
+    end
+
     context 'with unsupported data payload content type' do
       context 'Integer' do
         let(:data) { 1 }
@@ -134,7 +161,7 @@ describe Ably::Rest::Channel, 'messages' do
             end
           end
 
-          it 'encrypts message automatically when published' do
+          it 'encrypts message automatically when published (#RTL7d)' do
             expect(client).to receive(:post) do |path, message|
               if protocol == :json
                 expect(message['encoding']).to eql(encrypted_encoding)
@@ -149,7 +176,7 @@ describe Ably::Rest::Channel, 'messages' do
             encrypted_channel.publish 'example', encoded_data_decoded
           end
 
-          it 'sends and retrieves messages that are encrypted & decrypted by the Ably library' do
+          it 'sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)' do
             encrypted_channel.publish 'example', encoded_data_decoded
 
             message = encrypted_channel.history.items.first
@@ -168,12 +195,12 @@ describe Ably::Rest::Channel, 'messages' do
           end
         end
 
-        context 'with AES-128-CBC using crypto-data-128.json fixtures' do
+        context 'with AES-128-CBC using crypto-data-128.json fixtures (#RTL7d)' do
           data = JSON.parse(File.read(File.join(resources_root, 'crypto-data-128.json')))
           add_tests_for_data data
         end
 
-        context 'with AES-256-CBC using crypto-data-256.json fixtures' do
+        context 'with AES-256-CBC using crypto-data-256.json fixtures (#RTL7d)' do
           data = JSON.parse(File.read(File.join(resources_root, 'crypto-data-256.json')))
           add_tests_for_data data
         end
@@ -246,21 +273,21 @@ describe Ably::Rest::Channel, 'messages' do
             encrypted_channel.publish 'example', payload
           end
 
-          it 'retrieves the message that remains encrypted with an encrypted encoding attribute' do
+          it 'retrieves the message that remains encrypted with an encrypted encoding attribute (#RTL7e)' do
             message = other_client_unencrypted_channel.history.items.first
             expect(message.data).to_not eql(payload)
             expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
           end
 
-          it 'logs a Cipher exception' do
-            expect(other_client.logger).to receive(:error) do |message|
-              expect(message).to match(/Message cannot be decrypted/)
+          it 'logs a Cipher exception (#RTL7e)' do
+            expect(other_client.logger).to receive(:error) do |*args, &block|
+              expect(args.concat([block ? block.call : nil]).join(',')).to match(/Message cannot be decrypted/)
             end
             other_client_unencrypted_channel.history
           end
         end
 
-        context 'publishing on an encrypted channel and retrieving #history with a different algorithm on another client' do
+        context 'publishing on an encrypted channel and retrieving #history with a different algorithm on another client (#RTL7e)' do
           let(:client_options)            { default_client_options.merge(log_level: :fatal) }
           let(:cipher_options_client1)    { { key: Ably::Util::Crypto.generate_random_key(256), algorithm: 'aes', mode: 'cbc', key_length: 256 } }
           let(:encrypted_channel_client1) { client.channel(channel_name, cipher: cipher_options_client1) }
@@ -273,15 +300,15 @@ describe Ably::Rest::Channel, 'messages' do
             encrypted_channel_client1.publish 'example', payload
           end
 
-          it 'retrieves the message that remains encrypted with an encrypted encoding attribute' do
+          it 'retrieves the message that remains encrypted with an encrypted encoding attribute (#RTL7e)' do
             message = encrypted_channel_client2.history.items.first
             expect(message.data).to_not eql(payload)
             expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
           end
 
-          it 'logs a Cipher exception' do
-            expect(other_client.logger).to receive(:error) do |message|
-              expect(message).to match(/Cipher algorithm [\w-]+ does not match/)
+          it 'logs a Cipher exception (#RTL7e)' do
+            expect(other_client.logger).to receive(:error) do |*args, &block|
+              expect(args.concat([block ? block.call : nil]).join(',')).to match(/Cipher algorithm [\w-]+ does not match/)
             end
             encrypted_channel_client2.history
           end
@@ -307,8 +334,8 @@ describe Ably::Rest::Channel, 'messages' do
           end
 
           it 'logs a Cipher exception' do
-            expect(other_client.logger).to receive(:error) do |message|
-              expect(message).to match(/CipherError decrypting data/)
+            expect(other_client.logger).to receive(:error) do |*args, &block|
+              expect(args.concat([block ? block.call : nil]).join(',')).to match(/CipherError decrypting data/)
             end
             encrypted_channel_client2.history
           end

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

@@ -399,8 +399,8 @@ describe Ably::Rest::Presence do
           end
 
           it 'logs a cipher error' do
-            expect(client.logger).to receive(:error) do |message|
-              expect(message).to match(/Cipher algorithm [\w-]+ does not match/)
+            expect(client.logger).to receive(:error) do |*args, &block|
+              expect(args.concat([block ? block.call : nil]).join(',')).to match(/Cipher algorithm [\w-]+ does not match/)
             end
             presence.get
           end
@@ -423,8 +423,8 @@ describe Ably::Rest::Presence do
           end
 
           it 'logs a cipher error' do
-            expect(client.logger).to receive(:error) do |message|
-              expect(message).to match(/Cipher algorithm [\w-]+ does not match/)
+            expect(client.logger).to receive(:error) do |*args, &block|
+              expect(args.concat([block ? block.call : nil]).join(',')).to match(/Cipher algorithm [\w-]+ does not match/)
             end
             presence.history
           end

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

@@ -41,7 +41,7 @@ RSpec.configure do |config|
   end
 
   if defined?(EventMachine)
-    config.before(:example) do
+    config.before(:example, :event_machine) do
       # Ensure EventMachine shutdown hooks are deregistered for every test
       EventMachine.instance_variable_set '@tails', []
     end
@@ -52,6 +52,7 @@ RSpec.configure do |config|
   if ENV['RSPEC_RETRY']
     puts 'Running tests using RSpec retry'
     config.verbose_retry = true # show retry status in spec process
+    config.display_try_failure_messages = true # show exception that triggered the try
     config.default_retry_count = 3
     config.default_sleep_interval = 2
   end

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

@@ -154,9 +154,9 @@ shared_examples 'a client initializer' do
     end
 
     context 'with token_params' do
-      let(:client_options) { { token_params: { ttl: 777, client_id: 'john' }, token: 'token', auto_connect: false } }
+      let(:client_options) { { default_token_params: { ttl: 777, client_id: 'john' }, token: 'token', auto_connect: false } }
 
-      it 'configures the default token_params' do
+      it 'configures default_token_params' do
         expect(subject.auth.token_params.fetch(:ttl)).to eql(777)
         expect(subject.auth.token_params.fetch(:client_id)).to eql('john')
       end

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

@@ -20,7 +20,9 @@ shared_examples 'a safe Deferrable' do
     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}/)
+      expect(subject.send(:logger)).to receive(:error) do |*args, &block|
+        expect(args.concat([block ? block.call : nil]).join(',')).to match(/#{exception.message}/)
+      end
       subject.errback do
         raise exception
       end
@@ -49,7 +51,9 @@ shared_examples 'a safe Deferrable' do
     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}/)
+      expect(subject.send(:logger)).to receive(:error) do |*args, &block|
+        expect(args.concat([block ? block.call : nil]).join(',')).to match(/#{exception.message}/)
+      end
       subject.callback do
         raise exception
       end

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

@@ -1,15 +1,31 @@
 RSpec.configure do |config|
-  config.before(:example) do
+  config.before(:example) do |example|
+    next if example.metadata[:prevent_log_stubbing]
+
     @log_output = []
     %w(fatal error warn info debug).each do |method_name|
-      allow_any_instance_of(Ably::Logger).to receive(method_name.to_sym).and_wrap_original do |method, *args|
-        @log_output << "#{Time.now.strftime('%H:%M:%S.%L')} [\e[33m#{method_name}\e[0m] #{args[0]}"
-        method.call(*args)
+      allow_any_instance_of(Ably::Logger).to receive(method_name.to_sym).and_wrap_original do |method, *args, &block|
+        # Don't log shutdown sequence to keep log noise to a minimum
+        next if RSpec.const_defined?(:EventMachine) && RSpec::EventMachine.reactor_stopping?
+
+        prefix = "#{Time.now.strftime('%H:%M:%S.%L')} [\e[33m#{method_name}\e[0m] "
+
+        begin
+          args << block.call unless block.nil?
+          @log_output << "#{prefix}#{args.compact.join(' ')}"
+        rescue StandardError => e
+          @log_output << "#{prefix}Failed to log block - #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}}"
+        end
+
+        # Call original
+        method.call(*args, &block)
       end
     end
   end
 
   config.after(:example) do |example|
+    next if example.metadata[:prevent_log_stubbing]
+
     exception = example.exception
     puts "\n#{'-'*34}\n\e[36mVerbose Ably log from test failure\e[0m\n#{'-'*34}\n#{@log_output.join("\n")}\n\n" if exception
   end

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

@@ -9,6 +9,8 @@ module RSpec
     DEFAULT_TIMEOUT = 15
 
     def run_reactor(timeout = DEFAULT_TIMEOUT)
+      @reactor_stopping = false
+
       Timeout::timeout(timeout + 0.5) do
         ::EventMachine.run do
           yield
@@ -16,7 +18,13 @@ module RSpec
       end
     end
 
+    def reactor_stopping?
+      @reactor_stopping
+    end
+
     def stop_reactor
+      mark_reactor_stopping
+
       unless realtime_clients.empty?
         realtime_clients.shift.tap do |client|
           # Ensure close appens outside of the caller as this can cause errbacks on Deferrables
@@ -45,6 +53,10 @@ module RSpec
       @realtime_clients ||= []
     end
 
+    def mark_reactor_stopping
+      @reactor_stopping = true
+    end
+
     # Allows multiple Deferrables to be passed in and calls the provided block when
     # all success callbacks have completed
     def when_all(*deferrables)
@@ -123,8 +135,27 @@ RSpec.configure do |config|
     example.run
   end
 
-  config.before(:example) do
+  config.before(:example, :event_machine) do
     # Ensure EventMachine shutdown hooks are deregistered for every test
     EventMachine.instance_variable_set '@tails', []
   end
 end
+
+module RSpec
+  module Expectations
+    module ExpectationHelper
+      class << self
+        # This is very hacky and ties into the internals of RSpec which is likely to break in future versions
+        # However, this is just a convenience to reduce log noise when the reactor is stopping
+        # i.e. debug_failure_helper logs the verbose messages generated by the libraries, however it also often
+        # catches all the shutdown messages which is unnecessary
+        alias_method :orig_handle_failure, :handle_failure
+
+        def handle_failure(*args, &block)
+          RSpec::EventMachine.mark_reactor_stopping
+          orig_handle_failure(*args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/auth_spec.rb

@@ -68,19 +68,12 @@ describe Ably::Auth do
   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)
+    it 'should have no default TTL' do
+      expect(Ably::Auth::TOKEN_DEFAULTS[:ttl]).to be_nil
     end
 
-    it 'should have defaults for :ttl and :capability' do
-      expect(Ably::Auth::TOKEN_DEFAULTS.keys).to include(:ttl, :capability)
+    it 'should have no default capability' do
+      expect(Ably::Auth::TOKEN_DEFAULTS[:capability]).to be_nil
     end
   end
 end

data/lib/submodules/ably-ruby/spec/unit/logger_spec.rb

@@ -18,7 +18,9 @@ describe Ably::Logger do
 
   context 'internals', :api_private do
     it 'delegates to the logger object' do
-      expect(subject.logger).to receive(:warn).with('message')
+      expect(subject.logger).to receive(:warn) do |*args, &block|
+        expect(args.concat([block ? block.call : nil]).join(',')).to match(/message/)
+      end
       subject.warn 'message'
     end
 
@@ -138,9 +140,33 @@ describe Ably::Logger do
       end
 
       it 'delegates log messages to logger', :api_private do
-        expect(custom_logger_object).to receive(:fatal).with('message')
+        expect(custom_logger_object).to receive(:fatal) do |*args, &block|
+          expect(args.concat([block ? block.call : nil]).join(',')).to match(/message/)
+        end
         subject.fatal 'message'
       end
     end
   end
+
+  context 'with blocks', :prevent_log_stubbing do
+    it 'does not call the block unless the log level is met' do
+      log_level_blocks = []
+      subject.warn { log_level_blocks << :warn }
+      subject.info { log_level_blocks << :info }
+      subject.debug { log_level_blocks << :debug }
+      expect(log_level_blocks).to contain_exactly(:warn, :info)
+    end
+
+    context 'with an exception in the logger block' do
+      before do
+        expect(subject.logger).to receive(:error) do |*args, &block|
+        expect(args.concat([block ? block.call : nil]).join(',')).to match(/Raise an error in the block/)
+        end
+      end
+
+      it 'catches the error and continues' do
+        subject.info { raise "Raise an error in the block" }
+      end
+    end
+  end
 end

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::AuthDetails do
+  include Ably::Modules::Conversions
+
+  subject { Ably::Models::AuthDetails }
+
+  # Spec model items AD2*
+  it_behaves_like 'a model', with_simple_attributes: %w(access_token) do
+    let(:model_args) { [] }
+  end
+
+  context '==' do
+    let(:attributes) { { access_token: 'unique' } }
+
+    it 'is true when attributes are the same' do
+      auth_details = -> { Ably::Models::AuthDetails.new(attributes) }
+      expect(auth_details.call).to eq(auth_details.call)
+    end
+
+    it 'is false when attributes are not the same' do
+      expect(Ably::Models::AuthDetails.new(access_token: '1')).to_not eq(Ably::Models::AuthDetails.new(access_token: '2'))
+    end
+
+    it 'is false when class type differs' do
+      expect(Ably::Models::AuthDetails.new(access_token: '1')).to_not eq(nil)
+    end
+  end
+
+  context 'AuthDetails conversion methods', :api_private do
+    context 'with a AuthDetails object' do
+      let(:details) { Ably::Models::AuthDetails.new(access_token: random_str) }
+
+      it 'returns the AuthDetails object' do
+        expect(Ably::Models::AuthDetails(details)).to eql(details)
+      end
+    end
+
+    context 'with a JSON object' do
+      let(:access_token) { random_str }
+      let(:details_json) { { access_token: access_token } }
+
+      it 'returns a new AuthDetails object from the JSON' do
+        expect(Ably::Models::AuthDetails(details_json).access_token).to eql(access_token)
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ describe Ably::Models::ChannelStateChange do
 
   subject { Ably::Models::ChannelStateChange }
 
-  context '#current' do
+  context '#current (#TH1)' do
     it 'is required' do
       expect { subject.new(previous: true) }.to raise_error ArgumentError
     end
@@ -16,7 +16,7 @@ describe Ably::Models::ChannelStateChange do
     end
   end
 
-  context '#previous' do
+  context '#previous (#TH2)' do
     it 'is required' do
       expect { subject.new(current: true) }.to raise_error ArgumentError
     end
@@ -26,7 +26,17 @@ describe Ably::Models::ChannelStateChange do
     end
   end
 
-  context '#reason' do
+  context '#event (#TH5)' do
+    it 'is not required' do
+      expect { subject.new(previous: true, current: true) }.to_not raise_error
+    end
+
+    it 'is an attribute' do
+      expect(subject.new(event: unique, previous: unique, current: true).event).to eql(unique)
+    end
+  end
+
+  context '#reason (#TH3)' do
     it 'is not required' do
       expect { subject.new(previous: true, current: true) }.to_not raise_error
     end
@@ -36,6 +46,16 @@ describe Ably::Models::ChannelStateChange do
     end
   end
 
+  context '#resumed (#TH4)' do
+    it 'is false when ommitted' do
+      expect(subject.new(previous: true, current: true).resumed).to be_falsey
+    end
+
+    it 'is true when provided' do
+      expect(subject.new(previous: true, current: true, resumed: true).resumed).to be_truthy
+    end
+  end
+
   context 'invalid attributes' do
     it 'raises an argument error' do
       expect { subject.new(invalid: true, current: true, previous: true) }.to raise_error ArgumentError