active_cached_resource 0.0.1.pre

data/lib/activeresource/test/cases/finder_test.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "fixtures/person"
+require "fixtures/customer"
+require "fixtures/street_address"
+require "fixtures/beast"
+require "fixtures/proxy"
+require "fixtures/pet"
+require "active_support/core_ext/hash/conversions"
+
+class FinderTest < ActiveSupport::TestCase
+  def setup
+    setup_response # find me in abstract_unit
+  end
+
+  def test_find_by_id
+    matz = Person.find(1)
+    assert_kind_of Person, matz
+    assert_equal "Matz", matz.name
+    assert matz.name?
+  end
+
+  def test_find_by_id_with_custom_prefix
+    addy = StreetAddress.find(1, params: { person_id: 1 })
+    assert_kind_of StreetAddress, addy
+    assert_equal "12345 Street", addy.street
+  end
+
+  def test_find_all
+    all = Person.find(:all)
+    assert_equal 2, all.size
+    assert_kind_of Person, all.first
+    assert_equal "Matz", all.first.name
+    assert_equal "David", all.last.name
+  end
+
+  def test_all
+    all = Person.all
+    assert_equal 2, all.size
+    assert_kind_of Person, all.first
+    assert_equal "Matz", all.first.name
+    assert_equal "David", all.last.name
+  end
+
+  def test_all_with_params
+    all = StreetAddress.all(params: { person_id: 1 })
+    assert_equal 1, all.size
+    assert_kind_of StreetAddress, all.first
+  end
+
+  def test_where
+    people = Person.where
+    assert_equal 2, people.size
+    assert_kind_of Person, people.first
+    assert_equal "Matz", people.first.name
+    assert_equal "David", people.last.name
+  end
+
+  def test_where_with_clauses
+    addresses = StreetAddress.where(person_id: 1)
+    assert_equal 1, addresses.size
+    assert_kind_of StreetAddress, addresses.first
+  end
+
+  def test_where_with_clause_in
+    ActiveResource::HttpMock.respond_to { |m| m.get "/people.json?id%5B%5D=2", {}, @people_david }
+    people = Person.where(id: [2])
+    assert_equal 1, people.size
+    assert_kind_of Person, people.first
+    assert_equal "David", people.first.name
+  end
+
+  def test_where_with_invalid_clauses
+    error = assert_raise(ArgumentError) { Person.where(nil) }
+    assert_equal "expected a clauses Hash, got nil", error.message
+  end
+
+  def test_find_first
+    matz = Person.find(:first)
+    assert_kind_of Person, matz
+    assert_equal "Matz", matz.name
+  end
+
+  def test_first
+    matz = Person.first
+    assert_kind_of Person, matz
+    assert_equal "Matz", matz.name
+  end
+
+  def test_first_with_params
+    addy = StreetAddress.first(params: { person_id: 1 })
+    assert_kind_of StreetAddress, addy
+    assert_equal "12345 Street", addy.street
+  end
+
+  def test_find_last
+    david = Person.find(:last)
+    assert_kind_of Person, david
+    assert_equal "David", david.name
+  end
+
+  def test_last
+    david = Person.last
+    assert_kind_of Person, david
+    assert_equal "David", david.name
+  end
+
+  def test_last_with_params
+    addy = StreetAddress.last(params: { person_id: 1 })
+    assert_kind_of StreetAddress, addy
+    assert_equal "12345 Street", addy.street
+  end
+
+  def test_find_by_id_not_found
+    assert_raise(ActiveResource::ResourceNotFound) { Person.find(99) }
+    assert_raise(ActiveResource::ResourceNotFound) { StreetAddress.find(99, params: { person_id: 1 }) }
+  end
+
+  def test_find_all_sub_objects
+    all = StreetAddress.find(:all, params: { person_id: 1 })
+    assert_equal 1, all.size
+    assert_kind_of StreetAddress, all.first
+    assert_equal ({ person_id: 1 }), all.first.prefix_options
+  end
+
+  def test_find_all_sub_objects_not_found
+    assert_nothing_raised do
+      StreetAddress.find(:all, params: { person_id: 2 })
+    end
+  end
+
+  def test_find_all_by_from
+    ActiveResource::HttpMock.respond_to { |m| m.get "/companies/1/people.json", {}, @people_david }
+
+    people = Person.find(:all, from: "/companies/1/people.json")
+    assert_equal 1, people.size
+    assert_equal "David", people.first.name
+  end
+
+  def test_find_all_by_from_with_options
+    ActiveResource::HttpMock.respond_to { |m| m.get "/companies/1/people.json", {}, @people_david }
+
+    people = Person.find(:all, from: "/companies/1/people.json")
+    assert_equal 1, people.size
+    assert_equal "David", people.first.name
+  end
+
+  def test_find_all_by_from_with_prefix
+    ActiveResource::HttpMock.respond_to { |m| m.get "/dogs.json", {}, @pets }
+
+    pets = Pet.find(:all, from: "/dogs.json", params: { person_id: 1 })
+    assert_equal 2, pets.size
+    assert_equal "Max", pets.first.name
+    assert_equal ({ person_id: 1 }), pets.first.prefix_options
+
+    assert_equal "Daisy", pets.second.name
+    assert_equal ({ person_id: 1 }), pets.second.prefix_options
+  end
+
+  def test_find_all_by_symbol_from
+    ActiveResource::HttpMock.respond_to { |m| m.get "/people/managers.json", {}, @people_david }
+
+    people = Person.find(:all, from: :managers)
+    assert_equal 1, people.size
+    assert_equal "David", people.first.name
+  end
+
+  def test_find_all_by_symbol_from_with_prefix
+    ActiveResource::HttpMock.respond_to { |m| m.get "/people/1/pets/dogs.json", {}, @pets }
+
+    pets = Pet.find(:all, from: :dogs, params: { person_id: 1 })
+    assert_equal 2, pets.size
+    assert_equal "Max", pets.first.name
+    assert_equal ({ person_id: 1 }), pets.first.prefix_options
+
+    assert_equal "Daisy", pets.second.name
+    assert_equal ({ person_id: 1 }), pets.second.prefix_options
+  end
+
+  def test_find_first_or_last_not_found
+    ActiveResource::HttpMock.respond_to { |m| m.get "/people.json", {}, "", 404 }
+
+    assert_nothing_raised { Person.find(:first) }
+    assert_nothing_raised { Person.find(:last)  }
+  end
+
+  def test_find_single_by_from
+    ActiveResource::HttpMock.respond_to { |m| m.get "/companies/1/manager.json", {}, @david }
+
+    david = Person.find(:one, from: "/companies/1/manager.json")
+    assert_equal "David", david.name
+  end
+
+  def test_find_single_by_symbol_from
+    ActiveResource::HttpMock.respond_to { |m| m.get "/people/leader.json", {}, @david }
+
+    david = Person.find(:one, from: :leader)
+    assert_equal "David", david.name
+  end
+
+  def test_find_identifier_encoding
+    ActiveResource::HttpMock.respond_to { |m| m.get "/people/%3F.json", {}, @david }
+
+    david = Person.find("?")
+
+    assert_equal "David", david.name
+  end
+
+  def test_find_identifier_encoding_for_path_traversal
+    ActiveResource::HttpMock.respond_to { |m| m.get "/people/..%2F.json", {}, @david }
+
+    david = Person.find("../")
+
+    assert_equal "David", david.name
+  end
+end

