active_model_serializers 0.8.3 → 0.10.8

data/test/adapter/json_api/type_test.rb

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

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

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

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

data/test/adapter_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  class AdapterTest < ActiveSupport::TestCase
+    def setup
+      profile = Profile.new
+      @serializer = ProfileSerializer.new(profile)
+      @adapter = ActiveModelSerializers::Adapter::Base.new(@serializer)
+    end
+
+    def test_serializable_hash_is_abstract_method
+      assert_raises(NotImplementedError) do
+        @adapter.serializable_hash(only: [:name])
+      end
+    end
+
+    def test_serialization_options_ensures_option_is_a_hash
+      adapter = Class.new(ActiveModelSerializers::Adapter::Base) do
+        def serializable_hash(options = nil)
+          serialization_options(options)
+        end
+      end.new(@serializer)
+      assert_equal({}, adapter.serializable_hash(nil))
+      assert_equal({}, adapter.serializable_hash({}))
+    ensure
+      ActiveModelSerializers::Adapter.adapter_map.delete_if { |k, _| k =~ /class/ }
+    end
+
+    def test_serialization_options_ensures_option_is_one_of_valid_options
+      adapter = Class.new(ActiveModelSerializers::Adapter::Base) do
+        def serializable_hash(options = nil)
+          serialization_options(options)
+        end
+      end.new(@serializer)
+      filtered_options = { now: :see_me, then: :not }
+      valid_options = ActiveModel::Serializer::SERIALIZABLE_HASH_VALID_KEYS.each_with_object({}) do |option, result|
+        result[option] = option
+      end
+      assert_equal(valid_options, adapter.serializable_hash(filtered_options.merge(valid_options)))
+    ensure
+      ActiveModelSerializers::Adapter.adapter_map.delete_if { |k, _| k =~ /class/ }
+    end
+
+    def test_serializer
+      assert_equal @serializer, @adapter.serializer
+    end
+
+    def test_create_adapter
+      adapter = ActiveModelSerializers::Adapter.create(@serializer)
+      assert_equal ActiveModelSerializers::Adapter::Attributes, adapter.class
+    end
+
+    def test_create_adapter_with_override
+      adapter = ActiveModelSerializers::Adapter.create(@serializer, adapter: :json_api)
+      assert_equal ActiveModelSerializers::Adapter::JsonApi, adapter.class
+    end
+
+    def test_inflected_adapter_class_for_known_adapter
+      ActiveSupport::Inflector.inflections(:en) { |inflect| inflect.acronym 'API' }
+      klass = ActiveModelSerializers::Adapter.adapter_class(:json_api)
+
+      ActiveSupport::Inflector.inflections.acronyms.clear
+
+      assert_equal ActiveModelSerializers::Adapter::JsonApi, klass
+    end
+  end
+end

data/test/array_serializer_test.rb

@@ -1,75 +1,22 @@
-require "test_helper"
-require "test_fakes"
-
-class ArraySerializerTest < ActiveModel::TestCase
-
-  def test_array_items_do_not_have_root
-    array = [
-        BasicActiveModel.new(:name => "First model"),
-        BasicActiveModel.new(:name => "Second model")
-    ]
-    expected = { "root" => [
-        { :name => "First model" },
-        { :name => "Second model" }
-    ] }
-
-    default_serializer = array.active_model_serializer.new(array, :root => "root")
-    each_serializer = array.active_model_serializer.new(array, :root => "root", :each_serializer => BasicSerializer)
-
-    default_json = default_serializer.as_json
-    each_json = each_serializer.as_json
-
-    assert_equal(expected, default_json)
-    assert_equal(expected, each_json)
-  end
-
-  # serialize different typed objects
-  def test_array_serializer
-    model    = Model.new
-    user     = User.new
-    comments = Comment.new(:title => "Comment1", :id => 1)
-
-    array = [model, user, comments]
-    serializer = array.active_model_serializer.new(array, :scope => {:scope => true})
-    assert_equal([
-      { :model => "Model" },
-      { :last_name => "Valim", :ok => true, :first_name => "Jose", :scope => true },
-      { :title => "Comment1" }
-    ], serializer.as_json)
-  end
-
-  def test_array_serializer_with_root
-    comment1 = Comment.new(:title => "Comment1", :id => 1)
-    comment2 = Comment.new(:title => "Comment2", :id => 2)
-
-    array = [ comment1, comment2 ]
-
-    serializer = array.active_model_serializer.new(array, :root => :comments)
-
-    assert_equal({ :comments => [
-      { :title => "Comment1" },
-      { :title => "Comment2" }
-    ]}, serializer.as_json)
-  end
-
-  def test_array_serializer_with_hash
-    hash = {:value => "something"}
-    array = [hash]
-    serializer = array.active_model_serializer.new(array, :root => :items)
-    assert_equal({ :items => [ hash.as_json ]}, serializer.as_json)
-  end
-
-  def test_array_serializer_with_specified_seriailizer
-    post1 = Post.new(:title => "Post1", :author => "Author1", :id => 1)
-    post2 = Post.new(:title => "Post2", :author => "Author2", :id => 2)
-
-    array = [ post1, post2 ]
-
-    serializer = array.active_model_serializer.new array, :each_serializer => CustomPostSerializer
-
-    assert_equal([
-      { :title => "Post1" },
-      { :title => "Post2" }
-    ], serializer.as_json)
+require 'test_helper'
+require_relative 'collection_serializer_test'
+
+module ActiveModel
+  class Serializer
+    class ArraySerializerTest < CollectionSerializerTest
+      extend Minitest::Assertions
+      def self.run_one_method(*)
+        _, stderr = capture_io do
+          super
+        end
+        if stderr !~ /NOTE: ActiveModel::Serializer::ArraySerializer.new is deprecated/
+          fail Minitest::Assertion, stderr
+        end
+      end
+
+      def collection_serializer
+        ArraySerializer
+      end
+    end
   end
 end