active_model_serializers 0.9.9 → 0.10.14

data/test/unit/active_model/array_serializer/key_format_test.rb

@@ -1,18 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class ArraySerializer
-    class KeyFormatTest < Minitest::Test
-      def test_array_serializer_pass_options_to_items_serializers
-        array = [WebLog.new({ name: 'Name 1', display_name: 'Display Name 1'}),
-                 WebLog.new({ name: 'Name 2', display_name: 'Display Name 2'})]
-        serializer = ArraySerializer.new(array, key_format: :lower_camel)
-
-        expected = [{ name: 'Name 1', displayName: 'Display Name 1' },
-                    { name: 'Name 2', displayName: 'Display Name 2' }]
-
-        assert_equal expected, serializer.serializable_array
-      end
-    end
-  end
-end

data/test/unit/active_model/array_serializer/meta_test.rb

@@ -1,53 +0,0 @@
-require 'test_helper'
-require 'active_model/serializer'
-
-module ActiveModel
-  class ArraySerializer
-    class MetaTest < Minitest::Test
-      def setup
-        @profile1 = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
-        @profile2 = Profile.new({ name: 'Name 2', description: 'Description 2', comments: 'Comments 2' })
-        @serializer = ArraySerializer.new([@profile1, @profile2], root: 'profiles')
-      end
-
-      def test_meta
-        @serializer.meta = { total: 10 }
-
-        assert_equal({
-          'profiles' => [
-            {
-              name: 'Name 1',
-              description: 'Description 1'
-            }, {
-              name: 'Name 2',
-              description: 'Description 2'
-            }
-          ],
-          meta: {
-            total: 10
-          }
-        }, @serializer.as_json)
-      end
-
-      def test_meta_using_meta_key
-        @serializer.meta_key = :my_meta
-        @serializer.meta     = { total: 10 }
-
-        assert_equal({
-          'profiles' => [
-            {
-              name: 'Name 1',
-              description: 'Description 1'
-            }, {
-              name: 'Name 2',
-              description: 'Description 2'
-            }
-          ],
-          my_meta: {
-            total: 10
-          }
-        }, @serializer.as_json)
-      end
-    end
-  end
-end

data/test/unit/active_model/array_serializer/only_test.rb

@@ -1,18 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class ArraySerializer
-    class OnlyTest < Minitest::Test
-      def test_array_serializer_pass_only_to_items_serializers
-        array = [Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' }),
-                 Profile.new({ name: 'Name 2', description: 'Description 2', comments: 'Comments 2' })]
-        serializer = ArraySerializer.new(array, only: [:name])
-
-        expected = [{ name: 'Name 1' },
-                    { name: 'Name 2' }]
-
-        assert_equal expected, serializer.serializable_array
-      end
-    end
-  end
-end

data/test/unit/active_model/array_serializer/options_test.rb

@@ -1,16 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class ArraySerializer
-    class OptionsTest < Minitest::Test
-      def test_custom_options_are_accessible_from_serializer
-
-        array = [Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' }),
-                 Profile.new({ name: 'Name 2', description: 'Description 2', comments: 'Comments 2' })]
-        serializer = ArraySerializer.new(array, only: [:name], context: {foo: :bar})
-
-        assert_equal({foo: :bar}, serializer.context)
-      end
-    end
-  end
-end

data/test/unit/active_model/array_serializer/root_test.rb