data/lib/activeresource/test/cases/format_test.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "fixtures/person"
+require "fixtures/street_address"
+
+class FormatTest < ActiveSupport::TestCase
+  def setup
+    @matz  = { id: 1, name: "Matz" }
+    @david = { id: 2, name: "David" }
+
+    @programmers = [ @matz, @david ]
+  end
+
+  def test_http_format_header_name
+    [:get, :head].each do |verb|
+      header_name = ActiveResource::Connection::HTTP_FORMAT_HEADER_NAMES[verb]
+      assert_equal "Accept", header_name
+    end
+
+    [:patch, :put, :post].each do |verb|
+      header_name = ActiveResource::Connection::HTTP_FORMAT_HEADER_NAMES[verb]
+      assert_equal "Content-Type", header_name
+    end
+  end
+
+  def test_formats_on_single_element
+    [ :json, :xml ].each do |format|
+      using_format(Person, format) do
+        ActiveResource::HttpMock.respond_to.get "/people/1.#{format}", { "Accept" => ActiveResource::Formats[format].mime_type }, ActiveResource::Formats[format].encode(@david)
+        assert_equal @david[:name], Person.find(1).name
+      end
+    end
+  end
+
+  def test_formats_on_collection
+    [ :json, :xml ].each do |format|
+      using_format(Person, format) do
+        ActiveResource::HttpMock.respond_to.get "/people.#{format}", { "Accept" => ActiveResource::Formats[format].mime_type }, ActiveResource::Formats[format].encode(@programmers)
+        remote_programmers = Person.find(:all)
+        assert_equal 2, remote_programmers.size
+        assert remote_programmers.find { |p| p.name == "David" }
+      end
+    end
+  end
+
+  def test_formats_on_custom_collection_method
+    [ :json, :xml ].each do |format|
+      using_format(Person, format) do
+        ActiveResource::HttpMock.respond_to.get "/people/retrieve.#{format}?name=David", { "Accept" => ActiveResource::Formats[format].mime_type }, ActiveResource::Formats[format].encode([@david])
+        remote_programmers = Person.get(:retrieve, name: "David")
+        assert_equal 1, remote_programmers.size
+        assert_equal @david[:id], remote_programmers[0]["id"]
+        assert_equal @david[:name], remote_programmers[0]["name"]
+      end
+    end
+  end
+
+  def test_formats_on_custom_element_method
+    [:json, :xml].each do |format|
+      using_format(Person, format) do
+        david = (format == :json ? { person: @david } : @david)
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get "/people/2.#{format}", { "Accept" => ActiveResource::Formats[format].mime_type }, ActiveResource::Formats[format].encode(david)
+          mock.get "/people/2/shallow.#{format}", { "Accept" => ActiveResource::Formats[format].mime_type }, ActiveResource::Formats[format].encode(david)
+        end
+
+        remote_programmer = Person.find(2).get(:shallow)
+        assert_equal @david[:id], remote_programmer["id"]
+        assert_equal @david[:name], remote_programmer["name"]
+      end
+
+      ryan_hash = { name: "Ryan" }
+      ryan_hash = (format == :json ? { person: ryan_hash } : ryan_hash)
+      ryan = ActiveResource::Formats[format].encode(ryan_hash)
+      using_format(Person, format) do
+        remote_ryan = Person.new(name: "Ryan")
+        ActiveResource::HttpMock.respond_to.post "/people.#{format}", { "Content-Type" => ActiveResource::Formats[format].mime_type }, ryan, 201, "Location" => "/people/5.#{format}"
+        remote_ryan.save
+
+        remote_ryan = Person.new(name: "Ryan")
+        ActiveResource::HttpMock.respond_to.post "/people/new/register.#{format}", { "Content-Type" => ActiveResource::Formats[format].mime_type }, ryan, 201, "Location" => "/people/5.#{format}"
+        assert_equal ActiveResource::Response.new(ryan, 201, "Location" => "/people/5.#{format}"), remote_ryan.post(:register)
+      end
+    end
+  end
+
+  def test_setting_format_before_site
+    resource = Class.new(ActiveResource::Base)
+    resource.format = :json
+    resource.site   = "http://37s.sunrise.i:3000"
+    assert_equal ActiveResource::Formats[:json], resource.connection.format
+  end
+
+  def test_serialization_of_nested_resource
+    address = { street: "12345 Street" }
+    person = { name: "Rus", address: address }
+
+    [:json, :xml].each do |format|
+      encoded_person = ActiveResource::Formats[format].encode(person)
+      assert_match(/12345 Street/, encoded_person)
+      remote_person = Person.new(person.update(address: StreetAddress.new(address)))
+      assert_kind_of StreetAddress, remote_person.address
+      using_format(Person, format) do
+        ActiveResource::HttpMock.respond_to.post "/people.#{format}", { "Content-Type" => ActiveResource::Formats[format].mime_type }, encoded_person, 201, "Location" => "/people/5.#{format}"
+        remote_person.save
+      end
+    end
+  end
+
+  def test_removing_root
+    matz = { name: "Matz" }
+    matz_with_root = { person: matz }
+
+    # On Array
+    people = [ matz ]
+    assert_equal ActiveResource::Formats.remove_root(people), [ matz ]
+
+    # On Hash with no root
+    person = matz
+    assert_equal ActiveResource::Formats.remove_root(person), matz
+
+    # On Hash with root
+    person = matz_with_root
+    assert_equal ActiveResource::Formats.remove_root(person), matz
+  end
+
+  private
+    def using_format(klass, mime_type_reference)
+      previous_format = klass.format
+      klass.format = mime_type_reference
+
+      yield
+    ensure
+      klass.format = previous_format
+    end
+end

