ably-rest 0.7.1 → 0.7.3

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

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+shared_examples 'a model' do |shared_options = {}|
+  let(:base_model_options) { shared_options.fetch(:base_model_options, {}) }
+  let(:args) { ([base_model_options.merge(model_options)] + model_args) }
+  let(:model) { subject.new(*args) }
+
+  context 'attributes' do
+    let(:unique_value) { random_str }
+
+    Array(shared_options[:with_simple_attributes]).each do |attribute|
+      context "##{attribute}" do
+        let(:model_options) { { attribute.to_sym => unique_value } }
+
+        it "retrieves attribute :#{attribute}" do
+          expect(model.public_send(attribute)).to eql(unique_value)
+        end
+      end
+    end
+
+    context '#hash', :api_private do
+      let(:model_options) { { action: 5 } }
+
+      it 'provides access to #hash' do
+        expect(model.hash).to eq(model_options)
+      end
+    end
+
+    context '#[]', :api_private do
+      let(:model_options) { { unusual: 'attribute' } }
+
+      it 'provides accessor method to #hash' do
+        expect(model[:unusual]).to eql('attribute')
+      end
+    end
+  end
+
+  context '#==' do
+    let(:model_options) { { channel: 'unique' } }
+
+    it 'is true when attributes are the same' do
+      new_message = -> { subject.new(*args) }
+      expect(new_message[]).to eq(new_message[])
+    end
+
+    it 'is false when attributes are not the same' do
+      expect(subject.new(*[action: 1] + model_args)).to_not eq(subject.new(*[action: 2] + model_args))
+    end
+
+    it 'is false when class type differs' do
+      expect(subject.new(*[action: 1] + model_args)).to_not eq(nil)
+    end
+  end
+
+  context '#to_msgpack', :api_private do
+    let(:model_options) { { name: 'test', action: 0, channel_snake_case: 'unique' } }
+    let(:serialized)    { model.to_msgpack }
+
+    it 'returns a msgpack object with Ably payload naming' do
+      expect(MessagePack.unpack(serialized)).to include('channelSnakeCase' => 'unique')
+    end
+  end
+
+  context '#to_json', :api_private do
+    let(:model_options) { { name: 'test', action: 0, channel_snake_case: 'unique' } }
+    let(:serialized)    { model.to_json }
+
+    it 'returns a JSON string with Ably payload naming' do
+      expect(JSON.parse(serialized)).to include('channelSnakeCase' => 'unique')
+    end
+  end
+
+  context 'is immutable' do
+    let(:model_options) { { channel: 'name' } }
+
+    it 'prevents changes' do
+      expect { model.hash[:channel] = 'new' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
+    end
+
+    it 'dups options' do
+      expect(model.hash[:channel]).to eql('name')
+      model_options[:channel] = 'new'
+      expect(model.hash[:channel]).to eql('name')
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+shared_examples 'a protocol message bus' do
+  describe '__protocol_msgbus__ PubSub', :api_private do
+    let(:protocol_message) do
+      Ably::Models::ProtocolMessage.new(
+        action: 15,
+        channel: 'channel',
+        msg_serial: 0,
+        messages: []
+      )
+    end
+
+    specify 'supports valid ProtocolMessage messages' do
+      received = 0
+      msgbus.subscribe(:protocol_message) { received += 1 }
+      expect { msgbus.publish(:protocol_message, protocol_message) }.to change { received }.to(1)
+    end
+
+    specify 'fail with unacceptable STATE event names' do
+      expect { msgbus.subscribe(:invalid) }.to raise_error KeyError
+      expect { msgbus.publish(:invalid) }.to raise_error KeyError
+      expect { msgbus.unsubscribe(:invalid) }.to raise_error KeyError
+    end
+  end
+end
+
+shared_examples 'an incoming protocol message bus' do
+  it_behaves_like 'a protocol message bus' do
+    let(:msgbus) { subject.__incoming_protocol_msgbus__ }
+  end
+end
+
+shared_examples 'an outgoing protocol message bus' do
+  it_behaves_like 'a protocol message bus' do
+    let(:msgbus) { subject.__outgoing_protocol_msgbus__ }
+  end
+end

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

@@ -0,0 +1,20 @@
+# Output the message to the console
+# Useful for debugging as clearly visible, and name is not used anywhere else in library as opposed to debug or puts
+def console(message)
+  puts "\033[31m[#{Time.now.strftime('%H:%M:%S.%L')}]\033[0m \033[33m#{message}\033[0m"
+end
+
+require 'webmock/rspec'
+
+require 'ably'
+
+require 'support/api_helper'
+require 'support/private_api_formatter'
+require 'support/protocol_helper'
+require 'support/random_helper'
+
+require 'rspec_config'
+
+# EM Helper must be loaded after rspec_config to ensure around block occurs before RSpec retry
+require 'support/event_machine_helper'
+require 'support/rest_testapp_before_retry'

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

@@ -0,0 +1,60 @@
+require 'support/test_app'
+
+module ApiHelper
+  def app_id
+    TestApp.instance.app_id
+  end
+
+  def key_id
+    TestApp.instance.key_id
+  end
+
+  def key_secret
+    api_key.split(':')[1]
+  end
+
+  def api_key
+    TestApp.instance.api_key
+  end
+
+  def restricted_api_key
+    TestApp.instance.restricted_api_key
+  end
+
+  def environment
+    TestApp.instance.environment
+  end
+
+  def reload_test_app
+    WebMock.disable!
+    TestApp.reload
+  end
+
+  def encode64(text)
+    Base64.encode64(text).gsub("\n", '')
+  end
+end
+
+RSpec.configure do |config|
+  config.include ApiHelper
+
+  config.before(:suite) do
+    WebMock.disable!
+  end
+
+  config.after(:suite) do
+    WebMock.disable!
+    TestApp.instance.delete
+  end
+end
+
+module ApiPreloader
+  def self.included(mod)
+    WebMock.disable!
+    TestApp.instance.api_key
+  end
+
+  RSpec.configure do |config|
+    config.include self, :file_path => %r(spec/acceptance)
+  end
+end

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

@@ -0,0 +1,104 @@
+require 'eventmachine'
+require 'rspec'
+require 'timeout'
+
+module RSpec
+  module EventMachine
+    extend self
+
+    DEFAULT_TIMEOUT = 10
+
+    def run_reactor(timeout = DEFAULT_TIMEOUT)
+      Timeout::timeout(timeout + 0.5) do
+        ::EventMachine.run do
+          yield
+        end
+      end
+    end
+
+    def stop_reactor
+      ::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)
+      raise ArgumentError, 'Block required' 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]) { yield }
+            else
+              yield
+            end
+          end
+        end
+
+        deferrable.errback do |error|
+          raise RuntimeError, "Deferrable failed: #{error.message}"
+        end
+      end
+    end
+
+    def wait_until(condition_block, &block)
+      raise ArgumentError, 'Block required' unless block_given?
+
+      yield if condition_block.call
+      ::EventMachine.add_timer(0.1) do
+        wait_until condition_block, &block
+      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
+
+  # Run the test block wrapped in an EventMachine reactor that has a configured timeout.
+  # As RSpec does not provide an API to wrap blocks, accessing the instance variables is required.
+  # Note, if you start a reactor and simply run the example with example#run then the example
+  # will run and not wait for the reactor to stop thus triggering after callbacks prematurely.
+  #
+  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
+
+    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
+      RSpec::EventMachine.run_reactor(timeout) do
+        example_group_instance.instance_exec(example, &example_block)
+      end
+    end
+
+    example.example.instance_variable_set('@example_block', event_machine_block)
+
+    example.run
+  end
+
+  config.before(:example) do
+    # Ensure EventMachine shutdown hooks are deregistered for every test
+    EventMachine.instance_variable_set '@tails', []
+  end
+end

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

