px-service-client 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eed1491471134440a4e1ca1644420395f15079e4
-  data.tar.gz: 5f50c16950abc5f20cd7eb7d82deb75f5731782e
+  metadata.gz: 260462f7c8c782f9a5a1b7a0996431e426f01f39
+  data.tar.gz: 31ffc0fff0138c3d8519d523da451b23e765de0c
 SHA512:
-  metadata.gz: cd65c7907b1870c02add4c35a4360df9487b8974b92b9bdfc2a0af941b6f1a2e44870b8b8c409d7235c72a103bc0d64d8828038bcc54457b2949c014b02f2051
-  data.tar.gz: cf39f661fb5c27d1643b036afd7d3b28028e9dc098186775dbb461a852bd9ae3b201b629685eb364e2e6ae5b768d29c3b1edb0a35f8952123e2fb784bbfd8c02
+  metadata.gz: dc00a6aca11761cc581dc3175a322027e8ee5ac8315933a6c72803665efae80bb5794ba5a25a83c0e831d5b01708f469cd84c79cd3cce8262ab71a5885a4e84f
+  data.tar.gz: 6aefddddf56c6968920130e3aaacddc3bcdf0ef41677d747e651a00cb8afcfe561e4a0341cbcfedf90df0b68cdb0ff848442991b63fc3c9fac66d09a01f87941

data/README.md

@@ -42,8 +42,16 @@ The features are:
 ```ruby
 include Px::Service::Client::Caching
 
-self.cache_client =  Dalli::Client.new(...)
-self.cache_logger = Logger.new(STDOUT) # or Rails.logger, for example
+# Optional
+caching do |config|
+  config.cache_strategy = :none
+  config.cache_expiry = 30.seconds
+  config.max_page = nil
+  config.cache_options = {}
+  config.cache_options[:policy_group] = 'general'
+  config.cache_client =  Dalli::Client.new(...)
+  config.cache_logger = Logger.new(STDOUT) # or Rails.logger, for example
+end
 ```
 
 Provides client-side response caching of service requests.  Responses are cached in memcached (using the provided cache client) in either a *last-resort* or *first-resort* manner.
@@ -55,6 +63,22 @@ to be refreshed probabilistically (rather than on every request).
 *first-resort* means that the cached value is always used, if present.  Requests to the service are only made
 when the cached value is close to expiry.
 
