active_model_serializers 0.10.3 → 0.10.12

data/test/serializers/options_test.rb

@@ -1,21 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class OptionsTest < ActiveSupport::TestCase
-      def setup
-        @profile = Profile.new(name: 'Name 1', description: 'Description 1')
-      end
-
-      def test_options_are_accessible
-        @profile_serializer = ProfileSerializer.new(@profile, my_options: :accessible)
-        assert @profile_serializer.arguments_passed_in?
-      end
-
-      def test_no_option_is_passed_in
-        @profile_serializer = ProfileSerializer.new(@profile)
-        refute @profile_serializer.arguments_passed_in?
-      end
-    end
-  end
-end

data/test/serializers/read_attribute_for_serialization_test.rb

@@ -1,79 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class ReadAttributeForSerializationTest < ActiveSupport::TestCase
-      # https://github.com/rails-api/active_model_serializers/issues/1653
-      class Parent < ActiveModelSerializers::Model
-        attr_accessor :id
-      end
-      class Child < Parent
-        attr_accessor :name
-      end
-      class ParentSerializer < ActiveModel::Serializer
-        attributes :$id
-
-        define_method(:$id) do
-          object.id
-        end
-      end
-      class ChildSerializer < ParentSerializer
-        attributes :name
-      end
-
-      def test_child_serializer_calls_dynamic_method_in_parent_serializer
-        parent = ParentSerializer.new(Parent.new(id: 5))
-        child  = ChildSerializer.new(Child.new(id: 6, name: 'Child'))
-        assert_equal 5, parent.read_attribute_for_serialization(:$id)
-        assert_equal 6, child.read_attribute_for_serialization(:$id)
-      end
-
-      # https://github.com/rails-api/active_model_serializers/issues/1658
-      class ErrorResponse < ActiveModelSerializers::Model
-        attr_accessor :error
-      end
-      class ApplicationSerializer < ActiveModel::Serializer
-        attributes :status
-
-        def status
-          object.try(:errors).blank? && object.try(:error).blank?
-        end
-      end
-      class ErrorResponseSerializer < ApplicationSerializer
-        attributes :error
-      end
-      class ErrorResponseWithSuperSerializer < ApplicationSerializer
-        attributes :error
-
-        def success
-          super
-        end
-      end
-
-      def test_child_serializer_with_error_attribute
-        error = ErrorResponse.new(error: 'i have an error')
-        serializer = ErrorResponseSerializer.new(error)
-        serializer_with_super = ErrorResponseWithSuperSerializer.new(error)
-        assert_equal false, serializer.read_attribute_for_serialization(:status)
-        assert_equal false, serializer_with_super.read_attribute_for_serialization(:status)
-      end
-
-      def test_child_serializer_with_errors
-        error = ErrorResponse.new
-        error.errors.add(:invalid, 'i am not valid')
-        serializer = ErrorResponseSerializer.new(error)
-        serializer_with_super = ErrorResponseWithSuperSerializer.new(error)
-        assert_equal false, serializer.read_attribute_for_serialization(:status)
-        assert_equal false, serializer_with_super.read_attribute_for_serialization(:status)
-      end
-
-      def test_child_serializer_no_error_attribute_or_errors
-        error = ErrorResponse.new
-        serializer = ErrorResponseSerializer.new(error)
-        serializer_with_super = ErrorResponseWithSuperSerializer.new(error)
-        assert_equal true, serializer.read_attribute_for_serialization(:status)
-        assert_equal true, serializer_with_super.read_attribute_for_serialization(:status)
-      end
-    end
-  end
-end

data/test/serializers/root_test.rb

@@ -1,21 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class RootTest < ActiveSupport::TestCase
-      def setup
-        @virtual_value = VirtualValue.new(id: 1)
-      end
-
-      def test_overwrite_root
-        serializer = VirtualValueSerializer.new(@virtual_value, root: 'smth')
-        assert_equal('smth', serializer.json_key)
-      end
-
-      def test_underscore_in_root
-        serializer = VirtualValueSerializer.new(@virtual_value)
-        assert_equal('virtual_value', serializer.json_key)
-      end
-    end
-  end
-end

data/test/serializers/serialization_test.rb