@@ -1,102 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class ArraySerializer
-    class RootAsOptionTest < Minitest::Test
-      def setup
-        @old_root = ArraySerializer._root
-        @profile1 = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
-        @profile2 = Profile.new({ name: 'Name 2', description: 'Description 2', comments: 'Comments 2' })
-        @serializer = ArraySerializer.new([@profile1, @profile2], root: :initialize)
-      end
-
-      def teardown
-        ArraySerializer._root = @old_root
-      end
-
-      def test_root_is_not_displayed_using_serializable_array
-        assert_equal([
-          { name: 'Name 1', description: 'Description 1' },
-          { name: 'Name 2', description: 'Description 2' }
-        ], @serializer.serializable_array)
-      end
-
-      def test_root_using_as_json
-        assert_equal({
-          initialize: [
-            { name: 'Name 1', description: 'Description 1' },
-            { name: 'Name 2', description: 'Description 2' }
-          ]
-        }, @serializer.as_json)
-      end
-
-      def test_root_as_argument_takes_precedence
-        assert_equal({
-          argument: [
-            { name: 'Name 1', description: 'Description 1' },
-            { name: 'Name 2', description: 'Description 2' }
-          ]
-        }, @serializer.as_json(root: :argument))
-      end
-
-      def test_using_false_root_in_initialize_takes_precedence
-        ArraySerializer._root = 'root'
-        @serializer = ArraySerializer.new([@profile1, @profile2], root: false)
-
-        assert_equal([
-          { name: 'Name 1', description: 'Description 1' },
-          { name: 'Name 2', description: 'Description 2' }
-        ], @serializer.as_json)
-      end
-    end
-
-    class RootInSerializerTest < Minitest::Test
-      def setup
-        @old_root = ArraySerializer._root
-        ArraySerializer._root = :in_serializer
-        @profile1 = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
-        @profile2 = Profile.new({ name: 'Name 2', description: 'Description 2', comments: 'Comments 2' })
-        @serializer = ArraySerializer.new([@profile1, @profile2])
-        @rooted_serializer = ArraySerializer.new([@profile1, @profile2], root: :initialize)
-      end
-
-      def teardown
-        ArraySerializer._root = @old_root
-      end
-
-      def test_root_is_not_displayed_using_serializable_hash
-        assert_equal([
-          { name: 'Name 1', description: 'Description 1' },
-          { name: 'Name 2', description: 'Description 2' }
-        ], @serializer.serializable_array)
-      end
-
-      def test_root_using_as_json
-        assert_equal({
-          in_serializer: [
-            { name: 'Name 1', description: 'Description 1' },
-            { name: 'Name 2', description: 'Description 2' }
-          ]
-        }, @serializer.as_json)
-      end
-
-      def test_root_in_initializer_takes_precedence
-        assert_equal({
-          initialize: [
-            { name: 'Name 1', description: 'Description 1' },
-            { name: 'Name 2', description: 'Description 2' }
-          ]
-        }, @rooted_serializer.as_json)
-      end
-
-      def test_root_as_argument_takes_precedence
-        assert_equal({
-          argument: [
-            { name: 'Name 1', description: 'Description 1' },
-            { name: 'Name 2', description: 'Description 2' }
-          ]
-        }, @rooted_serializer.as_json(root: :argument))
-      end
-    end
-  end
-end

data/test/unit/active_model/array_serializer/scope_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class ArraySerializer
-    class ScopeTest < Minitest::Test
-      def test_array_serializer_pass_options_to_items_serializers
-        array = [Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' }),
-                 Profile.new({ name: 'Name 2', description: 'Description 2', comments: 'Comments 2' })]
-        serializer = ArraySerializer.new(array, scope: current_user)
-
-        expected = [{ name: 'Name 1', description: 'Description 1 - user' },
-                    { name: 'Name 2', description: 'Description 2 - user' }]
-
-        assert_equal expected, serializer.serializable_array
-      end
-
-      private
-
-      def current_user
-        'user'
-      end
-    end
-  end
-end

data/test/unit/active_model/array_serializer/serialization_test.rb

