active_cached_resource 0.1.0 → 0.1.1

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

@@ -1,276 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-require "abstract_unit"
-
-class AuthorizationTest < ActiveSupport::TestCase
-  Response = Struct.new(:code)
-
-  def setup
-    @conn = ActiveResource::Connection.new("http://localhost")
-    @matz  = { person: { id: 1, name: "Matz" } }.to_json
-    @david = { person: { id: 2, name: "David" } }.to_json
-    @authenticated_conn = ActiveResource::Connection.new("http://david:test123@localhost")
-    @basic_authorization_request_header = { "Authorization" => "Basic ZGF2aWQ6dGVzdDEyMw==" }
-    @jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
-    @bearer_token_authorization_request_header = { "Authorization" => "Bearer #{@jwt}" }
-  end
-
-  private
-    def decode(response)
-      @authenticated_conn.format.decode(response.body)
-    end
-end
-
-class BasicAuthorizationTest < AuthorizationTest
-  def setup
-    super
-    @authenticated_conn.auth_type = :basic
-
-    ActiveResource::HttpMock.respond_to do |mock|
-      mock.get    "/people/2.json",           @basic_authorization_request_header, @david
-      mock.get    "/people/1.json",           @basic_authorization_request_header, nil, 401, "WWW-Authenticate" => "i_should_be_ignored"
-      mock.get    "/people/3.json",           @bearer_token_authorization_request_header, @david
-      mock.put    "/people/2.json",           @basic_authorization_request_header, nil, 204
-      mock.delete "/people/2.json",           @basic_authorization_request_header, nil, 200
-      mock.post   "/people/2/addresses.json", @basic_authorization_request_header, nil, 201, "Location" => "/people/1/addresses/5"
-      mock.head   "/people/2.json",           @basic_authorization_request_header, nil, 200
-    end
-  end
-
-  def test_get
-    david = decode(@authenticated_conn.get("/people/2.json"))
-    assert_equal "David", david["name"]
-  end
-
-  def test_post
-    response = @authenticated_conn.post("/people/2/addresses.json")
-    assert_equal "/people/1/addresses/5", response["Location"]
-  end
-
-  def test_put
-    response = @authenticated_conn.put("/people/2.json")
-    assert_equal 204, response.code
-  end
-
-  def test_delete
-    response = @authenticated_conn.delete("/people/2.json")
-    assert_equal 200, response.code
-  end
-
-  def test_head
-    response = @authenticated_conn.head("/people/2.json")
-    assert_equal 200, response.code
-  end
-
-  def test_retry_on_401_doesnt_happen_with_basic_auth
-    assert_raise(ActiveResource::UnauthorizedAccess) { @authenticated_conn.get("/people/1.json") }
-    assert_equal "", @authenticated_conn.send(:response_auth_header)
-  end
-
-  def test_raises_invalid_request_on_unauthorized_requests
-    assert_raise(ActiveResource::InvalidRequestError) { @conn.get("/people/2.json") }
-    assert_raise(ActiveResource::InvalidRequestError) { @conn.post("/people/2/addresses.json") }
-    assert_raise(ActiveResource::InvalidRequestError) { @conn.put("/people/2.json") }
-    assert_raise(ActiveResource::InvalidRequestError) { @conn.delete("/people/2.json") }
-    assert_raise(ActiveResource::InvalidRequestError) { @conn.head("/people/2.json") }
-  end
-
-
-  def test_authorization_header
-    authorization_header = @authenticated_conn.__send__(:authorization_header, :get, URI.parse("/people/2.json"))
-    assert_equal @basic_authorization_request_header["Authorization"], authorization_header["Authorization"]
-    authorization = authorization_header["Authorization"].to_s.split
-
-    assert_equal "Basic", authorization[0]
-    assert_equal ["david", "test123"], ::Base64.decode64(authorization[1]).split(":")[0..1]
-  end
-
-  def test_authorization_header_with_username_but_no_password
-    @conn = ActiveResource::Connection.new("http://david:@localhost")
-    authorization_header = @conn.__send__(:authorization_header, :get, URI.parse("/people/2.json"))
-    authorization = authorization_header["Authorization"].to_s.split
-
-    assert_equal "Basic", authorization[0]
-    assert_equal ["david"], ::Base64.decode64(authorization[1]).split(":")[0..1]
-  end
-
-  def test_authorization_header_with_password_but_no_username
-    @conn = ActiveResource::Connection.new("http://:test123@localhost")
-    authorization_header = @conn.__send__(:authorization_header, :get, URI.parse("/people/2.json"))
-    authorization = authorization_header["Authorization"].to_s.split
-
-    assert_equal "Basic", authorization[0]
-    assert_equal ["", "test123"], ::Base64.decode64(authorization[1]).split(":")[0..1]
-  end
-
-  def test_authorization_header_with_decoded_credentials_from_url
-    @conn = ActiveResource::Connection.new("http://my%40email.com:%31%32%33@localhost")
-    authorization_header = @conn.__send__(:authorization_header, :get, URI.parse("/people/2.json"))
-    authorization = authorization_header["Authorization"].to_s.split
-
-    assert_equal "Basic", authorization[0]
-    assert_equal ["my@email.com", "123"], ::Base64.decode64(authorization[1]).split(":")[0..1]
-  end
-
-  def test_authorization_header_explicitly_setting_username_and_password
-    @authenticated_conn = ActiveResource::Connection.new("http://@localhost")
-    @authenticated_conn.user = "david"
-    @authenticated_conn.password = "test123"
-    authorization_header = @authenticated_conn.__send__(:authorization_header, :get, URI.parse("/people/2.json"))
-    assert_equal @basic_authorization_request_header["Authorization"], authorization_header["Authorization"]
-    authorization = authorization_header["Authorization"].to_s.split
-
-    assert_equal "Basic", authorization[0]
-    assert_equal ["david", "test123"], ::Base64.decode64(authorization[1]).split(":")[0..1]
-  end
-
-  def test_authorization_header_explicitly_setting_username_but_no_password
-    @conn = ActiveResource::Connection.new("http://@localhost")
-    @conn.user = "david"
-    authorization_header = @conn.__send__(:authorization_header, :get, URI.parse("/people/2.json"))
-    authorization = authorization_header["Authorization"].to_s.split
-
-    assert_equal "Basic", authorization[0]
-    assert_equal ["david"], ::Base64.decode64(authorization[1]).split(":")[0..1]
-  end
-
-  def test_authorization_header_explicitly_setting_password_but_no_username
-    @conn = ActiveResource::Connection.new("http://@localhost")
-    @conn.password = "test123"
-    authorization_header = @conn.__send__(:authorization_header, :get, URI.parse("/people/2.json"))
-    authorization = authorization_header["Authorization"].to_s.split
-
-    assert_equal "Basic", authorization[0]
-    assert_equal ["", "test123"], ::Base64.decode64(authorization[1]).split(":")[0..1]
-  end
-
-  def test_authorization_header_if_credentials_supplied_and_auth_type_is_basic
-    authorization_header = @authenticated_conn.__send__(:authorization_header, :get, URI.parse("/people/2.json"))
-    assert_equal @basic_authorization_request_header["Authorization"], authorization_header["Authorization"]
-    authorization = authorization_header["Authorization"].to_s.split
-
-    assert_equal "Basic", authorization[0]
-    assert_equal ["david", "test123"], ::Base64.decode64(authorization[1]).split(":")[0..1]
-  end
-
-  def test_authorization_header_explicitly_setting_jwt_and_auth_type_is_bearer
-    @conn = ActiveResource::Connection.new("http://localhost")
-    @conn.auth_type = :bearer
-    @conn.bearer_token = @jwt
-    authorization_header = @conn.__send__(:authorization_header, :get, URI.parse("/people/3.json"))
-    assert_equal @bearer_token_authorization_request_header["Authorization"], authorization_header["Authorization"]
-    authorization = authorization_header["Authorization"].to_s.split
-
-    assert_equal "Bearer", authorization[0]
-    assert_equal @jwt, authorization[1]
-  end
-
-  def test_authorization_header_if_no_jwt_and_auth_type_is_bearer
-    @conn = ActiveResource::Connection.new("http://localhost")
-    @conn.auth_type = :bearer
-    authorization_header = @conn.__send__(:authorization_header, :get, URI.parse("/people/3.json"))
-    assert_nil authorization_header["Authorization"]
-  end
-
-  def test_client_nonce_is_not_nil
-    assert_not_nil ActiveResource::Connection.new("http://david:test123@localhost").send(:client_nonce)
-  end
-end
-
-class DigestAuthorizationTest < AuthorizationTest
-  def setup
-    super
-    @authenticated_conn.auth_type = :digest
-
-    # Make client nonce deterministic
-    def @authenticated_conn.client_nonce; "i-am-a-client-nonce" end
-
-    @nonce = "MTI0OTUxMzc4NzpjYWI3NDM3NDNmY2JmODU4ZjQ2ZjcwNGZkMTJiMjE0NA=="
-
-    ActiveResource::HttpMock.respond_to do |mock|
-      mock.get    "/people/2.json",           { "Authorization" => blank_digest_auth_header("/people/2.json", "fad396f6a34aeba28e28b9b96ddbb671") }, nil, 401, "WWW-Authenticate" => response_digest_auth_header
-      mock.get    "/people/2.json",           { "Authorization" => request_digest_auth_header("/people/2.json", "c064d5ba8891a25290c76c8c7d31fb7b") }, @david, 200
-      mock.get    "/people/1.json",           { "Authorization" => request_digest_auth_header("/people/1.json", "f9c0b594257bb8422af4abd429c5bb70") }, @matz, 200
-
-      mock.put    "/people/2.json",           { "Authorization" => blank_digest_auth_header("/people/2.json", "50a685d814f94665b9d160fbbaa3958a") }, nil, 401, "WWW-Authenticate" => response_digest_auth_header
-      mock.put    "/people/2.json",           { "Authorization" => request_digest_auth_header("/people/2.json", "5a75cde841122d8e0f20f8fd1f98a743") }, nil, 204
-
-      mock.delete "/people/2.json",           { "Authorization" => blank_digest_auth_header("/people/2.json", "846f799107eab5ca4285b909ee299a33") }, nil, 401, "WWW-Authenticate" => response_digest_auth_header
-      mock.delete "/people/2.json",           { "Authorization" => request_digest_auth_header("/people/2.json", "9f5b155224edbbb69fd99d8ce094681e") }, nil, 200
-
-      mock.post   "/people/2/addresses.json", { "Authorization" => blank_digest_auth_header("/people/2/addresses.json", "6984d405ff3d9ed07bbf747dcf16afb0") }, nil, 401, "WWW-Authenticate" => response_digest_auth_header
-      mock.post   "/people/2/addresses.json", { "Authorization" => request_digest_auth_header("/people/2/addresses.json", "4bda6a28dbf930b5af9244073623bd04") }, nil, 201, "Location" => "/people/1/addresses/5"
-
-      mock.head   "/people/2.json",           { "Authorization" => blank_digest_auth_header("/people/2.json", "15e5ed84ba5c4cfcd5c98a36c2e4f421") }, nil, 401, "WWW-Authenticate" => response_digest_auth_header
-      mock.head   "/people/2.json",           { "Authorization" => request_digest_auth_header("/people/2.json", "d4c6d2bcc8717abb2e2ccb8c49ee6a91") }, nil, 200
-    end
-  end
-
-  def test_authorization_header_if_credentials_supplied_and_auth_type_is_digest
-    authorization_header = @authenticated_conn.__send__(:authorization_header, :get, URI.parse("/people/2.json"))
-    assert_equal blank_digest_auth_header("/people/2.json", "fad396f6a34aeba28e28b9b96ddbb671"), authorization_header["Authorization"]
-  end
-
-  def test_authorization_header_with_query_string_if_auth_type_is_digest
-    authorization_header = @authenticated_conn.__send__(:authorization_header, :get, URI.parse("/people/2.json?only=name"))
-    assert_equal blank_digest_auth_header("/people/2.json?only=name", "f8457b0b5d21b6b80737a386217afb24"), authorization_header["Authorization"]
-  end
-
-  def test_get_with_digest_auth_handles_initial_401_response_and_retries
-    response = @authenticated_conn.get("/people/2.json")
-    assert_equal "David", decode(response)["name"]
-  end
-
-  def test_post_with_digest_auth_handles_initial_401_response_and_retries
-    response = @authenticated_conn.post("/people/2/addresses.json")
-    assert_equal "/people/1/addresses/5", response["Location"]
-    assert_equal 201, response.code
-  end
-
-  def test_put_with_digest_auth_handles_initial_401_response_and_retries
-    response = @authenticated_conn.put("/people/2.json")
-    assert_equal 204, response.code
-  end
-
-  def test_delete_with_digest_auth_handles_initial_401_response_and_retries
-    response = @authenticated_conn.delete("/people/2.json")
-    assert_equal 200, response.code
-  end
-
-  def test_head_with_digest_auth_handles_initial_401_response_and_retries
-    response = @authenticated_conn.head("/people/2.json")
-    assert_equal 200, response.code
-  end
-
-  def test_get_with_digest_auth_caches_nonce
-    response = @authenticated_conn.get("/people/2.json")
-    assert_equal "David", decode(response)["name"]
-
-    # There is no mock for this request with a non-cached nonce.
-    response = @authenticated_conn.get("/people/1.json")
-    assert_equal "Matz", decode(response)["name"]
-  end
-
-  def test_raises_invalid_request_on_unauthorized_requests_with_digest_auth
-    @conn.auth_type = :digest
-    assert_raise(ActiveResource::InvalidRequestError) { @conn.get("/people/2.json") }
-    assert_raise(ActiveResource::InvalidRequestError) { @conn.post("/people/2/addresses.json") }
-    assert_raise(ActiveResource::InvalidRequestError) { @conn.put("/people/2.json") }
-    assert_raise(ActiveResource::InvalidRequestError) { @conn.delete("/people/2.json") }
-    assert_raise(ActiveResource::InvalidRequestError) { @conn.head("/people/2.json") }
-  end
-
-  private
-    def blank_digest_auth_header(uri, response)
-      %Q(Digest username="david", realm="", qop="", uri="#{uri}", nonce="", nc="0", cnonce="i-am-a-client-nonce", response="#{response}")
-    end
-
-    def request_digest_auth_header(uri, response)
-      %Q(Digest username="david", realm="RailsTestApp", qop="auth", uri="#{uri}", nonce="#{@nonce}", nc="0", cnonce="i-am-a-client-nonce", response="#{response}", opaque="ef6dfb078ba22298d366f99567814ffb")
-    end
-
-    def response_digest_auth_header
-      %Q(Digest realm="RailsTestApp", qop="auth", algorithm=MD5, nonce="#{@nonce}", opaque="ef6dfb078ba22298d366f99567814ffb")
-    end
-end

