active_rest_client 1.0.6 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3477c6e4b20c5133c874a8ef329c9e71f2d50be0
-  data.tar.gz: 7cdfcda9c6f33f0262228c80a5b1cdade5aee5ff
+  metadata.gz: 9e90aa3aab74da133bb45147624a0723812c609e
+  data.tar.gz: fe25689f084ddcaa682c7230152e2c1a49fa03db
 SHA512:
-  metadata.gz: 29e829f81a617090b82e56cb68a03f46ca92238bcc6c9f5d056ad524daa5822724ad65dc9a79f1fdebf60e642d270200bd379748257ba84771d9454167000743
-  data.tar.gz: 9b2b9b9de8634f62e9ff1a78879dd0d5fd1ec7272550ab4dfa7a6e2aee74e41cbe927f6e784f0abffb8f1ebab250cbd106351927642b86d7b7e4ba560a7ecbc4
+  metadata.gz: a5376c72339436353eb5e46ef657c479bda1adb14bd446e7bc731aae88ace39c6a42a64a449de3cb49f3f123c3f2b1ef85a0e214ff01c4f838bc5fd07f1e7e0c
+  data.tar.gz: dbf38d4b667137b07724da1d3fb0d365f7cb415df6b7aafd28cbcb4c1b74d5e225077a221110342de9bded154501708022883f35e35d9bf5de90340d00db1729

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
 rvm:
+  - 2.2.0
   - 2.1.0
   - 2.0.0
   - 1.9.3

data/README.md

@@ -75,6 +75,15 @@ id = @person.id
 end
 ```
 
+If an API returns an array of results and you have [will_paginate](https://rubygems.org/gems/will_paginate) installed then you can call the paginate method to return a particular page of the results (note: this doesn't reduce the load on the server, but it can help with pagination if you have a cached response).
+
+```ruby
+@people = Person.all
+@people.paginate(page: 1, per_page: 10).each do |person|
+  puts "You made the first page: " + person.first_name
+end
+```
+
 Note, you can assign to any attribute, whether it exists or not before and read from any attribute (which will return nil if not found).  If you pass a string or a number to a method it will assume that it's for the "id" field.  Any other field values must be passed as a hash and you can't mix passing a string/number and a hash.
 
 ```ruby
