active_cached_resource 0.0.1.pre

data/lib/activeresource/test/abstract_unit.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "rubygems" unless defined? Gem
+require "bundler/setup"
+
+lib = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$:.unshift(lib) unless $:.include?("lib") || $:.include?(lib)
+
+require "minitest/autorun"
+require "active_resource"
+require "active_support"
+require "active_support/test_case"
+require "setter_trap"
+require "active_support/logger"
+require "base64"
+
+ActiveSupport::TestCase.test_order = :random if ActiveSupport::TestCase.respond_to?(:test_order=)
+ActiveResource::Base.logger = ActiveSupport::Logger.new("#{File.dirname(__FILE__)}/debug.log")
+ActiveResource::Base.include_root_in_json = true
+
+def setup_response
+  matz_hash = { "person" => { id: 1, name: "Matz" } }
+
+  @default_request_headers = { "Content-Type" => "application/json" }
+  @matz = matz_hash.to_json
+  @matz_xml = matz_hash.to_xml
+  @david = { person: { id: 2, name: "David" } }.to_json
+  @greg  = { person: { id: 3, name: "Greg" } }.to_json
+  @addy  = { address: { id: 1, street: "12345 Street", country: "Australia" } }.to_json
+  @rick  = { person: { name: "Rick", age: 25 } }.to_json
+  @joe    = { person: { id: 6, name: "Joe", likes_hats: true } }.to_json
+  @people = { people: [ { person: { id: 1, name: "Matz" } }, { person: { id: 2, name: "David" } }] }.to_json
+  @people_david = { people: [ { person: { id: 2, name: "David" } }] }.to_json
+  @addresses = { addresses: [{ address: { id: 1, street: "12345 Street", country: "Australia" } }] }.to_json
+  @post  = { id: 1, title: "Hello World", body: "Lorem Ipsum" }.to_json
+  @posts = [{ id: 1, title: "Hello World", body: "Lorem Ipsum" }, { id: 2, title: "Second Post", body: "Lorem Ipsum" }].to_json
+  @comments = [{ id: 1, post_id: 1, content: "Interesting post" }, { id: 2, post_id: 1, content: "I agree" }].to_json
+  @pets = [{ id: 1, name: "Max" }, { id: 2, name: "Daisy" }].to_json
+
+  # - deep nested resource -
+  # - Luis (Customer)
+  #   - JK (Customer::Friend)
+  #     - Mateo (Customer::Friend::Brother)
+  #       - Edith (Customer::Friend::Brother::Child)
+  #       - Martha (Customer::Friend::Brother::Child)
+  #     - Felipe (Customer::Friend::Brother)
+  #       - Bryan (Customer::Friend::Brother::Child)
+  #       - Luke (Customer::Friend::Brother::Child)
+  #   - Eduardo (Customer::Friend)
+  #     - Sebas (Customer::Friend::Brother)
+  #       - Andres (Customer::Friend::Brother::Child)
+  #       - Jorge (Customer::Friend::Brother::Child)
+  #     - Elsa (Customer::Friend::Brother)
+  #       - Natacha (Customer::Friend::Brother::Child)
+  #     - Milena (Customer::Friend::Brother)
+  #
+  @luis = {
+    customer: {
+      id: 1,
+      name: "Luis",
+      friends: [{
+        name: "JK",
+        brothers: [
+          {
+            name: "Mateo",
+            children: [{ name: "Edith" }, { name: "Martha" }]
+          }, {
+            name: "Felipe",
+            children: [{ name: "Bryan" }, { name: "Luke" }]
+          }
+        ]
+      }, {
+        name: "Eduardo",
+        brothers: [
+          {
+            name: "Sebas",
+            children: [{ name: "Andres" }, { name: "Jorge" }]
+          }, {
+            name: "Elsa",
+            children: [{ name: "Natacha" }]
+          }, {
+            name: "Milena",
+            children: []
+          }
+        ]
+      }],
+      enemies: [{ name: "Joker" }],
+      mother: { name: "Ingeborg" }
+    }
+  }.to_json
+
+  @startup_sound = {
+    sound: {
+      name: "Mac Startup Sound", author: { name: "Jim Reekes" }
+    }
+  }.to_json
+
+  @product = { id: 1, name: "Rails book" }.to_json
+  @inventory = { status: "Sold Out", total: 10, used: 10 }.to_json
+
+  ActiveResource::HttpMock.respond_to do |mock|
+    mock.get    "/people/1.json",               {}, @matz
+    mock.get    "/people/1.xml",                {}, @matz_xml
+    mock.get    "/people/2.xml",                {}, @david
+    mock.get    "/people/Greg.json",            {}, @greg
+    mock.get    "/people/6.json",               {}, @joe
+    mock.get    "/people/4.json",               { "key" => "value" }, nil, 404
+    mock.put    "/people/1.json",               {}, nil, 204
+    mock.delete "/people/1.json",               {}, nil, 200
+    mock.delete "/people/2.xml",                {}, nil, 400
+    mock.get    "/people/99.json",              {}, nil, 404
+    mock.post   "/people.json",                 {}, @rick, 201, "Location" => "/people/5.xml"
+    mock.get    "/people.json",                 {}, @people
+    mock.get    "/people/1/addresses.json",     {}, @addresses
+    mock.get    "/people/1/addresses/1.json",   {}, @addy
+    mock.get    "/people/1/addresses/2.xml",    {}, nil, 404
+    mock.get    "/people/2/addresses.json",     {}, nil, 404
+    mock.get    "/people/2/addresses/1.xml",    {}, nil, 404
+    mock.get    "/people/Greg/addresses/1.json", {}, @addy
+    mock.put    "/people/1/addresses/1.json",   {}, nil, 204
+    mock.delete "/people/1/addresses/1.json",   {}, nil, 200
+    mock.post   "/people/1/addresses.json",     {}, nil, 201, "Location" => "/people/1/addresses/5"
+    mock.get    "/people/1/addresses/99.json",  {}, nil, 404
+    mock.get    "/people//addresses.xml",       {}, nil, 404
+    mock.get    "/people//addresses/1.xml",     {}, nil, 404
+    mock.put    "/people//addresses/1.xml",     {}, nil, 404
+    mock.delete "/people//addresses/1.xml",     {}, nil, 404
+    mock.post   "/people//addresses.xml",       {}, nil, 404
+    mock.head   "/people/1.json",               {}, nil, 200
+    mock.head   "/people/Greg.json",            {}, nil, 200
+    mock.head   "/people/99.json",              {}, nil, 404
+    mock.head   "/people/1/addresses/1.json",   {}, nil, 200
+    mock.head   "/people/1/addresses/2.json",   {}, nil, 404
+    mock.head   "/people/2/addresses/1.json",    {}, nil, 404
+    mock.head   "/people/Greg/addresses/1.json", {}, nil, 200
+    # customer
+    mock.get    "/customers/1.json",             {}, @luis
+    # sound
+    mock.get    "/sounds/1.json",                {}, @startup_sound
+    # post
+    mock.get    "/posts.json",                   {}, @posts
+    mock.get    "/posts/1.json",                 {}, @post
+    mock.get    "/posts/1/comments.json",        {}, @comments
+    # products
+    mock.get "/products/1.json", { "Accept" => "application/json", "X-Inherited-Header" => "present" }, @product
+    mock.get "/products/1/inventory.json", {}, @inventory
+    # pets
+    mock.get "/people/1/pets.json", {}, @pets
+  end
+
+  Person.user = nil
+  Person.password = nil
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+require "fixtures/project"
+require "fixtures/person"
+require "fixtures/product"
+require "active_job"
+require "active_job/arguments"
+require "active_resource/active_job_serializer"
+
+class ActiveJobSerializerTest < ActiveSupport::TestCase
+  setup do
+    @klass = ActiveResource::ActiveJobSerializer
+  end
+
+  def test_serialize
+    project = Project.new(id: 1, name: "Ruby on Rails")
+    project.prefix_options[:person_id] = 1
+    project_json = {
+      _aj_serialized: @klass.name,
+      class: project.class.name,
+      persisted: project.persisted?,
+      prefix_options: project.prefix_options,
+      attributes: project.attributes
+    }.as_json
+    serialized_json = @klass.serialize(project)
+
+    assert_equal project_json, serialized_json
+  end
+
+  def test_deserialize
+    person = Person.new(id: 2, name: "David")
+    person.persisted = true
+    person_json = {
+      _aj_serialized: @klass.name,
+      class: person.class.name,
+      persisted: person.persisted?,
+      prefix_options: person.prefix_options,
+      attributes: person.attributes
+    }.as_json
+    deserialized_object = @klass.deserialize(person_json)
+
+    assert_equal person, deserialized_object
+  end
+
+  def test_serialize?
+    product = Product.new(id: 3, name: "Chunky Bacon")
+
+    assert @klass.serialize?(product)
+    assert_not @klass.serialize?("not a resource")
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+require "fixtures/person"
+require "fixtures/beast"
+require "fixtures/customer"
+
+
+class AssociationTest < ActiveSupport::TestCase
+  def setup
+    @klass = ActiveResource::Associations::Builder::Association
+    @reflection = ActiveResource::Reflection::AssociationReflection.new :belongs_to, :customer, {}
+  end
+
+
+  def test_validations_for_instance
+    object = @klass.new(Person, :customers, {})
+    assert_equal({}, object.send(:validate_options))
+  end
+
+  def test_instance_build
+    object = @klass.new(Person, :customers, {})
+    assert_kind_of ActiveResource::Reflection::AssociationReflection, object.build
+  end
+
+  def test_valid_options
+    assert @klass.build(Person, :customers, class_name: "Client")
+
+    assert_raise ArgumentError do
+      @klass.build(Person, :customers, soo_invalid: true)
+    end
+  end
+
+  def test_association_class_build
+    assert_kind_of ActiveResource::Reflection::AssociationReflection, @klass.build(Person, :customers, {})
+  end
+
+  def test_has_many
+    External::Person.send(:has_many, :people)
+    assert_equal 1, External::Person.reflections.select { |name, reflection| reflection.macro.eql?(:has_many) }.count
+  end
+
+  def test_has_many_on_new_record
+    Post.send(:has_many, :topics)
+
+    assert_kind_of ActiveResource::Collection, Post.new.topics
+  end
+
+  def test_has_one
+    External::Person.send(:has_one, :customer)
+    assert_equal 1, External::Person.reflections.select { |name, reflection| reflection.macro.eql?(:has_one) }.count
+  end
+
+  def test_belongs_to
+    External::Person.belongs_to(:Customer)
+    assert_equal 1, External::Person.reflections.select { |name, reflection| reflection.macro.eql?(:belongs_to) }.count
+  end
+
+  def test_defines_belongs_to_finder_method_with_instance_variable_cache
+    Person.defines_belongs_to_finder_method(@reflection)
+
+    person = Person.new
+    assert_not person.instance_variable_defined?(:@customer)
+    person.stubs(:customer_id).returns(2)
+    Customer.expects(:find).with(2).once()
+    2.times { person.customer }
+    assert person.instance_variable_defined?(:@customer)
+  end
+
+  def test_belongs_to_with_finder_key
+    Person.defines_belongs_to_finder_method(@reflection)
+
+    person = Person.new
+    person.stubs(:customer_id).returns(1)
+    Customer.expects(:find).with(1).once()
+    person.customer
+  end
+
+  def test_belongs_to_with_nil_finder_key
+    Person.defines_belongs_to_finder_method(@reflection)
+
+    person = Person.new
+    person.stubs(:customer_id).returns(nil)
+    Customer.expects(:find).with(nil).never()
+    person.customer
+  end
+
+  def test_inverse_associations_do_not_create_circular_dependencies
+    code = <<-CODE
+      class Park < ActiveResource::Base
+        has_many :trails
+      end
+
+      class Trail < ActiveResource::Base
+        belongs_to :park
+      end
+    CODE
+
+    assert_nothing_raised do
+      eval code
+    end
+  end
+end

