active_model_serializers 0.8.3 → 0.9.4

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

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

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

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

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

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

@@ -0,0 +1,216 @@
+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)
+      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

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

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

@@ -0,0 +1,19 @@
+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
+    end
+  end
+end

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

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

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

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class Config
+      class Test < Minitest::Test
+        def test_config_const_is_an_instance_of_config
+          assert_kind_of Config, CONFIG
+        end
+
+        def test_config_instance
+          config = Config.new
+          config.setting1 = 'value1'
+
+          assert_equal 'value1', config.setting1
+        end
+
+        def test_each_config
+          config = Config.new
+          config.setting1 = 'value1'
+          config.setting2 = 'value2'
+
+          actual = {}
+
+          config.each do |k, v|
+            actual[k] = v
+          end
+
+          assert_equal({ 'setting1' => 'value1', 'setting2' => 'value2' }, actual)
+        end
+      end
+
+      class ConfigTest < Minitest::Test
+        def test_setup
+          Serializer.setup do |config|
+            config.a = 'v1'
+            config.b = 'v2'
+          end
+
+          assert_equal 'v1', CONFIG.a
+          assert_equal 'v2', CONFIG.b
+        ensure
+          CONFIG.clear
+        end
+
+        def test_config_accessors
+          Serializer.setup do |config|
+            config.foo = 'v1'
+            config.bar = 'v2'
+          end
+
+          assert_equal 'v1', CONFIG.foo
+          assert_equal 'v2', CONFIG.bar
+        ensure
+          CONFIG.clear
+        end
+
+        def test_acessor_when_nil
+          assert_nil CONFIG.foo
+          CONFIG.foo = 1
+          assert_equal 1, CONFIG.foo
+          assert_nil CONFIG.bar
+        end
+      end
+
+      class ApplyConfigTest < Minitest::Test
+        def test_apply_config_to_associations
+          CONFIG.embed     = :ids
+          CONFIG.embed_in_root = true
+          CONFIG.key_format = :lower_camel
+
+          association = PostSerializer._associations[:comments]
+          old_association = association.dup
+
+          association.send :initialize, association.name, association.options
+
+          assert association.embed_ids?
+          assert !association.embed_objects?
+          assert association.embed_in_root
+          assert_equal :lower_camel, association.key_format
+          assert_equal 'post', PostSerializer.root_name
+          CONFIG.plural_default_root = true
+          assert_equal 'posts', PostSerializer.root_name
+        ensure
+          PostSerializer._associations[:comments] = old_association
+          CONFIG.clear
+        end
+      end
+    end
+  end
+end