ably-rest 1.0.5 → 1.1.3

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Rest::Push do
+  vary_by_protocol do
+    let(:default_options) { { key: api_key, environment: environment, protocol: protocol} }
+    let(:client_options)  { default_options }
+    let(:client) do
+      Ably::Rest::Client.new(client_options)
+    end
+    subject { client.push }
+
+    describe '#activate' do
+      it 'raises an unsupported exception' do
+        expect { subject.activate('foo') }.to raise_error(Ably::Exceptions::PushNotificationsNotSupported)
+      end
+    end
+
+    describe '#deactivate' do
+      it 'raises an unsupported exception' do
+        expect { subject.deactivate('foo') }.to raise_error(Ably::Exceptions::PushNotificationsNotSupported)
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ describe Ably::Rest::Client, '#time' do
 
       context 'with reconfigured HTTP timeout' do
         let(:client) do
-          Ably::Rest::Client.new(http_request_timeout: 0.0001, key: api_key, environment: environment, protocol: protocol)
+          Ably::Rest::Client.new(http_request_timeout: 0.0001, key: api_key, environment: environment, protocol: protocol, log_retries_as_info: true)
         end
 
         it 'should raise a timeout exception' do

data/lib/submodules/ably-ruby/spec/run_parallel_tests

@@ -0,0 +1,33 @@
+#!/bin/bash
+#
+# Run the unit tests first without RSpec parallel, then run acceptance tests in parallel
+#
+# When splitting all tests across all parallel processes, it's quite plausible
+# that some processes only run a majority of unit tests, whilst others only run a
+# a majority of acceptance tests. This ensures acceptance tests are split out.
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )"
+
+bundle exec rspec "${DIR}/unit"
+unit_status=$?
+
+if ruby -v | grep -e "1.9"; then
+  # Output with test ID is not supported with this old version of RSpec
+  # So it will be jumbled sadly for 1.9.*
+  bundle exec parallel_rspec "${DIR}/acceptance"
+else
+  bundle exec parallel_rspec "${DIR}/acceptance" --prefix-output-with-test-env-number
+fi
+acceptance_status=$?
+
+if [ $unit_status -ne 0 ]; then
+  echo -e "\e[31m⚠ Note: Unit tests have also failed, but are not listed in the test failures above. Scroll up to the unit tests ⚠\e[0m"
+fi
+
+if [ $unit_status -ne 0 ] || [ $acceptance_status -ne 0 ]; then
+  echo "Unit tests exit code: ${unit_status}"
+  echo "Acceptance tests exit code: ${acceptance_status}"
+  exit 1
+fi
+
+

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

@@ -261,15 +261,7 @@ shared_examples 'a client initializer' do
       end
 
       context 'with custom logger and log_level' do
-        let(:custom_logger) do
-          Class.new do
-            extend Forwardable
-            def initialize
-              @logger = Logger.new(STDOUT)
-            end
-            def_delegators :@logger, :fatal, :error, :warn, :info, :debug, :level, :level=
-          end
-        end
+        let(:custom_logger) { TestLogger }
         let(:client_options) { default_options.merge(logger: custom_logger.new, log_level: Logger::DEBUG, auto_connect: false) }
 
         it 'uses the custom logger' do

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

@@ -4,7 +4,7 @@ def console(message)
   puts "\033[31m[#{Time.now.strftime('%H:%M:%S.%L')}]\033[0m \033[33m#{message}\033[0m"
 end
 
-unless RUBY_VERSION.match(/^1/)
+unless RUBY_VERSION.match(/^1\./)
   require 'coveralls'
   Coveralls.wear!
 end
@@ -15,9 +15,11 @@ require 'ably'
 
 require 'support/api_helper'
 require 'support/debug_failure_helper'
+require 'support/event_emitter_helper'
 require 'support/private_api_formatter'
 require 'support/protocol_helper'
 require 'support/random_helper'
+require 'support/test_logger_helper'
 
 require 'rspec_config'
 

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

@@ -2,6 +2,8 @@ RSpec.configure do |config|
   config.before(:example) do |example|
     next if example.metadata[:prevent_log_stubbing]
 
+    log_mutex = Mutex.new
+
     @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, &block|
@@ -10,11 +12,13 @@ RSpec.configure do |config|
 
         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")}}"
+        log_mutex.synchronize do
+          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
         end
 
         # Call original

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

