ably 0.6.2 → 0.7.0

data/spec/support/event_machine_helper.rb

@@ -1,17 +1,115 @@
+require 'eventmachine'
+require 'rspec'
 require 'timeout'
 
 module RSpec
   module EventMachine
-    def run_reactor(timeout = 3)
+    extend self
+
+    DEFAULT_TIMEOUT = 5
+
+    def run_reactor(timeout = DEFAULT_TIMEOUT)
       Timeout::timeout(timeout + 0.5) do
-        EM.run do
+        ::EventMachine.run do
           yield
         end
       end
     end
 
     def stop_reactor
-      EM.stop
+      ::EventMachine.next_tick do
+        ::EventMachine.stop
+      end
+    end
+
+    # Allows multiple Deferrables to be passed in and calls the provided block when
+    # all success callbacks have completed
+    def when_all(*deferrables, &block)
+      raise "Block expected" unless block_given?
+
+      options = if deferrables.last.kind_of?(Hash)
+        deferrables.pop
+      else
+        {}
+      end
+
+      successful_deferrables = {}
+
+      deferrables.each do |deferrable|
+        deferrable.callback do
+          successful_deferrables[deferrable.object_id] = true
+          if successful_deferrables.keys.sort == deferrables.map(&:object_id).sort
+            if options[:and_wait]
+              ::EventMachine.add_timer(options[:and_wait]) { block.call }
+            else
+              block.call
+            end
+          end
+        end
+
+        deferrable.errback do |error|
+          raise RuntimeError, "Deferrable failed: #{error.message}"
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:context, :event_machine) do |context|
+    context.class.class_eval do
+      include RSpec::EventMachine
     end
   end
+
+  # Running a reactor block and then calling the example block with #call
+  # does not work as expected as the example completes immediately and the block
+  # calls after hooks before it returns the EventMachine loop.
+  #
+  # As there is no public API to inject around blocks correctly without calling the after blocks,
+  # we have to monkey patch the run_after_example method at https://github.com/rspec/rspec-core/blob/master/lib/rspec/core/example.rb#L376
+  # so that it does not run until we explicitly call it once the EventMachine reactor loop is finished.
+  #
+  def patch_example_block_with_surrounding_eventmachine_reactor(example)
+    example.example.class.class_eval do
+      alias_method :run_after_example_original, :run_after_example
+      public :run_after_example_original
+
+      # prevent after hooks being run for example until EventMachine reactor has finished
+      def run_after_example; end
+    end
+  end
+
+  def remove_patch_example_block(example)
+    example.example.class.class_eval do
+      remove_method :run_after_example
+      alias_method :run_after_example, :run_after_example_original
+      remove_method :run_after_example_original
+    end
+  end
+
+  config.around(:example, :event_machine) do |example|
+    timeout = if example.metadata[:em_timeout].is_a?(Numeric)
+      example.metadata[:em_timeout]
+    else
+      RSpec::EventMachine::DEFAULT_TIMEOUT
+    end
+
+    patch_example_block_with_surrounding_eventmachine_reactor example
+
+    begin
+      RSpec::EventMachine.run_reactor(timeout) do
+        example.call
+        raise example.exception if example.exception
+      end
+    ensure
+      example.example.run_after_example_original
+      remove_patch_example_block example
+    end
+  end
+
+  config.before(:example) do
+    # Ensure EventMachine shutdown hooks are deregistered for every test
+    EventMachine.instance_variable_set '@tails', []
+  end
 end

data/spec/support/markdown_spec_formatter.rb