@@ -1,239 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class ArraySerializer
-    class BasicObjectsSerializationTest < Minitest::Test
-      def setup
-        array = [1, 2, 3]
-        @serializer = Serializer.serializer_for(array).new(array)
-      end
-
-      def test_serializer_for_array_returns_appropriate_type
-        assert_kind_of ActiveModel::ArraySerializer, @serializer
-      end
-
-      def test_array_serializer_serializes_simple_objects
-        assert_equal [1, 2, 3], @serializer.serializable_array
-        assert_equal [1, 2, 3], @serializer.as_json
-      end
-    end
-
-    class CustomArraySerializerSupport < Minitest::Test
-      def setup
-        Object.const_set(:ArraySerializer, Class.new)
-
-        array = [1, 2, 3]
-        @serializer_class = Serializer.serializer_for(array)
-      end
-
-      def teardown
-        Object.send(:remove_const, :ArraySerializer)
-      end
-
-      def test_serializer_for_array_returns_appropriate_type
-        assert_equal ::ArraySerializer, @serializer_class
-      end
-    end
-
-    class CustomSerializerClassTest < Minitest::Test
-      def setup
-        Object.const_set(:CustomSerializer, Class.new)
-      end
-
-      def teardown
-        Object.send(:remove_const, :CustomSerializer)
-      end
-
-      def test_serializer_for_array_returns_appropriate_type
-        object = {}
-        def object.serializer_class; CustomSerializer; end
-
-        assert_equal CustomSerializer, Serializer.serializer_for(object)
-        assert_equal CustomSerializer, Serializer.serializer_for('Custom')
-      end
-    end
-
-    class ModelSerializationNamespaceTest < Minitest::Test
-      def test_namespace
-        test1 = TestNamespace2::Test.new(name: 'Test 1', email: 'test1@test.com', gender: 'M')
-        test2 = TestNamespace2::Test.new(name: 'Test 2', email: 'test2@test.com', gender: 'M')
-        sub_test1 = TestNamespace2::SubTest.new(name: 'Name 1', description: 'Description 1', comments: 'Comments 1')
-        sub_test2 = TestNamespace2::SubTest.new(name: 'Name 2', description: 'Description 2', comments: 'Comments 2')
-        test1.sub_test = sub_test1
-        test2.sub_test = sub_test2
-
-        array = [test1, test2]
-        serializer = ArraySerializer.new(array)
-
-        expected = [
-          { name: 'Test 1', email: 'test1@test.com', sub_test: { name: 'Name 1', description: 'Description 1' }},
-          { name: 'Test 1', email: 'test2@test.com', sub_test: { name: 'Name 2', description: 'Description 2' }}
-        ]
-
-        assert_equal expected, serializer.serializable_array
-        assert_equal expected, serializer.as_json
-      end
-    end
-
-    class ModelSerializationTest < Minitest::Test
-      def test_array_serializer_serializes_models
-        array = [Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' }),
-                 Profile.new({ name: 'Name 2', description: 'Description 2', comments: 'Comments 2' })]
-        serializer = ArraySerializer.new(array)
-
-        expected = [{ name: 'Name 1', description: 'Description 1' },
-                    { name: 'Name 2', description: 'Description 2' }]
-
-        assert_equal expected, serializer.serializable_array
-        assert_equal expected, serializer.as_json
-      end
-
-      def test_array_serializers_each_serializer
-        array = [::Model.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' }),
-                 ::Model.new({ name: 'Name 2', description: 'Description 2', comments: 'Comments 2' })]
-        serializer = ArraySerializer.new(array, each_serializer: ProfileSerializer)
-
-        expected = [{ name: 'Name 1', description: 'Description 1' },
-                    { name: 'Name 2', description: 'Description 2' }]
-
-        assert_equal expected, serializer.serializable_array
-        assert_equal expected, serializer.as_json
-      end
-
-      def test_associated_objects_of_multiple_instances_embedded_in_root
-        @association = PostSerializer._associations[:comments]
-        @old_association = @association.dup
-
-        @association.embed = :ids
-        @association.embed_in_root = true
-
-        @post1 = Post.new({ title: 'Title 1', body: 'Body 1', date: '1/1/2000' })
-        @post2 = Post.new({ title: 'Title 2', body: 'Body 2', date: '1/1/2000' })
-
-        class << @post2
-          attr_writer :comments
-        end
-
-        @post2.comments = [
-          Comment.new(content: 'C3'),
-          Comment.new(content: 'C4')
-        ]
-
-        @serializer = ArraySerializer.new([@post1, @post2], root: :posts)
-        assert_equal({
-            posts: [
-              {title: "Title 1", body: "Body 1", "comment_ids" => @post1.comments.map(&:object_id) },
-              {title: "Title 2", body: "Body 2", "comment_ids" => @post2.comments.map(&:object_id) }
-            ],
-            'comments' => [
-              {content: "C1"},
-              {content: "C2"},
-              {content: "C3"},
-              {content: "C4"}
-            ]
-          }, @serializer.as_json)
-      ensure
-        PostSerializer._associations[:comments] = @old_association
-      end
-
-      def test_embed_object_for_has_one_association_with_nil_value
-        @association = UserSerializer._associations[:profile]
-        @old_association = @association.dup
-
-        @association.embed = :objects
-
-        @user1 = User.new({ name: 'User 1', email: 'email1@server.com' })
-        @user2 = User.new({ name: 'User 2', email: 'email2@server.com' })
-
-        class << @user1
-          def profile
-            nil
-          end
-        end
-
-        class << @user2
-          def profile
-            @profile ||= Profile.new(name: 'Name 1', description: 'Desc 1')
-          end
-        end
-
-        @serializer = ArraySerializer.new([@user1, @user2]) #, root: :posts)
-        assert_equal([
-          { name: "User 1", email: "email1@server.com", profile: nil },
-          { name: "User 2", email: "email2@server.com", profile: { name: 'Name 1', description: 'Desc 1' } }
-        ], @serializer.as_json)
-      ensure
-        UserSerializer._associations[:profile] = @old_association
-      end
-
-      def test_embed_object_in_root_for_has_one_association_with_nil_value
-        @association = UserSerializer._associations[:profile]
-        @old_association = @association.dup
-
-        @association.embed = :ids
-        @association.embed_in_root = true
-
-        @user1 = User.new({ name: 'User 1', email: 'email1@server.com' })
-        @user2 = User.new({ name: 'User 2', email: 'email2@server.com' })
-
-        class << @user1
-          def profile
-            nil
-          end
-        end
-
-        class << @user2
-          def profile
-            @profile ||= Profile.new(name: 'Name 1', description: 'Desc 1')
-          end
-        end
-
-        @serializer = ArraySerializer.new([@user1, @user2], root: :users)
-        assert_equal({
-            users: [
-              { name: "User 1", email: "email1@server.com", 'profile_id' => nil },
-              { name: "User 2", email: "email2@server.com", 'profile_id' => @user2.profile.object_id }
-            ],
-            'profiles' => [
-              { name: 'Name 1', description: 'Desc 1' }
-            ]
-          }, @serializer.as_json)
-      ensure
-        UserSerializer._associations[:profile] = @old_association
-      end
-
-      def test_embed_object_in_root_for_has_one_association_with_all_nil_values
-        @association = UserSerializer._associations[:profile]
-        @old_association = @association.dup
-
-        @association.embed = :ids
-        @association.embed_in_root = true
-
-        @user1 = User.new({ name: 'User 1', email: 'email1@server.com' })
-        @user2 = User.new({ name: 'User 2', email: 'email2@server.com' })
-
-        class << @user1
-          def profile
-            nil
-          end
-        end
-
-        class << @user2
-          def profile
-            nil
-          end
-        end
-
-        @serializer = ArraySerializer.new([@user1, @user2], root: :users)
-        assert_equal({
-            users: [
-              { name: "User 1", email: "email1@server.com", 'profile_id' => nil },
-              { name: "User 2", email: "email2@server.com", 'profile_id' => nil }
-            ]
-          }, @serializer.as_json)
-      ensure
-        UserSerializer._associations[:profile] = @old_association
-      end
-    end
-  end
-end