@@ -0,0 +1,31 @@
+module Ably
+  module Modules
+    module EventEmitter
+      # Unplugs currently registered listener callbacks
+      # Ensures multiple calls to unplug is not destructive
+      def unplug_listeners
+        unplugged_callbacks[:callbacks] = unplugged_callbacks.fetch(:callbacks).merge(callbacks)
+        unplugged_callbacks[:callbacks_any] = unplugged_callbacks.fetch(:callbacks_any) + callbacks_any
+        callbacks.clear
+        callbacks_any.clear
+      end
+
+      # Plug in previously unplugged listener callbacks
+      # But merge them together in case other listners have been added in the mean time
+      def plugin_listeners
+        @callbacks = callbacks.merge(unplugged_callbacks.fetch(:callbacks))
+        @callbacks_any = callbacks_any + unplugged_callbacks.fetch(:callbacks_any)
+        unplugged_callbacks.fetch(:callbacks).clear
+        unplugged_callbacks.fetch(:callbacks_any).clear
+      end
+
+      private
+      def unplugged_callbacks
+        @unplugged_callbacks ||= {
+          callbacks: Hash.new { |hash, key| hash[key] = [] },
+          callbacks_any: []
+        }
+      end
+    end
+  end
+end

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

@@ -124,7 +124,7 @@ RSpec.configure do |config|
     example_block          = example.example.instance_variable_get('@example_block')
     example_group_instance = example.example.instance_variable_get('@example_group_instance')
 
-    event_machine_block = Proc.new do
+    event_machine_block = lambda do |*args|
       RSpec::EventMachine.run_reactor(timeout) do
         example_group_instance.instance_exec(example, &example_block)
       end

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

@@ -4,11 +4,11 @@ class TestApp
   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
+  # See https://github.com/ably/ably-common/blob/main/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
+  # See https://github.com/ably/ably-common/blob/main/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

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

@@ -0,0 +1,42 @@
+# Class with standard Ruby Logger interface
+#   but it keeps a record of the lof entries for later inspection
+#
+# Recommendation: Use :prevent_log_stubbing attibute on tests that use this logger
+#
+class TestLogger
+  def initialize
+    @messages = []
+  end
+
+  SEVERITIES = [:fatal, :error, :warn, :info, :debug]
+  SEVERITIES.each do |severity_sym|
+    define_method(severity_sym) do |*args, &block|
+      if block
+        @messages << [severity_sym, block.call]
+      else
+        @messages << [severity_sym, args.join(', ')]
+      end
+    end
+  end
+
+  def logs(options = {})
+    min_severity = options[:min_severity]
+    if min_severity
+      severity_level = SEVERITIES.index(min_severity)
+      raise "Unknown severity: #{min_severity}" if severity_level.nil?
+
+      @messages.select do |severity, message|
+        SEVERITIES.index(severity) <= severity_level
+      end
+    else
+      @messages
+    end
+  end
+
+  def level
+    1
+  end
+
+  def level=(new_level)
+  end
+end

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

@@ -17,11 +17,15 @@ describe Ably::Logger do
   end
 
   context 'internals', :api_private do
-    it 'delegates to the logger object' do
-      expect(subject.logger).to receive(:warn) do |*args, &block|
+    it 'delegates to the default Logger object' do
+      received = false
+      expect(subject.logger).to be_a(::Logger)
+      allow_any_instance_of(::Logger).to receive(:warn) do |*args, &block|
         expect(args.concat([block ? block.call : nil]).join(',')).to match(/message/)
+        received = true
       end
       subject.warn 'message'
+      expect(received).to be_truthy
     end
 
     context 'formatter' do
@@ -121,15 +125,7 @@ describe Ably::Logger do
     end
 
     context 'with a valid interface' do
-      let(:custom_logger) do
-        Class.new do
-          extend Forwardable
-          def initialize
-            @logger = Logger.new(STDOUT)
-          end
-          def_delegators :@logger, :fatal, :error, :warn, :info, :debug, :level, :level=
-        end
-      end
+      let(:custom_logger) { TestLogger }
       let(:custom_logger_object) { custom_logger.new }
 
       subject { Ably::Logger.new(rest_client, Logger::INFO, custom_logger_object) }
@@ -140,10 +136,13 @@ describe Ably::Logger do
       end
 
       it 'delegates log messages to logger', :api_private do