@@ -1,55 +0,0 @@
-module ActiveModel
-  class Serializer
-    class SerializationTest < ActiveSupport::TestCase
-      class Blog < ActiveModelSerializers::Model
-        attr_accessor :id, :name, :authors
-      end
-      class Author < ActiveModelSerializers::Model
-        attr_accessor :id, :name
-      end
-      class BlogSerializer < ActiveModel::Serializer
-        attributes :id
-        attribute :name, key: :title
-
-        has_many :authors
-      end
-      class AuthorSerializer < ActiveModel::Serializer
-        attributes :id, :name
-      end
-
-      setup do
-        @authors = [Author.new(id: 1, name: 'Blog Author')]
-        @blog = Blog.new(id: 2, name: 'The Blog', authors: @authors)
-        @serializer_instance = BlogSerializer.new(@blog)
-        @serializable = ActiveModelSerializers::SerializableResource.new(@blog, serializer: BlogSerializer, adapter: :attributes)
-        @expected_hash = { id: 2, title: 'The Blog', authors: [{ id: 1, name: 'Blog Author' }] }
-        @expected_json = '{"id":2,"title":"The Blog","authors":[{"id":1,"name":"Blog Author"}]}'
-      end
-
-      test '#serializable_hash is the same as generated by the attributes adapter' do
-        assert_equal @serializable.serializable_hash, @serializer_instance.serializable_hash
-        assert_equal @expected_hash, @serializer_instance.serializable_hash
-      end
-
-      test '#as_json is the same as generated by the attributes adapter' do
-        assert_equal @serializable.as_json, @serializer_instance.as_json
-        assert_equal @expected_hash, @serializer_instance.as_json
-      end
-
-      test '#to_json is the same as generated by the attributes adapter' do
-        assert_equal @serializable.to_json, @serializer_instance.to_json
-        assert_equal @expected_json, @serializer_instance.to_json
-      end
-
-      test '#to_h is an alias for #serializable_hash' do
-        assert_equal @serializable.serializable_hash, @serializer_instance.to_h
-        assert_equal @expected_hash, @serializer_instance.to_h
-      end
-
-      test '#to_hash is an alias for #serializable_hash' do
-        assert_equal @serializable.serializable_hash, @serializer_instance.to_hash
-        assert_equal @expected_hash, @serializer_instance.to_hash
-      end
-    end
-  end
-end

data/test/serializers/serializer_for_test.rb

