active_rest_client 0.9.58

data/spec/lib/lazy_loader_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe ActiveRestClient::LazyLoader do
+  let(:request) { double("Request") }
+  let(:response) { double("Response") }
+
+  it "should not #call the passed in request during initialisation" do
+    request.should_not_receive(:call)
+    ActiveRestClient::LazyLoader.new(request)
+  end
+
+  it "should #call the passed in request if you check for response to a message" do
+    request.should_receive(:call)
+    loader = ActiveRestClient::LazyLoader.new(request)
+    loader.respond_to?(:each)
+  end
+
+  it "should #call the passed in request if you call a method and pass through the method" do
+    request.should_receive(:call).and_return(response)
+    response.should_receive(:valid).and_return(true)
+    loader = ActiveRestClient::LazyLoader.new(request)
+    expect(loader.valid).to be_true
+  end
+
+end

data/spec/lib/logger_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe ActiveRestClient::Instrumentation do
+  before :each do
+    ActiveRestClient::Logger.reset!
+  end
+
+  it "should log things to the Rails logger if available" do
+    class Rails
+      class << self
+        attr_accessor :logger
+      end
+    end
+
+    Rails.logger = double("Logger")
+    Rails.logger.should_receive(:debug)
+    Rails.logger.should_receive(:info)
+    Rails.logger.should_receive(:warn)
+    Rails.logger.should_receive(:error)
+    ActiveRestClient::Logger.debug("Hello world")
+    ActiveRestClient::Logger.info("Hello world")
+    ActiveRestClient::Logger.warn("Hello world")
+    ActiveRestClient::Logger.error("Hello world")
+    Object.send(:remove_const, :Rails)
+  end
+
+  it "should write to a logfile if one has been specified" do
+    ActiveRestClient::Logger.logfile = "/dev/null"
+    file = double('file')
+    File.should_receive(:open).with("/dev/null", "a").and_yield(file)
+    file.should_receive(:<<).with("Hello world")
+    ActiveRestClient::Logger.debug("Hello world")
+
+    file = double('file')
+    File.should_receive(:open).with("/dev/null", "a").and_yield(file)
+    file.should_receive(:<<).with("Hello info")
+    ActiveRestClient::Logger.info("Hello info")
+
+    file = double('file')
+    File.should_receive(:open).with("/dev/null", "a").and_yield(file)
+    file.should_receive(:<<).with("Hello error")
+    ActiveRestClient::Logger.error("Hello error")
+
+    file = double('file')
+    File.should_receive(:open).with("/dev/null", "a").and_yield(file)
+    file.should_receive(:<<).with("Hello warn")
+    ActiveRestClient::Logger.warn("Hello warn")
+  end
+
+  it "should append to its own messages list if neither Rails nor a logfile has been specified" do
+    File.should_not_receive(:open)
+    ActiveRestClient::Logger.debug("Hello world")
+    ActiveRestClient::Logger.info("Hello info")
+    ActiveRestClient::Logger.warn("Hello warn")
+    ActiveRestClient::Logger.error("Hello error")
+    expect(ActiveRestClient::Logger.messages.size).to eq(4)
+    expect(ActiveRestClient::Logger.messages[0]).to eq("Hello world")
+    expect(ActiveRestClient::Logger.messages[1]).to eq("Hello info")
+    expect(ActiveRestClient::Logger.messages[2]).to eq("Hello warn")
+    expect(ActiveRestClient::Logger.messages[3]).to eq("Hello error")
+  end
+
+end

data/spec/lib/mapping_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+class MappingExampleBase
+  include ActiveRestClient::Mapping
+end
+
+class MappingExample < MappingExampleBase
+  get :test_get, "/get", tag:1, fake:"{result:true}", lazy:[:something]
+  put :test_put, "/put", tag:2
+  post :test_post, "/post", tag:3
+  delete :test_delete, "/delete", tag:4
+end
+
+describe ActiveRestClient::Mapping do
+  it "should support methods for get/put/post/delete for mapping" do
+    expect(EmptyExample).to respond_to(:get)
+    expect(EmptyExample).to respond_to(:put)
+    expect(EmptyExample).to respond_to(:post)
+    expect(EmptyExample).to respond_to(:delete)
+  end
+
+  it "should save URL for each mapped call" do
+    expect(MappingExample._calls[:test_get][:url]).to eq("/get")
+    expect(MappingExample._calls[:test_put][:url]).to eq("/put")
+    expect(MappingExample._calls[:test_post][:url]).to eq("/post")
+    expect(MappingExample._calls[:test_delete][:url]).to eq("/delete")
+  end
+
+  it "should save the correct method type for each mapped call" do
+    expect(MappingExample._calls[:test_get][:method]).to eq(:get)
+    expect(MappingExample._calls[:test_put][:method]).to eq(:put)
+    expect(MappingExample._calls[:test_post][:method]).to eq(:post)
+    expect(MappingExample._calls[:test_delete][:method]).to eq(:delete)
+  end
+
+  it "should remember options set for each mapped call" do
+    expect(MappingExample._calls[:test_get][:options][:fake]).to eq("{result:true}")
+    expect(MappingExample._calls[:test_get][:options][:lazy]).to eq([:something])
+    expect(MappingExample._calls[:test_get][:options][:tag]).to eq(1)
+    expect(MappingExample._calls[:test_put][:options][:tag]).to eq(2)
+    expect(MappingExample._calls[:test_post][:options][:tag]).to eq(3)
+    expect(MappingExample._calls[:test_delete][:options][:tag]).to eq(4)
+  end
+
+  it "should allow for mapped calls on the class" do
+    expect(MappingExample).to respond_to(:test_get)
+  end
+end

