active_cached_resource 0.0.1.pre

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

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

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

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