agi_active_model_serializers 0.10.7

data/test/adapter/json_api/resource_identifier_test.rb

@@ -0,0 +1,110 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class ResourceIdentifierTest < ActiveSupport::TestCase
+        class WithDefinedTypeSerializer < ActiveModel::Serializer
+          type 'with_defined_type'
+        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
+          test_type(WithDefinedTypeSerializer, 'with-defined-type')
+        end
+
+        def test_singular_type
+          test_type_inflection(AuthorSerializer, 'author', :singular)
+        end
+
+        def test_plural_type
+          test_type_inflection(AuthorSerializer, 'authors', :plural)
+        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
+          test_id(AuthorSerializer, @model.id.to_s)
+        end
+
+        def test_id_defined_on_serializer
+          test_id(WithDefinedIdSerializer, 'special_id')
+        end
+
+        def test_id_defined_on_fragmented
+          test_id(FragmentedSerializer, 'special_id')
+        end
+
+        private
+
+        def test_type_inflection(serializer_class, expected_type, inflection)
+          original_inflection = ActiveModelSerializers.config.jsonapi_resource_type
+          ActiveModelSerializers.config.jsonapi_resource_type = inflection
+          test_type(serializer_class, expected_type)
+        ensure
+          ActiveModelSerializers.config.jsonapi_resource_type = original_inflection
+        end
+
+        def test_type(serializer_class, expected_type)
+          serializer = serializer_class.new(@model)
+          resource_identifier = ResourceIdentifier.new(serializer, nil)
+          expected = {
+            id: @model.id.to_s,
+            type: expected_type
+          }
+
+          assert_equal(expected, resource_identifier.as_json)
+        end
+
+        def test_id(serializer_class, id)
+          serializer = serializer_class.new(@model)
+          resource_identifier = ResourceIdentifier.new(serializer, nil)
+          inflection = ActiveModelSerializers.config.jsonapi_resource_type
+          type = @model.class.model_name.send(inflection)
+          expected = {
+            id: id,
+            type: type
+          }
+
+          assert_equal(expected, resource_identifier.as_json)
+        end
+      end
+    end
+  end
+end

data/test/adapter/json_api/resource_meta_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        class ResourceMetaTest < Minitest::Test
+          class MetaHashPostSerializer < ActiveModel::Serializer
+            attributes :id
+            meta stuff: 'value'
+          end
+
+          class MetaBlockPostSerializer < ActiveModel::Serializer
+            attributes :id
+            meta do
+              { comments_count: object.comments.count }
+            end
+          end
+
+          class MetaBlockPostBlankMetaSerializer < ActiveModel::Serializer
+            attributes :id
+            meta do
+              {}
+            end
+          end
+
+          class MetaBlockPostEmptyStringSerializer < ActiveModel::Serializer
+            attributes :id
+            meta do
+              ''
+            end
+          end
+
+          def setup
+            @post = Post.new(id: 1337, comments: [], author: nil)
+          end
+
+          def test_meta_hash_object_resource
+            hash = ActiveModelSerializers::SerializableResource.new(
+              @post,
+              serializer: MetaHashPostSerializer,
+              adapter: :json_api
+            ).serializable_hash
+            expected = {
+              stuff: 'value'
+            }
+            assert_equal(expected, hash[:data][:meta])
+          end
+
+          def test_meta_block_object_resource
+            hash = ActiveModelSerializers::SerializableResource.new(
+              @post,
+              serializer: MetaBlockPostSerializer,
+              adapter: :json_api
+            ).serializable_hash
+            expected = {
+              :"comments-count" => @post.comments.count
+            }
+            assert_equal(expected, hash[:data][:meta])
+          end
+
+          def test_meta_object_resource_in_array
+            post2 = Post.new(id: 1339, comments: [Comment.new])
+            posts = [@post, post2]
+            hash = ActiveModelSerializers::SerializableResource.new(
+              posts,
+              each_serializer: MetaBlockPostSerializer,
+              adapter: :json_api
+            ).serializable_hash
+            expected = {
+              data: [
+                { id: '1337', type: 'posts', meta: { :"comments-count" => 0 } },
+                { id: '1339', type: 'posts', meta: { :"comments-count" => 1 } }
+              ]
+            }
+            assert_equal(expected, hash)
+          end
+
+          def test_meta_object_blank_omitted
+            hash = ActiveModelSerializers::SerializableResource.new(
+              @post,
+              serializer: MetaBlockPostBlankMetaSerializer,
+              adapter: :json_api
+            ).serializable_hash
+            refute hash[:data].key? :meta
+          end
+
+          def test_meta_object_empty_string_omitted
+            hash = ActiveModelSerializers::SerializableResource.new(
+              @post,
+              serializer: MetaBlockPostEmptyStringSerializer,
+              adapter: :json_api
+            ).serializable_hash
+            refute hash[:data].key? :meta
+          end
+        end
+      end
+    end
+  end
+end