data/lib/activeresource/test/cases/associations/builder/belongs_to_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+require "fixtures/person"
+require "fixtures/beast"
+require "fixtures/customer"
+
+
+class ActiveResource::Associations::Builder::BelongsToTest < ActiveSupport::TestCase
+  def setup
+    @klass = ActiveResource::Associations::Builder::BelongsTo
+  end
+
+
+  def test_validations_for_instance
+    object = @klass.new(Person, :customer, {})
+    assert_equal({}, object.send(:validate_options))
+  end
+
+  def test_instance_build
+    object = @klass.new(Person, :customer, {})
+    Person.expects(:defines_belongs_to_finder_method).with(kind_of(ActiveResource::Reflection::AssociationReflection))
+
+    reflection = object.build
+
+    assert_kind_of ActiveResource::Reflection::AssociationReflection, reflection
+    assert_equal :customer, reflection.name
+    assert_equal Customer, reflection.klass
+    assert_equal "customer_id", reflection.foreign_key
+  end
+
+
+  def test_valid_options
+    assert @klass.build(Person, :customer, class_name: "Person")
+    assert @klass.build(Person, :customer, foreign_key: "person_id")
+
+    assert_raise ArgumentError do
+      @klass.build(Person, :customer, soo_invalid: true)
+    end
+  end
+end

