rester 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5c3b74a7feec8cfd51a193a182876636d04d77e
-  data.tar.gz: d5cc9861ec2c2a607e7a726a86b5569e10c72d97
+  metadata.gz: ed31a2e9f930e5607d9905098c61fae665750d3a
+  data.tar.gz: a3cfb90ab6eb177fd2291d5bd6e5013014023f63
 SHA512:
-  metadata.gz: 27782ad11aa2d68798ae77c346e2627606fc6e0ef9b67ad7d39904675d74a88be0f3b529c9c8418f53f77801efe045f8c57ad32046a86f50053dc923105b9e69
-  data.tar.gz: 6f511e675e4684e6d2aec4b6a088f54478b496b36ea518df1113890e1c5ed10a021b41881b76884498e58880492d3645872d8bd2d38f0f4b9f3c7842a71703f6
+  metadata.gz: fb965a25b5f15759c4998897c831a4959d512d6b89225d8228879ed2e8185cb99397617417ee54b7c8e2b69444d5f8af1ca9ba8a903e7fd39b70d2ea407ccb58
+  data.tar.gz: a9fc47ffea8f0a68e66f8577e82e1733d06639c6ba7a8275121ddd92deee1b131ee42ca1192cb492e65b86fd0d7e3530c58abb8b2db190e330697011b333caa7

data/lib/rester/client/adapters/adapter.rb

@@ -1,7 +1,6 @@
 module Rester
   module Client::Adapters
     class Adapter
-
       class << self
         ##
         # Returns whether or not the Adapter can connect to the service
@@ -10,8 +9,11 @@ module Rester
         end
       end # Class Methods
 
-      def initialize(*args)
-        connect(*args) unless args.empty?
+      attr_reader :timeout
+
+      def initialize(service=nil, opts={})
+        @timeout = opts[:timeout]
+        connect(service) if service
       end
 
       ##
@@ -34,7 +36,7 @@ module Rester
         raise NotImplementedError
       end
 
-      def request(verb, path, params={}, &block)
+      def request(verb, path, params={})
         params ||= {}
         _validate_verb(verb)
         params = _validate_params(params)
@@ -44,14 +46,14 @@ module Rester
       [:get, :post, :put, :delete].each do |verb|
         ##
         # Define helper methods: get, post, put, delete
