active_model_serializers 0.10.9 → 0.10.10

data/test/adapter/json_api/type_test.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class JsonApi
-      class TypeTest < ActiveSupport::TestCase
-        class StringTypeSerializer < ActiveModel::Serializer
-          attribute :name
-          type 'profile'
-        end
-
-        class SymbolTypeSerializer < ActiveModel::Serializer
-          attribute :name
-          type :profile
-        end
-
-        setup do
-          @author = Author.new(id: 1, name: 'Steve K.')
-        end
-
-        def test_config_plural
-          with_jsonapi_inflection :plural do
-            assert_type(@author, 'authors')
-          end
-        end
-
-        def test_config_singular
-          with_jsonapi_inflection :singular do
-            assert_type(@author, 'author')
-          end
-        end
-
-        def test_explicit_string_type_value
-          assert_type(@author, 'profile', serializer: StringTypeSerializer)
-        end
-
-        def test_explicit_symbol_type_value
-          assert_type(@author, 'profile', serializer: SymbolTypeSerializer)
-        end
-
-        private
-
-        def assert_type(resource, expected_type, opts = {})
-          opts = opts.reverse_merge(adapter: :json_api)
-          hash = serializable(resource, opts).serializable_hash
-          assert_equal(expected_type, hash.fetch(:data).fetch(:type))
-        end
-      end
-      class ResourceIdentifierTest < ActiveSupport::TestCase
-        class WithDefinedTypeSerializer < ActiveModel::Serializer
-          type 'with_defined_types'
-        end
-
-        class WithDefinedIdSerializer < ActiveModel::Serializer
-          def id
-            'special_id'
-          end
-        end
-
-        class FragmentedSerializer < ActiveModel::Serializer
-          cache only: :id
-
-          def id
-            'special_id'
-          end
-        end
-
-        setup do
-          @model = Author.new(id: 1, name: 'Steve K.')
-          ActionController::Base.cache_store.clear
-        end
-
-        def test_defined_type
-          actual = with_jsonapi_inflection :plural do
-            actual_resource_identifier_object(WithDefinedTypeSerializer, @model)
-          end
-          expected = { id: expected_model_id(@model), type: 'with-defined-types' }
-          assert_equal actual, expected
-        end
-
-        def test_defined_type_not_inflected
-          actual = with_jsonapi_inflection :singular do
-            actual_resource_identifier_object(WithDefinedTypeSerializer, @model)
-          end
-          expected = { id: expected_model_id(@model), type: 'with-defined-types' }
-          assert_equal actual, expected
-        end
-
-        def test_singular_type
-          actual = with_jsonapi_inflection :singular do
-            actual_resource_identifier_object(AuthorSerializer, @model)
-          end
-          expected = { id: expected_model_id(@model), type: 'author' }
-          assert_equal actual, expected
-        end
-
-        def test_plural_type
-          actual = with_jsonapi_inflection :plural do
-            actual_resource_identifier_object(AuthorSerializer, @model)
-          end
-          expected = { id: expected_model_id(@model), type: 'authors' }
-          assert_equal actual, expected
-        end
-
-        def test_type_with_namespace
-          Object.const_set(:Admin, Module.new)
-          model = Class.new(::Model)
-          Admin.const_set(:PowerUser, model)
-          serializer = Class.new(ActiveModel::Serializer)
-          Admin.const_set(:PowerUserSerializer, serializer)
-          with_namespace_separator '--' do
-            admin_user = Admin::PowerUser.new
-            serializer = Admin::PowerUserSerializer.new(admin_user)
-            expected = {
-              id: admin_user.id,
-              type: 'admin--power-users'
-            }
-
-            identifier = ResourceIdentifier.new(serializer, {})
-            actual = identifier.as_json
-            assert_equal(expected, actual)
-          end
-        end
-
-        def test_id_defined_on_object
-          actual = actual_resource_identifier_object(AuthorSerializer, @model)
-          expected = { id: @model.id.to_s, type: expected_model_type(@model) }
-          assert_equal actual, expected
-        end
-
-        def test_blank_id
-          model = Author.new(id: nil, name: 'Steve K.')
-          actual = actual_resource_identifier_object(AuthorSerializer, model)
-          expected = { type: expected_model_type(model) }
-          assert_equal actual, expected
-        end
-
-        def test_for_type_with_id
-          id = 1
-          actual = ResourceIdentifier.for_type_with_id('admin_user', id, {})
-          expected = { id: '1', type: 'admin-users' }
-          assert_equal actual, expected
-        end
-
-        def test_for_type_with_id_given_blank_id
-          id = ''
-          actual = ResourceIdentifier.for_type_with_id('admin_user', id, {})
-          expected = { type: 'admin-users' }
-          assert_equal actual, expected
-        end
-
-        def test_for_type_with_id_inflected
-          id = 2
-          actual = with_jsonapi_inflection :singular do
-            ResourceIdentifier.for_type_with_id('admin_users', id, {})
-          end
-          expected = { id: '2', type: 'admin-user' }
-          assert_equal actual, expected
-        end
-
-        def test_id_defined_on_serializer
-          actual = actual_resource_identifier_object(WithDefinedIdSerializer, @model)
-          expected = { id: 'special_id', type: expected_model_type(@model) }
-          assert_equal actual, expected
-        end
-
-        def test_id_defined_on_fragmented
-          actual = actual_resource_identifier_object(FragmentedSerializer, @model)
-          expected = { id: 'special_id', type: expected_model_type(@model) }
-          assert_equal actual, expected
-        end
-
-        private
-
-        def actual_resource_identifier_object(serializer_class, model)
-          serializer = serializer_class.new(model)
-          resource_identifier = ResourceIdentifier.new(serializer, nil)
-          resource_identifier.as_json
-        end
-
-        def expected_model_type(model, inflection = ActiveModelSerializers.config.jsonapi_resource_type)
-          with_jsonapi_inflection inflection do
-            model.class.model_name.send(inflection)
-          end
-        end
-
-        def expected_model_id(model)
-          model.id.to_s
-        end
-      end
-    end
-  end
-end