data/lib/activeresource/test/cases/base/custom_methods_test.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-require "fixtures/person"
-require "fixtures/street_address"
-require "active_support/core_ext/hash/conversions"
-
-class CustomMethodsTest < ActiveSupport::TestCase
-  def setup
-    @matz = { person: { id: 1, name: "Matz" } }.to_json
-    @matz_deep  = { person: { id: 1, name: "Matz", other: "other" } }.to_json
-    @matz_array = { people: [{ person: { id: 1, name: "Matz" } }] }.to_json
-    @ryan  = { person: { name: "Ryan" } }.to_json
-    @addy  = { address: { id: 1, street: "12345 Street" } }.to_json
-    @addy_deep = { address: { id: 1, street: "12345 Street", zip: "27519" } }.to_json
-
-    ActiveResource::HttpMock.respond_to do |mock|
-      mock.get    "/people/1.json",        {}, @matz
-      mock.get    "/people/1/shallow.json", {}, @matz
-      mock.get    "/people/1/deep.json", {}, @matz_deep
-      mock.get    "/people/retrieve.json?name=Matz", {}, @matz_array
-      mock.get    "/people/managers.json", {}, @matz_array
-      mock.post   "/people/hire.json?name=Matz", {}, nil, 201
-      mock.put    "/people/1/promote.json?position=Manager", {}, nil, 204
-      mock.put    "/people/promote.json?name=Matz", {}, nil, 204, {}
-      mock.put    "/people/sort.json?by=name", {}, nil, 204
-      mock.delete "/people/deactivate.json?name=Matz", {}, nil, 200
-      mock.delete "/people/1/deactivate.json", {}, nil, 200
-      mock.post   "/people/new/register.json",      {}, @ryan, 201, "Location" => "/people/5.json"
-      mock.post   "/people/1/register.json", {}, @matz, 201
-      mock.get    "/people/1/addresses/1.json", {}, @addy
-      mock.get    "/people/1/addresses/1/deep.json", {}, @addy_deep
-      mock.put    "/people/1/addresses/1/normalize_phone.json?locale=US", {}, nil, 204
-      mock.put    "/people/1/addresses/sort.json?by=name", {}, nil, 204
-      mock.post   "/people/1/addresses/new/link.json", {}, { address: { street: "12345 Street" } }.to_json, 201, "Location" => "/people/1/addresses/2.json"
-    end
-
-    Person.user = nil
-    Person.password = nil
-  end
-
-  def teardown
-    ActiveResource::HttpMock.reset!
-  end
-
-  def test_custom_collection_method
-    # GET
-    assert_equal([{ "id" => 1, "name" => "Matz" }], Person.get(:retrieve, name: "Matz"))
-
-    # POST
-    assert_equal(ActiveResource::Response.new("", 201, {}), Person.post(:hire, name: "Matz"))
-
-    # PUT
-    assert_equal ActiveResource::Response.new("", 204, {}),
-                   Person.put(:promote, { name: "Matz" }, "atestbody")
-    assert_equal ActiveResource::Response.new("", 204, {}), Person.put(:sort, by: "name")
-
-    # DELETE
-    Person.delete :deactivate, name: "Matz"
-
-    # Nested resource
-    assert_equal ActiveResource::Response.new("", 204, {}), StreetAddress.put(:sort, person_id: 1, by: "name")
-  end
-
-  def test_custom_element_method
-    # Test GET against an element URL
-    assert_equal Person.find(1).get(:shallow), "id" => 1, "name" => "Matz"
-    assert_equal Person.find(1).get(:deep), "id" => 1, "name" => "Matz", "other" => "other"
-
-    # Test PUT against an element URL
-    assert_equal ActiveResource::Response.new("", 204, {}), Person.find(1).put(:promote, { position: "Manager" }, "body")
-
-    # Test DELETE against an element URL
-    assert_equal ActiveResource::Response.new("", 200, {}), Person.find(1).delete(:deactivate)
-
-    # With nested resources
-    assert_equal StreetAddress.find(1, params: { person_id: 1 }).get(:deep),
-                  "id" => 1, "street" => "12345 Street", "zip" => "27519"
-    assert_equal ActiveResource::Response.new("", 204, {}),
-                   StreetAddress.find(1, params: { person_id: 1 }).put(:normalize_phone, locale: "US")
-  end
-
-  def test_custom_new_element_method
-    # Test POST against a new element URL
-    ryan = Person.new(name: "Ryan")
-    assert_equal ActiveResource::Response.new(@ryan, 201, "Location" => "/people/5.json"), ryan.post(:register)
-    expected_request = ActiveResource::Request.new(:post, "/people/new/register.json", @ryan)
-    assert_equal expected_request.body, ActiveResource::HttpMock.requests.first.body
-
-    # Test POST against a nested collection URL
-    addy = StreetAddress.new(street: "123 Test Dr.", person_id: 1)
-    assert_equal ActiveResource::Response.new({ address: { street: "12345 Street" } }.to_json,
-                   201, "Location" => "/people/1/addresses/2.json"),
-                 addy.post(:link)
-
-    matz = Person.find(1)
-    assert_equal ActiveResource::Response.new(@matz, 201), matz.post(:register)
-  end
-
-  def test_find_custom_resources
-    assert_equal "Matz", Person.find(:all, from: :managers).first.name
-  end
-
-  def test_paths_with_format
-    path_with_format = "/people/active.json"
-
-    ActiveResource::HttpMock.respond_to do |mock|
-      mock.get      path_with_format, {}, @matz
-      mock.post     path_with_format, {}, nil
-      mock.patch    path_with_format, {}, nil
-      mock.delete   path_with_format, {}, nil
-      mock.put      path_with_format, {}, nil
-    end
-
-    [:get, :post, :delete, :patch, :put].each_with_index do |method, index|
-      Person.send(method, :active)
-      expected_request = ActiveResource::Request.new(method, path_with_format)
-      assert_equal expected_request.path, ActiveResource::HttpMock.requests[index].path
-      assert_equal expected_request.method, ActiveResource::HttpMock.requests[index].method
-    end
-  end
-
-  def test_paths_without_format
-    ActiveResource::Base.include_format_in_path = false
-    path_without_format = "/people/active"
-
-    ActiveResource::HttpMock.respond_to do |mock|
-      mock.get      path_without_format, {}, @matz
-      mock.post     path_without_format, {}, nil
-      mock.patch    path_without_format, {}, nil
-      mock.delete   path_without_format, {}, nil
-      mock.put      path_without_format, {}, nil
-    end
-
-    [:get, :post, :delete, :patch, :put].each_with_index do |method, index|
-      Person.send(method, :active)
-      expected_request = ActiveResource::Request.new(method, path_without_format)
-      assert_equal expected_request.path, ActiveResource::HttpMock.requests[index].path
-      assert_equal expected_request.method, ActiveResource::HttpMock.requests[index].method
-    end
-  ensure
-    ActiveResource::Base.include_format_in_path = true
-  end
-
-  def test_custom_element_method_identifier_encoding
-    luis = { person: { id: "luís", name: "Luís" } }.to_json
-
-    ActiveResource::HttpMock.respond_to do |mock|
-      mock.get "/people/lu%C3%ADs.json", {}, luis
-      mock.put "/people/lu%C3%ADs/deactivate.json", {}, luis, 204
-    end
-
-    assert_equal ActiveResource::Response.new(luis, 204), Person.find("luís").put(:deactivate)
-  end
-end

