active_rest_client 1.0.9 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77e442c1fd4bf22c3ef98a18bb9f67d034d13dcb
-  data.tar.gz: eb7c6b99213a31eb56f69c276642fe03825e3a9d
+  metadata.gz: 93a842b5f48d12dcd6e53fe6ffef4ff8bed6ba35
+  data.tar.gz: 2fe79284a9107ababa2758575b61906b2814b9d1
 SHA512:
-  metadata.gz: f21a5d8fad3841c0891d4a619d59b6bdaf0f5f920c4512cf3be1b9eb72b9d8f7d2ac1acff05ce62a3aef9cbb17661c5f1ebedd13943863c149b4b63ad3ba7e47
-  data.tar.gz: 7ed888f35736130ffc40118dbde8ec51f764d13f38cb48fcc5b71337b4fbd2a45a0cd77aee19ea96d6135f3c66393272406391a7924cc7338771a2562e3eef73
+  metadata.gz: f45afa7dde42bc05d0b22cb913ce121b99dd77d20ce2f67e2b7990f3ea0b686cb8c533c4e91a03eb0eb043a00c0bb0953f5e8390e77b945bff319f321136a941
+  data.tar.gz: 12307bd1cb569a0dba41172e052a60667ef27b7c81aacf7f1b2db9df30806d26ab75b717fc9aca10ea4eb740c01d96081dd852ec98d3b539edf29c1ceda75609

data/README.md