-        define_method(verb) { |*args, &block|
-          request(verb, *args, &block)
+        define_method(verb) { |*args|
+          request(verb, *args)
         }
 
         ##
         # Define implementation methods: get!, post!, put!, delete!
         # These methods should be overridden by the specific adapter.
-        define_method("#{verb}!") { |*args, &block|
+        define_method("#{verb}!") { |*args|
           raise NotImplementedError
         }
       end

data/lib/rester/client/adapters/http_adapter/connection.rb

@@ -10,40 +10,57 @@ module Rester
       }.freeze
 
       attr_reader :url
+      attr_reader :timeout
 
-      def initialize(url)
+      def initialize(url, opts={})
         @url = url.is_a?(String) ? URI(url) : url
         @url.path = @url.path[0..-2] if @url.path[-1] == '/'
+        @timeout = opts[:timeout]
       end
 
       def get(path, params={})
-        _http.get(
+        _request(
+          :get,
           _path(path, params[:query]),
           _prepare_headers(params[:headers])
         )
       end
 
       def delete(path, params={})
-        _http.delete(
+        _request(
+          :delete,
           _path(path, params[:query]),
           _prepare_headers(params[:headers])
         )
       end
 
       def put(path, params={})
-        encoded_data = _encode_data(params[:data])
-        headers = _prepare_data_headers(params[:headers])
-        _http.put(_path(path), encoded_data, headers)
+        _request(
+          :put,
+          _path(path),
+          _prepare_data_headers(params[:headers]),
+          _encode_data(params[:data])
+        )
       end
 
       def post(path, params={})
-        encoded_data = _encode_data(params[:data])
-        headers = _prepare_data_headers(params[:headers])
-        _http.post(_path(path), encoded_data, headers)
+        _request(
+          :post,
+          _path(path),
+          _prepare_data_headers(params[:headers]),
+          _encode_data(params[:data])
+        )
       end
 
       private
 
+      def _request(verb, path, headers={}, data='')
+        data = nil if [:get, :delete].include?(verb)
+        _http.public_send(verb, *[path, data, headers].compact)
+      rescue Net::ReadTimeout, Net::OpenTimeout
+        fail Errors::TimeoutError
+      end
+
       def _path(path, query=nil)
         u = url.dup
         u.path = Utils.join_paths(u.path, path)
@@ -68,6 +85,8 @@ module Rester
               s.set_default_paths
             }
           end
+
+          http.open_timeout = http.read_timeout = timeout
         }
       end
 

data/lib/rester/client/adapters/http_adapter.rb

@@ -17,8 +17,8 @@ module Rester
         end
       end # Class Methods
 
-      def connect(*args)
-        nil.tap { @connection = Connection.new(*args) }
+      def connect(url)
+        nil.tap { @connection = Connection.new(url, timeout: timeout) }
       end
 
       def connected?

data/lib/rester/client/adapters/local_adapter.rb

@@ -1,5 +1,6 @@
 require 'stringio'
 require 'rack'
+require 'timeout'
 
 module Rester
   module Client::Adapters
@@ -15,7 +16,7 @@ module Rester
         end
       end # Class Methods
 
-      def connect(service, opts={})
+      def connect(service)
         nil.tap { @service = service }
       end
 
@@ -45,13 +46,15 @@ module Rester
         body = URI.encode_www_form(opts[:data] || {})
         query = URI.encode_www_form(opts[:query] || {})
 
-        response = service.call(
-          'REQUEST_METHOD' => verb.to_s.upcase,
-          'PATH_INFO'      => path,
-          'CONTENT_TYPE'   => 'application/x-www-form-urlencoded',
-          'QUERY_STRING'   => query,
-          'rack.input'     => StringIO.new(body)
-        )
+        response = Timeout::timeout(timeout) do
+          service.call(
+            'REQUEST_METHOD' => verb.to_s.upcase,
+            'PATH_INFO'      => path,
+            'CONTENT_TYPE'   => 'application/x-www-form-urlencoded',
+            'QUERY_STRING'   => query,
+            'rack.input'     => StringIO.new(body)
+          )
+        end
 
         body = response.last
         body = body.body if body.respond_to?(:body)
@@ -62,6 +65,8 @@ module Rester
           response.first, # The status code
           body            # The response body.
         ]
+      rescue Timeout::Error
+        fail Errors::TimeoutError
       end
     end # LocalAdapter
   end # Client::Adapters

data/lib/rester/client/adapters/stub_adapter.rb

@@ -8,6 +8,9 @@ module Rester
     # An adapter to be used to stub the responses needed from specified service
     # requests via a yaml file. This will be used in spec tests to perform
     # "contractual testing"
+    #
+    # Note, this does not implement the "timeout" feature defined by the adapter
+    # interface.
     class StubAdapter < Adapter
       attr_reader :stub
 
@@ -17,7 +20,9 @@ module Rester
         end
       end # Class Methods
 
-      def connect(stub_filepath, opts={})
+      ##
+      # Connects to the StubFile.
+      def connect(stub_filepath)
         @stub = Utils::StubFile.new(stub_filepath)
       end
 
@@ -60,13 +65,13 @@ module Rester
 
         context = @_context || _find_context_by_params(path, verb, params)
 
-        unless (action = stub[path][verb][context])
+        unless (spec = stub[path][verb][context])
           fail Errors::StubError,
             "#{verb} #{path} with context '#{context}' not found"
         end
 
         # Verify body, if there is one
-        unless (request = Utils.stringify_vals(action['request'] || {})) == params
+        unless (request = spec['request']) == params
           fail Errors::StubError,
             "#{verb} #{path} with context '#{context}' params don't match stub. Expected: #{request} Got: #{params}"
         end
@@ -80,9 +85,8 @@ module Rester
       # Find the first request object with the same params as what's passed in.
       # Useful for testing without having to set the context.
       def _find_context_by_params(path, verb, params)
-        (stub[path][verb].find { |_, action|
-          (Utils.stringify_vals(action['request'] || {})) == params
-        } || []).first
+        (stub[path][verb].find { |_, spec| spec['request'] == params } || []
+          ).first
       end
     end # StubAdapter
   end # Client::Adapters