data/test/adapter/json_api/toplevel_jsonapi_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class TopLevelJsonApiTest < ActiveSupport::TestCase
+        def setup
+          @author = Author.new(id: 1, name: 'Steve K.')
+          @author.bio = nil
+          @author.roles = []
+          @blog = Blog.new(id: 23, name: 'AMS Blog')
+          @post = Post.new(id: 42, title: 'New Post', body: 'Body')
+          @anonymous_post = Post.new(id: 43, title: 'Hello!!', body: 'Hello, world!!')
+          @comment = Comment.new(id: 1, body: 'ZOMG A COMMENT')
+          @post.comments = [@comment]
+          @post.blog = @blog
+          @anonymous_post.comments = []
+          @anonymous_post.blog = nil
+          @comment.post = @post
+          @comment.author = nil
+          @post.author = @author
+          @anonymous_post.author = nil
+          @blog = Blog.new(id: 1, name: 'My Blog!!')
+          @blog.writer = @author
+          @blog.articles = [@post, @anonymous_post]
+          @author.posts = []
+        end
+
+        def test_toplevel_jsonapi_defaults_to_false
+          assert_equal config.fetch(:jsonapi_include_toplevel_object), false
+        end
+
+        def test_disable_toplevel_jsonapi
+          with_config(jsonapi_include_toplevel_object: false) do
+            hash = serialize(@post)
+            assert_nil(hash[:jsonapi])
+          end
+        end
+
+        def test_enable_toplevel_jsonapi
+          with_config(jsonapi_include_toplevel_object: true) do
+            hash = serialize(@post)
+            refute_nil(hash[:jsonapi])
+          end
+        end
+
+        def test_default_toplevel_jsonapi_version
+          with_config(jsonapi_include_toplevel_object: true) do
+            hash = serialize(@post)
+            assert_equal('1.0', hash[:jsonapi][:version])
+          end
+        end
+
+        def test_toplevel_jsonapi_no_meta
+          with_config(jsonapi_include_toplevel_object: true) do
+            hash = serialize(@post)
+            assert_nil(hash[:jsonapi][:meta])
+          end
+        end
+
+        def test_toplevel_jsonapi_meta
+          new_config = {
+            jsonapi_include_toplevel_object: true,
+            jsonapi_toplevel_meta: {
+              'copyright' => 'Copyright 2015 Example Corp.'
+            }
+          }
+          with_config(new_config) do
+            hash = serialize(@post)
+            assert_equal(new_config[:jsonapi_toplevel_meta], hash.fetch(:jsonapi).fetch(:meta))
+          end
+        end
+
+        private
+
+        def serialize(resource, options = {})
+          serializable(resource, { adapter: :json_api }.merge!(options)).serializable_hash
+        end
+      end
+    end
+  end
+end

data/test/adapter/json_api/transform_test.rb