+An example of a cached request:
+
+```ruby
+req = subject.make_request(method, url)
+result = subject.cache_request(url) do
+  resp = nil
+  multi.context do
+    resp = multi.do(req)
+  end.run
+
+  resp
+end
+```
+
+`cache_request` expects a block that returns a `RetriableResponseFuture`. It then returns a `Typhoeus::Response`.
+
 #### Px::Service::Client::CircuitBreaker
 
 ```ruby

data/lib/px/service/client.rb

@@ -18,3 +18,4 @@ require "px/service/client/list_response"
 require "px/service/client/base"
 require "px/service/client/multiplexer"
 require "px/service/client/retriable_response_future"
+require "px/service/client/circuit_breaker_retriable_response_future"

data/lib/px/service/client/caching.rb

@@ -21,13 +21,14 @@ module Px::Service::Client
     end
 
     module ClassMethods
-      DefaultConfig = Struct.new(:cache_strategy, :cache_expiry, :max_page, :cache_options, :cache_client) do
+      DefaultConfig = Struct.new(:cache_strategy, :cache_expiry, :max_page, :cache_options, :cache_logger, :cache_client) do
         def initialize
           self.cache_strategy = :none
           self.cache_expiry = 30.seconds
           self.max_page = nil
           self.cache_options = {}
           self.cache_options[:policy_group] = 'general'
+          self.cache_logger = nil
           self.cache_client = nil
         end
       end
@@ -71,13 +72,10 @@ module Px::Service::Client
 
       Future.new do
         begin
-          if retry_response.is_a?(Future)
-            resp = retry_response.value!.options
-          else
-            resp = retry_response
-          end
+          raise ArgumentError.new('Block did not return a Future.') unless retry_response.is_a?(Future)
+          resp = retry_response.value!
 
-          entry = CacheEntry.new(config.cache_client, url, policy_group, resp)
+          entry = CacheEntry.new(config.cache_client, url, policy_group, resp.options)
 
           # Only store a new result if we roll a 0
           r = rand(refresh_probability)
@@ -85,7 +83,6 @@ module Px::Service::Client
           resp
         rescue Px::Service::ServiceError => ex
           cache_logger.error "Service responded with exception: #{ex.class.name}: #{ex.message}\n#{ex.backtrace.join('\n')}" if cache_logger
-
           entry = CacheEntry.fetch(config.cache_client, url, policy_group)
           if entry.nil?
             # Re-raise the error, no cached response
@@ -93,7 +90,7 @@ module Px::Service::Client
           end
 
           entry.touch(expires_in, refresh_window: 1.minute)
-          entry.data
+          Typhoeus::Response.new(HashWithIndifferentAccess.new(entry.data))
         end
       end
     end
@@ -114,7 +111,7 @@ module Px::Service::Client
           # don't also try to update the cache.
           entry.touch(expires_in)
         else
-          return Future.new { entry.data }
+          return Future.new { Typhoeus::Response.new(HashWithIndifferentAccess.new(entry.data)) }
         end
       end
 
@@ -122,13 +119,10 @@ module Px::Service::Client
 
       Future.new do
         begin
-          if retry_response.is_a?(Future)
-            resp = retry_response.value!.options
-          else
-            resp = retry_response
-          end
+          raise ArgumentError.new('Block did not return a Future.') unless retry_response.is_a?(Future)
+          resp = retry_response.value!
           
-          entry = CacheEntry.new(config.cache_client, url, policy_group, resp)
+          entry = CacheEntry.new(config.cache_client, url, policy_group, resp.options)
           entry.store(expires_in)
           resp
         rescue Px::Service::ServiceError => ex
@@ -143,22 +137,21 @@ module Px::Service::Client
           # Set the entry to be expired again (but reset the refresh window).  This allows the next call to try again
           # (assuming the circuit breaker is reset) but keeps the value in the cache in the meantime
           entry.touch(0.seconds)
-          entry.data
+          Typhoeus::Response.new(HashWithIndifferentAccess.new(entry.data))
         end
       end
+
+    rescue ArgumentError => ex
+      Future.new { ex }
     end
 
     def no_cache(&block)
       retry_response = block.call
 
       Future.new do
-        if retry_response.is_a?(Future)
-          resp = retry_response.value!.options
-        else
-          resp = retry_response
-        end
+        raise ArgumentError.new('Block did not return a Future.') unless retry_response.is_a?(Future)
 
-        resp
+        retry_response.value!
       end
     end
   end

data/lib/px/service/client/caching/cache_entry.rb

@@ -18,6 +18,8 @@ module Px::Service::Client::Caching
     ##
     # Store this entry in the cache with the given expiry.
     def store(expires_in, refresh_window: 5.minutes)
+      raise ArgumentError.new('Cache client has not been set.') unless cache_client.present?
+
       self.expires_at = DateTime.now + expires_in
 
       ActiveSupport::Notifications.instrument("store.caching", { url: url, policy_group: policy_group, expires_in: expires_in} ) do
@@ -33,6 +35,8 @@ module Px::Service::Client::Caching
     ##
     # Fetch an entry from the cache.  Returns the entry if it's present, otherwise returns nil
     def self.fetch(cache_client, url, policy_group)
+      raise ArgumentError.new('Cache client has not been set.') unless cache_client.present?
+
       key_values = nil
       data_key = cache_key(url, policy_group, :data)
       meta_key = cache_key(url, policy_group, :meta)
@@ -54,6 +58,8 @@ module Px::Service::Client::Caching
     ##
     # Touch this entry in the cache, updating its expiry time but not its data
     def touch(expires_in, refresh_window: 5.minutes)
+      raise ArgumentError.new('Cache client has not been set.') unless cache_client.present?
+
       self.expires_at = DateTime.now + expires_in
 
       ActiveSupport::Notifications.instrument("touch.caching", { url: url, policy_group: policy_group, expires_in: expires_in} ) do

data/lib/px/service/client/circuit_breaker.rb

@@ -24,38 +24,40 @@ module Px::Service::Client
     ##
     # Make the request, respecting the circuit breaker, if configured
     def make_request_with_breaker(method, uri, query: nil, headers: nil, body: nil)
-      Future.new do
-        state = self.class.circuit_state
-        handler = self.class.circuit_handler
-        
-        if handler.is_tripped(state)
-          handler.logger.debug("handle: breaker is tripped, refusing to execute: #{state}") if handler.logger
-          begin
-            handler.on_circuit_open(state)
-          rescue StandardError => ex
-            # Wrap and reroute other exceptions, includes CircuitBreaker::CircuitBrokenException
-            raise Px::Service::ServiceError.new(ex.message, 503), ex, ex.backtrace
-          end
-        end
+      state = self.class.circuit_state
+      handler = self.class.circuit_handler
 
+      if handler.is_tripped(state)
+        handler.logger.debug("handle: breaker is tripped, refusing to execute: #{state}") if handler.logger
         begin
-          response = make_request_without_breaker(
-            method,
-            uri,
-            query: query,
-            headers: headers,
-            body: body,
-            timeout: handler.invocation_timeout)
-
-          result = response.value!
-          handler.on_success(state)
-
-          result
-        rescue Px::Service::ServiceError
-          handler.on_failure(state)
-          raise
+          handler.on_circuit_open(state)
+        rescue StandardError => ex
+          # Wrap and reroute other exceptions, includes CircuitBreaker::CircuitBrokenException
+          error = Px::Service::ServiceError.new(ex.message, 503)
+          return CircuitBreakerRetriableResponseFuture.new(error)
+        end
+      end
+
+      retry_request = make_request_without_breaker(
+        method,
+        uri,
+        query: query,
+        headers: headers,
+        body: body,
+        timeout: handler.invocation_timeout)
+
+      retry_request.request.on_complete do |response|
+        # Wait for request to exhaust retries
+        if retry_request.completed?
+          if response.response_code >= 500 || response.response_code == 0
+            handler.on_failure(state)
+          else
+            handler.on_success(state)
+          end
         end
       end
+
+      retry_request
     end
 
   end

data/lib/px/service/client/circuit_breaker_retriable_response_future.rb

@@ -0,0 +1,13 @@
+module Px::Service::Client
+  class CircuitBreakerRetriableResponseFuture < RetriableResponseFuture
+
+    ##
+    # Sets the value of a RetriableResponseFuture to the exception
+    # raised when opening the circuit breaker.
+    def initialize(ex)
+      super()
+      
+      complete(ex)
+    end
+  end
+end

data/lib/px/service/client/multiplexer.rb

@@ -18,7 +18,7 @@ module Px::Service::Client
       response = request_or_future
       if request_or_future.is_a?(Typhoeus::Request)
         response = RetriableResponseFuture.new(request_or_future, retries: retries)
-      elsif !request_or_future.is_a?(RetriableResponseFuture)
+      elsif !request_or_future.is_a?(RetriableResponseFuture) || request_or_future.completed?
         return request_or_future
       end
 

data/lib/px/service/client/version.rb

@@ -1,7 +1,7 @@
 module Px
   module Service
     module Client
-      VERSION = "1.1.0"
+      VERSION = "1.2.0"
     end
   end
 end

data/px-service-client.gemspec

@@ -31,6 +31,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "vcr"
   spec.add_development_dependency "guard"
   spec.add_development_dependency "guard-rspec"
-  spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency "rspec", "~> 2.99"
   spec.add_development_dependency "timecop", "~> 0.5"
 end

data/spec/px/service/client/base_spec.rb

@@ -16,7 +16,7 @@ describe Px::Service::Client::Base do
   let(:successful_response) do
     Typhoeus::Response.new(
       code: 200,
-      body: { status: 200, message: "Success"}.to_json,
+      body: { status: 200, message: "Success" }.to_json,
       headers: { "Content-Type" => "application/json"} )
   end
 
@@ -277,7 +277,7 @@ describe Px::Service::Client::Base do
                 end.run
                 
                 resp
-              end.value!['code']).to eq(200)
+              end.value!.response_code).to be(200)
             end
           end
 

data/spec/px/service/client/caching/caching_spec.rb

@@ -18,12 +18,21 @@ describe Px::Service::Client::Caching do
   }
 
   let (:url) { "http://search/foo?bar=baz" }
-  let(:response) { { "response" => ["foo", "bar"], "status" => 200 } }
-  let(:entry) { Px::Service::Client::Caching::CacheEntry.new(dalli, url, 'general', response) }
+  let(:multi) { Px::Service::Client::Multiplexer.new }
+  let(:request) { Typhoeus::Request.new(url, method: :get) }
+  let(:future) { Px::Service::Client::RetriableResponseFuture.new(request) }
+  let(:response) do
+    Typhoeus::Response.new(
+      code: 200,
+      body: { status: 200, message: "Success" }.to_json,
+      headers: { "Content-Type" => "application/json"} )
+  end
+  let(:entry) { Px::Service::Client::Caching::CacheEntry.new(dalli, url, 'general', response.options) }
   let(:strategy) { :none }
 
   before :each do
     dalli.flush_all
+    Typhoeus.stub(url).and_return(response)
   end
 
   shared_examples_for "a successful request" do
@@ -38,8 +47,13 @@ describe Px::Service::Client::Caching do
 
     it "should return the block's return value" do
       expect(subject.cache_request(url, strategy: strategy) do
-        response
-      end.value!).to eq(response)
+        resp = nil
+        multi.context do
+          resp = multi.do(future)
+        end.run
+
+        resp
+      end.value!.options).to eq(response.options)
     end
   end
 
@@ -68,6 +82,22 @@ describe Px::Service::Client::Caching do
   context "when not caching" do
     it_behaves_like "a successful request"
     it_behaves_like "a failed uncacheable request"
+
+    context 'when cache client is not set' do
+      before :each do
+        subject.class.caching do |config|
+          config.cache_client = nil
+        end
+      end
+
+      it 'does not raise an exception' do
+        expect {
+          subject.cache_request(url, strategy: strategy) do
+            nil
+          end
+        }.to_not raise_error
+      end
+    end
   end
 
   context "when caching as a last resort" do
@@ -77,29 +107,47 @@ describe Px::Service::Client::Caching do
     it_behaves_like "a failed uncacheable request"
 
     context "when there is a cached response" do
-      before :each do
-        Px::Service::Client::Caching::CacheEntry.stub(:fetch).and_return(entry)
-      end
+      context 'when cache client is not set' do
+        before :each do
+          subject.class.caching do |config|
+            config.cache_client = nil
+          end
+        end
 
-      it "returns the cached response on failure" do
-        expect(subject.cache_request(url, strategy: strategy) do
-          Px::Service::Client::Future.new { raise Px::Service::ServiceError.new("Error", 500) }
-        end.value!).to eq(response)
+        it 'raises an argument exception' do
+          expect {
+            subject.cache_request(url, strategy: strategy) do
+              Px::Service::Client::Future.new { raise Px::Service::ServiceError.new("Error", 500) }
+            end.value!
+          }.to raise_error(ArgumentError)
+        end
       end
 
-      it "does not returns the cached response on request error" do
-        expect {
-          subject.cache_request(url, strategy: strategy) do
-            Px::Service::Client::Future.new { raise Px::Service::ServiceRequestError.new("Error", 404) }
-          end.value!
-        }.to raise_error(Px::Service::ServiceRequestError)
-      end
+      context 'when the cache client is set' do
+        before :each do
+          Px::Service::Client::Caching::CacheEntry.stub(:fetch).and_return(entry)
+        end
 
-      it "touches the cache entry on failure" do
-        expect(dalli).to receive(:touch).with(a_kind_of(String), a_kind_of(Fixnum))
+        it "returns the cached response on failure" do
+          expect(subject.cache_request(url, strategy: strategy) do
+            Px::Service::Client::Future.new { raise Px::Service::ServiceError.new("Error", 500) }
+          end.value!.options).to eq(response.options.stringify_keys)
+        end
 
-        subject.cache_request(url, strategy: strategy) do
-          Px::Service::Client::Future.new { raise Px::Service::ServiceError.new("Error", 500) }
+        it "does not returns the cached response on request error" do
+          expect {
+            subject.cache_request(url, strategy: strategy) do
+              Px::Service::Client::Future.new { raise Px::Service::ServiceRequestError.new("Error", 404) }
+            end.value!
+          }.to raise_error(Px::Service::ServiceRequestError)
+        end
+
+        it "touches the cache entry on failure" do
+          expect(dalli).to receive(:touch).with(a_kind_of(String), a_kind_of(Fixnum))
+
+          subject.cache_request(url, strategy: strategy) do
+            Px::Service::Client::Future.new { raise Px::Service::ServiceError.new("Error", 500) }
+          end
         end
       end
     end
@@ -114,24 +162,42 @@ describe Px::Service::Client::Caching do
     it_behaves_like "a failed uncacheable request"
 
     context "when there is a cached response" do
-      before :each do
-        Px::Service::Client::Caching::CacheEntry.stub(:fetch).and_return(entry)
-        entry.expires_at = DateTime.now + 1.day
+      context 'when cache client is not set' do
+        before :each do
+          subject.class.caching do |config|
+            config.cache_client = nil
+          end
+        end
+
+        it 'raises an argument exception' do
+          expect {
+            subject.cache_request(url, strategy: strategy) do
+              nil
+            end.value!
+          }.to raise_error(ArgumentError)
+        end
       end
 
-      it "does not invoke the block" do
-        called = false
-        subject.cache_request(url, strategy: strategy) do
-          called = true
+      context 'when the cache client is set' do
+        before :each do
+          Px::Service::Client::Caching::CacheEntry.stub(:fetch).and_return(entry)
+          entry.expires_at = DateTime.now + 1.day
         end
 
-        expect(called).to be_falsey
-      end
+        it "does not invoke the block" do
+          called = false
+          subject.cache_request(url, strategy: strategy) do
+            called = true
+          end
 
-      it "returns the response" do
-        expect(subject.cache_request(url, strategy: strategy) do
-          nil
-        end.value!).to eq(response)
+          expect(called).to be_falsey
+        end
+
+        it "returns the response" do
+          expect(subject.cache_request(url, strategy: strategy) do
+            nil
+          end.value!.options).to eq(response.options.stringify_keys)
+        end
       end
     end
 
@@ -141,7 +207,12 @@ describe Px::Service::Client::Caching do
         entry.expires_at = DateTime.now - 1.day
       end
 
-      let (:response) { { "value" => "response" } }
+      let(:response) do
+        Typhoeus::Response.new(
+          code: 200,
+          body: { status: 200, message: "New response" }.to_json,
+          headers: { "Content-Type" => "application/json"} )
+      end
 
       it "invokes the block" do
         called = false
@@ -153,9 +224,18 @@ describe Px::Service::Client::Caching do
       end
 
       it "returns the new response" do
-        expect(subject.cache_request(url, strategy: strategy) do
-          response
-        end.value!).to eq(response)
+        result = subject.cache_request(url, strategy: strategy) do
+          resp = nil
+          multi.context do
+            resp = multi.do(future)
+          end.run
+
+          resp
+        end.value!
+
+        body = JSON.parse(result.body)
+
+        expect(body[:message]).to eq(JSON.parse(response.body)[:message])
       end
 
       it "updates the cache entry before making the request" do
@@ -166,8 +246,13 @@ describe Px::Service::Client::Caching do
           called = false
           expect(subject.cache_request(url, strategy: strategy) do
             called = true
-            response
-          end.value!).to eq(response)
+            resp = nil
+            multi.context do
+              resp = multi.do(future)
+            end.run
+
+            resp
+          end.value!.options).to eq(response.options.stringify_keys)
 
           expect(called).to be_falsey
 
@@ -177,18 +262,23 @@ describe Px::Service::Client::Caching do
 
       it "caches the new response" do
         subject.cache_request(url, strategy: strategy) do
-          response
+          resp = nil
+          multi.context do
+            resp = multi.do(future)
+          end.run
+
+          resp
         end
 
         expect(subject.cache_request(url, strategy: strategy) do
           nil
-        end.value).to eq(response)
+        end.value.options).to eq(response.options.stringify_keys)
       end
 
       it "returns the cached response on failure" do
         expect(subject.cache_request(url, strategy: strategy) do
           Px::Service::Client::Future.new { raise Px::Service::ServiceError.new("Error", 500) }
-        end.value!).to eq(response)
+        end.value!.options).to eq(response.options.stringify_keys)
       end
 
       it "does not returns the cached response on request error" do

data/spec/px/service/client/circuit_breaker_spec.rb

@@ -2,13 +2,7 @@ require 'spec_helper'
 
 describe Px::Service::Client::CircuitBreaker do
   let(:subject_class) {
-    Class.new do
-      def make_request(method, uri, query: nil, headers: nil, body: nil, timeout: 0)
-        Px::Service::Client::Future.new do
-          _result
-        end
-      end
-    end.tap do |c|
+    Class.new(Px::Service::Client::Base).tap do |c|
       # Anonymous classes don't have a name.  Stub out :name so that things work
       allow(c).to receive(:name).and_return("CircuitBreaker")
       c.include(Px::Service::Client::CircuitBreaker)
@@ -36,19 +30,37 @@ describe Px::Service::Client::CircuitBreaker do
   end
 
   describe '#make_request' do
-    context "when the underlying request method succeeds" do
-      before :each do
-        subject_class.send(:define_method, :_result) do
-          "returned test"
-        end
-      end
+    let(:url) { "http://test" }
+    let(:multi) { Px::Service::Client::Multiplexer.new }
+    let(:response) do
+      Typhoeus::Response.new(
+        code: 200,
+        body: { status: 200, message: "Success" }.to_json,
+        headers: { "Content-Type" => "application/json"} )
+    end
 
-      it "returns a Future" do
-        expect(subject.make_request(:get, "http://test")).to be_a_kind_of(Px::Service::Client::Future)
+    let(:request) do
+      req = @object.send(:make_request, 'get', url)
+
+      multi.context do
+        multi.do(req)
+      end.run
+
+      req
+    end
+
+    before :each do
+      @object = subject
+      Typhoeus.stub(url).and_return(response)
+    end
+
+    context "when the underlying request method succeeds" do
+      it "returns a RetriableResponseFuture" do
+        expect(subject.send(:make_request, 'get', url)).to be_a_kind_of(Px::Service::Client::RetriableResponseFuture)
       end
 
       it "returns the return value" do
-        expect(subject.make_request(:get, "http://test").value!).to eq("returned test")
+        expect(request.value!).to eq(response)
       end
 
       context "when the breaker is open" do
@@ -62,84 +74,76 @@ describe Px::Service::Client::CircuitBreaker do
 
         it "resets the failure count of the breaker" do
           expect {
-            subject.make_request(:get, "http://test").value!
+            request.value!
           }.to change{subject.class.circuit_state.failure_count}.to(0)
         end
 
         it "closes the breaker" do
           expect {
-            subject.make_request(:get, "http://test").value!
+            request.value!
           }.to change{subject.class.circuit_state.closed?}.from(false).to(true)
         end
       end
     end
 
     context "when the wrapped method fails with a ServiceRequestError" do
-      before :each do
-        subject_class.send(:define_method, :_result) do
-          raise Px::Service::ServiceRequestError.new("Error", 404)
-        end
+      let(:response) do
+        Typhoeus::Response.new(
+          code: 404,
+          body: { status: 404, error: "Not Found"}.to_json,
+          headers: { "Content-Type" => "application/json"} )
       end
 
       it "raises a ServiceRequestError" do
         expect {
-          subject.make_request(:get, "http://test").value!
-        }.to raise_error(Px::Service::ServiceRequestError, "Error")
+          request.value!
+        }.to raise_error(Px::Service::ServiceRequestError, "Not Found")
       end
 
       it "does not increment the failure count of the breaker" do
         expect {
-          subject.make_request(:get, "http://test").value! rescue nil
+          request.value! rescue nil
         }.not_to change{subject.class.circuit_state.failure_count}
       end
     end
 
     context "when the wrapped method fails with a ServiceError" do
-      before :each do
-        subject_class.send(:define_method, :_result) do
-          raise Px::Service::ServiceError.new("Error", 500)
-        end
+      let(:response) do
+        Typhoeus::Response.new(
+          code: 500,
+          body: { status: 500, error: "Error"}.to_json,
+          headers: { "Content-Type" => "application/json"} )
       end
 
       it "raises a ServiceError" do
         expect {
-          subject.make_request(:get, "http://test").value!
+          request.value!
         }.to raise_error(Px::Service::ServiceError, "Error")
       end
 
       it "increments the failure count of the breaker" do
         expect {
-          subject.make_request(:get, "http://test").value! rescue nil
+          request.value! rescue nil
         }.to change{subject.class.circuit_state.failure_count}.by(1)
       end
     end
 
     context "when the circuit is open" do
       before :each do
-        subject_class.send(:define_method, :_result) do
-          "should not be called"
-        end
-
         subject.circuit_state.trip
         subject.circuit_state.last_failure_time = Time.now
       end
 
       it "raises a ServiceError" do
         expect {
-          subject.make_request(:get, "http://test").value!
+          request.value!
         }.to raise_error(Px::Service::ServiceError)
       end
     end
 
     context "with multiple classes" do
       let(:other_class) {
-        Class.new do
-          def make_request(method, uri, query: nil, headers: nil, body: nil, timeout: 0)
-            Px::Service::Client::Future.new do
-              "result"
-            end
-          end
-        end.tap do |c|
+        Class.new(Px::Service::Client::Base).tap do |c|
           # Anonymous classes don't have a name.  Stub out :name so that things work
           allow(c).to receive(:name).and_return("OtherCircuitBreaker")
           c.include(Px::Service::Client::CircuitBreaker)
@@ -148,12 +152,6 @@ describe Px::Service::Client::CircuitBreaker do
 
       let(:other) { other_class.new }
 
-      before :each do
-        subject_class.send(:define_method, :_result) do
-          "should not be called"
-        end
-      end
-
       context "when the breaker opens on the first instance" do
         before :each do
           subject.circuit_state.trip
@@ -162,12 +160,13 @@ describe Px::Service::Client::CircuitBreaker do
 
         it "raises a ServiceError on the first instance" do
           expect {
-            subject.make_request(:get, "http://test").value!
+            request.value!
           }.to raise_error(Px::Service::ServiceError)
         end
 
         it "does not raise a ServiceError on the second instance" do
-          expect(other.make_request(:get, "http://test").value!).to eq("result")
+          @object = other
+          expect(request.value!).to eq(response)
         end
       end
     end
@@ -175,12 +174,6 @@ describe Px::Service::Client::CircuitBreaker do
     context "with multiple instances of the same class" do
       let(:other) { subject_class.new }
 
-      before :each do
-        subject_class.send(:define_method, :_result) do
-          "should not be called"
-        end
-      end
-
       context "when the breaker opens on the first instance" do
         before :each do
           subject.circuit_state.trip
@@ -189,13 +182,14 @@ describe Px::Service::Client::CircuitBreaker do
 
         it "raises a ServiceError on the first instance" do
           expect {
-            subject.make_request(:get, "http://test").value!
+            request.value!
           }.to raise_error(Px::Service::ServiceError)
         end
 
         it "raises a ServiceError on the second instance" do
+          @object = other
           expect {
-            other.make_request(:get, "http://test").value!
+            request.value!
           }.to raise_error(Px::Service::ServiceError)
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: px-service-client
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Chris Micacchi
@@ -198,14 +198,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '2.99'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '2.99'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
@@ -244,6 +244,7 @@ files:
 - lib/px/service/client/caching/log_subscriber.rb
 - lib/px/service/client/caching/railtie.rb
 - lib/px/service/client/circuit_breaker.rb
+- lib/px/service/client/circuit_breaker_retriable_response_future.rb
 - lib/px/service/client/future.rb
 - lib/px/service/client/list_response.rb
 - lib/px/service/client/multiplexer.rb