ably 0.7.0 → 0.7.1

data/spec/acceptance/rest/auth_spec.rb

@@ -5,17 +5,19 @@ describe Ably::Auth do
   include Ably::Modules::Conversions
 
   def hmac_for(token_request, secret)
-    text = token_request.values_at(
+    ruby_named_token_request = Ably::Models::IdiomaticRubyWrapper.new(token_request)
+
+    text = [
       :id,
       :ttl,
       :capability,
       :client_id,
       :timestamp,
       :nonce
-    ).map { |t| "#{t}\n" }.join("")
+    ].map { |key| "#{ruby_named_token_request[key]}\n" }.join("")
 
     encode64(
-      Digest::HMAC.digest(text, key_secret, Digest::SHA256)
+      OpenSSL::HMAC.digest(OpenSSL::Digest::SHA256.new, secret, text)
     )
   end
 
@@ -38,7 +40,7 @@ describe Ably::Auth do
       else
         JSON.parse(request.body)
       end
-      body[key.to_s].to_s == val.to_s
+      body[convert_to_mixed_case(key)].to_s == val.to_s
     end
 
     def serialize(object, protocol)
@@ -50,7 +52,7 @@ describe Ably::Auth do
     end
 
     it 'has immutable options' do
-      expect { auth.options['key_id'] = 'new_id' }.to raise_error RuntimeError, /can't modify frozen Hash/
+      expect { auth.options['key_id'] = 'new_id' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
     end
 
     describe '#request_token' do
@@ -70,7 +72,7 @@ describe Ably::Auth do
       end
 
       %w(client_id capability nonce timestamp ttl).each do |option|
-        context "option :#{option}", :webmock do
+        context "with option :#{option}", :webmock do
           let(:random)         { random_int_str }
           let(:options)        { { option.to_sym => random } }
 
@@ -88,7 +90,7 @@ describe Ably::Auth do
 
           before { auth.request_token options }
 
-          it 'overrides default' do
+          it 'overrides default and uses camelCase notation for all attributes' do
             expect(request_token_stub).to have_been_requested
           end
         end
@@ -134,7 +136,7 @@ describe Ably::Auth do
       context 'without :query_time option' do
         let(:options) { { query_time: false } }
 
-        it 'queries the server for the time' do
+        it 'does not query the server for the time' do
           expect(client).to_not receive(:time)
           auth.request_token(options)
         end
@@ -356,25 +358,25 @@ describe Ably::Auth do
       subject { auth.create_token_request(options) }
 
       it 'uses the key ID from the client' do
-        expect(subject[:id]).to eql(key_id)
+        expect(subject['id']).to eql(key_id)
       end
 
       it 'uses the default TTL' do
-        expect(subject[:ttl]).to eql(Ably::Models::Token::DEFAULTS[:ttl])
+        expect(subject['ttl']).to eql(Ably::Models::Token::DEFAULTS[:ttl])
       end
 
       it 'uses the default capability' do
-        expect(subject[:capability]).to eql(Ably::Models::Token::DEFAULTS[:capability].to_json)
+        expect(subject['capability']).to eql(Ably::Models::Token::DEFAULTS[:capability].to_json)
       end
 
       context 'the nonce' do
         it 'is unique for every request' do
-          unique_nonces = 100.times.map { auth.create_token_request[:nonce] }
+          unique_nonces = 100.times.map { auth.create_token_request['nonce'] }
           expect(unique_nonces.uniq.length).to eql(100)
         end
 
         it 'is at least 16 characters' do
-          expect(subject[:nonce].length).to be >= 16
+          expect(subject['nonce'].length).to be >= 16
         end
       end
 
@@ -385,7 +387,7 @@ describe Ably::Auth do
             options[attribute.to_sym] = option_value
           end
           it "overrides default" do
-            expect(subject[attribute.to_sym].to_s).to eql(option_value.to_s)
+            expect(subject[convert_to_mixed_case(attribute)].to_s).to eql(option_value.to_s)
           end
         end
       end
@@ -394,8 +396,9 @@ describe Ably::Auth do
         let(:options) { { nonce: 'valid', is_not_used_by_token_request: 'invalid' } }
         specify 'are ignored' do
           expect(subject.keys).to_not include(:is_not_used_by_token_request)
-          expect(subject.keys).to include(:nonce)
-          expect(subject[:nonce]).to eql('valid')
+          expect(subject.keys).to_not include(convert_to_mixed_case(:is_not_used_by_token_request))
+          expect(subject.keys).to include('nonce')
+          expect(subject['nonce']).to eql('valid')
         end
       end
 
@@ -417,7 +420,7 @@ describe Ably::Auth do
 
         it 'queries the server for the timestamp' do
           expect(client).to receive(:time).and_return(time)
-          expect(subject[:timestamp]).to eql(time.to_i)
+          expect(subject['timestamp']).to eql(time.to_i)
         end
       end
 
@@ -426,7 +429,7 @@ describe Ably::Auth do
         let(:options) { { timestamp: token_request_time } }
 
         it 'uses the provided timestamp in the token request' do
-          expect(subject[:timestamp]).to eql(token_request_time.to_i)
+          expect(subject['timestamp']).to eql(token_request_time.to_i)
         end
       end
 
@@ -444,7 +447,7 @@ describe Ably::Auth do
 
         it 'generates a valid HMAC' do
           hmac = hmac_for(options, key_secret)
-          expect(subject[:mac]).to eql(hmac)
+          expect(subject['mac']).to eql(hmac)
         end
       end
     end

data/spec/acceptance/rest/client_spec.rb

@@ -54,12 +54,12 @@ describe Ably::Rest::Client do
 
         it 'creates a new token automatically when the old token expires' do
           expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(token_request_1[:client_id])
+          expect(client.auth.current_token.client_id).to eql(token_request_1['clientId'])
 
           sleep 1
 
           expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(token_request_2[:client_id])
+          expect(client.auth.current_token.client_id).to eql(token_request_2['clientId'])
         end
       end
 
@@ -68,12 +68,12 @@ describe Ably::Rest::Client do
 
         it 'reuses the existing token for every request' do
           expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(token_request_1[:client_id])
+          expect(client.auth.current_token.client_id).to eql(token_request_1['clientId'])
 
           sleep 1
 
           expect { client.channel('channel_name').publish('event', 'message') }.to_not change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(token_request_1[:client_id])
+          expect(client.auth.current_token.client_id).to eql(token_request_1['clientId'])
         end
       end
     end

data/spec/acceptance/rest/presence_spec.rb

@@ -18,13 +18,13 @@ describe Ably::Rest::Presence do
     end
 
     context 'tested against presence fixture data set up in test app' do
-      before(:context) do
-        # When this test is run as a part of a test suite, the presence data injected in the test app may have expired
-        WebMock.disable!
-        TestApp.reload
-      end
-
       describe '#get' do
+        before(:context) do
+          # When this test is run as a part of a test suite, the presence data injected in the test app may have expired
+          WebMock.disable!
+          TestApp.reload
+        end
+
         let(:channel) { client.channel('persisted:presence_fixtures') }
         let(:presence) { channel.presence.get }
 
@@ -52,6 +52,12 @@ describe Ably::Rest::Presence do
       end
 
       describe '#history' do
+        before(:context) do
+          # When this test is run as a part of a test suite, the presence data injected in the test app may have expired
+          WebMock.disable!
+          TestApp.reload
+        end
+
         let(:channel) { client.channel('persisted:presence_fixtures') }
         let(:presence_history) { channel.presence.history }
 

data/spec/rspec_config.rb

@@ -5,6 +5,8 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
+require 'rspec/retry'
+
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
@@ -45,4 +47,11 @@ RSpec.configure do |config|
   end
 
   config.add_formatter Ably::RSpec::PrivateApiFormatter
+
+  if ENV['RSPEC_RETRY']
+    puts 'Running tests using RSpec retry'
+    config.verbose_retry = true # show retry status in spec process
+    config.default_retry_count = 3
+    config.default_sleep_interval = 2
+  end
 end

data/spec/shared/model_behaviour.rb

@@ -74,7 +74,7 @@ shared_examples 'a model' do |shared_options = {}|
     let(:model_options) { { channel: 'name' } }
 
     it 'prevents changes' do
-      expect { model.hash[:channel] = 'new' }.to raise_error RuntimeError, /can't modify frozen Hash/
+      expect { model.hash[:channel] = 'new' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
     end
 
     it 'dups options' do

data/spec/spec_helper.rb

@@ -9,9 +9,12 @@ require 'webmock/rspec'
 require 'ably'
 
 require 'support/api_helper'
-require 'support/event_machine_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/spec/support/event_machine_helper.rb

@@ -6,7 +6,7 @@ module RSpec
   module EventMachine
     extend self
 
-    DEFAULT_TIMEOUT = 5
+    DEFAULT_TIMEOUT = 10
 
     def run_reactor(timeout = DEFAULT_TIMEOUT)
       Timeout::timeout(timeout + 0.5) do
@@ -24,8 +24,8 @@ module RSpec
 
     # 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?
+    def when_all(*deferrables)
+      raise ArgumentError, 'Block required' unless block_given?
 
       options = if deferrables.last.kind_of?(Hash)
         deferrables.pop
@@ -40,9 +40,9 @@ module RSpec
           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 }
+              ::EventMachine.add_timer(options[:and_wait]) { yield }
             else
-              block.call
+              yield
             end
           end
         end
@@ -52,6 +52,15 @@ module RSpec
         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
 
@@ -62,32 +71,11 @@ RSpec.configure do |config|
     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.
+  # 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.
   #
-  # 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]
@@ -95,17 +83,18 @@ RSpec.configure do |config|
       RSpec::EventMachine::DEFAULT_TIMEOUT
     end
 
-    patch_example_block_with_surrounding_eventmachine_reactor example
+    example_block          = example.example.instance_variable_get('@example_block')
+    example_group_instance = example.example.instance_variable_get('@example_group_instance')
 
-    begin
+    event_machine_block = Proc.new do
       RSpec::EventMachine.run_reactor(timeout) do
-        example.call
-        raise example.exception if example.exception
+        example_group_instance.instance_exec(example, &example_block)
       end
-    ensure
-      example.example.run_after_example_original
-      remove_patch_example_block example
     end
+
+    example.example.instance_variable_set('@example_block', event_machine_block)
+
+    example.run
   end
 
   config.before(:example) do

data/spec/support/markdown_spec_formatter.rb

@@ -1,89 +1,117 @@
-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
+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"
-      output.write "# Ably Client Library #{Ably::VERSION} Specification\n"
-    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 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_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_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
+      def example_passed(notification)
+        unless notification.example.metadata[:api_private]
+          output.write "#{indent_prefix}#{example_name_and_link(notification)}\n"
+          @passed += 1
+        end
       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
+      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
-    end
 
-    def example_pending(notification)
-      unless notification.example.metadata[:api_private]
-        output.write "#{indent_prefix}PENDING: *#{example_name_and_link(notification)}*\n"
-        @pending += 1
+      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
-    end
 
-    def dump_summary(notification)
-      output.write <<-EOF.gsub('        ', '')
+      def dump_summary(notification)
+        output.write <<-EOF.gsub('        ', '')
 
-        -------
+          -------
 
-        ## Test summary
+          ## Test summary
 
-        * Passing tests: #{@passed}
-        * Pending tests: #{@pending}
-        * Failing tests: #{@failed}
-      EOF
-    end
+          * Passing tests: #{@passed}
+          * Pending tests: #{@pending}
+          * Failing tests: #{@failed}
+        EOF
+      end
 
-    private
-    attr_reader :output, :indent
+      private
+      attr_reader :output, :indent
 
-    def example_name_and_link(notification)
-      "[#{notification.example.metadata[:description]}](#{notification.example.location.gsub(/\:(\d+)/, '#L\1')})"
-    end
+      def documenting_rest_only?
+        File.exists?(File.expand_path('../../../../../../ably-rest.gemspec', __FILE__))
+      end
 
-    def heading_location_path(notification)
-      "[#{notification.group.location.gsub(/\:(\d+)/, '').gsub(%r{^.\/}, '')}](#{notification.group.location.gsub(/\:(\d+)/, '')})"
-    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### "
+      def indent_prefix
+        if indent > 0
+          "#{'  ' * indent}* "
+        else
+          "\n### "
+        end
       end
     end
   end