ably 0.6.2 → 0.7.0

data/lib/ably/rest.rb

@@ -36,8 +36,8 @@ module Ably
     #    # create a new client authenticating with basic auth and a client_id
     #    client = Ably::Rest.new(api_key: 'key.id:secret', client_id: 'john')
     #
-    def self.new(options, &auth_block)
-      Ably::Rest::Client.new(options, &auth_block)
+    def self.new(options, &token_request_block)
+      Ably::Rest::Client.new(options, &token_request_block)
     end
   end
 end

data/lib/ably/rest/channel.rb

@@ -23,6 +23,8 @@ module Ably
       # @option channel_options [Hash]     :cipher_params   A hash of options to configure the encryption. *:key* is required, all other options are optional.  See {Ably::Util::Crypto#initialize} for a list of `cipher_params` options
       #
       def initialize(client, name, channel_options = {})
+        ensure_utf_8 :name, name
+
         @client  = client
         @name    = name
         @options = channel_options.clone.freeze
@@ -34,6 +36,8 @@ module Ably
       # @param data [String] The message payload
       # @return [Boolean] true if the message was published, otherwise false
       def publish(name, data)
+        ensure_utf_8 :name, name
+
         payload = {
           name: name,
           data: data
@@ -62,19 +66,18 @@ module Ably
         url = "#{base_path}/messages"
         options = options.dup
 
-        merge_options = { live: true }  # TODO: Remove live param as all history should be live
-        [:start, :end].each { |option| merge_options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
+        [:start, :end].each { |option| options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
 
         paginated_options = {
           coerce_into: 'Ably::Models::Message',
           async_blocking_operations: options.delete(:async_blocking_operations),
         }
 
-        response = client.get(url, options.merge(merge_options))
+        response = client.get(url, options)
 
         Ably::Models::PaginatedResource.new(response, url, client, paginated_options) do |message|
           message.tap do |message|
-            message.decode self
+            decode_message message
           end
         end
       end
@@ -90,6 +93,12 @@ module Ably
       def base_path
         "/channels/#{CGI.escape(name)}"
       end
+
+      def decode_message(message)
+        message.decode self
+      rescue Ably::Exceptions::CipherError, Ably::Exceptions::EncoderError => e
+        client.logger.error "Decoding Error on channel '#{name}', message event name '#{message.name}'. #{e.class.name}: #{e.message}"
+      end
     end
   end
 end

data/lib/ably/rest/client.rb

@@ -8,34 +8,56 @@ module Ably
   module Rest
     # Client for the Ably REST API
     #
-    # @!attribute [r] auth
-    #   @return {Ably::Auth} authentication object configured for this connection
     # @!attribute [r] client_id
     #   @return [String] A client ID, used for identifying this client for presence purposes
     # @!attribute [r] auth_options
     #   @return [Hash] {Ably::Auth} options configured for this client
-    # @!attribute [r] environment
-    #   @return [String] May contain 'sandbox' when testing the client library against an alternate Ably environment
-    # @!attribute [r] log_level
-    #   @return [Logger::Severity] Log level configured for this {Client}
-    # @!attribute [r] channels
-    #   @return [Aby::Rest::Channels] The collection of {Ably::Rest::Channel}s that have been created
-    # @!attribute [r] protocol
-    #   @return [Symbol] The protocol configured for this client, either binary `:msgpack` or text based `:json`
     #
     class Client
       include Ably::Modules::Conversions
       include Ably::Modules::HttpHelpers
       extend Forwardable
 
+      # Default Ably domain for REST
       DOMAIN = 'rest.ably.io'
 
-      attr_reader :environment, :protocol, :auth, :channels, :log_level
+      # Configuration for connection retry attempts
+      CONNECTION_RETRY = {
+        single_request_open_timeout: 4,
+        single_request_timeout: 15,
+        cumulative_request_open_timeout: 10,
+        max_retry_attempts: 3
+      }.freeze
+
       def_delegators :auth, :client_id, :auth_options
 
-      # @api private
+      # Custom environment to use such as 'sandbox' when testing the client library against an alternate Ably environment
+      # @return [String]
+      attr_reader :environment
+
+      # The protocol configured for this client, either binary `:msgpack` or text based `:json`
+      # @return [Symbol]
+      attr_reader :protocol
+
+      # {Ably::Auth} authentication object configured for this connection
+      # @return [Ably::Auth]
+      attr_reader :auth
+
+      # The collection of {Ably::Rest::Channel}s that have been created
+      # @return [Aby::Rest::Channels]
+      attr_reader :channels
+
+      # Log level configured for this {Client}
+      # @return [Logger::Severity]
+      attr_reader :log_level
+
+      # The custom host that is being used if it was provided with the option `:rest_host` when the {Client} was created
+      # @return [String,Nil]
+      attr_reader :custom_host
+
       # The registered encoders that are used to encode and decode message payloads
       # @return [Array<Ably::Models::MessageEncoder::Base>]
+      # @api private
       attr_reader :encoders
 
       # The additional options passed to this Client's #initialize method not available as attributes of this class
@@ -47,12 +69,13 @@ module Ably
       #
       # @param [Hash,String] options an options Hash used to configure the client and the authentication, or String with an API key
       # @option options (see Ably::Auth#authorise)
-      # @option options [Boolean]                 :tls                 TLS is used by default, providing a value of false disbles TLS.  Please note Basic Auth is disallowed without TLS as secrets cannot be transmitted over unsecured connections.
+      # @option options [Boolean]                 :tls                 TLS is used by default, providing a value of false disables TLS.  Please note Basic Auth is disallowed without TLS as secrets cannot be transmitted over unsecured connections.
       # @option options [String]                  :api_key             API key comprising the key ID and key secret in a single string
+      # @option options [Boolean]                 :use_token_auth      Will force Basic Auth if set to false, and TOken auth if set to true
       # @option options [String]                  :environment         Specify 'sandbox' when testing the client library against an alternate Ably environment
       # @option options [Symbol]                  :protocol            Protocol used to communicate with Ably, :json and :msgpack currently supported. Defaults to :msgpack
       # @option options [Boolean]                 :use_binary_protocol Protocol used to communicate with Ably, defaults to true and uses MessagePack protocol.  This option will overide :protocol option
-      # @option options [Logger::Severity,Symbol] :log_level           Log level for the standard Logger that outputs to STDOUT.  Defaults to Logger::ERROR, can be set to :fatal (Logger::FATAL), :error (Logger::ERROR), :warn (Logger::WARN), :info (Logger::INFO), :debug (Logger::DEBUG)
+      # @option options [Logger::Severity,Symbol] :log_level           Log level for the standard Logger that outputs to STDOUT.  Defaults to Logger::ERROR, can be set to :fatal (Logger::FATAL), :error (Logger::ERROR), :warn (Logger::WARN), :info (Logger::INFO), :debug (Logger::DEBUG) or :none
       # @option options [Logger]                  :logger              A custom logger can be used however it must adhere to the Ruby Logger interface, see http://www.ruby-doc.org/stdlib-1.9.3/libdoc/logger/rdoc/Logger.html
       #
       # @yield (see Ably::Auth#authorise)
@@ -68,7 +91,9 @@ module Ably
       #    # create a new client and configure a client ID used for presence
       #    client = Ably::Rest::Client.new(api_key: 'key.id:secret', client_id: 'john')
       #
-      def initialize(options, &auth_block)
+      def initialize(options, &token_request_block)
+        raise ArgumentError, 'Options Hash is expected' if options.nil?
+
         options = options.clone
         if options.kind_of?(String)
           options = { api_key: options }
@@ -80,8 +105,13 @@ module Ably
         @debug_http    = options.delete(:debug_http)
         @log_level     = options.delete(:log_level) || ::Logger::ERROR
         @custom_logger = options.delete(:logger)
+        @custom_host   = options.delete(:rest_host)
 
-        @log_level     = ::Logger.const_get(log_level.to_s.upcase) if log_level.kind_of?(Symbol) || log_level.kind_of?(String)
+        if @log_level == :none
+          @custom_logger = Ably::Models::NilLogger.new
+        else
+          @log_level = ::Logger.const_get(log_level.to_s.upcase) if log_level.kind_of?(Symbol) || log_level.kind_of?(String)
+        end
 
         options.delete(:use_binary_protocol).tap do |use_binary_protocol|
           if use_binary_protocol == true
@@ -93,7 +123,7 @@ module Ably
         raise ArgumentError, 'Protocol is invalid.  Must be either :msgpack or :json' unless [:msgpack, :json].include?(@protocol)
 
         @options  = options.freeze
-        @auth     = Auth.new(self, options, &auth_block)
+        @auth     = Auth.new(self, options, &token_request_block)
         @channels = Ably::Rest::Channels.new(self)
         @encoders = []
 
@@ -157,10 +187,7 @@ module Ably
       # @!attribute [r] endpoint
       # @return [URI::Generic] Default Ably REST endpoint used for all requests
       def endpoint
-        URI::Generic.build(
-          scheme: use_tls? ? "https" : "http",
-          host:   [@environment, DOMAIN].compact.join('-')
-        )
+        endpoint_for_host(custom_host || [@environment, DOMAIN].compact.join('-'))
       end
 
       # @!attribute [r] logger
@@ -191,7 +218,9 @@ module Ably
       # @api private
       def register_encoder(encoder)
         encoder_klass = if encoder.kind_of?(String)
-          Object.const_get(encoder)
+          encoder.split('::').inject(Kernel) do |base, klass_name|
+            base.public_send(:const_get, klass_name)
+          end
         else
           encoder
         end
@@ -207,37 +236,104 @@ module Ably
         protocol == :msgpack
       end
 
+      # Connection used to make HTTP requests
+      #
+      # @param [Hash] options
+      # @option options [Boolean] :use_fallback when true, one of the fallback connections is used randomly, see {Ably::FALLBACK_HOSTS}
+      #
+      # @return [Faraday::Connection]
+      #
+      # @api private
+      def connection(options = {})
+        if options[:use_fallback]
+          fallback_connection
+        else
+          @connection ||= Faraday.new(endpoint.to_s, connection_options)
+        end
+      end
+
+      # Fallback connection used to make HTTP requests.
+      # Note, each request uses a random and then subsequent random {Ably::FALLBACK_HOSTS fallback host}
+      #
+      # @return [Faraday::Connection]
+      #
+      # @api private
+      def fallback_connection
+        unless @fallback_connections
+          @fallback_connections = Ably::FALLBACK_HOSTS.shuffle.map { |host| Faraday.new(endpoint_for_host(host).to_s, connection_options) }
+        end
+        @fallback_index ||= 0
+
+        @fallback_connections[@fallback_index % @fallback_connections.count].tap do
+          @fallback_index += 1
+        end
+      end
+
       private
       def request(method, path, params = {}, options = {})
-        reauthorise_on_authorisation_failure do
-          connection.send(method, path, params) do |request|
+        options = options.clone
+        if options.delete(:disable_automatic_reauthorise) == true
+          send_request(method, path, params, options)
+        else
+          reauthorise_on_authorisation_failure do
+            send_request(method, path, params, options)
+          end
+        end
+      end
+
+      # Sends HTTP request to connection end point
+      # Connection failures will automatically be reattempted until thresholds are met
+      def send_request(method, path, params, options)
+        max_retry_attempts = CONNECTION_RETRY.fetch(:max_retry_attempts)
+        cumulative_timeout = CONNECTION_RETRY.fetch(:cumulative_request_open_timeout)
+        requested_at       = Time.now
+        retry_count        = 0
+
+        begin
+          use_fallback = can_fallback_to_alternate_ably_host? && retry_count > 0
+
+          connection(use_fallback: use_fallback).send(method, path, params) do |request|
             unless options[:send_auth_header] == false
               request.headers[:authorization] = auth.auth_header
             end
           end
+
+        rescue Faraday::TimeoutError, Faraday::ClientError => error
+          time_passed = Time.now - requested_at
+          if can_fallback_to_alternate_ably_host? && retry_count < max_retry_attempts && time_passed <= cumulative_timeout
+            retry_count += 1
+            retry
+          end
+
+          case error
+            when Faraday::TimeoutError
+              raise Ably::Exceptions::ConnectionTimeoutError.new(error.message, nil, 80014, error)
+            when Faraday::ClientError
+              raise Ably::Exceptions::ConnectionError.new(error.message, nil, 80000, error)
+          end
         end
       end
 
       def reauthorise_on_authorisation_failure
-        attempts = 0
-        begin
-          yield
-        rescue Ably::Exceptions::InvalidRequest => e
-          attempts += 1
-          if attempts == 1 && e.code == 40140 && auth.token_renewable?
+        yield
+      rescue Ably::Exceptions::InvalidRequest => e
+        if e.code == 40140
+          if auth.token_renewable?
             auth.authorise force: true
-            retry
+            yield
           else
             raise Ably::Exceptions::InvalidToken.new(e.message, e.status, e.code)
           end
+        else
+          raise e
         end
       end
 
-      # Return a Faraday::Connection to use to make HTTP requests
-      #
-      # @return [Faraday::Connection]
-      def connection
-        @connection ||= Faraday.new(endpoint.to_s, connection_options)
+      def endpoint_for_host(host)
+        URI::Generic.build(
+          scheme: use_tls? ? 'https' : 'http',
+          host:   host
+        )
       end
 
       # Return a Hash of connection options to initiate the Faraday::Connection with
@@ -252,8 +348,8 @@ module Ably
             user_agent:   user_agent
           },
           request: {
-            open_timeout: 5,
-            timeout:      10
+            open_timeout: CONNECTION_RETRY.fetch(:single_request_open_timeout),
+            timeout:      CONNECTION_RETRY.fetch(:single_request_timeout)
           }
         }
       end
@@ -275,6 +371,10 @@ module Ably
         end
       end
 
+      def can_fallback_to_alternate_ably_host?
+        !custom_host && !environment
+      end
+
       def initialize_default_encoders
         Ably::Models::MessageEncoders.register_default_encoders self
       end

data/lib/ably/rest/middleware/logger.rb

@@ -18,19 +18,40 @@ module Ably
 
         def call(env)
           debug "=> URL: #{env.method} #{env.url}, Headers: #{dump_headers env.request_headers}"
-          debug "=> Body: #{env.body}"
-          @app.call env
+          debug "=> Body: #{body_for(env)}"
+          super
         end
 
         def on_complete(env)
           debug "<= Status: #{env.status}, Headers: #{dump_headers env.response_headers}"
-          debug "<= Body: #{env.body}"
+          debug "<= Body: #{body_for(env)}"
         end
 
         private
         def dump_headers(headers)
           headers.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
         end
+
+        def body_for(env)
+          return '' if !env.body || env.body.empty?
+
+          if env.request_headers['Content-Type'] == 'application/x-msgpack'
+            MessagePack.unpack(env.body)
+          else
+            env.body
+          end
+
+        rescue StandardError
+          "Error displaying body: (as hex) '#{readable_body(env.body)}'"
+        end
+
+        def readable_body(body)
+          if body.respond_to?(:encoding) && body.encoding == Encoding::ASCII_8BIT
+            body.unpack('H*')
+          else
+            body
+          end
+        end
       end
     end
   end

data/lib/ably/rest/presence.rb

@@ -41,8 +41,8 @@ module Ably
         response = client.get(base_path, options)
 
         Ably::Models::PaginatedResource.new(response, base_path, client, paginated_options) do |presence_message|
-          presence_message.tap do |message|
-            message.decode self.channel
+          presence_message.tap do |presence_message|
+            decode_message presence_message
           end
         end
       end
@@ -61,19 +61,18 @@ module Ably
         url = "#{base_path}/history"
         options = options.dup
 
-        merge_options = { live: true }  # TODO: Remove live param as all history should be live
-        [:start, :end].each { |option| merge_options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
+        [:start, :end].each { |option| options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
 
         paginated_options = {
           coerce_into: 'Ably::Models::PresenceMessage',
           async_blocking_operations: options.delete(:async_blocking_operations),
         }
 
-        response = client.get(url, options.merge(merge_options))
+        response = client.get(url, options)
 
         Ably::Models::PaginatedResource.new(response, url, client, paginated_options) do |presence_message|
-          presence_message.tap do |message|
-            message.decode self.channel
+          presence_message.tap do |presence_message|
+            decode_message presence_message
           end
         end
       end
@@ -82,6 +81,12 @@ module Ably
       def base_path
         "/channels/#{CGI.escape(channel.name)}/presence"
       end
+
+      def decode_message(presence_message)
+        presence_message.decode self.channel
+      rescue Ably::Exceptions::CipherError, Ably::Exceptions::EncoderError => e
+        client.logger.error "Decoding Error on presence channel '#{channel.name}', presence message client_id '#{presence_message.client_id}'. #{e.class.name}: #{e.message}"
+      end
     end
   end
 end

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.6.2'
+  VERSION = '0.7.0'
 end

data/spec/acceptance/realtime/channel_history_spec.rb

@@ -1,136 +1,152 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'securerandom'
 
-describe Ably::Realtime::Channel do
-  include RSpec::EventMachine
+describe Ably::Realtime::Channel, '#history', :event_machine do
+  vary_by_protocol do
+    let(:default_options) { options.merge(api_key: api_key, environment: environment, protocol: protocol) }
 
-  [:json].each do |protocol| # :msgpack,
-    context "over #{protocol}" do
-      let(:default_options) { options.merge(api_key: api_key, environment: environment, protocol: protocol) }
+    let(:client)       { Ably::Realtime::Client.new(default_options) }
+    let(:channel)      { client.channel(channel_name) }
 
-      let(:client) do
-        Ably::Realtime::Client.new(default_options)
-      end
-      let(:channel) { client.channel(channel_name) }
-
-      let(:client2) do
-        Ably::Realtime::Client.new(default_options)
-      end
-      let(:channel2) { client2.channel(channel_name) }
+    let(:client2)      { Ably::Realtime::Client.new(default_options) }
+    let(:channel2)     { client2.channel(channel_name) }
 
-      let(:channel_name) { "persisted:#{SecureRandom.hex(2)}" }
-      let(:payload) { SecureRandom.hex(4) }
-      let(:messages) { [] }
+    let(:channel_name) { "persisted:#{random_str(2)}" }
+    let(:payload)      { random_str }
+    let(:messages)     { [] }
 
-      let(:options) { { :protocol => :json } }
+    let(:options)      { { :protocol => :json } }
 
-      it 'returns a Deferrable' do
-        run_reactor do
-          channel.publish('event', payload) do |message|
-            expect(channel.history).to be_a(EventMachine::Deferrable)
-            stop_reactor
-          end
+    it 'returns a Deferrable' do
+      channel.publish('event', payload) do |message|
+        history = channel.history
+        expect(history).to be_a(EventMachine::Deferrable)
+        history.callback do |messages|
+          expect(messages.count).to eql(1)
+          expect(messages).to be_a(Ably::Models::PaginatedResource)
+          stop_reactor
         end
       end
+    end
 
+    context 'with a single client publishing and receiving' do
       it 'retrieves real-time history' do
-        run_reactor do
-          channel.publish('event', payload) do |message|
-            channel.history do |history|
-              expect(history.length).to eql(1)
-              expect(history[0].data).to eql(payload)
-              stop_reactor
-            end
+        channel.publish('event', payload) do |message|
+          channel.history do |history|
+            expect(history.length).to eql(1)
+            expect(history[0].data).to eql(payload)
+            stop_reactor
           end
         end
       end
+    end
+
+    context 'with two clients publishing messages on the same channel' do
+      it 'retrieves real-time history on both channels' do
+        channel.publish('event', payload) do |message|
+          channel2.publish('event', payload) do |message|
+            channel.history do |history|
+              expect(history.length).to eql(2)
+              expect(history.map(&:data).uniq).to eql([payload])
 
-      it 'retrieves real-time history across two channels' do
-        run_reactor do
-          channel.publish('event', payload) do |message|
-            channel2.publish('event', payload) do |message|
-              channel2.history do |history|
-                expect(history.length).to eql(2)
-                expect(history.map(&:data).uniq).to eql([payload])
+              channel2.history do |history_2|
+                expect(history_2.length).to eql(2)
                 stop_reactor
               end
             end
           end
         end
       end
+    end
+
+    context 'with lots of messages published with a single client and channel' do
+      let(:messages_sent) { 40 }
+      let(:limit)         { 20 }
 
-      context 'with multiple messages' do
-        let(:messages_sent) { 20 }
-        let(:limit) { 10 }
+      def ensure_message_history_direction_and_paging_is_correct(direction)
+        channel.history(direction: direction, limit: limit) do |history|
+          expect(history.length).to eql(limit)
+          limit.times do |index|
+            expect(history[index].data).to eql("history#{index}")
+          end
 
-        def check_limited_history(direction)
-          channel.history(direction: direction, limit: limit) do |history|
+          history.next_page do |history|
             expect(history.length).to eql(limit)
             limit.times do |index|
-              expect(history[index].data).to eql("history#{index}")
+              expect(history[index].data).to eql("history#{index + limit}")
             end
+            expect(history.last_page?).to eql(true)
 
-            history.next_page do |history|
-              expect(history.length).to eql(limit)
-              limit.times do |index|
-                expect(history[index].data).to eql("history#{index + limit}")
-              end
-              expect(history.last_page?).to eql(true)
+            stop_reactor
+          end
+        end
+      end
 
-              stop_reactor
+      context 'as one ProtocolMessage' do
+        it 'retrieves history forwards with pagination through :limit option' do
+          messages_sent.times do |index|
+            channel.publish('event', "history#{index}") do
+              next unless index == messages_sent - 1
+              ensure_message_history_direction_and_paging_is_correct :forwards
             end
           end
         end
 
-        context 'as one ProtocolMessage' do
-          it 'retrieves limited history forwards with pagination' do
-            run_reactor(5) do
-              messages_sent.times do |index|
-                channel.publish('event', "history#{index}") do
-                  check_limited_history :forwards if index == messages_sent - 1
-                end
-              end
+        it 'retrieves history backwards with pagination through :limit option' do
+          messages_sent.times.to_a.reverse.each do |index|
+            channel.publish('event', "history#{index}") do
+              next unless index == 0
+              ensure_message_history_direction_and_paging_is_correct :backwards
             end
           end
+        end
+      end
 
-          it 'retrieves limited history backwards with pagination' do
-            run_reactor(5) do
-              messages_sent.times.to_a.reverse.each do |index|
-                channel.publish('event', "history#{index}") do
-                  check_limited_history :backwards if index == messages_sent - 1
-                end
+      context 'in multiple ProtocolMessages' do
+        it 'retrieves limited history forwards with pagination' do
+          messages_sent.times do |index|
+            EventMachine.add_timer(index.to_f / 10) do
+              channel.publish('event', "history#{index}") do
+                next unless index == messages_sent - 1
+                ensure_message_history_direction_and_paging_is_correct :forwards
               end
             end
           end
         end
 
-        context 'in multiple ProtocolMessages' do
-          it 'retrieves limited history forwards with pagination' do
-            run_reactor(5) do
-              messages_sent.times do |index|
-                EventMachine.add_timer(index.to_f / 10) do
-                  channel.publish('event', "history#{index}") do
-                    check_limited_history :forwards if index == messages_sent - 1
-                  end
-                end
+        it 'retrieves limited history backwards with pagination' do
+          messages_sent.times.to_a.reverse.each do |index|
+            EventMachine.add_timer((messages_sent - index).to_f / 10) do
+              channel.publish('event', "history#{index}") do
+                next unless index == 0
+                ensure_message_history_direction_and_paging_is_correct :backwards if index == 0
               end
             end
           end
+        end
+      end
+
+      context 'and REST history' do
+        let(:batches) { 3 }
+        let(:messages_per_batch) { 10 }
 
-          it 'retrieves limited history backwards with pagination' do
-            run_reactor(5) do
-              messages_sent.times.to_a.reverse.each do |index|
-                EventMachine.add_timer((messages_sent - index).to_f / 10) do
-                  channel.publish('event', "history#{index}") do
-                    check_limited_history :backwards if index == 0
-                  end
-                end
+        it 'return the same results with unique matching message IDs' do
+          batches.times do |batch|
+            EventMachine.add_timer(batch.to_f / batches.to_f) do
+              messages_per_batch.times { channel.publish('event', 'data') }
+            end
+          end
+
+          channel.subscribe('event') do |message|
+            messages << message
+            if messages.count == batches * messages_per_batch
+              channel.history do |history|
+                expect(history.map(&:id).sort).to eql(messages.map(&:id).sort)
+                stop_reactor
               end
             end
           end
         end
-
-        skip 'ensure REST history message IDs match ProtocolMessage wrapped message IDs via Realtime'
       end
     end
   end