data/test/unit/active_model/default_serializer_test.rb

@@ -1,13 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class DefaultSerializer
-    class Test < Minitest::Test
-      def test_serialize_objects
-        assert_equal(nil, DefaultSerializer.new(nil).serializable_object)
-        assert_equal(1, DefaultSerializer.new(1).serializable_object)
-        assert_equal('hi', DefaultSerializer.new('hi').serializable_object)
-      end
-    end
-  end
-end

data/test/unit/active_model/serializer/associations/build_serializer_test.rb

@@ -1,36 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class Association
-      class BuildSerializerTest < Minitest::Test
-        def setup
-          @association = Association::HasOne.new('post', serializer: PostSerializer)
-          @post = Post.new({ title: 'Title 1', body: 'Body 1', date: '1/1/2000' })
-          @user = User.new
-        end
-
-        def test_build_serializer_for_array_called_twice
-          2.times do
-            serializer = @association.build_serializer(@post)
-            assert_instance_of(PostSerializer, serializer)
-          end
-        end
-
-        def test_build_serializer_from_in_a_namespace
-          assoc      = Association::HasOne.new('profile')
-          serializer = TestNamespace::UserSerializer.new(@user).build_serializer(assoc)
-
-          assert_instance_of(TestNamespace::ProfileSerializer, serializer)
-        end
-
-        def test_build_serializer_with_prefix
-          assoc      = Association::HasOne.new('profile', prefix: :short)
-          serializer = UserSerializer.new(@user).build_serializer(assoc)
-
-          assert_instance_of(ShortProfileSerializer, serializer)
-        end
-      end
-    end
-  end
-end