@@ -495,6 +495,28 @@ class Person < ActiveRestClient::Base
 end
 ```
 
+### Parallel Requests
+
+Sometimes you know you will need to make a bunch of requests and you don't want to wait for one to finish to start the next. When using parallel requests there is the potential to finish many requests all at the same time taking only as long as the single longest request. To use parallel requests you will need to set Active-Rest-Client to use a Faraday adapter that supports parallel requests [(such as Typhoeus)](https://github.com/lostisland/faraday/wiki/Parallel-requests).
+```ruby
+# Set adapter to Typhoeus to use parallel requests
+ActiveRestClient::Base.adapter = :typhoeus
+```
+
+Now you just need to get ahold of the connection that is going to make the requests by specifying the same host that the models will be using. When inside the `in_parallel` block call request methods as usual and access the results after the `in_parallel` block ends.
+```ruby
+ActiveRestClient::ConnectionManager.in_parallel('https://www.example.com') do
+    @person = Person.find(1234)
+    @employers = Employer.all
+
+    puts @person #=> nil
+    puts @employers #=> nil
+end # The requests are all fired in parallel during this end statement
+
+puts @person.name #=> "John"
+puts @employers.size #=> 7
+```
+
 ### Faking Calls
 
 There are times when an API hasn't been developed yet, so you want to fake the API call response.  To do this, you can simply pass a `fake` option when mapping the call containing the response.

data/active_rest_client.gemspec

@@ -30,6 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'terminal-notifier-guard'
   spec.add_development_dependency 'coveralls'
   spec.add_development_dependency "api-auth", ">= 1.3.1"
+  spec.add_development_dependency 'typhoeus'
 
   spec.add_runtime_dependency "multi_json"
   spec.add_runtime_dependency "activesupport"

data/lib/active_rest_client/base.rb

@@ -12,7 +12,7 @@ module ActiveRestClient
     attr_accessor :_headers
 
     instance_methods.each do |m|
-      next unless %w{display errors presence load require hash untrust trust freeze method enable_warnings with_warnings suppress capture silence quietly debugger breakpoint}.map(&:to_sym).include? m
+      next unless %w{display presence load require hash untrust trust freeze method enable_warnings with_warnings suppress capture silence quietly debugger breakpoint}.map(&:to_sym).include? m
       undef_method m
     end
 
@@ -52,6 +52,10 @@ module ActiveRestClient
       @dirty_attributes.size > 0
     end
 
+    def errors
+      @attributes[:errors] || (_errors != {} ? _errors : nil)
+    end
+
     def self._request(request, method = :get, params = nil)
       prepare_direct_request(request, method).call(params)
     end

data/lib/active_rest_client/caching.rb

@@ -56,17 +56,18 @@ module ActiveRestClient
         return if result.is_a? Symbol
         return unless perform_caching
         return unless !result.respond_to?(:_status) || [200, 304].include?(result._status)
+        headers = response.response_headers
 
-        response.headers.keys.select{|h| h.is_a? String}.each do |key|
-          response.headers[key.downcase.to_sym] = response.headers[key]
+        headers.keys.select{|h| h.is_a? String}.each do |key|
+          headers[key.downcase.to_sym] = headers[key]
         end
 
-        if cache_store && (response.headers[:etag] || response.headers[:expires])
+        if cache_store && (headers[:etag] || headers[:expires])
           key = "#{request.class_name}:#{request.original_url}"
           ActiveRestClient::Logger.debug "  \033[1;4;32m#{ActiveRestClient::NAME}\033[0m #{key} - Writing to cache"
           cached_response = CachedResponse.new(status:response.status, result:result)
-          cached_response.etag = response.headers[:etag] if response.headers[:etag]
-          cached_response.expires = Time.parse(response.headers[:expires]) rescue nil if response.headers[:expires]
+          cached_response.etag = headers[:etag] if headers[:etag]
+          cached_response.expires = Time.parse(headers[:expires]) rescue nil if headers[:expires]
           cache_store.write(key, Marshal.dump(cached_response), {}) if cached_response.etag.present? || cached_response.expires
         end
       end

data/lib/active_rest_client/configuration.rb

@@ -1,3 +1,5 @@
+require 'cgi'
+
 module ActiveRestClient
   module Configuration
     module ClassMethods
@@ -36,12 +38,14 @@ module ActiveRestClient
             @username
           end
         else
+          value = CGI::escape(value) if value.present? && !value.include?("%")
           @username = value
         end
       end
 
       def username=(value)
         ActiveRestClient::Logger.info "\033[1;4;32m#{name}\033[0m Username set to be #{value}"
+        value = CGI::escape(value) if value.present? && !value.include?("%")
         @@username = value
       end
 
@@ -53,12 +57,14 @@ module ActiveRestClient
             @password
           end
         else
+          value = CGI::escape(value) if value.present? && !value.include?("%")
           @password = value
         end
       end
 
       def password=(value)
         ActiveRestClient::Logger.info "\033[1;4;32m#{name}\033[0m Password set..."
+        value = CGI::escape(value) if value.present? && !value.include?("%")
         @@password = value
       end
 

data/lib/active_rest_client/connection_manager.rb

@@ -17,5 +17,20 @@ module ActiveRestClient
       Thread.current[:_connections][found] if found
     end
 
+    def self.in_parallel(base_url)
+      begin
+        require 'typhoeus'
+        require 'typhoeus/adapters/faraday'
+      rescue LoadError
+        raise MissingOptionalLibraryError.new("To call '::ActiveRestClient::ConnectionManager.in_parallel' you must include the gem 'Typhoeus' in your Gemfile.")
+      end
+      session = ConnectionManager.get_connection(base_url).session
+      session.in_parallel do
+        yield
+      end
+    end
+
   end
+
+  class MissingOptionalLibraryError < StandardError ; end
 end

data/lib/active_rest_client/proxy_base.rb

@@ -68,7 +68,7 @@ module ActiveRestClient
 
       def translate(result, options = {})
         result.headers["content-type"] = "application/hal+json"
-        result = OpenStruct.new(status:result.status, headers:result.headers, body:result.body)
+        result = FaradayResponseProxy.new(OpenStruct.new(status:result.status, response_headers:result.headers, body:result.body))
         if result.body.present?
           result.body = yield MultiJson.load(result.body)
         end
@@ -135,7 +135,7 @@ module ActiveRestClient
 
       def render(body, status=200, content_type="application/javascript", headers={})
         headers["Content-type"] = content_type
-        OpenStruct.new(body:body, status:status, headers:headers, proxied:true)
+        FaradayResponseProxy.new(OpenStruct.new(body:body, status:status, response_headers:headers, proxied:true))
       end
     end
 
@@ -143,4 +143,38 @@ module ActiveRestClient
       base.extend(ClassMethods)
     end
   end
+
+  # FaradayResponseProxy acts just like a Faraday Response object,
+  # however it always resolves the request immediately regardless of
+  # whether it is inside an in_parallel block or not
+  class FaradayResponseProxy
+    def initialize(response)
+      @response = response
+    end
+
+    def headers
+      @response.response_headers
+    end
+
+    def status
+      @response.status
+    end
+
+    def body
+      @response.body
+    end
+
+    def body=(value)
+      @response.body = value
+      value
+    end
+
+    def on_complete
+      yield(@response)
+    end
+
+    def finished?
+      true
+    end
+  end
 end

data/lib/active_rest_client/request.rb

@@ -13,6 +13,7 @@ module ActiveRestClient
       @method[:options][:has_one] ||= {}
       @overriden_name             = @method[:options][:overriden_name]
       @object                     = object
+      @response_delegate          = ActiveRestClient::RequestDelegator.new(nil)
       @params                     = params
       @headers                    = HeadersList.new
     end
@@ -45,14 +46,6 @@ module ActiveRestClient
       end
     end
 
-    def base_url
-      if object_is_class?
-        @object.base_url
-      else
-        @object.class.base_url
-      end
-    end
-
     def username
       if object_is_class?
         @object.username
@@ -123,7 +116,7 @@ module ActiveRestClient
             fake = fake.call(self)
           end
           ActiveRestClient::Logger.debug "  \033[1;4;32m#{ActiveRestClient::NAME}\033[0m #{@instrumentation_name} - Faked response found"
-          return handle_response(OpenStruct.new(status:200, body:fake, headers:{"X-ARC-Faked-Response" => "true"}))
+          return handle_response(OpenStruct.new(status:200, body:fake, response_headers:{"X-ARC-Faked-Response" => "true"}))
         end
         if object_is_class?
           @object.send(:_filter_request, :before, @method[:name], self)
@@ -143,24 +136,47 @@ module ActiveRestClient
             etag = cached.etag
           end
         end
-        response = if proxy
-          proxy.handle(self) do |request|
-            request.do_request(etag)
+
+        response = (
+          if proxy
+            proxy.handle(self) do |request|
+              request.do_request(etag)
+            end
+          else
+            do_request(etag)
           end
-        else
-          do_request(etag)
-        end
-        if object_is_class? && @object.record_response?
-          @object.record_response(self.url, response)
-        end
-        if object_is_class?
-          @object.send(:_filter_request, :after, @method[:name], response)
-        else
-          @object.class.send(:_filter_request, :after, @method[:name], response)
+        )
+
+        # This block is called immediately when this request is not inside a parallel request block.
+        # Otherwise this callback is called after the parallel request block ends.
+        response.on_complete do |response_env|
+          if verbose?
+            ActiveRestClient::Logger.debug "  Response"
+            ActiveRestClient::Logger.debug "  << Status : #{response_env.status}"
+            response_env.response_headers.each do |k,v|
+              ActiveRestClient::Logger.debug "  << #{k} : #{v}"
+            end
+            ActiveRestClient::Logger.debug "  << Body:\n#{response_env.body}"
+          end
+
+          if object_is_class? && @object.record_response?
+            @object.record_response(self.url, response_env)
+          end
+          if object_is_class?
+            @object.send(:_filter_request, :after, @method[:name], response_env)
+          else
+            @object.class.send(:_filter_request, :after, @method[:name], response_env)
+          end
+
+          result = handle_response(response_env, cached)
+          @response_delegate.__setobj__(result)
+          original_object_class.write_cached_response(self, response_env, result)
         end
-        result = handle_response(response, cached)
-        original_object_class.write_cached_response(self, response, result)
-        result
+
+        # If this was not a parallel request just return the original result
+        return result if response.finished?
+        # Otherwise return the delegate which will get set later once the call back is completed
+        return @response_delegate
       end
     end
 
@@ -277,15 +293,6 @@ module ActiveRestClient
         raise InvalidRequestException.new("Invalid method #{http_method}")
       end
 
-      if verbose?
-        ActiveRestClient::Logger.debug "  Response"
-        ActiveRestClient::Logger.debug "  << Status : #{response.status}"
-        response.headers.each do |k,v|
-          ActiveRestClient::Logger.debug "  << #{k} : #{v}"
-        end
-        ActiveRestClient::Logger.debug "  << Body:\n#{response.body}"
-      end
-
       response
     end
 
@@ -343,6 +350,8 @@ module ActiveRestClient
           raise HTTPClientException.new(status:status, result:error_response, url:@url)
         elsif (500..599).include? status
           raise HTTPServerException.new(status:status, result:error_response, url:@url)
+        elsif status == 0
+          raise TimeoutException.new("Timed out getting #{response.url}")
         end
       end
 
@@ -359,11 +368,7 @@ module ActiveRestClient
         overriden_name = name
         object = @method[:options][:has_one][name].new
       else
-        if object_is_class?
-          object = @object.new
-        else
-          object = @object.class.new
-        end
+        object = create_object_instance
       end
 
       if hal_response? && name.nil?
@@ -400,8 +405,8 @@ module ActiveRestClient
     end
 
     def hal_response?
-      _, content_type = @response.headers.detect{|k,v| k.downcase == "content-type"}
-      faked_response = @response.headers.detect{|k,v| k.downcase == "x-arc-faked-response"}
+      _, content_type = @response.response_headers.detect{|k,v| k.downcase == "content-type"}
+      faked_response = @response.response_headers.detect{|k,v| k.downcase == "x-arc-faked-response"}
       if content_type && content_type.respond_to?(:each)
         content_type.each do |ct|
           return true if ct[%r{application\/hal\+json}i]
@@ -448,6 +453,10 @@ module ActiveRestClient
 
     private
 
+    def create_object_instance
+      return object_is_class? ? @object.new : @object.class.new
+    end
+
     def select_name(name, parent_name)
       if @method[:options][:has_many][name] || @method[:options][:has_one][name]
         return name
@@ -457,7 +466,7 @@ module ActiveRestClient
     end
 
     def is_json_response?
-      @response.headers['Content-Type'].nil? || @response.headers['Content-Type'].include?('json')
+      @response.response_headers['Content-Type'].nil? || @response.response_headers['Content-Type'].include?('json')
     end
 
     def generate_new_object(options={})
@@ -472,15 +481,15 @@ module ActiveRestClient
         body
       end
       if body.is_a? Array
-        result = ActiveRestClient::ResultIterator.new(@response.status)
+        result = ActiveRestClient::ResultIterator.new(@response)
         body.each do |json_object|
           result << new_object(json_object, @overriden_name)
         end
       else
         result = new_object(body, @overriden_name)
         result._status = @response.status
-        result._headers = @response.headers
-        result._etag = @response.headers['ETag']
+        result._headers = @response.response_headers
+        result._etag = @response.response_headers['ETag']
         if !object_is_class? && options[:mutable] != false
           @object._copy_from(result)
           @object._clean!

data/lib/active_rest_client/request_delegator.rb

@@ -0,0 +1,44 @@
+module ActiveRestClient
+  class RequestDelegator < Delegator
+    def initialize(obj)
+      super
+      @delegate_obj = obj
+    end
+
+    def __getobj__
+      @delegate_obj
+    end
+
+    def __setobj__(obj)
+      @delegate_obj = obj
+    end
+
+    def class
+      @delegate_obj.class
+    end
+
+    def method_missing(name, *args, &block)
+      # Handles issue with private method 'test' on base Ruby Object
+      return @delegate_obj.test if name.to_sym == :test
+
+      # Forward request to delegate
+      @delegate_obj.send(name, *args, &block)
+    end
+
+    def kind_of?(obj)
+      @delegate_obj.kind_of?(obj)
+    end
+
+    def is_a?(obj)
+      @delegate_obj.is_a?(obj)
+    end
+
+    def instance_of?(obj)
+      @delegate_obj.instance_of?(obj)
+    end
+
+    def _delegate?
+      return true
+    end
+  end
+end

data/lib/active_rest_client/result_iterator.rb

@@ -3,10 +3,11 @@ module ActiveRestClient
     include Enumerable
 
     attr_accessor :_status
-    attr_reader :items
+    attr_reader :items, :_headers
 
-    def initialize(status = nil)
-      @_status = status
+    def initialize(response = nil)
+      @_status  = response.try :status
+      @_headers = response.try :response_headers
       @items = []
     end
 

data/lib/active_rest_client/validation.rb

@@ -51,7 +51,7 @@ module ActiveRestClient
       @errors.empty?
     end
 
-    def errors
+    def _errors
       @errors ||= Hash.new {|h,k| h[k] = []}
       @errors
     end

data/lib/active_rest_client/version.rb

@@ -1,3 +1,3 @@
 module ActiveRestClient
-  VERSION = "1.0.9"
+  VERSION = "1.1.0"
 end

data/lib/active_rest_client.rb

@@ -12,6 +12,7 @@ require "active_rest_client/headers_list"
 require "active_rest_client/lazy_loader"
 require "active_rest_client/lazy_association_loader"
 require "active_rest_client/request"
+require "active_rest_client/request_delegator"
 require "active_rest_client/validation"
 require "active_rest_client/request_filtering"
 require "active_rest_client/proxy_base"

data/spec/lib/base_spec.rb

@@ -156,14 +156,14 @@ describe ActiveRestClient::Base do
   end
 
   it "should be able to lazy instantiate an object from a prefixed lazy_ method call" do
-    expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with('/find/1', anything).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with('/find/1', anything).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:"{\"first_name\":\"Billy\"}")))
     example = AlteringClientExample.lazy_find(1)
     expect(example).to be_an_instance_of(ActiveRestClient::LazyLoader)
     expect(example.first_name).to eq("Billy")
   end
 
   it "should be able to lazy instantiate an object from a prefixed lazy_ method call from an instance" do
-    expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with('/find/1', anything).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+    expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with('/find/1', anything).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:"{\"first_name\":\"Billy\"}")))
     example = AlteringClientExample.new.lazy_find(1)
     expect(example).to be_an_instance_of(ActiveRestClient::LazyLoader)
     expect(example.first_name).to eq("Billy")
@@ -246,49 +246,65 @@ describe ActiveRestClient::Base do
 
   context "directly call a URL, rather than via a mapped method" do
     it "should be able to directly call a URL" do
-      expect_any_instance_of(ActiveRestClient::Request).to receive(:do_request).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      expect_any_instance_of(ActiveRestClient::Request).to receive(:do_request).with(any_args).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:"{\"first_name\":\"Billy\"}")))
       EmptyExample._request("http://api.example.com/")
     end
 
     it "runs filters as usual" do
-      expect_any_instance_of(ActiveRestClient::Request).to receive(:do_request).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      expect_any_instance_of(ActiveRestClient::Request).to receive(:do_request).with(any_args).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:"{\"first_name\":\"Billy\"}")))
       expect(EmptyExample).to receive(:_filter_request).with(any_args).exactly(2).times
       EmptyExample._request("http://api.example.com/")
     end
 
     it "should make an HTTP request" do
-      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with(any_args).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:"{\"first_name\":\"Billy\"}")))
       EmptyExample._request("http://api.example.com/")
     end
 
     it "should make an HTTP request including the path in the base_url" do
-      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with('/v1/all', anything).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with('/v1/all', anything).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:"{\"first_name\":\"Billy\"}")))
       NonHostnameBaseUrlExample.all
     end
 
     it "should map the response from the directly called URL in the normal way" do
-      expect_any_instance_of(ActiveRestClient::Request).to receive(:do_request).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      expect_any_instance_of(ActiveRestClient::Request).to receive(:do_request).with(any_args).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:"{\"first_name\":\"Billy\"}")))
       example = EmptyExample._request("http://api.example.com/")
       expect(example.first_name).to eq("Billy")
     end
 
     it "should be able to pass the plain response from the directly called URL bypassing JSON loading" do
-      response = OpenStruct.new(_status:200, body:"This is another non-JSON string")
-      expect_any_instance_of(ActiveRestClient::Connection).to receive(:post).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:response))
-      expect(EmptyExample._plain_request("http://api.example.com/", :post, {id:1234})).to eq(response)
+      response_body = "This is another non-JSON string"
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:post).with(any_args).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:response_body)))
+      expect(EmptyExample._plain_request("http://api.example.com/", :post, {id:1234})).to eq(response_body)
+    end
+
+    context "Simulating Faraday connection in_parallel" do
+      it "should be able to pass the plain response from the directly called URL bypassing JSON loading" do
+        response_body = "This is another non-JSON string"
+        response = ::FaradayResponseMock.new(
+          OpenStruct.new(status:200, response_headers:{}, body:response_body),
+          false)
+        expect_any_instance_of(ActiveRestClient::Connection).to receive(:post).with(any_args).and_return(response)
+        result = EmptyExample._plain_request("http://api.example.com/", :post, {id:1234})
+
+        expect(result).to eq(nil)
+
+        response.finish
+        expect(result).to eq(response_body)
+      end
     end
 
     it "should cache plain requests separately" do
       perform_caching = EmptyExample.perform_caching
       cache_store = EmptyExample.cache_store
       begin
-        response = OpenStruct.new(_status:200, body:"This is a non-JSON string")
-        other_response = OpenStruct.new(_status:200, body:"This is another non-JSON string")
+        response = "This is a non-JSON string"
+        other_response = "This is another non-JSON string"
         allow_any_instance_of(ActiveRestClient::Connection).to receive(:get) do |instance, url, others|
           if url == "/?test=1"
-            OpenStruct.new(status:200, headers:{}, body:response)
+            ::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:response))
           else
-            OpenStruct.new(status:200, headers:{}, body:other_response)
+            ::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:other_response))
           end
         end
         EmptyExample.perform_caching = true
@@ -302,19 +318,19 @@ describe ActiveRestClient::Base do
     end
 
     it "should be able to lazy load a direct URL request" do
-      expect_any_instance_of(ActiveRestClient::Request).to receive(:do_request).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      expect_any_instance_of(ActiveRestClient::Request).to receive(:do_request).with(any_args).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:"{\"first_name\":\"Billy\"}")))
       example = EmptyExample._lazy_request("http://api.example.com/")
       expect(example).to be_an_instance_of(ActiveRestClient::LazyLoader)
       expect(example.first_name).to eq("Billy")
     end
 
     it "should be able to specify a method and parameters for the call" do
-      expect_any_instance_of(ActiveRestClient::Connection).to receive(:post).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:post).with(any_args).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:"{\"first_name\":\"Billy\"}")))
       EmptyExample._request("http://api.example.com/", :post, {id:1234})
     end
 
     it "should be able to use mapped methods to create a request to pass in to _lazy_request" do
-      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with('/find/1', anything).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with('/find/1', anything).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:"{\"first_name\":\"Billy\"}")))
       request = AlteringClientExample._request_for(:find, :id => 1)
       example = AlteringClientExample._lazy_request(request)
       expect(example.first_name).to eq("Billy")
@@ -323,7 +339,7 @@ describe ActiveRestClient::Base do
 
   context "Recording a response" do
     it "calls back to the record_response callback with the url and response body" do
-      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"Hello world"))
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with(any_args).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, response_headers:{}, body:"Hello world")))
       expect{RecordResponseExample.all}.to raise_error(Exception, "/all|Hello world")
     end
   end

data/spec/lib/caching_spec.rb

@@ -111,7 +111,7 @@ describe ActiveRestClient::Caching do
         result:@cached_object,
         etag:@etag)
       expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
-      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/", hash_including("If-None-Match" => @etag)).and_return(OpenStruct.new(status:304, headers:{}))
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/", hash_including("If-None-Match" => @etag)).and_return(::FaradayResponseMock.new(OpenStruct.new(status:304, response_headers:{})))
       ret = Person.all
       expect(ret.first_name).to eq("Johnny")
     end
@@ -125,7 +125,7 @@ describe ActiveRestClient::Caching do
       allow_any_instance_of(CachingExampleCacheStore5).to receive(:read).and_return(Marshal.dump(cached_response))
       new_name = 'Pete'
       response_body = Person.new(first_name: new_name).to_json
-      response = double(status: 200, headers: {}, body: response_body)
+      response = ::FaradayResponseMock.new(double(status: 200, response_headers: {}, body: response_body))
       allow_any_instance_of(ActiveRestClient::Connection).to(
         receive(:get).with('/', hash_including('If-None-Match' => @etag)).and_return(response))
 
@@ -159,7 +159,7 @@ describe ActiveRestClient::Caching do
 
     it "should restore a result iterator from the cache store, if there's a hard expiry" do
       class CachingExample3 < ActiveRestClient::Base ; end
-      object = ActiveRestClient::ResultIterator.new(200)
+      object = ActiveRestClient::ResultIterator.new(double(status: 200))
       object << CachingExample3.new(first_name:"Johnny")
       object << CachingExample3.new(first_name:"Billy")
       etag = "6527914a91e0c5769f6de281f25bd891"
@@ -185,7 +185,7 @@ describe ActiveRestClient::Caching do
     it "should write the response to the cache if there's an etag" do
       expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
       expect_any_instance_of(CachingExampleCacheStore5).to receive(:write).once.with("Person:/", an_instance_of(String), {})
-      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{etag:"1234567890"}))
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, body:"{\"result\":true}", response_headers:{etag:"1234567890"})))
       Person.perform_caching true
       ret = Person.all
     end
@@ -193,7 +193,7 @@ describe ActiveRestClient::Caching do
     it "should write the response to the cache if there's a hard expiry" do
       expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
       expect_any_instance_of(CachingExampleCacheStore5).to receive(:write).once.with("Person:/", an_instance_of(String), an_instance_of(Hash))
-      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{expires:(Time.now + 30).rfc822}))
+      expect_any_instance_of(ActiveRestClient::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, body:"{\"result\":true}", response_headers:{expires:(Time.now + 30).rfc822})))
       Person.perform_caching = true
       ret = Person.all
     end