active_cached_resource 0.0.1.pre → 0.1.1

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

@@ -1,217 +0,0 @@
-# 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

@@ -1,137 +0,0 @@
-# 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

@@ -1,213 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-# 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