data/lib/rester/client/adapters.rb

@@ -6,11 +6,36 @@ module Rester
       autoload(:LocalAdapter, 'rester/client/adapters/local_adapter')
       autoload(:StubAdapter,  'rester/client/adapters/stub_adapter')
 
+      ##
+      # Default connection options.
+      DEFAULT_OPTS = {
+        timeout: 10 # time in seconds (may be float)
+      }.freeze
+
       class << self
+        ##
+        # Returns a list of available adapter classes.
         def list
           constants.map { |c| const_get(c) }
             .select { |c| c.is_a?(Class) && c < Adapter }
         end
+
+        ##
+        # Returns an instance of the appropriate adapter that is connected to
+        # the service.
+        def connect(service, opts={})
+          klass = list.find { |a| a.can_connect_to?(service) }
+          fail "unable to connect to #{service.inspect}" unless klass
+          klass.new(service, opts)
+        end
+
+        ##
+        # Given a hash, extracts the options that are part of the adapter
+        # interface.
+        def extract_opts(opts={})
+          sel = proc { |k, _| DEFAULT_OPTS.keys.include?(k) }
+          DEFAULT_OPTS.merge(opts.select(&sel).tap { opts.delete_if(&sel) })
+        end
       end
     end
   end

data/lib/rester/client.rb

@@ -1,5 +1,6 @@
 require 'json'
 require 'active_support/inflector'
+require 'logger'
 
 module Rester
   class Client
@@ -9,11 +10,19 @@ module Rester
 
     attr_reader :adapter
     attr_reader :version
+    attr_reader :error_threshold
+    attr_reader :retry_period
+    attr_reader :logger
 
     def initialize(adapter, params={})
       self.adapter = adapter
-      @version = params[:version] || 1
+      self.version = params[:version]
+      @error_threshold = (params[:error_threshold] || 3).to_i
+      @retry_period = (params[:retry_period] || 1).to_f
+      @logger = params[:logger] || Logger.new(STDOUT)
+
       @_resource = Resource.new(self)
+      _init_request_breaker
     end
 
     def connect(*args)
@@ -24,10 +33,13 @@ module Rester
       adapter.connected? && adapter.get('/ping').first == 200
     end
 
-    def request(verb, path, params={}, &block)
-      path = _path_with_version(path)
-
-      _process_response(path, *adapter.request(verb, path, params, &block))
+    def request(verb, path, params={})
+      @_request_breaker.call(verb, path, params)
+    rescue Utils::CircuitBreaker::CircuitOpenError
+      # Translate this error so it's easier handle for clients.
+      # Also, at some point we may want to extract CircuitBreaker into its own
+      # gem, and this will make that easier.
+      raise Errors::CircuitOpenError
     end
 
     ##
@@ -42,6 +54,12 @@ module Rester
       @adapter = adapter
     end
 
+    def version=(version)
+      unless (@version = (version || 1).to_i) > 0
+        fail ArgumentError, 'version must be > 0'
+      end
+    end
+
     private
 
     ##
@@ -50,6 +68,34 @@ module Rester
       @_resource.send(:method_missing, meth, *args, &block)
     end
 
+    ##
+    # Sets up the circuit breaker for making requests to the service.
+    #
+    # Any exception raised by the `_request` method will count as a failure for
+    # the circuit breaker.  Once the threshold for errors has been reached, the
+    # circuit opens and all subsequent requests will raise a CircuitOpenError.
+    #
+    # When the circuit is opened or closed, a message is sent to the logger for
+    # the client.
+    def _init_request_breaker
+      @_request_breaker = Utils::CircuitBreaker.new(
+        threshold: error_threshold, retry_period: retry_period
+      ) { |*args| _request(*args) }
+
+      @_request_breaker.on_open do
+        logger.error("circuit opened")
+      end
+
+      @_request_breaker.on_close do
+        logger.info("circuit closed")
+      end
+    end
+
+    def _request(verb, path, params)
+      path = _path_with_version(path)
+      _process_response(path, *adapter.request(verb, path, params))
+    end
+
     def _path_with_version(path)
       Utils.join_paths("/v#{version}", path)
     end

data/lib/rester/errors.rb

@@ -12,7 +12,17 @@ module Rester
 
     class Error < StandardError; end
     class MethodError < Error; end