@@ -0,0 +1,512 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class KeyCaseTest < ActiveSupport::TestCase
+        class Post < ::Model
+          attributes :title, :body, :publish_at
+          associations :author, :comments
+        end
+        class Author < ::Model
+          attributes :first_name, :last_name
+        end
+        class Comment < ::Model
+          attributes :body
+          associations :author, :post
+        end
+
+        class PostSerializer < ActiveModel::Serializer
+          type 'posts'
+          attributes :title, :body, :publish_at
+          belongs_to :author
+          has_many :comments
+
+          link(:self) { post_url(object.id) }
+          link(:post_authors) { post_authors_url(object.id) }
+          link(:subscriber_comments) { post_comments_url(object.id) }
+
+          meta do
+            {
+              rating: 5,
+              favorite_count: 10
+            }
+          end
+        end
+
+        class AuthorSerializer < ActiveModel::Serializer
+          type 'authors'
+          attributes :first_name, :last_name
+        end
+
+        class CommentSerializer < ActiveModel::Serializer
+          type 'comments'
+          attributes :body
+          belongs_to :author
+        end
+
+        def mock_request(transform = nil)
+          context = Minitest::Mock.new
+          context.expect(:request_url, URI)
+          context.expect(:query_parameters, {})
+          context.expect(:url_helpers, Rails.application.routes.url_helpers)
+          @options = {}
+          @options[:key_transform] = transform if transform
+          @options[:serialization_context] = context
+        end
+
+        def setup
+          Rails.application.routes.draw do
+            resources :posts do
+              resources :authors
+              resources :comments
+            end
+          end
+          @publish_at = 1.day.from_now
+          @author = Author.new(id: 1, first_name: 'Bob', last_name: 'Jones')
+          @comment1 = Comment.new(id: 7, body: 'cool', author: @author)
+          @comment2 = Comment.new(id: 12, body: 'awesome', author: @author)
+          @post = Post.new(id: 1337, title: 'Title 1', body: 'Body 1',
+                           author: @author, comments: [@comment1, @comment2],
+                           publish_at: @publish_at)
+          @comment1.post = @post
+          @comment2.post = @post
+        end
+
+        def test_success_document_transform_default
+          mock_request
+          serializer = PostSerializer.new(@post)
+          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+          result = adapter.serializable_hash
+          assert_equal({
+                         data: {
+                           id: '1337',
+                           type: 'posts',
+                           attributes: {
+                             title: 'Title 1',
+                             body: 'Body 1',
+                             :"publish-at" => @publish_at
+                           },
+                           relationships: {
+                             author: {
+                               data: { id: '1', type: 'authors' }
+                             },
+                             comments: {
+                               data: [
+                                 { id: '7', type: 'comments' },
+                                 { id: '12', type: 'comments' }
+                               ]
+                             }
+                           },
+                           links: {
+                             self: 'http://example.com/posts/1337',
+                             :"post-authors" => 'http://example.com/posts/1337/authors',
+                             :"subscriber-comments" => 'http://example.com/posts/1337/comments'
+                           },
+                           meta: { rating: 5, :"favorite-count" => 10 }
+                         }
+                       }, result)
+        end
+
+        def test_success_document_transform_global_config
+          mock_request
+          result = with_config(key_transform: :camel_lower) do
+            serializer = PostSerializer.new(@post)
+            adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+            adapter.serializable_hash
+          end
+          assert_equal({
+                         data: {
+                           id: '1337',
+                           type: 'posts',
+                           attributes: {
+                             title: 'Title 1',
+                             body: 'Body 1',
+                             publishAt: @publish_at
+                           },
+                           relationships: {
+                             author: {
+                               data: { id: '1', type: 'authors' }
+                             },
+                             comments: {
+                               data: [
+                                 { id: '7', type: 'comments' },
+                                 { id: '12', type: 'comments' }
+                               ]
+                             }
+                           },
+                           links: {
+                             self: 'http://example.com/posts/1337',
+                             postAuthors: 'http://example.com/posts/1337/authors',
+                             subscriberComments: 'http://example.com/posts/1337/comments'
+                           },
+                           meta: { rating: 5, favoriteCount: 10 }
+                         }
+                       }, result)
+        end
+
+        def test_success_doc_transform_serialization_ctx_overrides_global
+          mock_request(:camel)
+          result = with_config(key_transform: :camel_lower) do
+            serializer = PostSerializer.new(@post)
+            adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+            adapter.serializable_hash
+          end
+          assert_equal({
+                         Data: {
+                           Id: '1337',
+                           Type: 'Posts',
+                           Attributes: {
+                             Title: 'Title 1',
+                             Body: 'Body 1',
+                             PublishAt: @publish_at
+                           },
+                           Relationships: {
+                             Author: {
+                               Data: { Id: '1', Type: 'Authors' }
+                             },
+                             Comments: {
+                               Data: [
+                                 { Id: '7', Type: 'Comments' },
+                                 { Id: '12', Type: 'Comments' }
+                               ]
+                             }
+                           },
+                           Links: {
+                             Self: 'http://example.com/posts/1337',
+                             PostAuthors: 'http://example.com/posts/1337/authors',
+                             SubscriberComments: 'http://example.com/posts/1337/comments'
+                           },
+                           Meta: { Rating: 5, FavoriteCount: 10 }
+                         }
+                       }, result)
+        end
+
+        def test_success_document_transform_dash
+          mock_request(:dash)
+          serializer = PostSerializer.new(@post)
+          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+          result = adapter.serializable_hash
+          assert_equal({
+                         data: {
+                           id: '1337',
+                           type: 'posts',
+                           attributes: {
+                             title: 'Title 1',
+                             body: 'Body 1',
+                             :"publish-at" => @publish_at
+                           },
+                           relationships: {
+                             author: {
+                               data: { id: '1', type: 'authors' }
+                             },
+                             comments: {
+                               data: [
+                                 { id: '7', type: 'comments' },
+                                 { id: '12', type: 'comments' }
+                               ]
+                             }
+                           },
+                           links: {
+                             self: 'http://example.com/posts/1337',
+                             :"post-authors" => 'http://example.com/posts/1337/authors',
+                             :"subscriber-comments" => 'http://example.com/posts/1337/comments'
+                           },
+                           meta: { rating: 5, :"favorite-count" => 10 }
+                         }
+                       }, result)
+        end
+
+        def test_success_document_transform_unaltered
+          mock_request(:unaltered)
+          serializer = PostSerializer.new(@post)
+          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+          result = adapter.serializable_hash
+          assert_equal({
+                         data: {
+                           id: '1337',
+                           type: 'posts',
+                           attributes: {
+                             title: 'Title 1',
+                             body: 'Body 1',
+                             publish_at: @publish_at
+                           },
+                           relationships: {
+                             author: {
+                               data: { id: '1', type: 'authors' }
+                             },
+                             comments: {
+                               data: [
+                                 { id: '7', type: 'comments' },
+                                 { id: '12', type: 'comments' }
+                               ]
+                             }
+                           },
+                           links: {
+                             self: 'http://example.com/posts/1337',
+                             post_authors: 'http://example.com/posts/1337/authors',
+                             subscriber_comments: 'http://example.com/posts/1337/comments'
+                           },
+                           meta: { rating: 5, favorite_count: 10 }
+                         }
+                       }, result)
+        end
+
+        def test_success_document_transform_undefined
+          mock_request(:zoot)
+          serializer = PostSerializer.new(@post)
+          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+          exception = assert_raises NoMethodError do
+            adapter.serializable_hash
+          end
+          assert_match(/undefined method.*zoot/, exception.message)
+        end
+
+        def test_success_document_transform_camel
+          mock_request(:camel)
+          serializer = PostSerializer.new(@post)
+          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+          result = adapter.serializable_hash
+          assert_equal({
+                         Data: {
+                           Id: '1337',
+                           Type: 'Posts',
+                           Attributes: {
+                             Title: 'Title 1',
+                             Body: 'Body 1',
+                             PublishAt: @publish_at
+                           },
+                           Relationships: {
+                             Author: {
+                               Data: { Id: '1', Type: 'Authors' }
+                             },
+                             Comments: {
+                               Data: [
+                                 { Id: '7', Type: 'Comments' },
+                                 { Id: '12', Type: 'Comments' }
+                               ]
+                             }
+                           },
+                           Links: {
+                             Self: 'http://example.com/posts/1337',
+                             PostAuthors: 'http://example.com/posts/1337/authors',
+                             SubscriberComments: 'http://example.com/posts/1337/comments'
+                           },
+                           Meta: { Rating: 5, FavoriteCount: 10 }
+                         }
+                       }, result)
+        end
+
+        def test_success_document_transform_camel_lower
+          mock_request(:camel_lower)
+          serializer = PostSerializer.new(@post)
+          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+          result = adapter.serializable_hash
+          assert_equal({
+                         data: {
+                           id: '1337',
+                           type: 'posts',
+                           attributes: {
+                             title: 'Title 1',
+                             body: 'Body 1',
+                             publishAt: @publish_at
+                           },
+                           relationships: {
+                             author: {
+                               data: { id: '1', type: 'authors' }
+                             },
+                             comments: {
+                               data: [
+                                 { id: '7', type: 'comments' },
+                                 { id: '12', type: 'comments' }
+                               ]
+                             }
+                           },
+                           links: {
+                             self: 'http://example.com/posts/1337',
+                             postAuthors: 'http://example.com/posts/1337/authors',
+                             subscriberComments: 'http://example.com/posts/1337/comments'
+                           },
+                           meta: { rating: 5, favoriteCount: 10 }
+                         }
+                       }, result)
+        end
+
+        def test_error_document_transform_default
+          mock_request
+          resource = ModelWithErrors.new
+          resource.errors.add(:published_at, 'must be in the future')
+          resource.errors.add(:title, 'must be longer')
+          serializer = ActiveModel::Serializer::ErrorSerializer.new(resource)
+          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+          result = adapter.serializable_hash
+          expected_errors_object = {
+            errors: [
+              {
+                source: { pointer: '/data/attributes/published-at' },
+                detail: 'must be in the future'
+              },
+              {
+                source: { pointer: '/data/attributes/title' },
+                detail: 'must be longer'
+              }
+            ]
+          }
+          assert_equal expected_errors_object, result
+        end
+
+        def test_error_document_transform_global_config
+          mock_request
+          result = with_config(key_transform: :camel) do
+            resource = ModelWithErrors.new
+            resource.errors.add(:published_at, 'must be in the future')
+            resource.errors.add(:title, 'must be longer')
+            serializer = ActiveModel::Serializer::ErrorSerializer.new(resource)
+            adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+            adapter.serializable_hash
+          end
+          expected_errors_object = {
+            Errors: [
+              {
+                Source: { Pointer: '/data/attributes/PublishedAt' },
+                Detail: 'must be in the future'
+              },
+              {
+                Source: { Pointer: '/data/attributes/Title' },
+                Detail: 'must be longer'
+              }
+            ]
+          }
+          assert_equal expected_errors_object, result
+        end
+
+        def test_error_document_transform_serialization_ctx_overrides_global
+          mock_request(:camel)
+          result = with_config(key_transform: :camel_lower) do
+            resource = ModelWithErrors.new
+            resource.errors.add(:published_at, 'must be in the future')
+            resource.errors.add(:title, 'must be longer')
+            serializer = ActiveModel::Serializer::ErrorSerializer.new(resource)
+            adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+            adapter.serializable_hash
+          end
+          expected_errors_object = {
+            Errors: [
+              {
+                Source: { Pointer: '/data/attributes/PublishedAt' },
+                Detail: 'must be in the future'
+              },
+              {
+                Source: { Pointer: '/data/attributes/Title' },
+                Detail: 'must be longer'
+              }
+            ]
+          }
+          assert_equal expected_errors_object, result
+        end
+
+        def test_error_document_transform_dash
+          mock_request(:dash)
+
+          resource = ModelWithErrors.new
+          resource.errors.add(:published_at, 'must be in the future')
+          resource.errors.add(:title, 'must be longer')
+
+          serializer = ActiveModel::Serializer::ErrorSerializer.new(resource)
+          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+          result = adapter.serializable_hash
+
+          expected_errors_object = {
+            errors: [
+              {
+                source: { pointer: '/data/attributes/published-at' },
+                detail: 'must be in the future'
+              },
+              {
+                source: { pointer: '/data/attributes/title' },
+                detail: 'must be longer'
+              }
+            ]
+          }
+          assert_equal expected_errors_object, result
+        end
+
+        def test_error_document_transform_unaltered
+          mock_request(:unaltered)
+
+          resource = ModelWithErrors.new
+          resource.errors.add(:published_at, 'must be in the future')
+          resource.errors.add(:title, 'must be longer')
+
+          serializer = ActiveModel::Serializer::ErrorSerializer.new(resource)
+          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+          result = adapter.serializable_hash
+
+          expected_errors_object = {
+            errors: [
+              { source: { pointer: '/data/attributes/published_at' }, detail: 'must be in the future' },
+              { source: { pointer: '/data/attributes/title' }, detail: 'must be longer' }
+            ]
+          }
+          assert_equal expected_errors_object, result
+        end
+
+        def test_error_document_transform_undefined
+          mock_request(:krazy)
+
+          resource = ModelWithErrors.new
+          resource.errors.add(:published_at, 'must be in the future')
+          resource.errors.add(:title, 'must be longer')
+
+          serializer = ActiveModel::Serializer::ErrorSerializer.new(resource)
+          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+
+          exception = assert_raises NoMethodError do
+            adapter.serializable_hash
+          end
+          assert_match(/undefined method.*krazy/, exception.message)
+        end
+
+        def test_error_document_transform_camel
+          mock_request(:camel)
+
+          resource = ModelWithErrors.new
+          resource.errors.add(:published_at, 'must be in the future')
+          resource.errors.add(:title, 'must be longer')
+
+          serializer = ActiveModel::Serializer::ErrorSerializer.new(resource)
+          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+          result = adapter.serializable_hash
+
+          expected_errors_object = {
+            Errors: [
+              { Source: { Pointer: '/data/attributes/PublishedAt' }, Detail: 'must be in the future' },
+              { Source: { Pointer: '/data/attributes/Title' }, Detail: 'must be longer' }
+            ]
+          }
+          assert_equal expected_errors_object, result
+        end
+
+        def test_error_document_transform_camel_lower
+          mock_request(:camel_lower)
+
+          resource = ModelWithErrors.new
+          resource.errors.add(:published_at, 'must be in the future')
+          resource.errors.add(:title, 'must be longer')
+
+          serializer = ActiveModel::Serializer::ErrorSerializer.new(resource)
+          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, @options)
+          result = adapter.serializable_hash
+
+          expected_errors_object = {
+            errors: [
+              { source: { pointer: '/data/attributes/publishedAt' }, detail: 'must be in the future' },
+              { source: { pointer: '/data/attributes/title' }, detail: 'must be longer' }
+            ]
+          }
+          assert_equal expected_errors_object, result
+        end
+      end
+    end
+  end
+end