data/spec/lib/proxy_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+require 'active_support/core_ext/hash'
+
+class ProxyExample < ActiveRestClient::ProxyBase
+  get "/all" do
+    url.gsub!("/all", "/getAll")
+    passthrough
+  end
+
+  get "/old" do
+    url "/new"
+    passthrough
+  end
+
+  get "/list" do
+    get_params[:first_name] = get_params.delete(:fname)
+    get_params[:age] = 12
+    get_params.delete(:lname)
+    passthrough
+  end
+
+  post "/create" do
+    post_params[:first_name] = post_params.delete(:fname)
+    post_params[:age] = 12
+    post_params.delete(:lname)
+    passthrough
+  end
+
+  put "/update" do
+    body "MY-BODY-CONTENT"
+    passthrough
+  end
+
+  delete '/remove' do
+    passthrough
+  end
+
+  get "/change-format" do
+    response = passthrough
+    translate(response) do |body|
+      body["first_name"] = body.delete("fname")
+      body
+    end
+  end
+
+  get "/hal_test/:id" do
+    response = passthrough
+    translate(response) do |body|
+      body["_links"] = {"test" => {href:"/this/is/a/test"}}
+      body
+    end
+  end
+
+  get "/param/:id/:name" do
+    render "{\"id\":\"#{params[:id]}\", \"name\":\"#{params[:name]}\"}"
+  end
+
+  get "/fake" do
+    render "{\"id\":1234}"
+  end
+end
+
+class ProxyClientExample < ActiveRestClient::Base
+  proxy ProxyExample
+  base_url "http://www.example.com"
+
+  get :all, "/all"
+  get :old, "/old"
+  get :list, "/list"
+  get :fake, "/fake"
+  get :param, "/param/:id/:name"
+  get :change_format, "/change-format"
+  post :create, "/create"
+  put :update, "/update"
+  get :not_proxied, "/not_proxied"
+  delete :remove, "/remove"
+  get :hal_test, "/hal_test/:id"
+end
+
+describe ActiveRestClient::Base do
+  it "allows the URL to be changed" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/getAll?id=1", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    ProxyClientExample.all(id:1)
+  end
+
+  it "allows the URL to be replaced" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/new", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    ProxyClientExample.old
+  end
+
+  it "has access to the GET params and allow them to be changed/removed/added" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/list?age=12&first_name=John", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    ProxyClientExample.list(fname:"John", lname:"Smith")
+  end
+
+  it "has access to the POST params and allow them to be changed/removed/added" do
+    ActiveRestClient::Connection.any_instance.should_receive(:post).with("/create", {age:12, first_name:"John"}.to_query, instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    ProxyClientExample.create(fname:"John", lname:"Smith")
+  end
+
+  it "has access to raw body content for requests" do
+    ActiveRestClient::Connection.any_instance.should_receive(:put).with("/update", "MY-BODY-CONTENT", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    ProxyClientExample.update(fname:"John", lname:"Smith")
+  end
+
+  it "handles DELETE requests" do
+    ActiveRestClient::Connection.any_instance.should_receive(:delete).with("/remove", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    ProxyClientExample.remove
+  end
+
+  it "can return fake JSON data and have this parsed in the normal way" do
+    ActiveRestClient::Connection.any_instance.should_not_receive(:get).with("/fake", instance_of(Hash))
+    ret = ProxyClientExample.fake
+    expect(ret.id).to eq(1234)
+  end
+
+  it "can intercept the response and parse the response, alter it and pass it on during the request" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/change-format", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"fname\":\"Billy\"}", status:200, headers:{}))
+    ret = ProxyClientExample.change_format
+    expect(ret.first_name).to eq("Billy")
+  end
+
+  it "can continue with the request in the normal way, passing it on to the server" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/not_proxied?id=1", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    ProxyClientExample.not_proxied(id:1)
+  end
+
+  it "caches responses in the standard way" do
+    cache_store = double("CacheStore")
+    cache_store.stub(:read).with(any_args).and_return(nil)
+    ActiveRestClient::Base.stub(:cache_store).and_return(cache_store)
+    expiry = 10.minutes.from_now.rfc2822
+    ActiveRestClient::Connection.any_instance.should_receive(:put).with("/update", "MY-BODY-CONTENT", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{"Expires" => expiry, "ETag" => "123456"}))
+    ActiveRestClient::Base.cache_store.should_receive(:write) do |key, object, options|
+      expect(key).to eq("ProxyClientExample:/update")
+      expect(object.etag).to eq("123456")
+      expect(object.expires).to eq(expiry)
+    end
+    ProxyClientExample.update(id:1)
+  end
+
+  it "can have parameters in the URL" do
+    ret = ProxyClientExample.param(id:1234, name:"Johnny")
+    expect(ret.id).to eq("1234")
+    expect(ret.name).to eq("Johnny")
+  end
+
+  it "can force the URL from a filter without it being passed through URL replacement" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/hal_test/1", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/this/is/a/test", instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", status:200, headers:{}))
+    expect(ProxyClientExample.hal_test(id:1).test.result).to eq(true)
+  end
+
+end