data/lib/activeresource/test/cases/http_mock_test.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/core_ext/object/inclusion"
+
+class HttpMockTest < ActiveSupport::TestCase
+  setup do
+    @http = ActiveResource::HttpMock.new("http://example.com")
+  end
+
+  FORMAT_HEADER = ActiveResource::Connection::HTTP_FORMAT_HEADER_NAMES
+
+  [:post, :patch, :put, :get, :delete, :head].each do |method|
+    test "responds to simple #{method} request" do
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.send(method, "/people/1", { FORMAT_HEADER[method] => "application/json" }, "Response")
+      end
+
+      assert_equal "Response", request(method, "/people/1", FORMAT_HEADER[method] => "application/json").body
+    end
+
+    test "adds format header by default to #{method} request" do
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.send(method, "/people/1", {}, "Response")
+      end
+
+      assert_equal "Response", request(method, "/people/1", FORMAT_HEADER[method] => "application/json").body
+    end
+
+    test "respond only when headers match header by default to #{method} request" do
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.send(method, "/people/1", { "X-Header" => "X" }, "Response")
+      end
+
+      assert_equal "Response", request(method, "/people/1", "X-Header" => "X").body
+      assert_raise(ActiveResource::InvalidRequestError) { request(method, "/people/1") }
+    end
+
+    test "does not overwrite format header to #{method} request" do
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.send(method, "/people/1", { FORMAT_HEADER[method] => "application/json" }, "Response")
+      end
+
+      assert_equal "Response", request(method, "/people/1", FORMAT_HEADER[method] => "application/json").body
+    end
+
+    test "ignores format header when there is only one response to same url in a #{method} request" do
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.send(method, "/people/1", {}, "Response")
+      end
+
+      assert_equal "Response", request(method, "/people/1", FORMAT_HEADER[method] => "application/json").body
+      assert_equal "Response", request(method, "/people/1", FORMAT_HEADER[method] => "application/xml").body
+    end
+
+    test "responds correctly when format header is given to #{method} request" do
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.send(method, "/people/1", { FORMAT_HEADER[method] => "application/xml" }, "XML")
+        mock.send(method, "/people/1", { FORMAT_HEADER[method] => "application/json" }, "Json")
+      end
+
+      assert_equal "XML", request(method, "/people/1", FORMAT_HEADER[method] => "application/xml").body
+      assert_equal "Json", request(method, "/people/1", FORMAT_HEADER[method] => "application/json").body
+    end
+
+    test "raises InvalidRequestError if no response found for the #{method} request" do
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.send(method, "/people/1", { FORMAT_HEADER[method] => "application/json" }, "json")
+      end
+
+      assert_raise(::ActiveResource::InvalidRequestError) do
+        request(method, "/people/1", FORMAT_HEADER[method] => "application/xml")
+      end
+    end
+  end
+
+  test "allows you to send in pairs directly to the respond_to method" do
+    matz = { person: { id: 1, name: "Matz" } }.to_json
+
+    create_matz = ActiveResource::Request.new(:post, "/people.json", matz, {})
+    created_response = ActiveResource::Response.new("", 201, "Location" => "/people/1.json")
+    get_matz = ActiveResource::Request.new(:get, "/people/1.json", nil)
+    ok_response = ActiveResource::Response.new(matz, 200, {})
+
+    pairs = { create_matz => created_response, get_matz => ok_response }
+
+    ActiveResource::HttpMock.respond_to(pairs)
+    assert_equal 2, ActiveResource::HttpMock.responses.length
+    assert_equal "", ActiveResource::HttpMock.responses.assoc(create_matz)[1].body
+    assert_equal matz, ActiveResource::HttpMock.responses.assoc(get_matz)[1].body
+  end
+
+  test "resets all mocked responses on each call to respond_to with a block by default" do
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.send(:get, "/people/1", {}, "JSON1")
+    end
+    assert_equal 1, ActiveResource::HttpMock.responses.length
+
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.send(:get, "/people/2", {}, "JSON2")
+    end
+    assert_equal 1, ActiveResource::HttpMock.responses.length
+  end
+
+  test "resets all mocked responses on each call to respond_to by passing pairs by default" do
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.send(:get, "/people/1", {}, "JSON1")
+    end
+    assert_equal 1, ActiveResource::HttpMock.responses.length
+
+    matz = { person: { id: 1, name: "Matz" } }.to_json
+    get_matz = ActiveResource::Request.new(:get, "/people/1.json", nil)
+    ok_response = ActiveResource::Response.new(matz, 200, {})
+    ActiveResource::HttpMock.respond_to(get_matz => ok_response)
+
+    assert_equal 1, ActiveResource::HttpMock.responses.length
+  end
+
+  test "allows you to add new responses to the existing responses by calling a block" do
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.send(:get, "/people/1", {}, "JSON1")
+    end
+    assert_equal 1, ActiveResource::HttpMock.responses.length
+
+    ActiveResource::HttpMock.respond_to(false) do |mock|
+      mock.send(:get, "/people/2", {}, "JSON2")
+    end
+    assert_equal 2, ActiveResource::HttpMock.responses.length
+  end
+
+  test "allows you to add new responses to the existing responses by passing pairs" do
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.send(:get, "/people/1", {}, "JSON1")
+    end
+    assert_equal 1, ActiveResource::HttpMock.responses.length
+
+    matz = { person: { id: 1, name: "Matz" } }.to_json
+    get_matz = ActiveResource::Request.new(:get, "/people/1.json", nil)
+    ok_response = ActiveResource::Response.new(matz, 200, {})
+    ActiveResource::HttpMock.respond_to({ get_matz => ok_response }, false)
+
+    assert_equal 2, ActiveResource::HttpMock.responses.length
+  end
+
+  test "allows you to replace the existing response with the same request by calling a block" do
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.send(:get, "/people/1", {}, "JSON1")
+    end
+    assert_equal 1, ActiveResource::HttpMock.responses.length
+
+    ActiveResource::HttpMock.respond_to(false) do |mock|
+      mock.send(:get, "/people/1", {}, "JSON2")
+    end
+    assert_equal 1, ActiveResource::HttpMock.responses.length
+  end
+
+  test "allows you to replace the existing response with the same request by passing pairs" do
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.send(:get, "/people/1", {}, "JSON1")
+    end
+    assert_equal 1, ActiveResource::HttpMock.responses.length
+
+    matz = { person: { id: 1, name: "Matz" } }.to_json
+    get_matz = ActiveResource::Request.new(:get, "/people/1", nil)
+    ok_response = ActiveResource::Response.new(matz, 200, {})
+
+    ActiveResource::HttpMock.respond_to({ get_matz => ok_response }, false)
+    assert_equal 1, ActiveResource::HttpMock.responses.length
+  end
+
+  test "do not replace the response with the same path but different method by calling a block" do
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.send(:get, "/people/1", {}, "JSON1")
+    end
+    assert_equal 1, ActiveResource::HttpMock.responses.length
+
+    ActiveResource::HttpMock.respond_to(false) do |mock|
+      mock.send(:put, "/people/1", {}, "JSON2")
+    end
+    assert_equal 2, ActiveResource::HttpMock.responses.length
+  end
+
+  test "do not replace the response with the same path but different method by passing pairs" do
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.send(:get, "/people/1", {}, "JSON1")
+    end
+    assert_equal 1, ActiveResource::HttpMock.responses.length
+
+    put_matz = ActiveResource::Request.new(:put, "/people/1", nil)
+    ok_response = ActiveResource::Response.new("", 200, {})
+
+    ActiveResource::HttpMock.respond_to({ put_matz => ok_response }, false)
+    assert_equal 2, ActiveResource::HttpMock.responses.length
+  end
+
+  test "omits query parameters from the URL when options[:omit_query_params] is true" do
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get("/endpoint", {}, "Response", 200, {}, { omit_query_in_path: true })
+    end
+
+    response = request(:get, "/endpoint?param1=value1&param2=value2")
+
+    assert_equal "Response", response.body
+  end
+
+  def request(method, path, headers = {}, body = nil)
+    if method.in?([:patch, :put, :post])
+      @http.send(method, path, body, headers)
+    else
+      @http.send(method, path, headers)
+    end
+  end
+end