@@ -0,0 +1,118 @@
+module Ably
+  module 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 = if documenting_rest_only?
+          File.open(File.expand_path('../../../../../../SPEC.md', __FILE__), 'w')
+        else
+          File.open(File.expand_path('../../../SPEC.md', __FILE__), 'w')
+        end
+
+        @indent  = 0
+        @passed  = 0
+        @pending = 0
+        @failed  = 0
+      end
+
+      def start(notification)
+        puts "\n\e[33m --> Creating SPEC.md <--\e[0m\n"
+        scope = if defined?(Ably::Realtime)
+          'Real-time & REST'
+        else
+          'REST'
+        end
+        output.write "# Ably #{scope} 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 documenting_rest_only?
+        File.exists?(File.expand_path('../../../../../../ably-rest.gemspec', __FILE__))
+      end
+
+      def example_name_and_link(notification)
+        "[#{notification.example.metadata[:description]}](#{path_for(notification.example.location).gsub(/\:(\d+)/, '#L\1')})"
+      end
+
+      def heading_location_path(notification)
+        "[#{notification.group.location.gsub(/\:(\d+)/, '').gsub(%r{^\.\/}, '')}](#{path_for(notification.group.location).gsub(/\:(\d+)/, '')})"
+      end
+
+      def path_for(location)
+        if documenting_rest_only?
+          "https://github.com/ably/ably-ruby/tree/#{submodule_sha}#{location.gsub(%r{^\./lib/submodules/ably-ruby}, '')}"
+        else
+          location
+        end
+      end
+
+      def submodule_sha
+        @sha ||= `git ls-tree HEAD:lib/submodules grep ably-ruby`[/^\w+\s+\w+\s+(\w+)/, 1]
+      end
+
+      def indent_prefix
+        if indent > 0
+          "#{'  ' * indent}* "
+        else
+          "\n### "
+        end
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/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