@@ -0,0 +1,90 @@
+module Ably::RSpec
+  # Generate Markdown Specification from the RSpec public API tests
+  #
+  class MarkdownSpecFormatter
+    ::RSpec::Core::Formatters.register self, :start, :close,
+                                             :example_group_started, :example_group_finished,
+                                             :example_passed, :example_failed, :example_pending,
+                                             :dump_summary
+
+    def initialize(output)
+      @output  = File.open(File.expand_path('../../../SPEC.md', __FILE__), 'w')
+      @indent  = 0
+      @passed  = 0
+      @pending = 0
+      @failed  = 0
+    end
+
+    def start(notification)
+      puts "\n\e[33m --> Creating SPEC.md <--\e[0m\n"
+      output.write "# Ably Client Library #{Ably::VERSION} Specification\n"
+    end
+
+    def close(notification)
+      output.close
+    end
+
+    def example_group_started(notification)
+      output.write "#{indent_prefix}#{notification.group.description}\n"
+      output.write "_(see #{heading_location_path(notification)})_\n" if indent == 0
+      @indent += 1
+    end
+
+    def example_group_finished(notification)
+      @indent -= 1
+    end
+
+    def example_passed(notification)
+      unless notification.example.metadata[:api_private]
+        output.write "#{indent_prefix}#{example_name_and_link(notification)}\n"
+        @passed += 1
+      end
+    end
+
+    def example_failed(notification)
+      unless notification.example.metadata[:api_private]
+        output.write "#{indent_prefix}FAILED: ~~#{example_name_and_link(notification)}~~\n"
+        @failed += 1
+      end
+    end
+
+    def example_pending(notification)
+      unless notification.example.metadata[:api_private]
+        output.write "#{indent_prefix}PENDING: *#{example_name_and_link(notification)}*\n"
+        @pending += 1
+      end
+    end
+
+    def dump_summary(notification)
+      output.write <<-EOF.gsub('        ', '')
+
+        -------
+
+        ## Test summary
+
+        * Passing tests: #{@passed}
+        * Pending tests: #{@pending}
+        * Failing tests: #{@failed}
+      EOF
+    end
+
+    private
+    attr_reader :output, :indent
+
+    def example_name_and_link(notification)
+      "[#{notification.example.metadata[:description]}](#{notification.example.location.gsub(/\:(\d+)/, '#L\1')})"
+    end
+
+    def heading_location_path(notification)
+      "[#{notification.group.location.gsub(/\:(\d+)/, '').gsub(%r{^.\/}, '')}](#{notification.group.location.gsub(/\:(\d+)/, '')})"
+    end
+
+    def indent_prefix
+      if indent > 0
+        "#{'  ' * indent}* "
+      else
+        "\n### "
+      end
+    end
+  end
+end

data/spec/support/private_api_formatter.rb

@@ -0,0 +1,36 @@
+module Ably::RSpec
+  # PrivateApiFormatter is an RSpec Formatter that prefixes all tests that are part of a Private API with '(private)'
+  #
+  # Private API methods are tested for this library, but every implementation of the Ably client library
+  # will likely be different and thus the private API method tests are not shared.
+  #
+  # Filter private API tests with `rspec --tag ~api_private`
+  #
+  class PrivateApiFormatter
+    ::RSpec::Core::Formatters.register self, :example_started
+
+    def initialize(output)
+      @output = output
+    end
+
+    def example_started(notification)
+      if notification.example.metadata[:api_private]
+        notification.example.metadata[:description] = "#{yellow('(private)')} #{green(notification.example.metadata[:description])}"
+      end
+    end
+
+    private
+    def colorize(color_code, string)
+      "\e[#{color_code}m#{string}\e[0m"
+    end
+
+    def yellow(string)
+      colorize(33, string)
+    end
+
+
+    def green(string)
+      colorize(32, string)
+    end
+  end
+end

data/spec/support/protocol_helper.rb

@@ -0,0 +1,32 @@
+module RSpec
+  module ProtocolHelper
+    PROTOCOLS = if ENV['TEST_LIMIT_PROTOCOLS']
+      JSON.parse(ENV['TEST_LIMIT_PROTOCOLS'])
+    else
+      {
+        json:    'JSON',
+        msgpack: 'MsgPack'
+      }
+    end
+
+    def vary_by_protocol(&block)
+      RSpec::ProtocolHelper::PROTOCOLS.each do |protocol, description|
+        context("using #{description} protocol", protocol: protocol, &block)
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.extend RSpec::ProtocolHelper
+
+  config.before(:context, protocol: :json) do |context|
+    context.class.let(:protocol) { :json }
+  end
+
+  config.before(:context, protocol: :msgpack) do |context|
+    context.class.let(:protocol) { :msgpack }
+  end
+end
+
+