data/spec/lib/recording_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe ActiveRestClient::Recording do
+  it "can confirm if a recording callback is set" do
+    class MyObject1
+      include ActiveRestClient::Recording
+    end
+    expect(MyObject1.record_response?).to be_false
+    MyObject1.record_response do
+      puts "Hello world"
+    end
+    expect(MyObject1.record_response?).to be_true
+  end
+
+  it "remembers a block given to it to later be called back" do
+    class MyObject2
+      include ActiveRestClient::Recording
+    end
+    MyObject2.record_response do
+      puts "Hello world"
+    end
+    expect(MyObject2.instance_variable_get(:@record_response)).to_not be_nil
+  end
+
+  it "calls back to the block if record_response is given a url and response" do
+    class MyObject3
+      include ActiveRestClient::Recording
+    end
+    MyObject3.record_response do |url, response|
+      raise Exception.new("#{url}|#{response}")
+    end
+    expect{MyObject3.record_response("http://www.example.com/", "Hello world")}.to raise_error(Exception, 'http://www.example.com/|Hello world')
+  end
+end

data/spec/lib/request_filtering_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+class RequestFilteringExample
+  include ActiveRestClient::RequestFiltering
+
+  before_request do |name, request|
+    request.get_params[:filter1] = "Hello"
+  end
+
+  before_request do |name, request|
+    request.post_params[:post_filter1] = "World"
+  end
+
+  before_request do |name, request|
+    request.headers["X-My-Header"] = "myvalue"
+  end
+
+  before_request :set_to_ssl
+  before_request :set_via_instance
+
+  private
+
+  def self.set_to_ssl(name, request)
+    request.url.gsub!("http://", "https://")
+  end
+
+  def set_via_instance(name, request)
+    request.url.gsub!("//www", "//new")
+  end
+end
+
+class SubClassedRequestFilteringExample < RequestFilteringExample
+  before_request do |name, request|
+    request.get_params[:api_key] = 1234
+  end
+end
+
+describe ActiveRestClient::RequestFiltering do
+  let(:request) { OpenStruct.new(get_params:{}, post_params:{}, url:"http://www.example.com", headers:ActiveRestClient::HeadersList.new) }
+
+  it "should call through to adjust the parameters" do
+    RequestFilteringExample._filter_request(:test, request)
+    expect(request.get_params).to have_key(:filter1)
+  end
+
+  it "should call through for more than one filter" do
+    RequestFilteringExample._filter_request(:test, request)
+    expect(request.get_params).to have_key(:filter1)
+    expect(request.post_params).to have_key(:post_filter1)
+  end
+
+  it "should allow adjusting the URL via a named filter" do
+    RequestFilteringExample._filter_request(:test, request)
+    expect(request.url).to match(/https:\/\//)
+  end
+
+  it "should allow adjusting the URL via a named filter as an instance method" do
+    RequestFilteringExample._filter_request(:test, request)
+    expect(request.url).to match(/\/\/new\./)
+  end
+
+  it "should allow filters to be set on the parent or on the child" do
+    SubClassedRequestFilteringExample._filter_request(:test, request)
+    expect(request.url).to match(/\/\/new\./)
+    expect(request.get_params[:api_key]).to eq(1234)
+  end
+
+  it "should allow filters to add custom headers" do
+    RequestFilteringExample._filter_request(:test, request)
+    expect(request.headers["X-My-Header"]).to eq("myvalue")
+  end
+end

data/spec/lib/request_spec.rb

@@ -0,0 +1,471 @@
+require 'spec_helper'
+
+describe ActiveRestClient::Request do
+  before :each do
+    class ExampleOtherClient < ActiveRestClient::Base ; end
+    class ExampleClient < ActiveRestClient::Base
+      base_url "http://www.example.com"
+
+      before_request do |name, request|
+        if request.method[:name] == :headers
+          request.headers["X-My-Header"] = "myvalue"
+        end
+      end
+
+      get :all, "/", :has_many => {:expenses => ExampleOtherClient}
+      get :babies, "/babies", :has_many => {:children => ExampleOtherClient}
+      get :headers, "/headers"
+      get :find, "/:id"
+      post :create, "/create"
+      put :update, "/put/:id"
+      delete :remove, "/remove/:id"
+      get :hal, "/hal", fake:"{\"_links\":{\"child\": {\"href\": \"/child/1\"}, \"other\": {\"href\": \"/other/1\"}, \"cars\":[{\"href\": \"/car/1\", \"name\":\"car1\"}, {\"href\": \"/car/2\", \"name\":\"car2\"}, {\"href\": \"/car/not-embed\", \"name\":\"car_not_embed\"} ], \"lazy\": {\"href\": \"/lazy/load\"}, \"invalid\": [{\"href\": \"/invalid/1\"}]}, \"_embedded\":{\"other\":{\"name\":\"Jane\"},\"child\":{\"name\":\"Billy\"}, \"cars\":[{\"_links\": {\"self\": {\"href\": \"/car/1\"} }, \"make\": \"Bugatti\", \"model\": \"Veyron\"}, {\"_links\": {\"self\": {\"href\": \"/car/2\"} }, \"make\": \"Ferrari\", \"model\": \"F458 Italia\"} ], \"invalid\": [{\"present\":true, \"_links\": {} } ] } }", has_many:{other:ExampleOtherClient}
+      get :fake, "/fake", fake:"{\"result\":true, \"list\":[1,2,3,{\"test\":true}], \"child\":{\"grandchild\":{\"test\":true}}}"
+      get :defaults, "/defaults", defaults:{overwrite:"no", persist:"yes"}
+    end
+
+    class LazyLoadedExampleClient < ExampleClient
+      lazy_load!
+      get :fake, "/fake", fake:"{\"result\":true, \"list\":[1,2,3,{\"test\":true}], \"child\":{\"grandchild\":{\"test\":true}}}"
+      get :lazy_test, "/does-not-matter", fake:"{\"people\":[\"http://www.example.com/some/url\"]}", :lazy => %i{people}
+    end
+
+    class VerboseExampleClient < ExampleClient
+      verbose!
+      get :all, "/all"
+    end
+
+    class FilteredBodyExampleClient < ExampleClient
+      base_url "http://www.example.com"
+      before_request do |name, request|
+        request.body = Oj.dump(request.post_params)
+      end
+
+      post :save, "/save"
+    end
+
+    ActiveRestClient::Request.any_instance.stub(:read_cached_response)
+  end
+
+  it "should get an HTTP connection when called" do
+    connection = double(ActiveRestClient::Connection).as_null_object
+    ActiveRestClient::ConnectionManager.should_receive(:get_connection).and_return(connection)
+    connection.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(body:'{"result":true}', headers:{}))
+    ExampleClient.all
+  end
+
+  it "should get an HTTP connection when called and call get on it" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(body:'{"result":true}', headers:{}))
+    ExampleClient.all
+  end
+
+  it "should get an HTTP connection when called and call delete on it" do
+    ActiveRestClient::Connection.any_instance.should_receive(:delete).with("/remove/1", an_instance_of(Hash)).and_return(OpenStruct.new(body:'{"result":true}', headers:{}))
+    ExampleClient.remove(id:1)
+  end
+
+  it "should pass through get parameters" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/?debug=true", an_instance_of(Hash)).and_return(OpenStruct.new(body:'{"result":true}', headers:{}))
+    ExampleClient.all debug:true
+  end
+
+  it "should pass through get parameters, using defaults specified" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/defaults?overwrite=yes&persist=yes", an_instance_of(Hash)).and_return(OpenStruct.new(body:'{"result":true}', headers:{}))
+    ExampleClient.defaults overwrite:"yes"
+  end
+
+  it "should pass through url parameters" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/1234", an_instance_of(Hash)).and_return(OpenStruct.new(body:'{"result":true}', headers:{}))
+    ExampleClient.find id:1234
+  end
+
+  it "should accept an integer as the only parameter and use it as id" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/1234", an_instance_of(Hash)).and_return(OpenStruct.new(body:'{"result":true}', headers:{}))
+    ExampleClient.find(1234)
+  end
+
+  it "should accept a string as the only parameter and use it as id" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/1234", an_instance_of(Hash)).and_return(OpenStruct.new(body:'{"result":true}', headers:{}))
+    ExampleClient.find("1234")
+  end
+
+  it "should pass through url parameters and get parameters" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/1234?debug=true", an_instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", headers:{}))
+    ExampleClient.find id:1234, debug:true
+  end
+
+  it "should pass through url parameters and put parameters" do
+    ActiveRestClient::Connection.any_instance.should_receive(:put).with("/put/1234", "debug=true", an_instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true}", headers:{}))
+    ExampleClient.update id:1234, debug:true
+  end
+
+  it "should pass through custom headers" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/headers", hash_including("X-My-Header" => "myvalue")).and_return(OpenStruct.new(body:'{"result":true}', headers:{}))
+    ExampleClient.headers
+  end
+
+  it "should parse JSON to give a nice object" do
+    ActiveRestClient::Connection.any_instance.should_receive(:put).with("/put/1234", "debug=true", an_instance_of(Hash)).and_return(OpenStruct.new(body:"{\"result\":true, \"list\":[1,2,3,{\"test\":true}], \"created_at\":\"2012-03-04T01:02:03Z\", \"child\":{\"grandchild\":{\"test\":true}}}", headers:{}))
+    object = ExampleClient.update id:1234, debug:true
+    expect(object.result).to eq(true)
+    expect(object.list.first).to eq(1)
+    expect(object.list.last.test).to eq(true)
+    expect(object.created_at).to be_an_instance_of(DateTime)
+    expect(object.child.grandchild.test).to eq(true)
+  end
+
+  it "should parse JSON and return a nice object for faked responses" do
+    object = ExampleClient.fake id:1234, debug:true
+    expect(object.result).to eq(true)
+    expect(object.list.first).to eq(1)
+    expect(object.list.last.test).to eq(true)
+    expect(object.child.grandchild.test).to eq(true)
+  end
+
+  it "should return a lazy loader object if lazy loading is enabled" do
+    object = LazyLoadedExampleClient.fake id:1234, debug:true
+    expect(object).to be_an_instance_of(ActiveRestClient::LazyLoader)
+  end
+
+  it "should proxy through nice object for lazy loaded responses" do
+    object = LazyLoadedExampleClient.fake id:1234, debug:true
+    expect(object.result).to eq(true)
+    expect(object.list.first).to eq(1)
+    expect(object.list.last.test).to eq(true)
+    expect(object.child.grandchild.test).to eq(true)
+  end
+
+  it "should return a LazyAssociationLoader for lazy loaded properties" do
+    object = LazyLoadedExampleClient.lazy_test
+    expect(object.people.size).to eq(1)
+    expect(object.people).to be_an_instance_of(ActiveRestClient::LazyAssociationLoader)
+  end
+
+  it "should log faked responses" do
+    ActiveRestClient::Logger.stub(:debug)
+    ActiveRestClient::Logger.should_receive(:debug).with {|*args| args.first["Faked response found"]}
+    object = ExampleClient.fake id:1234, debug:true
+  end
+
+  it "should parse an array within JSON to be a result iterator" do
+    ActiveRestClient::Connection.any_instance.should_receive(:put).with("/put/1234", "debug=true", an_instance_of(Hash)).and_return(OpenStruct.new(body:"[{\"first_name\":\"Johnny\"}, {\"first_name\":\"Billy\"}]", status:200, headers:{}))
+    object = ExampleClient.update id:1234, debug:true
+    expect(object).to be_instance_of(ActiveRestClient::ResultIterator)
+    expect(object.first.first_name).to eq("Johnny")
+    expect(object[1].first_name).to eq("Billy")
+    expect(object._status).to eq(200)
+  end
+
+  it "should instantiate other classes using has_many when required to do so" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(body:"{\"first_name\":\"Johnny\", \"expenses\":[{\"amount\":1}, {\"amount\":2}]}", status:200, headers:{}))
+    object = ExampleClient.all
+    expect(object.expenses.first).to be_instance_of(ExampleOtherClient)
+  end
+
+  it "should instantiate other classes using has_many even if nested off the root" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/babies", an_instance_of(Hash)).and_return(OpenStruct.new(body:"{\"first_name\":\"Johnny\", \"children\":{\"eldest\":[{\"name\":\"Billy\"}]}}", status:200, headers:{}))
+    object = ExampleClient.babies
+    expect(object.children.eldest.first).to be_instance_of(ExampleOtherClient)
+  end
+
+  it "should assign new attributes to the existing object if possible" do
+    ActiveRestClient::Connection.
+      any_instance.
+      should_receive(:post).
+      with("/create", "first_name=John&should_disappear=true", an_instance_of(Hash)).
+      and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}))
+    object = ExampleClient.new(first_name:"John", should_disappear:true)
+    object.create
+    expect(object.first_name).to eq("John")
+    expect(object.should_disappear).to eq(nil)
+    expect(object.id).to eq(1234)
+  end
+
+  it "should clearly pass through 200 status responses" do
+    ActiveRestClient::Connection.
+      any_instance.
+      should_receive(:post).
+      with("/create", "first_name=John&should_disappear=true", an_instance_of(Hash)).
+      and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:200))
+    ActiveRestClient::Logger.should_receive(:info).with {|*args| args.first[%r{Requesting http://www.example.com/create}]}
+    ActiveRestClient::Logger.should_receive(:debug).with {|*args| args.first[/Response received \d+ bytes/]}
+
+    object = ExampleClient.new(first_name:"John", should_disappear:true)
+    object.create
+    expect(object._status).to eq(200)
+  end
+
+  it "should debug log 200 responses" do
+    ActiveRestClient::Connection.
+      any_instance.
+      should_receive(:post).
+      with("/create", "first_name=John&should_disappear=true", an_instance_of(Hash)).
+      and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:200))
+    ActiveRestClient::Logger.should_receive(:info).with {|*args| args.first[%r{Requesting http://www.example.com/create}]}
+    ActiveRestClient::Logger.should_receive(:debug).with {|*args| args.first[/Response received \d+ bytes/]}
+
+    object = ExampleClient.new(first_name:"John", should_disappear:true)
+    object.create
+  end
+
+  it "should verbose log if enabled" do
+    connection = double(ActiveRestClient::Connection).as_null_object
+    ActiveRestClient::ConnectionManager.should_receive(:get_connection).and_return(connection)
+    connection.should_receive(:get).with("/all", an_instance_of(Hash)).and_return(OpenStruct.new(body:'{"result":true}', headers:{"Content-Type" => "application/json", "Connection" => "close"}))
+    ActiveRestClient::Logger.should_receive(:debug).with("ActiveRestClient Verbose Log:")
+    ActiveRestClient::Logger.should_receive(:debug).with(/ > /).at_least(:twice)
+    ActiveRestClient::Logger.should_receive(:debug).with(/ < /).at_least(:twice)
+    ActiveRestClient::Logger.stub(:debug).with(any_args)
+    VerboseExampleClient.all
+  end
+
+  it "should raise an unauthorised exception for 401 errors" do
+    ActiveRestClient::Connection.
+      any_instance.
+      should_receive(:post).
+      with("/create", "first_name=John&should_disappear=true", an_instance_of(Hash)).
+      and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:401))
+    object = ExampleClient.new(first_name:"John", should_disappear:true)
+    begin
+      object.create
+    rescue ActiveRestClient::HTTPUnauthorisedClientException => e
+      e
+    end
+    expect(e).to be_instance_of(ActiveRestClient::HTTPUnauthorisedClientException)
+    expect(e.status).to eq(401)
+    expect(e.result.first_name).to eq("John")
+  end
+
+  it "should raise a forbidden client exception for 403 errors" do
+    ActiveRestClient::Connection.
+      any_instance.
+      should_receive(:post).
+      with("/create", "first_name=John&should_disappear=true", an_instance_of(Hash)).
+      and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:403))
+    object = ExampleClient.new(first_name:"John", should_disappear:true)
+    begin
+      object.create
+    rescue ActiveRestClient::HTTPForbiddenClientException => e
+      e
+    end
+    expect(e).to be_instance_of(ActiveRestClient::HTTPForbiddenClientException)
+    expect(e.status).to eq(403)
+  expect(e.result.first_name).to eq("John")
+  end
+
+  it "should raise a not found client exception for 404 errors" do
+    ActiveRestClient::Connection.
+      any_instance.
+      should_receive(:post).
+      with("/create", "first_name=John&should_disappear=true", an_instance_of(Hash)).
+      and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:404))
+    object = ExampleClient.new(first_name:"John", should_disappear:true)
+    begin
+      object.create
+    rescue ActiveRestClient::HTTPNotFoundClientException => e
+      e
+    end
+    expect(e).to be_instance_of(ActiveRestClient::HTTPNotFoundClientException)
+    expect(e.status).to eq(404)
+    expect(e.result.first_name).to eq("John")
+  end
+
+  it "should raise a client exceptions for 4xx errors" do
+    ActiveRestClient::Connection.
+      any_instance.
+      should_receive(:post).
+      with("/create", "first_name=John&should_disappear=true", an_instance_of(Hash)).
+      and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:409))
+    object = ExampleClient.new(first_name:"John", should_disappear:true)
+    begin
+      object.create
+    rescue ActiveRestClient::HTTPClientException => e
+      e
+    end
+    expect(e).to be_instance_of(ActiveRestClient::HTTPClientException)
+    expect(e.status).to eq(409)
+  expect(e.result.first_name).to eq("John")
+  end
+
+  it "should raise a server exception for 5xx errors" do
+    ActiveRestClient::Connection.
+      any_instance.
+      should_receive(:post).
+      with("/create", "first_name=John&should_disappear=true", an_instance_of(Hash)).
+      and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:500))
+    object = ExampleClient.new(first_name:"John", should_disappear:true)
+    begin
+      object.create
+    rescue ActiveRestClient::HTTPServerException => e
+      e
+    end
+    expect(e).to be_instance_of(ActiveRestClient::HTTPServerException)
+    expect(e.status).to eq(500)
+    expect(e.result.first_name).to eq("John")
+  end
+
+  it "should raise a parse exception for invalid JSON returns" do
+    error_content = "<h1>500 Server Error</h1>"
+    ActiveRestClient::Connection.
+      any_instance.
+      should_receive(:post).
+      with("/create", "first_name=John&should_disappear=true", an_instance_of(Hash)).
+      and_return(OpenStruct.new(body:error_content, headers:{}, status:500))
+    object = ExampleClient.new(first_name:"John", should_disappear:true)
+    begin
+      object.create
+    rescue ActiveRestClient::ResponseParseException => e
+      e
+    end
+    expect(e).to be_instance_of(ActiveRestClient::ResponseParseException)
+    expect(e.status).to eq(500)
+    expect(e.body).to eq(error_content)
+  end
+
+  it "should raise an exception if you try to pass in an unsupport method" do
+    method = {:method => :wiggle, url:"/"}
+    class RequestFakeObject
+      def base_url
+        "http://www.example.com/"
+      end
+
+      def name ; end
+      def _filter_request(*args) ; end
+      def verbose ; false ; end
+    end
+    fake_object = RequestFakeObject.new
+    request = ActiveRestClient::Request.new(method, fake_object, {})
+    expect{request.call}.to raise_error(ActiveRestClient::InvalidRequestException)
+  end
+
+  it "should send all class mapped methods through _filter_request" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(body:"{\"first_name\":\"Johnny\", \"expenses\":[{\"amount\":1}, {\"amount\":2}]}", status:200, headers:{}))
+    ExampleClient.should_receive(:_filter_request).with(any_args)
+    ExampleClient.all
+  end
+
+  it "should send all instance mapped methods through _filter_request" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(body:"{\"first_name\":\"Johnny\", \"expenses\":[{\"amount\":1}, {\"amount\":2}]}", status:200, headers:{}))
+    ExampleClient.should_receive(:_filter_request).with(any_args)
+    e = ExampleClient.new
+    e.all
+  end
+
+  context "Direct URL requests" do
+    class SameServerExampleClient < ActiveRestClient::Base
+      URL = "http://www.example.com/some/url"
+      base_url "http://www.example.com/v1"
+      get :same_server, "/does-not-matter", url:URL
+    end
+
+    class OtherServerExampleClient < ActiveRestClient::Base
+      URL = "http://other.example.com/some/url"
+      base_url "http://www.example.com/v1"
+      get :other_server, "/does-not-matter", url:URL
+    end
+
+    it "should allow requests directly to URLs" do
+      ActiveRestClient::ConnectionManager.reset!
+      ActiveRestClient::Connection.
+        any_instance.
+        should_receive(:get).
+        with("/some/url", an_instance_of(Hash)).
+        and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:200))
+      SameServerExampleClient.same_server
+    end
+
+    it "should allow requests directly to URLs even if to different URLs" do
+      ActiveRestClient::ConnectionManager.reset!
+      connection = double("Connection")
+      connection.
+        should_receive(:get).
+        with("/some/url", an_instance_of(Hash)).
+        and_return(OpenStruct.new(body:"", headers:{}, status:304))
+      connection.
+        stub(:base_url).
+        and_return("http://other.example.com")
+      ActiveRestClient::ConnectionManager.should_receive(:find_connection_for_url).with(OtherServerExampleClient::URL).and_return(connection)
+      OtherServerExampleClient.other_server
+    end
+
+    it "should allow requests to partial URLs using the current base_url" do
+      ActiveRestClient::ConnectionManager.reset!
+      connection = double("Connection").as_null_object
+      ActiveRestClient::ConnectionManager.should_receive(:get_connection).with("http://www.example.com").and_return(connection)
+      connection.
+        should_receive(:get).
+        with("/people", an_instance_of(Hash)).
+        and_return(OpenStruct.new(body:"{\"first_name\":\"John\", \"id\":1234}", headers:{}, status:200))
+      @obj = SameServerExampleClient._request('/people')
+    end
+  end
+
+  # HAL is Hypermedia Application Language
+  context "HAL" do
+    let(:hal) { ExampleClient.hal }
+
+    it "should request a HAL response or plain JSON" do
+      ActiveRestClient::Connection.any_instance.should_receive(:get).with("/headers", hash_including("Accept" => "application/hal+json, application/json;q=0.5")).and_return(OpenStruct.new(body:'{"result":true}', headers:{}))
+      ExampleClient.headers
+    end
+
+    it "should recognise a HAL response" do
+      method = {:method => :get, url:"/"}
+      class RequestFakeObject
+        def base_url
+          "http://www.example.com/"
+        end
+
+        def name ; end
+        def _filter_request(*args) ; end
+      end
+      fake_object = RequestFakeObject.new
+      request = ActiveRestClient::Request.new(method, fake_object, {})
+      request.instance_variable_set(:@response, OpenStruct.new(headers:{"Content-Type" => "application/hal+json"}))
+      expect(request.hal_response?).to be_true
+      request.instance_variable_set(:@response, OpenStruct.new(headers:{"Content-Type" => "application/json"}))
+      expect(request.hal_response?).to be_true
+      request.instance_variable_set(:@response, OpenStruct.new(headers:{"Content-Type" => "text/plain"}))
+      expect(request.hal_response?).to be_false
+      request.instance_variable_set(:@response, OpenStruct.new(headers:{"Content-Type" => ["text/plain", "application/hal+json"]}))
+      expect(request.hal_response?).to be_true
+      request.instance_variable_set(:@response, OpenStruct.new(headers:{"Content-Type" => ["text/plain", "application/json"]}))
+      expect(request.hal_response?).to be_true
+      request.instance_variable_set(:@response, OpenStruct.new(headers:{"Content-Type" => ["text/plain"]}))
+      expect(request.hal_response?).to be_false
+    end
+
+    it "should map _links in to the normal attributes" do
+      expect(hal.child).to be_an_instance_of(ExampleClient)
+      expect(hal.cars.size).to eq(3)
+    end
+
+    it "should be able to use other attributes of _links using _hal_attributes method with a key" do
+      expect(hal.child).to be_an_instance_of(ExampleClient)
+      expect(hal.cars[2]._hal_attributes("name")).to eq('car_not_embed')
+    end
+
+    it "should use _embedded responses instead of lazy loading if possible" do
+      expect(hal.child.name).to eq("Billy")
+      expect(hal.cars.first.make).to eq("Bugatti")
+    end
+
+    it "should instantiate other classes defined using has_many when using _embedded responses" do
+      expect(hal.other).to be_an(ExampleOtherClient)
+    end
+
+    it "should convert invalid _embedded responses in to lazy loading on error" do
+      expect(hal.invalid.first).to be_an_instance_of(ActiveRestClient::LazyAssociationLoader)
+    end
+
+    it "should lazy load _links attributes if not embedded" do
+      expect(hal.lazy).to be_an_instance_of(ActiveRestClient::LazyAssociationLoader)
+      expect(hal.lazy.instance_variable_get(:@url)).to eq("/lazy/load")
+    end
+  end
+
+  it "replaces the body completely in a filter" do
+    ActiveRestClient::Connection.any_instance.should_receive(:post).with("/save", "{\":id\":1234,\":name\":\"john\"}", an_instance_of(Hash)).and_return(OpenStruct.new(body:"{}", headers:{}))
+    FilteredBodyExampleClient.save id:1234, name:'john'
+  end
+end