active_cached_resource 0.0.1.pre → 0.1.1

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

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-require "active_support/core_ext/hash/conversions"
-
-class Developer < ActiveResource::Base
-  self.site = "http://37s.sunrise.i:3000"
-
-  class << self
-    def callback_string(callback_method)
-      "history << [#{callback_method.to_sym.inspect}, :string]"
-    end
-
-    def callback_proc(callback_method)
-      Proc.new { |model| model.history << [callback_method, :proc] }
-    end
-
-    def define_callback_method(callback_method)
-      define_method(callback_method) do
-        self.history << [callback_method, :method]
-      end
-      send(callback_method, :"#{callback_method}")
-    end
-
-    def callback_object(callback_method)
-      klass = Class.new
-      klass.send(:define_method, callback_method) do |model|
-        model.history << [callback_method, :object]
-      end
-      klass.new
-    end
-  end
-
-  ActiveResource::Callbacks::CALLBACKS.each do |callback_method|
-    next if callback_method.to_s =~ /^around_/
-    define_callback_method(callback_method)
-    send(callback_method, callback_proc(callback_method))
-    send(callback_method, callback_object(callback_method))
-    send(callback_method) { |model| model.history << [callback_method, :block] }
-  end
-
-  def history
-    @history ||= []
-  end
-end
-
-class CallbacksTest < ActiveSupport::TestCase
-  def setup
-    @developer_attrs = { id: 1, name: "Guillermo", salary: 100_000 }
-    @developer = { "developer" => @developer_attrs }.to_json
-    ActiveResource::HttpMock.respond_to do |mock|
-      mock.post   "/developers.json",   {}, @developer, 201, "Location" => "/developers/1.json"
-      mock.get    "/developers/1.json", {}, @developer
-      mock.put    "/developers/1.json", {}, nil, 204
-      mock.delete "/developers/1.json", {}, nil, 200
-    end
-  end
-
-  def test_valid?
-    developer = Developer.new
-    developer.valid?
-    assert_equal [
-      [ :before_validation,           :method ],
-      [ :before_validation,           :proc   ],
-      [ :before_validation,           :object ],
-      [ :before_validation,           :block  ],
-      [ :after_validation,            :method ],
-      [ :after_validation,            :proc   ],
-      [ :after_validation,            :object ],
-      [ :after_validation,            :block  ],
-    ], developer.history
-  end
-
-  def test_create
-    developer = Developer.create(@developer_attrs)
-    assert_equal [
-      [ :before_validation,           :method ],
-      [ :before_validation,           :proc   ],
-      [ :before_validation,           :object ],
-      [ :before_validation,           :block  ],
-      [ :after_validation,            :method ],
-      [ :after_validation,            :proc   ],
-      [ :after_validation,            :object ],
-      [ :after_validation,            :block  ],
-      [ :before_save,                 :method ],
-      [ :before_save,                 :proc   ],
-      [ :before_save,                 :object ],
-      [ :before_save,                 :block  ],
-      [ :before_create,               :method ],
-      [ :before_create,               :proc   ],
-      [ :before_create,               :object ],
-      [ :before_create,               :block  ],
-      [ :after_create,                :method ],
-      [ :after_create,                :proc   ],
-      [ :after_create,                :object ],
-      [ :after_create,                :block  ],
-      [ :after_save,                  :method ],
-      [ :after_save,                  :proc   ],
-      [ :after_save,                  :object ],
-      [ :after_save,                  :block  ]
-    ], developer.history
-  end
-
-  def test_update
-    developer = Developer.find(1)
-    developer.save
-    assert_equal [
-      [ :before_validation,           :method ],
-      [ :before_validation,           :proc   ],
-      [ :before_validation,           :object ],
-      [ :before_validation,           :block  ],
-      [ :after_validation,            :method ],
-      [ :after_validation,            :proc   ],
-      [ :after_validation,            :object ],
-      [ :after_validation,            :block  ],
-      [ :before_save,                 :method ],
-      [ :before_save,                 :proc   ],
-      [ :before_save,                 :object ],
-      [ :before_save,                 :block  ],
-      [ :before_update,               :method ],
-      [ :before_update,               :proc   ],
-      [ :before_update,               :object ],
-      [ :before_update,               :block  ],
-      [ :after_update,                :method ],
-      [ :after_update,                :proc   ],
-      [ :after_update,                :object ],
-      [ :after_update,                :block  ],
-      [ :after_save,                  :method ],
-      [ :after_save,                  :proc   ],
-      [ :after_save,                  :object ],
-      [ :after_save,                  :block  ]
-    ], developer.history
-  end
-
-  def test_destroy
-    developer = Developer.find(1)
-    developer.destroy
-    assert_equal [
-      [ :before_destroy,              :method ],
-      [ :before_destroy,              :proc   ],
-      [ :before_destroy,              :object ],
-      [ :before_destroy,              :block  ],
-      [ :after_destroy,               :method ],
-      [ :after_destroy,               :proc   ],
-      [ :after_destroy,               :object ],
-      [ :after_destroy,               :block  ]
-    ], developer.history
-  end
-
-  def test_delete
-    developer = Developer.find(1)
-    Developer.delete(developer.id)
-    assert_equal [], developer.history
-  end
-end

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

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class CollectionTest < ActiveSupport::TestCase
-  def setup
-    @collection = ActiveResource::Collection.new
-  end
-end
-
-class BasicCollectionTest < CollectionTest
-  def test_collection_respond_to_first_or_create
-    assert @collection.respond_to?(:first_or_create)
-  end
-
-  def test_collection_respond_to_first_or_initialize
-    assert @collection.respond_to?(:first_or_initialize)
-  end
-
-  def test_first_or_create_without_resource_class_raises_error
-    assert_raise(RuntimeError) { @collection.first_or_create }
-  end
-
-  def test_first_or_initialize_without_resource_class_raises_error
-    assert_raise(RuntimeError) { @collection.first_or_initialize }
-  end
-
-  def respond_to_where
-    assert @collection.respond_to?(:where)
-  end
-end
-
-class PaginatedCollection < ActiveResource::Collection
-  attr_accessor :next_page
-  def parse_response(parsed)
-    @elements = parsed["results"]
-    @next_page = parsed["next_page"]
-  end
-end
-
-class PaginatedPost < ActiveResource::Base
-  self.site = "http://37s.sunrise.i:3000"
-  self.collection_parser = "PaginatedCollection"
-end
-
-class ReduxCollection < ActiveResource::Base
-  self.site = "http://37s.sunrise.i:3000"
-  self.collection_parser = PaginatedCollection
-end
-
-
-class CollectionInheritanceTest < ActiveSupport::TestCase
-  def setup
-    @post = { id: 1, title: "Awesome" }
-    @post_even_more = { id: 1, title: "Awesome", subtitle: "EvenMore" }
-    @posts_hash = { "results" => [@post], :next_page => "/paginated_posts.json?page=2" }
-    @posts = @posts_hash.to_json
-    @posts2 = { "results" => [@post.merge(id: 2)], :next_page => nil }.to_json
-
-    @empty_posts = { "results" => [], :next_page => nil }.to_json
-    @new_post = { id: nil, title: nil }.to_json
-    ActiveResource::HttpMock.respond_to do |mock|
-      mock.get    "/paginated_posts.json", {}, @posts
-      mock.get    "/paginated_posts/new.json", {}, @new_post
-      mock.get    "/paginated_posts.json?page=2", {}, @posts
-      mock.get    "/paginated_posts.json?title=test", {}, @empty_posts
-      mock.get    "/paginated_posts.json?page=2&title=Awesome", {}, @posts
-      mock.get    "/paginated_posts.json?subtitle=EvenMore&title=Awesome", {}, @posts
-      mock.get    "/paginated_posts.json?title=notfound", {}, nil, 404
-      mock.get    "/paginated_posts.json?title=internalservererror", {}, nil, 500
-      mock.post   "/paginated_posts.json", {}, nil
-    end
-  end
-
-  def test_setting_collection_parser
-    assert_kind_of PaginatedCollection, PaginatedPost.find(:all)
-  end
-
-  def test_setting_collection_parser_resource_class
-    assert_equal PaginatedPost, PaginatedPost.where(page: 2).resource_class
-  end
-
-  def test_setting_collection_parser_query_params
-    assert_equal({ page: 2 }, PaginatedPost.where(page: 2).query_params)
-  end
-
-  def test_custom_accessor
-    assert_equal PaginatedPost.find(:all).call.next_page, @posts_hash[:next_page]
-  end
-
-  def test_first_or_create
-    post = PaginatedPost.where(title: "test").first_or_create
-    assert post.valid?
-  end
-
-  def test_first_or_initialize
-    post = PaginatedPost.where(title: "test").first_or_initialize
-    assert post.valid?
-  end
-
-  def test_where
-    posts = PaginatedPost.where(page: 2)
-    next_posts = posts.where(title: "Awesome")
-    assert_kind_of PaginatedCollection, next_posts
-  end
-
-  def test_where_lazy_chain
-    expected_request = ActiveResource::Request.new(
-      :get,
-      "/paginated_posts.json?subtitle=EvenMore&title=Awesome",
-      nil,
-      { "Accept" => "application/json" }
-    )
-    posts = PaginatedPost.where(title: "Awesome").where(subtitle: "EvenMore")
-    assert_not posts.requested?
-    assert_equal 0, ActiveResource::HttpMock.requests.count { |r| r == expected_request }
-    # Call twice to ensure the request is only made once
-    posts.to_a
-    posts.to_a
-    assert_equal 1, ActiveResource::HttpMock.requests.count { |r| r == expected_request }
-    assert posts.requested?
-  end
-
-  def test_where_lazy_chain_with_no_results
-    posts = PaginatedPost.where(title: "notfound")
-    assert_not posts.requested?
-    assert_equal [], posts.to_a
-    assert posts.requested?
-  end
-
-  def test_where_lazy_chain_internal_server_error
-    posts = PaginatedPost.where(title: "internalservererror")
-    assert_not posts.requested?
-    assert_raise ActiveResource::ServerError do
-      posts.to_a
-    end
-    assert posts.requested?
-  end
-
-  def test_refresh
-    expected_request = ActiveResource::Request.new(
-      :get,
-      "/paginated_posts.json?page=2",
-      @posts,
-      { "Accept" => "application/json" }
-    )
-    posts = PaginatedPost.where(page: 2)
-
-    assert_not posts.requested?
-    posts.to_a
-    assert posts.requested?
-    assert_equal 1, ActiveResource::HttpMock.requests.count { |r| r == expected_request }
-    posts.refresh
-    assert_equal 2, ActiveResource::HttpMock.requests.count { |r| r == expected_request }
-    assert posts.requested?
-  end
-
-  def test_call
-    expected_request = ActiveResource::Request.new(
-      :get,
-      "/paginated_posts.json?page=2",
-      @posts,
-      { "Accept" => "application/json" }
-    )
-    posts = PaginatedPost.where(page: 2)
-
-    assert_not posts.requested?
-    assert_kind_of PaginatedCollection, posts.call
-    assert posts.requested?
-    assert_equal 1, ActiveResource::HttpMock.requests.count { |r| r == expected_request }
-  end
-end

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