@@ -1,136 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class SerializerForTest < ActiveSupport::TestCase
-      class CollectionSerializerTest < ActiveSupport::TestCase
-        def setup
-          @array = [1, 2, 3]
-          @previous_collection_serializer = ActiveModelSerializers.config.collection_serializer
-        end
-
-        def teardown
-          ActiveModelSerializers.config.collection_serializer = @previous_collection_serializer
-        end
-
-        def test_serializer_for_array
-          serializer = ActiveModel::Serializer.serializer_for(@array)
-          assert_equal ActiveModelSerializers.config.collection_serializer, serializer
-        end
-
-        def test_overwritten_serializer_for_array
-          new_collection_serializer = Class.new
-          ActiveModelSerializers.config.collection_serializer = new_collection_serializer
-          serializer = ActiveModel::Serializer.serializer_for(@array)
-          assert_equal new_collection_serializer, serializer
-        end
-      end
-
-      class SerializerTest < ActiveSupport::TestCase
-        module ResourceNamespace
-          class Post    < ::Model; end
-          class Comment < ::Model; end
-
-          class PostSerializer < ActiveModel::Serializer
-            class CommentSerializer < ActiveModel::Serializer
-            end
-          end
-        end
-
-        class MyProfile < Profile
-        end
-
-        class CustomProfile
-          def serializer_class
-            ProfileSerializer
-          end
-        end
-
-        class Tweet < ::Model; end
-        TweetSerializer = Class.new
-
-        def setup
-          @profile = Profile.new
-          @my_profile = MyProfile.new
-          @custom_profile = CustomProfile.new
-          @model = ::Model.new
-          @tweet = Tweet.new
-        end
-
-        def test_serializer_for_non_ams_serializer
-          serializer = ActiveModel::Serializer.serializer_for(@tweet)
-          assert_equal nil, serializer
-        end
-
-        def test_serializer_for_existing_serializer
-          serializer = ActiveModel::Serializer.serializer_for(@profile)
-          assert_equal ProfileSerializer, serializer
-        end
-
-        def test_serializer_for_existing_serializer_with_lookup_disabled
-          serializer = with_serializer_lookup_disabled do
-            ActiveModel::Serializer.serializer_for(@profile)
-          end
-          assert_equal nil, serializer
-        end
-
-        def test_serializer_for_not_existing_serializer
-          serializer = ActiveModel::Serializer.serializer_for(@model)
-          assert_equal nil, serializer
-        end
-
-        def test_serializer_inherited_serializer
-          serializer = ActiveModel::Serializer.serializer_for(@my_profile)
-          assert_equal ProfileSerializer, serializer
-        end
-
-        def test_serializer_inherited_serializer_with_lookup_disabled
-          serializer = with_serializer_lookup_disabled do
-            ActiveModel::Serializer.serializer_for(@my_profile)
-          end
-          assert_equal nil, serializer
-        end
-
-        def test_serializer_custom_serializer
-          serializer = ActiveModel::Serializer.serializer_for(@custom_profile)
-          assert_equal ProfileSerializer, serializer
-        end
-
-        def test_serializer_custom_serializer_with_lookup_disabled
-          serializer = with_serializer_lookup_disabled do
-            ActiveModel::Serializer.serializer_for(@custom_profile)
-          end
-          assert_equal ProfileSerializer, serializer
-        end
-
-        def test_serializer_for_namespaced_resource
-          post = ResourceNamespace::Post.new
-          serializer = ActiveModel::Serializer.serializer_for(post)
-          assert_equal ResourceNamespace::PostSerializer, serializer
-        end
-
-        def test_serializer_for_namespaced_resource_with_lookup_disabled
-          post = ResourceNamespace::Post.new
-          serializer = with_serializer_lookup_disabled do
-            ActiveModel::Serializer.serializer_for(post)
-          end
-          assert_equal nil, serializer
-        end
-
-        def test_serializer_for_nested_resource
-          comment = ResourceNamespace::Comment.new
-          serializer = ResourceNamespace::PostSerializer.serializer_for(comment)
-          assert_equal ResourceNamespace::PostSerializer::CommentSerializer, serializer
-        end
-
-        def test_serializer_for_nested_resource_with_lookup_disabled
-          comment = ResourceNamespace::Comment.new
-          serializer = with_serializer_lookup_disabled do
-            ResourceNamespace::PostSerializer.serializer_for(comment)
-          end
-          assert_equal nil, serializer
-        end
-      end
-    end
-  end
-end

data/test/serializers/serializer_for_with_namespace_test.rb

@@ -1,87 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class SerializerForWithNamespaceTest < ActiveSupport::TestCase
-      class Book < ::Model; end
-      class Page < ::Model; end
-      class Publisher < ::Model; end
-
-      module Api
-        module V3
-          class BookSerializer < ActiveModel::Serializer
-            attributes :title, :author_name
-
-            has_many :pages
-            belongs_to :publisher
-          end
-
-          class PageSerializer < ActiveModel::Serializer
-            attributes :number, :text
-
-            belongs_to :book
-          end
-
-          class PublisherSerializer < ActiveModel::Serializer
-            attributes :name
-          end
-        end
-      end
-
-      class BookSerializer < ActiveModel::Serializer
-        attributes :title, :author_name
-      end
-      test 'resource without a namespace' do
-        book = Book.new(title: 'A Post', author_name: 'hello')
-
-        # TODO: this should be able to pull up this serializer without explicitly specifying the serializer
-        #       currently, with no options, it still uses the Api::V3 serializer
-        result = ActiveModelSerializers::SerializableResource.new(book, serializer: BookSerializer).serializable_hash
-
-        expected = { title: 'A Post', author_name: 'hello' }
-        assert_equal expected, result
-      end
-
-      test 'resource with namespace' do
-        book = Book.new(title: 'A Post', author_name: 'hi')
-
-        result = ActiveModelSerializers::SerializableResource.new(book, namespace: Api::V3).serializable_hash
-
-        expected = { title: 'A Post', author_name: 'hi', pages: nil, publisher: nil }
-        assert_equal expected, result
-      end
-
-      test 'has_many with nested serializer under the namespace' do
-        page = Page.new(number: 1, text: 'hello')
-        book = Book.new(title: 'A Post', author_name: 'hi', pages: [page])
-
-        result = ActiveModelSerializers::SerializableResource.new(book, namespace: Api::V3).serializable_hash
-
-        expected = {
-          title: 'A Post', author_name: 'hi',
-          publisher: nil,
-          pages: [{
-            number: 1, text: 'hello'
-          }]
-        }
-        assert_equal expected, result
-      end
-
-      test 'belongs_to with nested serializer under the namespace' do
-        publisher = Publisher.new(name: 'Disney')
-        book = Book.new(title: 'A Post', author_name: 'hi', publisher: publisher)
-
-        result = ActiveModelSerializers::SerializableResource.new(book, namespace: Api::V3).serializable_hash
-
-        expected = {
-          title: 'A Post', author_name: 'hi',
-          pages: nil,
-          publisher: {
-            name: 'Disney'
-          }
-        }
-        assert_equal expected, result
-      end
-    end
-  end
-end