data/spec/support/random_helper.rb

@@ -0,0 +1,15 @@
+require 'securerandom'
+
+module RandomHelper
+  def random_str(length = 16)
+    SecureRandom.hex(length).encode(Encoding::UTF_8)
+  end
+
+  def random_int_str(size = 1_000_000_000)
+    SecureRandom.random_number(size).to_s.encode(Encoding::UTF_8)
+  end
+
+  RSpec.configure do |config|
+    config.include self
+  end
+end

data/spec/support/test_app.rb

@@ -90,6 +90,10 @@ class TestApp
     @attributes = JSON.parse(response.body)
   end
 
+  def host
+    sandbox_client.endpoint.host
+  end
+
   private
   def sandbox_client
     @sandbox_client ||= Ably::Rest::Client.new(api_key: 'app.key:secret', tls: true, environment: environment)

data/spec/unit/auth_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+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 } }
+
+  subject do
+    Ably::Auth.new(client, options)
+  end
+
+  describe 'client_id option' do
+    let(:client_id) { random_str.encode(encoding) }
+
+    context 'with nil value' do
+      let(:client_id) { nil }
+
+      it 'is permitted' do
+        expect(subject.client_id).to be_nil
+      end
+    end
+
+    context 'as UTF_8 string' do
+      let(:encoding) { Encoding::UTF_8 }
+
+      it 'is permitted' do
+        expect(subject.client_id).to eql(client_id)
+      end
+
+      it 'remains as UTF-8' do
+        expect(subject.client_id.encoding).to eql(encoding)
+      end
+    end
+
+    context 'as SHIFT_JIS string' do
+      let(:encoding) { Encoding::SHIFT_JIS }
+
+      it 'gets converted to UTF-8' do
+        expect(subject.client_id.encoding).to eql(Encoding::UTF_8)
+      end
+
+      it 'is compatible with original encoding' do
+        expect(subject.client_id.encode(encoding)).to eql(client_id)
+      end
+    end
+
+    context 'as ASCII_8BIT string' do
+      let(:encoding) { Encoding::ASCII_8BIT }
+
+      it 'gets converted to UTF-8' do
+        expect(subject.client_id.encoding).to eql(Encoding::UTF_8)
+      end
+
+      it 'is compatible with original encoding' do
+        expect(subject.client_id.encode(encoding)).to eql(client_id)
+      end
+    end
+
+    context 'as Integer' do
+      let(:client_id) { 1 }
+
+      it 'raises an argument error' do
+        expect { subject.client_id }.to raise_error ArgumentError, /must be a String/
+      end
+    end
+  end
+end

data/spec/unit/logger_spec.rb

@@ -1,96 +1,107 @@
 require 'spec_helper'
 
 describe Ably::Logger do
-  let(:new_client) do
-    instance_double('Ably::Realtime::Client', connection: instance_double('Ably::Realtime::Connection', id: nil))
-  end
-  let(:connected_client) do
-    instance_double('Ably::Realtime::Client', connection: instance_double('Ably::Realtime::Connection', id: '0000'))
-  end
   let(:rest_client) do
     instance_double('Ably::Rest::Client')
   end
 