data/lib/activeresource/test/cases/base/equality_test.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-require "fixtures/person"
-require "fixtures/street_address"
-
-class BaseEqualityTest < ActiveSupport::TestCase
-  def setup
-    @new = Person.new
-    @one = Person.new(id: 1)
-    @two = Person.new(id: 2)
-    @street = StreetAddress.new(id: 2)
-  end
-
-  def test_should_equal_self
-    assert @new == @new, "@new == @new"
-    assert @one == @one, "@one == @one"
-  end
-
-  def test_shouldnt_equal_new_resource
-    assert @new != @one, "@new != @one"
-    assert @one != @new, "@one != @new"
-  end
-
-  def test_shouldnt_equal_different_class
-    assert @two != @street, "person != street_address with same id"
-    assert @street != @two, "street_address != person with same id"
-  end
-
-  def test_eql_should_alias_equals_operator
-    assert_equal @new == @new, @new.eql?(@new)
-    assert_equal @new == @one, @new.eql?(@one)
-
-    assert_equal @one == @one, @one.eql?(@one)
-    assert_equal @one == @new, @one.eql?(@new)
-
-    assert_equal @one == @street, @one.eql?(@street)
-  end
-
-  def test_hash_should_be_id_hash
-    [@new, @one, @two, @street].each do |resource|
-      assert_equal resource.id.hash, resource.hash
-    end
-  end
-
-  def test_with_prefix_options
-    assert_equal @one == @one, @one.eql?(@one)
-    assert_equal @one == @one.dup, @one.eql?(@one.dup)
-    new_one = @one.dup
-    new_one.prefix_options = { foo: "bar" }
-    assert_not_equal @one, new_one
-  end
-end