@@ -317,7 +326,7 @@ ActiveRestClient::Base.cache_store = Redis::Store.new("redis://localhost:6379/0/
 
 You can use filters to alter get/post parameters, the URL or set the post body (doing so overrides normal parameter insertion in to the body) before a request or to adjust the response after a request.  This can either be a block or a named method (like ActionController's `before_filter`/`before_action` methods).
 
-The filter is passed the name of the method (e.g. `:save`) and an object (a request object for `before_filter` and a response object for `after_filter`). The request object has four public attributes `post_params` (a Hash of the POST parameters), `get_params` (a Hash of the GET parameters), headers and `url` (a String containing the full URL without GET parameters appended)
+The filter is passed the name of the method (e.g. `:save`) and an object (a request object for `before_request` and a response object for `after_request`). The request object has four public attributes `post_params` (a Hash of the POST parameters), `get_params` (a Hash of the GET parameters), headers and `url` (a String containing the full URL without GET parameters appended)
 
 ```ruby
 require 'secure_random'
@@ -372,11 +381,11 @@ After filters work in exactly the same way:
 
 ```ruby
 class Person < ActiveRestClient::Base
-  after_filter :fix_empty_content
+  after_request :fix_empty_content
 
   private
 
-  def fix_empty_content
+  def fix_empty_content(name, response)
     if response.status == 204 && response.body.blank?
       response.body = '{"empty": true}'
     end
@@ -443,13 +452,25 @@ or
 ActiveRestClient::Base.request_body_type = :json
 ```
 
+This will also set the header `Content-Type` to `application/x-www-form-urlencoded` by default or `application/json` when `:json`.
+
+If you have an API that is inconsistent in its body type requirements, you can also specify it on the individual method mapping:
+
+```ruby
+class Person < ActiveRestClient::Base
+  request_body_type :form_encoded # This is the default, but just for demo purposes
+
+  get :all, '/people', request_body_type: :json
+end
+```
+
 ### 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.
 
 ```ruby
 class Person < ActiveRestClient::Base
-  get :all, '/people', :fake => "[{first_name:"Johnny"}, {first_name:"Bob"}]"
+  get :all, '/people', fake: [{first_name:"Johnny"}, {first_name:"Bob"}]
 end
 ```
 
@@ -457,7 +478,7 @@ You may want to run a proc when faking data (to put information from the paramet
 
 ```ruby
 class Person < ActiveRestClient::Base
-  get :all, '/people', :fake => ->(request) { "{\"result\":#{request.get_params[:id]}}" }
+  get :all, '/people', fake: ->(request) { {result: request.get_params[:id]} }
 end
 ```
 

data/active_rest_client.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 2"
+  spec.add_development_dependency "rspec", "~> 3"
   spec.add_development_dependency "webmock"
   spec.add_development_dependency "rspec_junit_formatter"
   spec.add_development_dependency "simplecov"
@@ -33,5 +33,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "multi_json"
   spec.add_runtime_dependency "activesupport"
   spec.add_runtime_dependency "faraday"
-  spec.add_development_dependency "patron", ">= 0.4.9" # 0.4.18 breaks against Curl v0.7.15 but works with webmock
+  spec.add_runtime_dependency "patron", ">= 0.4.9" # 0.4.18 breaks against Curl v0.7.15 but works with webmock
 end

data/lib/active_rest_client/base.rb

@@ -8,6 +8,8 @@ module ActiveRestClient
     include Recording
 
     attr_accessor :_status
+    attr_accessor :_etag
+    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
@@ -24,6 +26,8 @@ module ActiveRestClient
         attribute_name = attribute_name.to_sym
         if attribute_value.to_s[/\d{4}\-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(Z|[+-]\d{2}:\d{2})/]
           @attributes[attribute_name] = DateTime.parse(attribute_value)
+        elsif attribute_value.to_s =~ /^\d{4}\-\d{2}-\d{2}$/
+          @attributes[attribute_name] = Date.parse(attribute_value)
         else
           @attributes[attribute_name] = attribute_value
         end
@@ -95,6 +99,20 @@ module ActiveRestClient
       end
     end
 
+    def inspect
+      inspection = if @attributes.any?
+                     @attributes.collect { |key, value|
+                       "#{key}: #{value_for_inspect(value)}"
+                     }.compact.join(", ")
+                   else
+                     "[uninitialized]"
+                   end
+      inspection += "#{"," if @attributes.any?} ETag: #{@_etag}" unless @_etag.nil?
+      inspection += "#{"," if @attributes.any?} Status: #{@_status}" unless @_status.nil?
+      inspection += " (unsaved: #{@dirty_attributes.map(&:to_s).join(", ")})" if @dirty_attributes.any?
+      "#<#{self.class} #{inspection}>"
+    end
+
     def method_missing(name, *args)
       if name.to_s[-1,1] == "="
         name = name.to_s.chop.to_sym
@@ -146,6 +164,19 @@ module ActiveRestClient
       output = to_hash
       output.to_json
     end
+
+    private
+
+    def value_for_inspect(value)
+      if value.is_a?(String) && value.length > 50
+        "#{value[0..50]}...".inspect
+      elsif value.is_a?(Date) || value.is_a?(Time)
+        %("#{value.to_s(:db)}")
+      else
+        value.inspect
+      end
+    end
+
   end
 
   class NoAttributeException < StandardError ; end

data/lib/active_rest_client/configuration.rb

@@ -2,6 +2,8 @@ module ActiveRestClient
   module Configuration
     module ClassMethods
       @@base_url = nil
+      @@username = nil
+      @@password = nil
       @@request_body_type = :form_encoded
       @lazy_load = false
 
@@ -24,6 +26,40 @@ module ActiveRestClient
         @@base_url = value
       end
 
+      def username(value = nil)
+        if value.nil?
+          if @username.nil?
+            @@username
+          else
+            @username
+          end
+        else
+          @username = value
+        end
+      end
+
+      def username=(value)
+        ActiveRestClient::Logger.info "\033[1;4;32m#{name}\033[0m Username set to be #{value}"
+        @@username = value
+      end
+
+      def password(value = nil)
+        if value.nil?
+          if @password.nil?
+            @@password
+          else
+            @password
+          end
+        else
+          @password = value
+        end
+      end
+
+      def password=(value)
+        ActiveRestClient::Logger.info "\033[1;4;32m#{name}\033[0m Password set..."
+        @@password = value
+      end
+
       def request_body_type(value = nil)
         if value.nil?
           if @request_body_type.nil?

data/lib/active_rest_client/request.rb

@@ -44,8 +44,34 @@ module ActiveRestClient
       end
     end
 
-    def request_body_type
+    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
+      else
+        @object.class.username
+      end
+    end
+
+    def password
+      if object_is_class?
+        @object.password
+      else
+        @object.class.password
+      end
+    end
+
+    def request_body_type
+      if @method[:options][:request_body_type]
+        @method[:options][:request_body_type]
+      elsif object_is_class?
         @object.request_body_type
       else
         @object.class.request_body_type
@@ -183,8 +209,10 @@ module ActiveRestClient
     def prepare_request_body(params = nil)
       if request_body_type == :form_encoded
         @body ||= (params || @post_params || {}).map {|k,v| "#{k}=#{CGI.escape(v.to_s)}"}.sort * "&"
+        headers["Content-Type"] ||= "application/x-www-form-urlencoded"
       elsif request_body_type == :json
         @body ||= (params || @post_params || {}).to_json
+        headers["Content-Type"] ||= "application/json"
       end
     end
 
@@ -210,6 +238,7 @@ module ActiveRestClient
           else
             _, @base_url, @url = parts
           end
+          base_url.gsub!(%r{//(.)}, "//#{username}:#{password}@\\1") if username && !base_url[%r{//[^/]*:[^/]*@}]
           connection = ActiveRestClient::ConnectionManager.get_connection(@base_url)
         end
       else
@@ -220,6 +249,7 @@ module ActiveRestClient
           @url = "#{base_url}#{@url}".gsub(@base_url, "")
           base_url = @base_url
         end
+        base_url.gsub!(%r{//(.)}, "//#{username}:#{password}@\\1") if username && !base_url[%r{//[^/]*:[^/]*@}]
         connection = ActiveRestClient::ConnectionManager.get_connection(base_url)
       end
       ActiveRestClient::Logger.info "  \033[1;4;32m#{ActiveRestClient::NAME}\033[0m #{@instrumentation_name} - Requesting #{connection.base_url}#{@url}"
@@ -437,8 +467,11 @@ module ActiveRestClient
       else
         result = new_object(body, @overriden_name)
         result._status = @response.status
+        result._headers = @response.headers
+        result._etag = @response.headers['ETag']
         if !object_is_class? && options[:mutable] != false
           @object._copy_from(result)
+          @object._clean!
           result = @object
         end
       end

data/lib/active_rest_client/result_iterator.rb

@@ -26,6 +26,10 @@ module ActiveRestClient
       size == 0
     end
 
+    def reverse
+      @reversed_items ||= @items.reverse
+    end
+
     def each
       @items.each do |el|
         yield el
@@ -62,5 +66,19 @@ module ActiveRestClient
       collected_responses
     end
 
+    def paginate(options = {})
+      raise WillPaginateNotAvailableException.new unless Object.constants.include?(:WillPaginate)
+
+      page     = options[:page] || 1
+      per_page = options[:per_page] || WillPaginate.per_page
+      total    = options[:total_entries] || @items.length
+
+      WillPaginate::Collection.create(page, per_page, total) do |pager|
+        pager.replace @items[pager.offset, pager.per_page].to_a
+      end
+    end
+
   end
+
+  class WillPaginateNotAvailableException < StandardError ; end
 end

data/lib/active_rest_client/version.rb

@@ -1,3 +1,3 @@
 module ActiveRestClient
-  VERSION = "1.0.6"
+  VERSION = "1.0.7"
 end

data/spec/lib/base_spec.rb

@@ -39,7 +39,7 @@ end
 
 describe ActiveRestClient::Base do
   it 'should instantiate a new descendant' do
-    expect{EmptyExample.new}.to_not raise_error(Exception)
+    expect{EmptyExample.new}.to_not raise_error
   end
 
   it "should not instantiate a new base class" do
@@ -73,13 +73,20 @@ describe ActiveRestClient::Base do
     expect(values).to eq(["Billy", "United Kingdom"])
   end
 
-  it "should automatically parse ISO 8601 format dates" do
+  it "should automatically parse ISO 8601 format date and time" do
     t = Time.now
     client = EmptyExample.new(:test => t.iso8601)
     expect(client["test"]).to be_an_instance_of(DateTime)
     expect(client["test"].to_s).to eq(t.to_datetime.to_s)
   end
 
+  it "should automatically parse ISO 8601 format dates" do
+    d = Date.today
+    client = EmptyExample.new(:test => d.iso8601)
+    expect(client["test"]).to be_an_instance_of(Date)
+    expect(client["test"]).to eq(d)
+  end
+
   it "should store attributes set using missing method names and mark them as dirty" do
     client = EmptyExample.new()
     client.test = "Something"
@@ -105,8 +112,8 @@ describe ActiveRestClient::Base do
 
   it 'should respond_to? attributes defined in the response' do
     client = EmptyExample.new(:hello => "World")
-    client.respond_to?(:hello).should be_true
-    client.respond_to?(:world).should be_false
+    expect(client.respond_to?(:hello)).to be_truthy
+    expect(client.respond_to?(:world)).to be_falsey
   end
 
   it "should save the base URL for the API server" do
@@ -149,22 +156,63 @@ describe ActiveRestClient::Base do
   end
 
   it "should be able to lazy instantiate an object from a prefixed lazy_ method call" do
-    ActiveRestClient::Connection.any_instance.should_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(OpenStruct.new(status:200, 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
-    ActiveRestClient::Connection.any_instance.should_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(OpenStruct.new(status:200, 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")
   end
 
+  context "#inspect output" do
+    it "displays a nice version" do
+      object = EmptyExample.new(id: 1, name: "John Smith")
+      expect(object.inspect).to match(/#<EmptyExample id: 1, name: "John Smith"/)
+    end
+
+    it "shows dirty attributes as a list of names at the end" do
+      object = EmptyExample.new(id: 1, name: "John Smith")
+      expect(object.inspect).to match(/#<EmptyExample id: 1, name: "John Smith" \(unsaved: id, name\)/)
+    end
+
+    it "doesn't show an empty list of dirty attributes" do
+      object = EmptyExample.new(id: 1, name: "John Smith")
+      object.instance_variable_set(:@dirty_attributes, Set.new)
+      expect(object.inspect).to_not match(/\(unsaved: id, name\)/)
+    end
+
+    it "shows dates in a nice format" do
+      object = EmptyExample.new(dob: Time.new(2015, 01, 02, 03, 04, 05))
+      expect(object.inspect).to match(/#<EmptyExample dob: "2015\-01\-02 03:04:05"/)
+    end
+
+    it "shows the etag if one is set" do
+      object = EmptyExample.new(id: 1)
+      object.instance_variable_set(:@_etag, "sample_etag")
+      expect(object.inspect).to match(/#<EmptyExample id: 1, ETag: sample_etag/)
+    end
+
+    it "shows the HTTP status code if one is set" do
+      object = EmptyExample.new(id: 1)
+      object.instance_variable_set(:@_status, 200)
+      expect(object.inspect).to match(/#<EmptyExample id: 1, Status: 200/)
+    end
+
+    it "shows [uninitialized] for new objects" do
+      object = EmptyExample.new
+      expect(object.inspect).to match(/#<EmptyExample \[uninitialized\]/)
+    end
+
+  end
+
   context "accepts a Translator to reformat JSON" do
     it "should log a deprecation warning when using a translator" do
-      ActiveRestClient::Logger.should_receive(:warn) do |message|
+      expect(ActiveRestClient::Logger).to receive(:warn) do |message|
         expect(message).to start_with("DEPRECATION")
       end
       Proc.new do
@@ -175,7 +223,7 @@ describe ActiveRestClient::Base do
     end
 
     it "should call Translator#method when calling the mapped method if it responds to it" do
-      TranslatorExample.should_receive(:all).with(an_instance_of(Hash)).and_return({})
+      expect(TranslatorExample).to receive(:all).with(an_instance_of(Hash)).and_return({})
       AlteringClientExample.all
     end
 
@@ -198,35 +246,35 @@ 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
-      ActiveRestClient::Request.any_instance.should_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(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
       EmptyExample._request("http://api.example.com/")
     end
 
     it "runs filters as usual" do
-      ActiveRestClient::Request.any_instance.should_receive(:do_request).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
-      EmptyExample.should_receive(:_filter_request).with(any_args).exactly(2).times
+      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(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
-      ActiveRestClient::Connection.any_instance.should_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(OpenStruct.new(status:200, 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
-      ActiveRestClient::Connection.any_instance.should_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(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
       NonHostnameBaseUrlExample.all
     end
 
     it "should map the response from the directly called URL in the normal way" do
-      ActiveRestClient::Request.any_instance.should_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(OpenStruct.new(status:200, 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")
-      ActiveRestClient::Connection.any_instance.should_receive(:post).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:response))
+      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)
     end
 
@@ -236,7 +284,7 @@ describe ActiveRestClient::Base do
       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")
-        allow_any_instance_of(ActiveRestClient::Connection).to receive(:get) do |url, others|
+        allow_any_instance_of(ActiveRestClient::Connection).to receive(:get) do |instance, url, others|
           if url == "/?test=1"
             OpenStruct.new(status:200, headers:{}, body:response)
           else
@@ -254,19 +302,19 @@ describe ActiveRestClient::Base do
     end
 
     it "should be able to lazy load a direct URL request" do
-      ActiveRestClient::Request.any_instance.should_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(OpenStruct.new(status:200, 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
-      ActiveRestClient::Connection.any_instance.should_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(OpenStruct.new(status:200, 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
-      ActiveRestClient::Connection.any_instance.should_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(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
       request = AlteringClientExample._request_for(:find, :id => 1)
       example = AlteringClientExample._lazy_request(request)
       expect(example.first_name).to eq("Billy")
@@ -275,7 +323,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
-      ActiveRestClient::Connection.any_instance.should_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(OpenStruct.new(status:200, headers:{}, body:"Hello world"))
       expect{RecordResponseExample.all}.to raise_error(Exception, "/all|Hello world")
     end
   end