-  subject { Ably::Logger.new(new_client, Logger::INFO) }
+  subject { Ably::Logger.new(rest_client, Logger::INFO) }
 
   def uncolorize(string)
     regex_pattern = /\033\[[0-9]+m(.+?)\033\[0m/m
     string.gsub(regex_pattern, '\1')
   end
 
-  it 'uses the Ruby Logger by default' do
+  it 'uses the language provided Logger by default' do
     expect(subject.logger).to be_a(Logger)
   end
 
-  it 'delegates to the logger object' do
-    expect(subject.logger).to receive(:warn).with('message')
-    subject.warn 'message'
-  end
+  context 'internals', :api_private do
+    it 'delegates to the logger object' do
+      expect(subject.logger).to receive(:warn).with('message')
+      subject.warn 'message'
+    end
 
-  context 'formatter' do
-    context 'when debugging' do
-      it 'uses short time format' do
-        formatted = subject.logger.formatter.call(Logger::DEBUG, Time.now, 'progid', 'unique_message')
-        formatted = uncolorize(formatted)
-        expect(formatted).to match(/^\d+:\d+:\d+.\d{3} DEBUG/)
+    context 'formatter' do
+      context 'when debugging' do
+        it 'uses short time format' do
+          formatted = subject.logger.formatter.call(Logger::DEBUG, Time.now, 'progid', 'unique_message')
+          formatted = uncolorize(formatted)
+          expect(formatted).to match(/^\d+:\d+:\d+.\d{3} DEBUG/)
+        end
       end
-    end
 
-    context 'when info -> fatal' do
-      it 'uses long time format' do
-        formatted = subject.logger.formatter.call(Logger::INFO, Time.now, 'progid', 'unique_message')
-        formatted = uncolorize(formatted)
-        expect(formatted).to match(/^\d+-\d+-\d+ \d+:\d+:\d+.\d{3} INFO/)
+      context 'when info -> fatal' do
+        it 'uses long time format' do
+          formatted = subject.logger.formatter.call(Logger::INFO, Time.now, 'progid', 'unique_message')
+          formatted = uncolorize(formatted)
+          expect(formatted).to match(/^\d+-\d+-\d+ \d+:\d+:\d+.\d{3} INFO/)
+        end
       end
-    end
 
-    context 'with Realtime disconnected client' do
-      subject { Ably::Logger.new(new_client, Logger::INFO) }
+      if defined?(Ably::Realtime)
+        context 'with Realtime client' do
+          let(:new_realtime_client) do
+            instance_double('Ably::Realtime::Client', connection: instance_double('Ably::Realtime::Connection', id: nil))
+          end
+          let(:connected_realtime_client) do
+            instance_double('Ably::Realtime::Client', connection: instance_double('Ably::Realtime::Connection', id: '0000'))
+          end
+          before do
+            allow(new_realtime_client).to receive(:kind_of?).with(Ably::Realtime::Client).and_return(true)
+            allow(connected_realtime_client).to receive(:kind_of?).with(Ably::Realtime::Client).and_return(true)
+          end
 
-      it 'formats logs with an empty client ID' do
-        formatted = subject.logger.formatter.call(Logger::DEBUG, Time.now, 'progid', 'unique_message')
-        formatted = uncolorize(formatted)
-        expect(formatted).to match(/\[ \-\- \]/)
-        expect(formatted).to match(%r{unique_message$})
-        expect(formatted).to match(%r{DEBUG})
-      end
-    end
+          context 'with Realtime disconnected client' do
+            subject { Ably::Logger.new(new_realtime_client, Logger::INFO) }
+
+            it 'formats logs with an empty client ID' do
+              formatted = subject.logger.formatter.call(Logger::DEBUG, Time.now, 'progid', 'unique_message')
+              formatted = uncolorize(formatted)
+              expect(formatted).to match(/\[ \-\- \]/)
+              expect(formatted).to match(%r{unique_message$})
+              expect(formatted).to match(%r{DEBUG})
+            end
+          end
 
-    context 'with Realtime connected client' do
-      subject { Ably::Logger.new(connected_client, Logger::INFO) }
+          context 'with Realtime connected client' do
+            subject { Ably::Logger.new(connected_realtime_client, Logger::INFO) }
 
-      it 'formats logs with a client ID' do
-        formatted = subject.logger.formatter.call(Logger::DEBUG, Time.now, 'progid', 'unique_message')
-        formatted = uncolorize(formatted)
-        expect(formatted).to match(/\[0000]/)
-        expect(formatted).to match(%r{unique_message$})
-        expect(formatted).to match(%r{DEBUG})
+            it 'formats logs with a client ID' do
+              formatted = subject.logger.formatter.call(Logger::DEBUG, Time.now, 'progid', 'unique_message')
+              formatted = uncolorize(formatted)
+              expect(formatted).to match(/\[0000\]/)
+              expect(formatted).to match(%r{unique_message$})
+              expect(formatted).to match(%r{DEBUG})
+            end
+          end
+        end
       end
-    end
 
-    context 'with REST client' do
-      subject { Ably::Logger.new(rest_client, Logger::INFO) }
+      context 'with REST client' do
+        subject { Ably::Logger.new(rest_client, Logger::INFO) }
 
-      it 'formats logs without a client ID' do
-        formatted = subject.logger.formatter.call(Logger::FATAL, Time.now, 'progid', 'unique_message')
-        formatted = uncolorize(formatted)
-        expect(formatted).to_not match(/\[.*\]/)
-        expect(formatted).to match(%r{unique_message$})
-        expect(formatted).to match(%r{FATAL})
+        it 'formats logs without a client ID' do
+          formatted = subject.logger.formatter.call(Logger::FATAL, Time.now, 'progid', 'unique_message')
+          formatted = uncolorize(formatted)
+          expect(formatted).to_not match(/\[.*\]/)
+          expect(formatted).to match(%r{unique_message$})
+          expect(formatted).to match(%r{FATAL})
+        end
       end
-    end
 
-    context 'severity argument' do
-      it 'can be an Integer' do
-        formatted = subject.logger.formatter.call(Logger::INFO, Time.now, 'progid', 'unique_message')
-        formatted = uncolorize(formatted)
-        expect(formatted).to match(/^\d+-\d+-\d+ \d+:\d+:\d+.\d{3} INFO/)
-      end
+      context 'severity argument' do
+        it 'can be an Integer' do
+          formatted = subject.logger.formatter.call(Logger::INFO, Time.now, 'progid', 'unique_message')
+          formatted = uncolorize(formatted)
+          expect(formatted).to match(/^\d+-\d+-\d+ \d+:\d+:\d+.\d{3} INFO/)
+        end
 
-      it 'can be a string' do
-        formatted = subject.logger.formatter.call('INFO', Time.now, 'progid', 'unique_message')
-        formatted = uncolorize(formatted)
-        expect(formatted).to match(/^\d+-\d+-\d+ \d+:\d+:\d+.\d{3} INFO/)
+        it 'can be a string' do
+          formatted = subject.logger.formatter.call('INFO', Time.now, 'progid', 'unique_message')
+          formatted = uncolorize(formatted)
+          expect(formatted).to match(/^\d+-\d+-\d+ \d+:\d+:\d+.\d{3} INFO/)
+        end
       end
     end
   end
@@ -100,7 +111,7 @@ describe Ably::Logger do
       let(:custom_logger_with_bad_interface) do
         Class.new.new
       end
-      subject { Ably::Logger.new(new_client, Logger::INFO, custom_logger_with_bad_interface) }
+      subject { Ably::Logger.new(rest_client, Logger::INFO, custom_logger_with_bad_interface) }
 
       it 'raises an exception' do
         expect { subject }.to raise_error ArgumentError, /The custom Logger's interface does not provide the method/
@@ -119,14 +130,14 @@ describe Ably::Logger do
       end
       let(:custom_logger_object) { custom_logger.new }
 
-      subject { Ably::Logger.new(new_client, Logger::INFO, custom_logger_object) }
+      subject { Ably::Logger.new(rest_client, Logger::INFO, custom_logger_object) }
 
       it 'is used' do
         expect { subject }.to_not raise_error
         expect(subject.logger.class).to eql(custom_logger)
       end
 
-      it 'delegates log messages to logger' do
+      it 'delegates log messages to logger', :api_private do
         expect(custom_logger_object).to receive(:fatal).with('message')
         subject.fatal 'message'
       end