data/test/support/custom_schemas/active_model_serializers/test/schema_test/my/index.json

@@ -1,6 +0,0 @@
-{
-  "properties": {
-    "name" : { "type" : "string" },
-    "description" : { "type" : "string" }
-  }
-}

data/test/support/isolated_unit.rb

@@ -1,82 +0,0 @@
-# https://github.com/rails/rails/blob/v5.0.0.beta1/railties/test/isolation/abstract_unit.rb
-
-# Usage Example:
-#
-# require 'support/isolated_unit'
-#
-# class RailtieTest < ActiveSupport::TestCase
-#   include ActiveSupport::Testing::Isolation
-#
-#   class WithRailsDefinedOnLoad < RailtieTest
-#     setup do
-#       require 'rails'
-#       require 'active_model_serializers'
-#       make_basic_app
-#     end
-#
-#     # some tests
-#   end
-#
-#   class WithoutRailsDefinedOnLoad < RailtieTest
-#     setup do
-#       require 'active_model_serializers'
-#       make_basic_app
-#     end
-#
-#     # some tests
-#   end
-# end
-#
-# Note:
-# It is important to keep this file as light as possible
-# the goal for tests that require this is to test booting up
-# rails from an empty state, so anything added here could
-# hide potential failures
-#
-# It is also good to know what is the bare minimum to get
-# Rails booted up.
-require 'bundler/setup' unless defined?(Bundler)
-require 'active_support'
-require 'active_support/core_ext/string/access'
-
-# These files do not require any others and are needed
-# to run the tests
-require 'active_support/testing/autorun'
-require 'active_support/testing/isolation'
-
-module TestHelpers
-  module Generation
-    module_function
-
-    # Make a very basic app, without creating the whole directory structure.
-    # Is faster and simpler than generating a Rails app in a temp directory
-    def make_basic_app
-      require 'rails'
-      require 'action_controller/railtie'
-
-      @app = Class.new(Rails::Application) do
-        config.eager_load = false
-        config.session_store :cookie_store, key: '_myapp_session'
-        config.active_support.deprecation = :log
-        config.active_support.test_order = :parallel
-        ActiveSupport::TestCase.respond_to?(:test_order=) && ActiveSupport::TestCase.test_order = :parallel
-        config.root = File.dirname(__FILE__)
-        config.log_level = :info
-        # Set a fake logger to avoid creating the log directory automatically
-        fake_logger = Logger.new(nil)
-        config.logger = fake_logger
-        Rails.application.routes.default_url_options = { host: 'example.com' }
-      end
-      @app.respond_to?(:secrets) && @app.secrets.secret_key_base = '3b7cd727ee24e8444053437c36cc66c4'
-
-      yield @app if block_given?
-      @app.initialize!
-    end
-  end
-end
-
-module ActiveSupport
-  class TestCase
-    include TestHelpers::Generation
-  end
-end