-    class MethodDefinitionError < Error; end
+    class MethodDefinitionError < MethodError; end
+
+    ################
+    # Adapter Errors
+    class AdapterError < Error; end
+    class TimeoutError < AdapterError; end
+
+    ###############
+    # Client Errors
+    class ClientError < Error; end
+    class CircuitOpenError < ClientError; end
 
     #############
     # Stub Errors

data/lib/rester/rspec.rb

@@ -1,5 +1,25 @@
 require 'json'
 
+##
+# include_stub_response custom matcher which checks inclusion on nested arrays
+# and objects as opposed to the top level object which RSpec's include only
+# checks
+RSpec::Matchers.define :include_stub_response do |stub|
+  failure = nil
+
+  match { |actual|
+    begin
+      Rester::Utils::RSpec.assert_deep_include(actual, stub || stub_response)
+      true
+    rescue Rester::Errors::StubError => e
+      failure = e
+      false
+    end
+  }
+
+  failure_message { |actual| failure }
+end
+
 RSpec.configure do |config|
   config.before :all, rester: // do |ex|
     # Load the stub file
@@ -96,7 +116,7 @@ RSpec.configure do |config|
 
         missing_contexts.each { |missing_context, _|
           context_group = _find_or_create_child(verb_group, missing_context)
-          context_group.it { is_expected.to include stub_response }
+          context_group.it { is_expected.to include_stub_response }
         }
       }
     }

data/lib/rester/service/resource/params.rb

@@ -4,6 +4,12 @@ module Rester
       DEFAULT_OPTS = { strict: true }.freeze
       BASIC_TYPES = [String, Symbol, Float, Integer].freeze
 
+      DEFAULT_TYPE_MATCHERS = {
+        Integer  => /\A\d+\z/,
+        Float    => /\A\d+(\.\d+)?\z/,
+        :boolean => /\A(true|false)\z/i
+      }.freeze
+
       attr_reader :options
 
       def initialize(opts={}, &block)
@@ -53,7 +59,10 @@ module Rester
       end
 
       def validate!(key, value)
-        klass = @_validators[key].first
+        _error!("expected string value for #{key}") unless value.is_a?(String)
+
+        klass, opts = @_validators[key]
+        _validate_match(key, value, opts[:match]) if opts[:match]
 
         _parse_with_class(klass, value).tap do |obj|
           _validate_obj(key, obj)
@@ -121,7 +130,8 @@ module Rester
       def _add_validator(name, klass, opts)
         fail 'must specify param name' unless name
         fail 'validation options must be a Hash' unless opts.is_a?(Hash)
-        opts = opts.dup
+        default_opts = { match: DEFAULT_TYPE_MATCHERS[klass] }
+        opts = default_opts.merge(opts)
 
         @_required_fields << name.to_sym if opts.delete(:required)
         default = opts.delete(:default)
@@ -137,8 +147,23 @@ module Rester
         nil
       end
 
+      ##
+      # Validates a default value specified in the params block. Raises
+      # validation error if necessary.
       def _validate_default(key, default)
-        error = catch(:error) { _validate_obj(key.to_sym, default) }
+        error = catch(:error) do
+          type = @_validators[key].first
+
+          unless _valid_type?(default, type)
+            # The .camelcase here is for when type = 'boolean'
+            _error!("default for #{key} should be of "\
+              "type #{type.to_s.camelcase}")
+          end
+
+          validate!(key.to_sym, default.to_s)
+          nil
+        end
+
         raise error if error
       end
 
@@ -172,24 +197,36 @@ module Rester
           case opt
           when :within
             _validate_within(key, obj, value)
+          when :match
+            # Nop - This is evaluated before the incoming string is parsed.
           else
             _validate_method(key, obj, opt, value) unless obj.nil?
           end
         end
-
-        nil
       end
 
       def _validate_type(key, obj, type)
+        unless _valid_type?(obj, type)
+          # The .camelcase here is for when type = 'boolean'
+          _error!("#{key} should be #{type.to_s.camelcase} but "\
+            "got #{obj.class}")
+        end
+      end
+
+      def _valid_type?(obj, type)
         case type
         when :boolean
-          unless obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
-            _error!("#{key} should be Boolean but got #{obj.class}")
-          end
+          obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
         else