data/lib/activeresource/test/cases/associations/builder/has_many_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+require "fixtures/person"
+require "fixtures/street_address"
+
+class ActiveResource::Associations::Builder::HasManyTest < ActiveSupport::TestCase
+  def setup
+    @klass = ActiveResource::Associations::Builder::HasMany
+  end
+
+  def test_validations_for_instance
+    object = @klass.new(Person, :street_address, {})
+    assert_equal({}, object.send(:validate_options))
+  end
+
+  def test_instance_build
+    object = @klass.new(Person, :street_address, {})
+    Person.expects(:defines_has_many_finder_method).with(kind_of(ActiveResource::Reflection::AssociationReflection))
+
+    reflection = object.build
+
+    assert_kind_of ActiveResource::Reflection::AssociationReflection, reflection
+    assert_equal :street_address, reflection.name
+    assert_equal StreetAddress, reflection.klass
+  end
+end

data/lib/activeresource/test/cases/associations/builder/has_one_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+require "fixtures/product"
+require "fixtures/inventory"
+
+class ActiveResource::Associations::Builder::HasOneTest < ActiveSupport::TestCase
+  def setup
+    @klass = ActiveResource::Associations::Builder::HasOne
+  end
+
+  def test_validations_for_instance
+    object = @klass.new(Product, :inventory, {})
+    assert_equal({}, object.send(:validate_options))
+  end
+
+  def test_instance_build
+    object = @klass.new(Product, :inventory, {})
+    Product.expects(:defines_has_one_finder_method).with(kind_of(ActiveResource::Reflection::AssociationReflection))
+
+    reflection = object.build
+
+    assert_kind_of ActiveResource::Reflection::AssociationReflection, reflection
+    assert_equal :inventory, reflection.name
+    assert_equal Inventory, reflection.klass
+  end
+end