data/test/unit/active_model/serializer/associations_test.rb

@@ -1,49 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class AssociationsTest < Minitest::Test
-      def test_associations_inheritance
-        inherited_serializer_klass = Class.new(PostSerializer) do
-          has_many :users
-        end
-        another_inherited_serializer_klass = Class.new(PostSerializer)
-
-        assert_equal([:comments, :users],
-                     inherited_serializer_klass._associations.keys)
-        assert_equal([:comments],
-                     another_inherited_serializer_klass._associations.keys)
-      end
-      def test_multiple_nested_associations
-        parent = SelfReferencingUserParent.new(name: "The Parent")
-        child = SelfReferencingUser.new(name: "The child", parent: parent)
-        self_referencing_user_serializer = SelfReferencingUserSerializer.new(child)
-        result = self_referencing_user_serializer.as_json
-        expected_result = {
-          "self_referencing_user"=>{
-            :name=>"The child",
-            "type_id"=>child.type.object_id,
-            "parent_id"=>child.parent.object_id
-
-          },
-          "types"=>[
-            {
-              :name=>"N1",
-            },
-            {
-              :name=>"N2",
-            }
-          ],
-          "parents"=>[
-            {
-              :name=>"N1",
-              "type_id"=>child.parent.type.object_id,
-              "parent_id"=>nil
-            }
-          ]
-        }
-        assert_equal(expected_result, result)
-      end
-    end
-  end
-end

data/test/unit/active_model/serializer/attributes_test.rb

@@ -1,57 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class AttributesTest < Minitest::Test
-      def setup
-        @profile = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
-        @profile_serializer = ProfileSerializer.new(@profile)
-      end
-
-      def test_attributes_definition
-        assert_equal([:name, :description],
-                     @profile_serializer.class._attributes)
-      end
-
-      def test_attributes_serialization_using_serializable_hash
-        assert_equal({
-          name: 'Name 1', description: 'Description 1'
-        }, @profile_serializer.serializable_hash)
-      end
-
-      def test_attributes_serialization_using_as_json
-        assert_equal({
-          'profile' => { name: 'Name 1', description: 'Description 1' }
-        }, @profile_serializer.as_json)
-      end
-
-      def test_attributes_inheritance
-        inherited_serializer_klass = Class.new(ProfileSerializer) do
-          attributes :comments
-        end
-        another_inherited_serializer_klass = Class.new(ProfileSerializer)
-
-        assert_equal([:name, :description, :comments],
-                     inherited_serializer_klass._attributes)
-        assert_equal([:name, :description],
-                     another_inherited_serializer_klass._attributes)
-      end
-
-      def tests_query_attributes_strip_question_mark
-        model = Class.new(::Model) do
-          def strip?
-            true
-          end
-        end
-
-        serializer = Class.new(ActiveModel::Serializer) do
-          attributes :strip?
-        end
-
-        actual = serializer.new(model.new).as_json
-
-        assert_equal({ strip: true }, actual)
-      end
-    end
-  end
-end