data/lib/activeresource/test/cases/inheritence_test.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+require "fixtures/product"
+
+class InheritenceTest < ActiveSupport::TestCase
+  def test_sub_class_retains_ancestor_headers
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get "/sub_products/1.json",
+               { "Accept" => "application/json", "X-Inherited-Header" => "present" },
+               { id: 1, name: "Sub Product" }.to_json,
+               200
+    end
+
+    sub_product = SubProduct.find(1)
+    assert_equal "SubProduct", sub_product.class.to_s
+  end
+end

data/lib/activeresource/test/cases/inheriting_hash_test.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class InheritingHashTest < ActiveSupport::TestCase
+  def setup
+    @parent = ActiveResource::InheritingHash.new({ override_me: "foo", parent_key: "parent_value" })
+    @child = ActiveResource::InheritingHash.new(@parent)
+    @child[:override_me] = "bar"
+    @child[:child_only] = "baz"
+  end
+
+  def test_child_key_overrides_parent_key
+    assert_equal "bar", @child[:override_me]
+  end
+
+  def test_parent_key_available_on_lookup
+    assert_equal "parent_value", @child[:parent_key]
+  end
+
+  def test_conversion_to_regular_hash_includes_parent_keys
+    hash = @child.to_hash
+
+    assert_equal 3, hash.keys.length
+    assert_equal "parent_value", hash[:parent_key]
+  end
+end

