active_cached_resource 0.0.1.pre

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

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

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

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