active_model_serializers 0.10.9 → 0.10.10

data/test/adapter/json_api/resource_meta_test.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,514 +0,0 @@
-# frozen_string_literal: true
-
-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