data/test/adapter/json_test.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class JsonTest < ActiveSupport::TestCase
-      def setup
-        ActionController::Base.cache_store.clear
-        @author = Author.new(id: 1, name: 'Steve K.')
-        @post = Post.new(id: 1, title: 'New Post', body: 'Body')
-        @first_comment = Comment.new(id: 1, body: 'ZOMG A COMMENT')
-        @second_comment = Comment.new(id: 2, body: 'ZOMG ANOTHER COMMENT')
-        @post.comments = [@first_comment, @second_comment]
-        @first_comment.post = @post
-        @second_comment.post = @post
-        @post.author = @author
-        @blog = Blog.new(id: 1, name: 'My Blog!!')
-        @post.blog = @blog
-
-        @serializer = PostSerializer.new(@post)
-        @adapter = ActiveModelSerializers::Adapter::Json.new(@serializer)
-      end
-
-      def test_has_many
-        assert_equal([
-                       { id: 1, body: 'ZOMG A COMMENT' },
-                       { id: 2, body: 'ZOMG ANOTHER COMMENT' }
-                     ], @adapter.serializable_hash[:post][:comments])
-      end
-
-      def test_custom_keys
-        serializer = PostWithCustomKeysSerializer.new(@post)
-        adapter = ActiveModelSerializers::Adapter::Json.new(serializer)
-
-        assert_equal({
-                       id: 1,
-                       reviews: [
-                         { id: 1, body: 'ZOMG A COMMENT' },
-                         { id: 2, body: 'ZOMG ANOTHER COMMENT' }
-                       ],
-                       writer: { id: 1, name: 'Steve K.' },
-                       site: { id: 1, name: 'My Blog!!' }
-                     }, adapter.serializable_hash[:post])
-      end
-    end
-  end
-end

data/test/adapter/null_test.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class NullTest < ActiveSupport::TestCase
-      def setup
-        profile = Profile.new(name: 'Name 1', description: 'Description 1', comments: 'Comments 1')
-        serializer = ProfileSerializer.new(profile)
-
-        @adapter = Null.new(serializer)
-      end
-
-      def test_serializable_hash
-        assert_equal({}, @adapter.serializable_hash)
-      end
-
-      def test_it_returns_empty_json
-        assert_equal('{}', @adapter.to_json)
-      end
-    end
-  end
-end

data/test/adapter/polymorphic_test.rb