@@ -1,357 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class ConnectionTest < ActiveSupport::TestCase
-  ResponseCodeStub = Struct.new(:code)
-  RedirectResponseStub = Struct.new(:code, :Location)
-
-  def setup
-    @conn = ActiveResource::Connection.new("http://localhost")
-    matz  = { person: { id: 1, name: "Matz" } }
-    david = { person: { id: 2, name: "David" } }
-    @people = { people: [ matz, david ] }.to_json
-    @people_single = { "people-single-elements" => [ matz ] }.to_json
-    @people_empty = { "people-empty-elements" => [ ] }.to_json
-    @matz  = matz.to_json
-    @david = david.to_json
-    @header = { "key" => "value" }.freeze
-
-    @default_request_headers = { "Content-Type" => "application/json" }
-    ActiveResource::HttpMock.respond_to do |mock|
-      mock.get    "/people/2.json", @header, @david
-      mock.get    "/people.json", {}, @people
-      mock.get    "/people_single_elements.json", {}, @people_single
-      mock.get    "/people_empty_elements.json", {}, @people_empty
-      mock.get    "/people/1.json", {}, @matz
-      mock.put    "/people/1.json", {}, nil, 204
-      mock.put    "/people/2.json", {}, @header, 204
-      mock.delete "/people/1.json", {}, nil, 200
-      mock.delete "/people/2.json", @header, nil, 200
-      mock.post   "/people.json",   {}, nil, 201, "Location" => "/people/5.json"
-      mock.post   "/members.json",  {}, @header, 201, "Location" => "/people/6.json"
-      mock.head   "/people/1.json", {}, nil, 200
-    end
-  end
-
-  def test_same_logger_as_base
-    old_logger = ActiveResource::Base.logger
-    ActiveResource::Base.logger = original_logger = Object.new
-    old_site = ActiveResource::Base.site
-
-    ActiveResource::Base.site = "http://localhost"
-    assert_equal original_logger, ActiveResource::Base.connection.logger
-
-    ActiveResource::Base.logger = Logger.new(STDOUT)
-    assert_equal ActiveResource::Base.logger, ActiveResource::Base.connection.logger
-  ensure
-    ActiveResource::Base.logger = old_logger
-    ActiveResource::Base.site = old_site
-  end
-
-  def test_handle_response
-    # 2xx and 3xx are valid responses.
-    [200, 299, 300, 399].each do |code|
-      expected = ResponseCodeStub.new(code)
-      assert_equal expected, handle_response(expected)
-    end
-
-    # 301 is moved permanently (redirect)
-    assert_redirect_raises 301
-
-    # 302 is found (redirect)
-    assert_redirect_raises 302
-
-    # 303 is see other (redirect)
-    assert_redirect_raises 303
-
-    # 307 is temporary redirect
-    assert_redirect_raises 307
-
-    # 400 is a bad request (e.g. malformed URI or missing request parameter)
-    assert_response_raises ActiveResource::BadRequest, 400
-
-    # 401 is an unauthorized request
-    assert_response_raises ActiveResource::UnauthorizedAccess, 401
-
-    # 402 is a payment required error.
-    assert_response_raises ActiveResource::PaymentRequired, 402
-
-    # 403 is a forbidden request (and authorizing will not help)
-    assert_response_raises ActiveResource::ForbiddenAccess, 403
-
-    # 404 is a missing resource.
-    assert_response_raises ActiveResource::ResourceNotFound, 404
-
-    # 405 is a method not allowed error
-    assert_response_raises ActiveResource::MethodNotAllowed, 405
-
-    # 409 is an optimistic locking error
-    assert_response_raises ActiveResource::ResourceConflict, 409
-
-    # 410 is a removed resource
-    assert_response_raises ActiveResource::ResourceGone, 410
-
-    # 412 is a precondition failed
-    assert_response_raises ActiveResource::PreconditionFailed, 412
-
-    # 422 is a validation error
-    assert_response_raises ActiveResource::ResourceInvalid, 422
-
-    # 429 is too many requests
-    assert_response_raises ActiveResource::TooManyRequests, 429
-
-    # 4xx are client errors.
-    [402, 499].each do |code|
-      assert_response_raises ActiveResource::ClientError, code
-    end
-
-    # 5xx are server errors.
-    [500, 599].each do |code|
-      assert_response_raises ActiveResource::ServerError, code
-    end
-
-    # Others are unknown.
-    [199, 600].each do |code|
-      assert_response_raises ActiveResource::ConnectionError, code
-    end
-  end
-
-  ResponseHeaderStub = Struct.new(:code, :message, "Allow")
-  def test_should_return_allowed_methods_for_method_no_allowed_exception
-    handle_response ResponseHeaderStub.new(405, "HTTP Failed...", "GET, POST")
-  rescue ActiveResource::MethodNotAllowed => e
-    assert_equal "Failed.  Response code = 405.  Response message = HTTP Failed....", e.message
-    assert_equal [:get, :post], e.allowed_methods
-  end
-
-  def test_initialize_raises_argument_error_on_missing_site
-    assert_raise(ArgumentError) { ActiveResource::Connection.new(nil) }
-  end
-
-  def test_site_accessor_accepts_uri_or_string_argument
-    site = URI.parse("http://localhost")
-
-    assert_raise(URI::InvalidURIError) { @conn.site = nil }
-
-    assert_nothing_raised { @conn.site = "http://localhost" }
-    assert_equal site, @conn.site
-
-    assert_nothing_raised { @conn.site = site }
-    assert_equal site, @conn.site
-  end
-
-  def test_proxy_accessor_accepts_uri_or_string_argument
-    proxy = URI.parse("http://proxy_user:proxy_password@proxy.local:4242")
-
-    assert_nothing_raised { @conn.proxy = "http://proxy_user:proxy_password@proxy.local:4242" }
-    assert_equal proxy, @conn.proxy
-
-    assert_nothing_raised { @conn.proxy = proxy }
-    assert_equal proxy, @conn.proxy
-  end
-
-  def test_proxy_accessor_accepts_uri_or_string_argument_with_special_characters
-    user = "proxy_;{(,!$%_user"
-    password = "proxy_;:{(,!$%_password"
-
-    encoded_user = URI.encode_www_form_component(user) # "proxy_;%7B(,!$%25_user"
-    encoded_password = URI.encode_www_form_component(password) # "proxy_;:%7B(,!$%25_password"
-
-    proxy = URI.parse("http://#{encoded_user}:#{encoded_password}@proxy.local:4242")
-
-    assert_nothing_raised { @conn.proxy = "http://#{encoded_user}:#{encoded_password}@proxy.local:4242" }
-    assert_equal user, @conn.send(:new_http).proxy_user
-    assert_equal password, @conn.send(:new_http).proxy_pass
-
-    assert_nothing_raised { @conn.proxy = proxy }
-    assert_equal user, @conn.send(:new_http).proxy_user
-    assert_equal password, @conn.send(:new_http).proxy_pass
-  end
-
-  def test_timeout_accessor
-    @conn.timeout = 5
-    assert_equal 5, @conn.timeout
-  end
-
-  def test_get
-    matz = decode(@conn.get("/people/1.json"))
-    assert_equal "Matz", matz["name"]
-  end
-
-  def test_head
-    response = @conn.head("/people/1.json")
-    assert response.body.blank?
-    assert_equal 200, response.code
-  end
-
-  def test_get_with_header
-    david = decode(@conn.get("/people/2.json", @header))
-    assert_equal "David", david["name"]
-  end
-
-  def test_get_collection
-    people = decode(@conn.get("/people.json"))
-    assert_equal "Matz", people[0]["person"]["name"]
-    assert_equal "David", people[1]["person"]["name"]
-  end
-
-  def test_get_collection_single
-    people = decode(@conn.get("/people_single_elements.json"))
-    assert_equal "Matz", people[0]["person"]["name"]
-  end
-
-  def test_get_collection_empty
-    people = decode(@conn.get("/people_empty_elements.json"))
-    assert_equal [], people
-  end
-
-  def test_post
-    response = @conn.post("/people.json")
-    assert_equal "/people/5.json", response["Location"]
-  end
-
-  def test_post_with_header
-    response = @conn.post("/members.json", @header)
-    assert_equal "/people/6.json", response["Location"]
-  end
-
-  def test_put
-    response = @conn.put("/people/1.json")
-    assert_equal 204, response.code
-  end
-
-  def test_put_with_header
-    response = @conn.put("/people/2.json", @header)
-    assert_equal 204, response.code
-  end
-
-  def test_delete
-    response = @conn.delete("/people/1.json")
-    assert_equal 200, response.code
-  end
-
-  def test_delete_with_header
-    response = @conn.delete("/people/2.json", @header)
-    assert_equal 200, response.code
-  end
-
-  def test_timeout
-    @http = mock("new Net::HTTP")
-    @conn.expects(:http).returns(@http)
-    @http.expects(:get).raises(Timeout::Error, "execution expired")
-    assert_raise(ActiveResource::TimeoutError) { @conn.get("/people_timeout.json") }
-  end
-
-  def test_setting_timeout
-    http = Net::HTTP.new("")
-
-    [10, 20].each do |timeout|
-      @conn.timeout = timeout
-      @conn.send(:configure_http, http)
-      assert_equal timeout, http.open_timeout
-      assert_equal timeout, http.read_timeout
-    end
-  end
-
-  def test_accept_http_header
-    @http = mock("new Net::HTTP")
-    @conn.expects(:http).returns(@http)
-    path = "/people/1.xml"
-    @http.expects(:get).with(path, { "Accept" => "application/xhtml+xml" }).returns(ActiveResource::Response.new(@matz, 200, { "Content-Type" => "text/xhtml" }))
-    assert_nothing_raised { @conn.get(path, "Accept" => "application/xhtml+xml") }
-  end
-
-  def test_ssl_options_get_applied_to_http
-    http = Net::HTTP.new("")
-    @conn.site = "https://secure"
-    @conn.ssl_options = { verify_mode: OpenSSL::SSL::VERIFY_PEER }
-    @conn.send(:configure_http, http)
-
-    assert http.use_ssl?
-    assert_equal http.verify_mode, OpenSSL::SSL::VERIFY_PEER
-  end
-
-  def test_ssl_options_get_applied_to_https_urls_without_explicitly_setting_ssl_options
-    http = Net::HTTP.new("")
-    @conn.site = "https://secure"
-    assert @conn.send(:configure_http, http).use_ssl?
-  end
-
-  def test_ssl_error
-    http = Net::HTTP.new("")
-    @conn.expects(:http).returns(http)
-    http.expects(:get).raises(OpenSSL::SSL::SSLError, "Expired certificate")
-    assert_raise(ActiveResource::SSLError) { @conn.get("/people/1.json") }
-  end
-
-  def test_auth_type_can_be_string
-    @conn.auth_type = "digest"
-    assert_equal(:digest, @conn.auth_type)
-  end
-
-  def test_auth_type_defaults_to_basic
-    @conn.auth_type = nil
-    assert_equal(:basic, @conn.auth_type)
-  end
-
-  def test_auth_type_ignores_nonsensical_values
-    @conn.auth_type = :wibble
-    assert_equal(:basic, @conn.auth_type)
-  end
-
-  def test_disable_net_connection_by_default_when_http_mock_is_available
-    assert_equal(ActiveResource::HttpMock, @conn.send(:http).class)
-  end
-
-  def test_enable_net_connection
-    @conn.send(:http)
-    keep_net_connection_status do
-      ActiveResource::HttpMock.enable_net_connection!
-      assert @conn.send(:http).kind_of?(Net::HTTP)
-    end
-  end
-
-  def test_disable_net_connection
-    keep_net_connection_status do
-      ActiveResource::HttpMock.enable_net_connection!
-      @conn.send(:http)
-      ActiveResource::HttpMock.disable_net_connection!
-      assert @conn.send(:http).kind_of?(ActiveResource::HttpMock)
-    end
-  end
-
-  def keep_net_connection_status
-    old = ActiveResource::HttpMock.net_connection_enabled?
-    begin
-      yield
-    ensure
-      if old
-        ActiveResource::HttpMock.enable_net_connection!
-      else
-        ActiveResource::HttpMock.disable_net_connection!
-      end
-    end
-  end
-
-  protected
-    def assert_response_raises(klass, code)
-      assert_raise(klass, "Expected response code #{code} to raise #{klass}") do
-        handle_response ResponseCodeStub.new(code)
-      end
-    end
-
-    def assert_redirect_raises(code)
-      assert_raise(ActiveResource::Redirection, "Expected response code #{code} to raise ActiveResource::Redirection") do
-        handle_response RedirectResponseStub.new(code, "http://example.com/")
-      end
-    end
-
-    def handle_response(response)
-      @conn.__send__(:handle_response, response)
-    end
-
-    def decode(response)
-      @conn.format.decode(response.body)
-    end
-end