active_cached_resource 0.1.0 → 0.1.1

data/lib/activeresource/test/abstract_unit.rb

@@ -1,154 +0,0 @@
-# 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_support"
-require "active_support/test_case"
-require "setter_trap"
-require "active_support/logger"
-require "base64"
-
-require_relative "../lib/active_resource"
-
-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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-require "fixtures/project"
-require "fixtures/person"
-require "fixtures/product"
-require "active_job"
-require "active_job/arguments"
-require_relative "../../lib/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

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

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

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

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