@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    module Adapter
-      class PolymorphicTest < ActiveSupport::TestCase
-        setup do
-          @employee = Employee.new(id: 42, name: 'Zoop Zoopler', email: 'zoop@example.com')
-          @picture = @employee.pictures.new(id: 1, title: 'headshot-1.jpg')
-          @picture.imageable = @employee
-        end
-
-        def serialization(resource, adapter = :attributes)
-          serializable(resource, adapter: adapter, serializer: PolymorphicBelongsToSerializer).as_json
-        end
-
-        def tag_serialization(adapter = :attributes)
-          tag = PolyTag.new(id: 1, phrase: 'foo')
-          tag.object_tags << ObjectTag.new(id: 1, poly_tag_id: 1, taggable: @employee)
-          tag.object_tags << ObjectTag.new(id: 5, poly_tag_id: 1, taggable: @picture)
-          serializable(tag, adapter: adapter, serializer: PolymorphicTagSerializer, include: '*.*').as_json
-        end
-
-        def test_attributes_serialization
-          expected =
-            {
-              id: 1,
-              title: 'headshot-1.jpg',
-              imageable: {
-                type: 'employee',
-                employee: {
-                  id: 42,
-                  name: 'Zoop Zoopler'
-                }
-              }
-            }
-
-          assert_equal(expected, serialization(@picture))
-        end
-
-        def test_attributes_serialization_without_polymorphic_association
-          expected =
-            {
-              id: 2,
-              title: 'headshot-2.jpg',
-              imageable: nil
-            }
-
-          simple_picture = Picture.new(id: 2, title: 'headshot-2.jpg')
-          assert_equal(expected, serialization(simple_picture))
-        end
-
-        def test_attributes_serialization_with_polymorphic_has_many
-          expected =
-            {
-              id: 1,
-              phrase: 'foo',
-              object_tags: [
-                {
-                  id: 1,
-                  taggable: {
-                    type: 'employee',
-                    employee: {
-                      id: 42
-                    }
-                  }
-                },
-                {
-                  id: 5,
-                  taggable: {
-                    type: 'picture',
-                    picture: {
-                      id: 1
-                    }
-                  }
-                }
-              ]
-            }
-          assert_equal(expected, tag_serialization)
-        end
-
-        def test_json_serialization
-          expected =
-            {
-              picture: {
-                id: 1,
-                title: 'headshot-1.jpg',
-                imageable: {
-                  type: 'employee',
-                  employee: {
-                    id: 42,
-                    name: 'Zoop Zoopler'
-                  }
-                }
-              }
-            }
-
-          assert_equal(expected, serialization(@picture, :json))
-        end
-
-        def test_json_serialization_without_polymorphic_association
-          expected =
-            {
-              picture: {
-                id: 2,
-                title: 'headshot-2.jpg',
-                imageable: nil
-              }
-            }
-
-          simple_picture = Picture.new(id: 2, title: 'headshot-2.jpg')
-          assert_equal(expected, serialization(simple_picture, :json))
-        end
-
-        def test_json_serialization_with_polymorphic_has_many
-          expected =
-            {
-              poly_tag: {
-                id: 1,
-                phrase: 'foo',
-                object_tags: [
-                  {
-                    id: 1,
-                    taggable: {
-                      type: 'employee',
-                      employee: {
-                        id: 42
-                      }
-                    }
-                  },
-                  {
-                    id: 5,
-                    taggable: {
-                      type: 'picture',
-                      picture: {
-                        id: 1
-                      }
-                    }
-                  }
-                ]
-              }
-            }
-          assert_equal(expected, tag_serialization(:json))
-        end
-
-        def test_json_api_serialization
-          expected =
-            {
-              data: {
-                id: '1',
-                type: 'pictures',
-                attributes: {
-                  title: 'headshot-1.jpg'
-                },
-                relationships: {
-                  imageable: {
-                    data: {
-                      id: '42',
-                      type: 'employees'
-                    }
-                  }
-                }
-              }
-            }
-
-          assert_equal(expected, serialization(@picture, :json_api))
-        end
-
-        def test_json_api_serialization_with_polymorphic_belongs_to
-          expected = {
-            data: {
-              id: '1',
-              type: 'poly-tags',
-              attributes: { phrase: 'foo' },
-              relationships: {
-                :"object-tags" => {
-                  data: [
-                    { id: '1', type: 'object-tags' },
-                    { id: '5', type: 'object-tags' }
-                  ]
-                }
-              }
-            },
-            included: [
-              {
-                id: '1',
-                type: 'object-tags',
-                relationships: {
-                  taggable: {
-                    data: { id: '42', type: 'employees' }
-                  }
-                }
-              },
-              {
-                id: '42',
-                type: 'employees'
-              },
-              {
-                id: '5',
-                type: 'object-tags',
-                relationships: {
-                  taggable: {
-                    data: { id: '1', type: 'pictures' }
-                  }
-                }
-              },
-              {
-                id: '1',
-                type: 'pictures'
-              }
-            ]
-          }
-          assert_equal(expected, tag_serialization(:json_api))
-        end
-      end
-    end
-  end
-end