-        expect(custom_logger_object).to receive(:fatal) do |*args, &block|
+        received = false
+        allow(custom_logger_object).to receive(:fatal) do |*args, &block|
           expect(args.concat([block ? block.call : nil]).join(',')).to match(/message/)
+          received = true
         end
         subject.fatal 'message'
+        expect(received).to be_truthy
       end
     end
   end

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

@@ -0,0 +1,102 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::DeviceDetails do
+  include Ably::Modules::Conversions
+
+  subject { Ably::Models::DeviceDetails }
+
+  %w(id platform form_factor client_id device_secret).each do |string_attribute|
+    let(:empty_device_details) { subject.new }
+
+    describe "##{string_attribute} and ##{string_attribute}=" do
+      let(:new_val) { random_str }
+
+      specify 'setter accepts a string value and getter returns the new value' do
+        expect(empty_device_details.public_send(string_attribute)).to be_nil
+        empty_device_details.public_send("#{string_attribute}=", new_val)
+        expect(empty_device_details.public_send(string_attribute)).to eql(new_val)
+      end
+
+      specify 'setter accepts nil' do
+        empty_device_details.public_send("#{string_attribute}=", new_val)
+        expect(empty_device_details.public_send(string_attribute)).to eql(new_val)
+        empty_device_details.public_send("#{string_attribute}=", nil)
+        expect(empty_device_details.public_send(string_attribute)).to be_nil
+      end
+
+      specify 'rejects non string or nil values' do
+        expect { empty_device_details.public_send("#{string_attribute}=", {}) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'camelCase constructor attributes' do
+    let(:client_id) { random_str }
+    let(:device_details) { subject.new("clientId" => client_id ) }
+
+    specify 'are rubyfied and exposed as underscore case' do
+      expect(device_details.client_id).to eql(client_id)
+    end
+
+    specify 'are generated when the object is serialised to JSON' do
+      expect(JSON.parse(device_details.to_json)["clientId"]).to eql(client_id)
+    end
+  end
+
+  describe "#metadata and #metadata=" do
+    let(:new_val) { { foo: random_str } }
+
+    specify 'setter accepts a Hash value and getter returns the new value' do
+      expect(empty_device_details.metadata).to eql({})
+      empty_device_details.metadata = new_val
+      expect(empty_device_details.metadata.to_json).to eql(new_val.to_json)
+    end
+
+    specify 'setter accepts nil but always returns an empty hash' do
+      empty_device_details.metadata = new_val
+      expect(empty_device_details.metadata.to_json).to eql(new_val.to_json)
+      empty_device_details.metadata = nil
+      expect(empty_device_details.metadata).to eql({})
+    end
+
+    specify 'rejects non Hash or nil values' do
+      expect { empty_device_details.metadata = "foo" }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#push and #push=" do
+    let(:transport_type) { random_str }
+    let(:new_val) { { recipient: { transport_type: transport_type } } }
+    let(:json_val) { { recipient: { transportType: transport_type } }.to_json }
+
+    specify 'setter accepts a DevicePushDetails object and getter returns a DevicePushDetails object' do
+      expect(empty_device_details.push.to_json).to eql({}.to_json)
+      empty_device_details.push = DevicePushDetails(new_val)
+      expect(empty_device_details.push).to be_a(Ably::Models::DevicePushDetails)
+      expect(empty_device_details.push.recipient[:transport_type]).to eql(transport_type)
+      expect(empty_device_details.push.to_json).to eql(json_val)
+    end
+
+    specify 'setter accepts a Hash value and getter returns a DevicePushDetails object' do
+      expect(empty_device_details.push.to_json).to eql({}.to_json)
+      empty_device_details.push = new_val
+      expect(empty_device_details.push).to be_a(Ably::Models::DevicePushDetails)
+      expect(empty_device_details.push.recipient[:transport_type]).to eql(transport_type)
+      expect(empty_device_details.push.to_json).to eql(json_val)
+    end
+
+    specify 'setter accepts nil but always returns a DevicePushDetails object' do
+      empty_device_details.push = new_val
+      expect(empty_device_details.push.to_json).to eql(json_val)
+      empty_device_details.push = nil
+      expect(empty_device_details.push).to be_a(Ably::Models::DevicePushDetails)
+      expect(empty_device_details.push.to_json).to eql({}.to_json)
+    end
+
+    specify 'rejects non Hash, DevicePushDetails or nil values' do
+      expect { empty_device_details.metadata = "foo" }.to raise_error(ArgumentError)
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::DevicePushDetails do
+  include Ably::Modules::Conversions
+
+  subject { Ably::Models::DevicePushDetails }
+
+  %w(state).each do |string_attribute|
+    let(:empty_push_details) { subject.new }
+
+    describe "##{string_attribute} and ##{string_attribute}=" do
+      let(:new_val) { random_str }
+
+      specify 'setter accepts a string value and getter returns the new value' do
+        expect(empty_push_details.public_send(string_attribute)).to be_nil
+        empty_push_details.public_send("#{string_attribute}=", new_val)
+        expect(empty_push_details.public_send(string_attribute)).to eql(new_val)
+      end
+
+      specify 'setter accepts nil' do
+        empty_push_details.public_send("#{string_attribute}=", new_val)
+        expect(empty_push_details.public_send(string_attribute)).to eql(new_val)
+        empty_push_details.public_send("#{string_attribute}=", nil)
+        expect(empty_push_details.public_send(string_attribute)).to be_nil
+      end
+
+      specify 'rejects non string or nil values' do
+        expect { empty_push_details.public_send("#{string_attribute}=", {}) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'camelCase constructor attributes' do
+    let(:transport_type) { random_str }
+    let(:push_details) { subject.new('errorReason' => { 'message' => 'foo' }, 'recipient' => { 'transportType' => transport_type }) }
+
+    specify 'are rubyfied and exposed as underscore case' do
+      expect(push_details.recipient[:transport_type]).to eql(transport_type)
+      expect(push_details.error_reason.message).to eql('foo')
+    end
+
+    specify 'are generated when the object is serialised to JSON' do
+      expect(JSON.parse(push_details.to_json)['recipient']['transportType']).to eql(transport_type)
+    end
+  end
+
+  describe "#recipient and #recipient=" do
+    let(:new_val) { { foo: random_str } }
+
+    specify 'setter accepts a Hash value and getter returns the new value' do
+      expect(empty_push_details.recipient).to eql({})
+      empty_push_details.recipient = new_val
+      expect(empty_push_details.recipient.to_json).to eql(new_val.to_json)
+    end
+
+    specify 'setter accepts nil but always returns an empty hash' do
+      empty_push_details.recipient = new_val
+      expect(empty_push_details.recipient.to_json).to eql(new_val.to_json)
+      empty_push_details.recipient = nil
+      expect(empty_push_details.recipient).to eql({})
+    end
+
+    specify 'rejects non Hash or nil values' do
+      expect { empty_push_details.recipient = "foo" }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#error_reason and #error_reason=" do
+    let(:error_message) { random_str }
+    let(:error_attributes) { { message: error_message } }
+
+    specify 'setter accepts a ErrorInfo object and getter returns a ErrorInfo object' do
+      expect(empty_push_details.error_reason).to be_nil
+      empty_push_details.error_reason = ErrorInfo(error_attributes)
+      expect(empty_push_details.error_reason).to be_a(Ably::Models::ErrorInfo)
+      expect(empty_push_details.error_reason.message).to eql(error_message)
+      expect(empty_push_details.error_reason.to_json).to eql(error_attributes.to_json)
+    end
+
+    specify 'setter accepts a Hash value and getter returns a ErrorInfo object' do
+      expect(empty_push_details.error_reason).to be_nil
+      empty_push_details.error_reason = error_attributes
+      expect(empty_push_details.error_reason).to be_a(Ably::Models::ErrorInfo)
+      expect(empty_push_details.error_reason.message).to eql(error_message)
+      expect(empty_push_details.error_reason.to_json).to eql(error_attributes.to_json)
+    end
+
+    specify 'setter accepts nil values' do
+      empty_push_details.error_reason = error_attributes
+      expect(empty_push_details.error_reason.to_json).to eql(error_attributes.to_json)
+      empty_push_details.error_reason = nil
+      expect(empty_push_details.error_reason).to be_nil
+    end
+
+    specify 'rejects non Hash, ErrorInfo or nil values' do
+      expect { empty_push_details.error_reason = "foo" }.to raise_error(ArgumentError)
+    end
+  end
+end