-          unless obj.is_a?(type)
-            _error!("#{key} should be #{type} but got #{obj.class}")
-          end
+          obj.is_a?(type)
+        end
+      end
+
+      ##
+      # To be called *before* the incoming string is parsed into the object.
+      def _validate_match(key, str, matcher)
+        unless matcher.match(str)
+          _error!("#{key} does not match #{matcher.inspect}")
         end
       end
 

data/lib/rester/utils/circuit_breaker.rb

@@ -0,0 +1,137 @@
+module Rester
+  module Utils
+    class CircuitBreaker
+      class Error < StandardError; end
+      class CircuitOpenError < Error; end
+
+      attr_reader :threshold
+      attr_reader :retry_period
+      attr_reader :block
+
+      attr_reader :failure_count
+      attr_reader :last_failed_at
+
+      def initialize(opts={}, &block)
+        @_synchronizer = Mutex.new
+        @_retry_lock = Mutex.new
+        self.threshold = opts[:threshold]
+        self.retry_period = opts[:retry_period]
+        @block = block
+        reset
+      end
+
+      def on_open(&block)
+        _callbacks[:open] = block
+      end
+
+      def on_close(&block)
+        _callbacks[:close] = block
+      end
+
+      def closed?
+        !reached_threshold?
+      end
+
+      def half_open?
+        !closed? && retry_period_passed?
+      end
+
+      def open?
+        !closed? && !half_open?
+      end
+
+      def reached_threshold?
+        failure_count >= threshold
+      end
+
+      def retry_period_passed?
+        lf_at = last_failed_at
+        !lf_at || (Time.now - lf_at) > retry_period
+      end
+
+      def call(*args)
+        if closed?
+          _call(*args)
+        elsif half_open? && @_retry_lock.try_lock
+          # Ensure only one thread can retry.
+          begin
+            _call(*args)
+          ensure
+            @_retry_lock.unlock
+          end
+        else
+          fail CircuitOpenError
+        end
+      end
+
+      def reset
+        _synchronize do
+          @failure_count = 0
+          @last_failed_at = nil
+        end
+      end
+
+      protected
+
+      def threshold=(threshold)
+        unless (@threshold = (threshold || 3).to_i) > 0
+          fail ArgumentError, 'threshold must be > 0'
+        end
+      end
+
+      def retry_period=(retry_period)
+        unless (@retry_period = (retry_period || 1).to_f) > 0
+          fail ArgumentError, 'retry_period must be > 0'
+        end
+      end
+
+      private
+
+      def _call(*args)
+        begin
+          block.call(*args).tap { _record_success }
+        rescue
+          _record_failure
+          raise
+        end
+      end
+
+      def _callbacks
+        @__callbacks ||= {}
+      end
+
+      def _call_on(type)
+        (cb = _callbacks[type]) && cb.call
+      end
+
+      def _synchronize(&block)
+        @_synchronizer.synchronize(&block)
+      end
+
+      def _record_success
+        if @failure_count > 0
+          _synchronize do
+            # If the threshold had been reached, we're now closing the circuit.
+            _call_on(:close) if @failure_count == threshold
+            @failure_count = 0
+          end
+        end
+      end
+
+      def _record_failure
+        if @failure_count < threshold
+          _synchronize do
+            if @failure_count < threshold
+              @failure_count += 1
+
+              # If the threshold has now been reached, we're opening the circuit.
+              _call_on(:open) if @failure_count == threshold
+            end
+          end
+        end
+
+        @last_failed_at = Time.now
+      end
+    end # CircuitBreaker
+  end # Utils
+end # Rester

data/lib/rester/utils/rspec.rb