data/lib/activeresource/test/cases/log_subscriber_test.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "fixtures/person"
+require "active_support/log_subscriber/test_helper"
+require "active_resource/log_subscriber"
+require "active_support/core_ext/hash/conversions"
+
+class LogSubscriberTest < ActiveSupport::TestCase
+  include ActiveSupport::LogSubscriber::TestHelper
+
+  def setup
+    super
+
+    @matz = { person: { id: 1, name: "Matz" } }.to_json
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get "/people/1.json", {}, @matz
+      mock.get "/people/2.json", {}, nil, 404
+      mock.get "/people/3.json", {}, nil, 502
+    end
+
+    ActiveResource::LogSubscriber.attach_to :active_resource
+  end
+
+  def set_logger(logger)
+    ActiveResource::Base.logger = logger
+  end
+
+  def test_request_notification
+    Person.find(1)
+    wait
+    assert_equal 2, @logger.logged(:info).size
+    assert_equal "GET http://37s.sunrise.i:3000/people/1.json", @logger.logged(:info)[0]
+    assert_match(/--> 200 200 33/, @logger.logged(:info)[1])
+  end
+
+  def test_failure_error_log
+    Person.find(2)
+  rescue
+    wait
+    assert_equal 2, @logger.logged(:error).size
+    assert_equal "GET http://37s.sunrise.i:3000/people/2.json", @logger.logged(:error)[0]
+    assert_match(/--> 404 404 0/, @logger.logged(:error)[1])
+  end
+
+  def test_server_error_log
+    Person.find(3)
+  rescue
+    wait
+    assert_equal 2, @logger.logged(:error).size
+    assert_equal "GET http://37s.sunrise.i:3000/people/3.json", @logger.logged(:error)[0]
+    assert_match(/--> 502 502 0/, @logger.logged(:error)[1])
+  end
+
+  def test_connection_failure
+    Person.find(99)
+  rescue
+    wait
+    assert_equal 2, @logger.logged(:error).size
+    assert_equal "GET http://37s.sunrise.i:3000/people/99.json", @logger.logged(:error)[0]
+    assert_match(/--> 523 ActiveResource connection error 0/, @logger.logged(:error)[1])
+  end
+end