@@ -0,0 +1,49 @@
+module Rester
+  module Utils
+    module RSpec
+      class << self
+        def assert_deep_include(response, stub, accessors=[])
+          case stub
+          when Hash
+            _type_error(response, stub, accessors) unless response.is_a?(Hash)
+            stub.all? { |k,v| assert_deep_include(response[k], v, accessors + [k]) }
+          when Array
+            unless response.is_a?(Array)
+              _type_error(response, stub, accessors)
+            end
+
+            unless response.length == stub.length
+              _length_error(response, stub, accessors)
+            end
+
+            stub.each_with_index.all? { |e,i|
+              assert_deep_include(response[i], e, accessors + [i])
+            }
+          else
+            _match_error(response, stub, accessors) unless stub == response
+            true
+          end
+        end
+
+        def _match_error(response, stub, accessors=[])
+          accessors_str = _pretty_print_accessors(accessors)
+          fail Errors::StubError, "Stub#{accessors_str}=#{stub.inspect} doesn't match Response#{accessors_str}=#{response.inspect}"
+        end
+
+        def _length_error(response, stub, accessors=[])
+          accessors_str = _pretty_print_accessors(accessors)
+          fail Errors::StubError, "Stub#{accessors_str} length: #{stub.length} doesn't match Response#{accessors_str} length: #{response.length}"
+        end
+
+        def _type_error(response, stub, accessors=[])
+          accessors_str = _pretty_print_accessors(accessors)
+          fail Errors::StubError, "Stub#{accessors_str} type: #{stub.class} doesn't match Response#{accessors_str} type: #{response.class}"
+        end
+
+        def _pretty_print_accessors(accessors=[])
+          accessors.map { |a| "[#{a.inspect}]" }.join
+        end
+      end # Class Methods
+    end # RSpec
+  end # Utils
+end # Rester

data/lib/rester/utils/stub_file.rb

@@ -48,6 +48,23 @@ module Rester
         # StubAdapter (i.e., removes tags from "response" key and puts them in
         # a "response_tags" key).
         def _update_context(path, verb, context, spec)
+          _update_request(path, verb, context, spec)
+          _update_response(path, verb, context, spec)
+        end
+
+        ##
+        # Converts all the values in the request hash to strings, which mimics
+        # how the data will be received on the service side.
+        def _update_request(path, verb, context, spec)
+          spec['request'] = Utils.stringify_vals(spec['request'] || {})
+        end
+
+        ##
+        # Parses response tags (e.g., response[successful=true]).
+        #
+        # Currently supported tags:
+        #   successful    must be 'true' or 'false'
+        def _update_response(path, verb, context, spec)
           responses = spec.select { |k,_|
             k =~ /\Aresponse(\[(\w+) *= *(\w+)(, *(\w+) *= *(\w+))*\])?\z/
           }

data/lib/rester/utils.rb

@@ -2,7 +2,9 @@ require 'date'
 
 module Rester
   module Utils
-    autoload(:StubFile,  'rester/utils/stub_file')
+    autoload(:StubFile,       'rester/utils/stub_file')
+    autoload(:RSpec,          'rester/utils/rspec')
+    autoload(:CircuitBreaker, 'rester/utils/circuit_breaker')
 
     class << self
       ##
@@ -49,14 +51,15 @@ module Rester
       end
 
       def stringify_vals(hash={})
-        hash.inject({}) { |memo,(k,v)|
+        hash.each_with_object({}) { |(k,v), memo|
           case v
           when Hash
             memo[k] = stringify_vals(v)
+          when NilClass
+            memo[k] = 'null'
           else
             memo[k] = v.to_s
           end
-          memo
         }
       end
 

data/lib/rester/version.rb

@@ -1,3 +1,3 @@
 module Rester
-  VERSION = '0.4.1'
+  VERSION = '0.4.2'
 end

data/lib/rester.rb

@@ -17,9 +17,8 @@ module Rester
     end
 
     def connect(service, params={})
-      klass = Client::Adapters.list.find { |a| a.can_connect_to?(service) }
-      fail "unable to connect to #{service.inspect}" unless klass
-      adapter = klass.new(service)
+      adapter_opts = Client::Adapters.extract_opts(params)
+      adapter = Client::Adapters.connect(service, adapter_opts)
       Client.new(adapter, params)
     end
   end # Class Methods

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rester
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Robert Honer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-18 00:00:00.000000000 Z
+date: 2015-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -145,6 +145,8 @@ files:
 - lib/rester/service/resource.rb
 - lib/rester/service/resource/params.rb
 - lib/rester/utils.rb
+- lib/rester/utils/circuit_breaker.rb
+- lib/rester/utils/rspec.rb
 - lib/rester/utils/stub_file.rb
 - lib/rester/version.rb
 homepage: http://github.com/payout/rester