active_model_serializers 0.10.9 → 0.10.13

data/test/adapter/json_api/include_data_if_sideloaded_test.rb

@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    module Adapter
-      class JsonApi
-        class IncludeParamTest < ActiveSupport::TestCase
-          IncludeParamAuthor = Class.new(::Model) do
-            associations :tags, :posts, :roles
-          end
-
-          class CustomCommentLoader
-            def all
-              [{ foo: 'bar' }]
-            end
-          end
-          class Tag < ::Model
-            attributes :id, :name
-          end
-
-          class TagSerializer < ActiveModel::Serializer
-            type 'tags'
-            attributes :id, :name
-          end
-
-          class PostWithTagsSerializer < ActiveModel::Serializer
-            type 'posts'
-            attributes :id
-            has_many :tags
-          end
-
-          class IncludeParamAuthorSerializer < ActiveModel::Serializer
-            class_attribute :comment_loader
-
-            has_many :tags, serializer: TagSerializer do
-              link :self, '//example.com/link_author/relationships/tags'
-              include_data :if_sideloaded
-            end
-
-            has_many :unlinked_tags, serializer: TagSerializer do
-              include_data :if_sideloaded
-            end
-
-            has_many :posts, serializer: PostWithTagsSerializer do
-              include_data :if_sideloaded
-            end
-            has_many :locations do
-              include_data :if_sideloaded
-            end
-            has_many :comments do
-              include_data :if_sideloaded
-              IncludeParamAuthorSerializer.comment_loader.all
-            end
-            has_many :roles, key: :granted_roles do
-              include_data :if_sideloaded
-            end
-          end
-
-          def setup
-            IncludeParamAuthorSerializer.comment_loader = Class.new(CustomCommentLoader).new
-            @tag = Tag.new(id: 1337, name: 'mytag')
-            @role = Role.new(id: 1337, name: 'myrole')
-            @author = IncludeParamAuthor.new(
-              id: 1337,
-              tags: [@tag],
-              roles: [@role]
-            )
-          end
-
-          def test_relationship_not_loaded_when_not_included
-            expected = {
-              links: {
-                self: '//example.com/link_author/relationships/tags'
-              }
-            }
-
-            @author.define_singleton_method(:read_attribute_for_serialization) do |attr|
-              fail 'should not be called' if attr == :tags
-              super(attr)
-            end
-
-            assert_relationship(:tags, expected)
-          end
-
-          def test_relationship_included
-            expected = {
-              data: [
-                {
-                  id: '1337',
-                  type: 'tags'
-                }
-              ],
-              links: {
-                self: '//example.com/link_author/relationships/tags'
-              }
-            }
-
-            assert_relationship(:tags, expected, include: :tags)
-          end
-
-          def test_sideloads_included
-            expected = [
-              {
-                id: '1337',
-                type: 'tags',
-                attributes: { name: 'mytag' }
-              }
-            ]
-            hash = result(include: :tags)
-            assert_equal(expected, hash[:included])
-          end
-
-          def test_sideloads_included_when_using_key
-            expected = [
-              {
-                id: '1337',
-                type: 'roles',
-                attributes: {
-                  name: 'myrole',
-                  description: nil,
-                  slug: 'myrole-1337'
-                },
-                relationships: {
-                  author: { data: nil }
-                }
-              }
-            ]
-
-            hash = result(include: :granted_roles)
-            assert_equal(expected, hash[:included])
-          end
-
-          def test_sideloads_not_included_when_using_name_when_key_defined
-            hash = result(include: :roles)
-            assert_nil(hash[:included])
-          end
-
-          def test_nested_relationship
-            expected = {
-              data: [
-                {
-                  id: '1337',
-                  type: 'tags'
-                }
-              ],
-              links: {
-                self: '//example.com/link_author/relationships/tags'
-              }
-            }
-
-            expected_no_data = {
-              links: {
-                self: '//example.com/link_author/relationships/tags'
-              }
-            }
-
-            assert_relationship(:tags, expected, include: [:tags, { posts: :tags }])
-
-            @author.define_singleton_method(:read_attribute_for_serialization) do |attr|
-              fail 'should not be called' if attr == :tags
-              super(attr)
-            end
-
-            assert_relationship(:tags, expected_no_data, include: { posts: :tags })
-          end
-
-          def test_include_params_with_no_block
-            @author.define_singleton_method(:read_attribute_for_serialization) do |attr|
-              fail 'should not be called' if attr == :locations
-              super(attr)
-            end
-
-            expected = { meta: {} }
-
-            assert_relationship(:locations, expected)
-          end
-
-          def test_block_relationship
-            expected = {
-              data: [
-                { 'foo' => 'bar' }
-              ]
-            }
-
-            assert_relationship(:comments, expected, include: [:comments])
-          end
-
-          def test_node_not_included_when_no_link
-            expected = { meta: {} }
-            assert_relationship(:unlinked_tags, expected, key_transform: :unaltered)
-          end
-
-          private
-
-          def assert_relationship(relationship_name, expected, opts = {})
-            actual = relationship_data(relationship_name, opts)
-            assert_equal(expected, actual)
-          end
-
-          def result(opts)
-            opts = { adapter: :json_api }.merge(opts)
-            serializable(@author, opts).serializable_hash
-          end
-
-          def relationship_data(relationship_name, opts = {})
-            hash = result(opts)
-            hash[:data][:relationships][relationship_name]
-          end
-        end
-      end
-    end
-  end
-end

data/test/adapter/json_api/json_api_test.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class JsonApiTest < 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
-      end
-
-      def test_custom_keys
-        serializer = PostWithCustomKeysSerializer.new(@post)
-        adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-
-        assert_equal({
-                       reviews: { data: [{ type: 'comments', id: '1' },
-                                         { type: 'comments', id: '2' }] },
-                       writer: { data: { type: 'authors', id: '1' } },
-                       site: { data: { type: 'blogs', id: '1' } }
-                     }, adapter.serializable_hash[:data][:relationships])
-      end
-    end
-  end
-end

data/test/adapter/json_api/linked_test.rb

@@ -1,415 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class NestedPost < ::Model; associations :nested_posts end
-class NestedPostSerializer < ActiveModel::Serializer
-  has_many :nested_posts
-end
-module ActiveModelSerializers
-  module Adapter
-    class JsonApi
-      class LinkedTest < ActiveSupport::TestCase
-        def setup
-          @author1 = Author.new(id: 1, name: 'Steve K.')
-          @author2 = Author.new(id: 2, name: 'Tenderlove')
-          @bio1 = Bio.new(id: 1, content: 'AMS Contributor')
-          @bio2 = Bio.new(id: 2, content: 'Rails Contributor')
-          @first_post = Post.new(id: 10, title: 'Hello!!', body: 'Hello, world!!')
-          @second_post = Post.new(id: 20, title: 'New Post', body: 'Body')
-          @third_post = Post.new(id: 30, title: 'Yet Another Post', body: 'Body')
-          @blog = Blog.new(name: 'AMS Blog')
-          @first_comment = Comment.new(id: 1, body: 'ZOMG A COMMENT')
-          @second_comment = Comment.new(id: 2, body: 'ZOMG ANOTHER COMMENT')
-          @first_post.blog = @blog
-          @second_post.blog = @blog
-          @third_post.blog = nil
-          @first_post.comments = [@first_comment, @second_comment]
-          @second_post.comments = []
-          @third_post.comments = []
-          @first_post.author = @author1
-          @second_post.author = @author2
-          @third_post.author = @author1
-          @first_comment.post = @first_post
-          @first_comment.author = nil
-          @second_comment.post = @first_post
-          @second_comment.author = nil
-          @author1.posts = [@first_post, @third_post]
-          @author1.bio = @bio1
-          @author1.roles = []
-          @author2.posts = [@second_post]
-          @author2.bio = @bio2
-          @author2.roles = []
-          @bio1.author = @author1
-          @bio2.author = @author2
-        end
-
-        def test_include_multiple_posts_and_linked_array
-          serializer = ActiveModel::Serializer::CollectionSerializer.new([@first_post, @second_post])
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(
-            serializer,
-            include: [:comments, author: [:bio]]
-          )
-          alt_adapter = ActiveModelSerializers::Adapter::JsonApi.new(
-            serializer,
-            include: [:comments, author: [:bio]]
-          )
-
-          expected = {
-            data: [
-              {
-                id: '10',
-                type: 'posts',
-                attributes: {
-                  title: 'Hello!!',
-                  body: 'Hello, world!!'
-                },
-                relationships: {
-                  comments: { data: [{ type: 'comments', id: '1' }, { type: 'comments', id: '2' }] },
-                  blog: { data: { type: 'blogs', id: '999' } },
-                  author: { data: { type: 'authors', id: '1' } }
-                }
-              },
-              {
-                id: '20',
-                type: 'posts',
-                attributes: {
-                  title: 'New Post',
-                  body: 'Body'
-                },
-                relationships: {
-                  comments: { data: [] },
-                  blog: { data: { type: 'blogs', id: '999' } },
-                  author: { data: { type: 'authors', id: '2' } }
-                }
-              }
-            ],
-            included: [
-              {
-                id: '1',
-                type: 'comments',
-                attributes: {
-                  body: 'ZOMG A COMMENT'
-                },
-                relationships: {
-                  post: { data: { type: 'posts', id: '10' } },
-                  author: { data: nil }
-                }
-              }, {
-                id: '2',
-                type: 'comments',
-                attributes: {
-                  body: 'ZOMG ANOTHER COMMENT'
-                },
-                relationships: {
-                  post: { data: { type: 'posts', id: '10' } },
-                  author: { data: nil }
-                }
-              }, {
-                id: '1',
-                type: 'authors',
-                attributes: {
-                  name: 'Steve K.'
-                },
-                relationships: {
-                  posts: { data: [{ type: 'posts', id: '10' }, { type: 'posts', id: '30' }] },
-                  roles: { data: [] },
-                  bio: { data: { type: 'bios', id: '1' } }
-                }
-              }, {
-                id: '1',
-                type: 'bios',
-                attributes: {
-                  content: 'AMS Contributor',
-                  rating: nil
-                },
-                relationships: {
-                  author: { data: { type: 'authors', id: '1' } }
-                }
-              }, {
-                id: '2',
-                type: 'authors',
-                attributes: {
-                  name: 'Tenderlove'
-                },
-                relationships: {
-                  posts: { data: [{ type: 'posts', id: '20' }] },
-                  roles: { data: [] },
-                  bio: { data: { type: 'bios', id: '2' } }
-                }
-              }, {
-                id: '2',
-                type: 'bios',
-                attributes: {
-                  rating: nil,
-                  content: 'Rails Contributor'
-                },
-                relationships: {
-                  author: { data: { type: 'authors', id: '2' } }
-                }
-              }
-            ]
-          }
-          assert_equal expected, adapter.serializable_hash
-          assert_equal expected, alt_adapter.serializable_hash
-        end
-
-        def test_include_multiple_posts_and_linked
-          serializer = BioSerializer.new @bio1
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(
-            serializer,
-            include: [author: [:posts]]
-          )
-          alt_adapter = ActiveModelSerializers::Adapter::JsonApi.new(
-            serializer,
-            include: [author: [:posts]]
-          )
-
-          expected = [
-            {
-              id: '1',
-              type: 'authors',
-              attributes: {
-                name: 'Steve K.'
-              },
-              relationships: {
-                posts: { data: [{ type: 'posts', id: '10' }, { type: 'posts', id: '30' }] },
-                roles: { data: [] },
-                bio: { data: { type: 'bios', id: '1' } }
-              }
-            }, {
-              id: '10',
-              type: 'posts',
-              attributes: {
-                title: 'Hello!!',
-                body: 'Hello, world!!'
-              },
-              relationships: {
-                comments: { data: [{ type: 'comments', id: '1' }, { type: 'comments', id: '2' }] },
-                blog: { data: { type: 'blogs', id: '999' } },
-                author: { data: { type: 'authors', id: '1' } }
-              }
-            }, {
-              id: '30',
-              type: 'posts',
-              attributes: {
-                title: 'Yet Another Post',
-                body: 'Body'
-              },
-              relationships: {
-                comments: { data: [] },
-                blog: { data: { type: 'blogs', id: '999' } },
-                author: { data: { type: 'authors', id: '1' } }
-              }
-            }
-          ]
-
-          assert_equal expected, adapter.serializable_hash[:included]
-          assert_equal expected, alt_adapter.serializable_hash[:included]
-        end
-
-        def test_underscore_model_namespace_for_linked_resource_type
-          spammy_post = Post.new(id: 123)
-          spammy_post.related = [Spam::UnrelatedLink.new(id: 456)]
-          serializer = SpammyPostSerializer.new(spammy_post)
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-          relationships = adapter.serializable_hash[:data][:relationships]
-          expected = {
-            related: {
-              data: [{
-                type: 'spam-unrelated-links',
-                id: '456'
-              }]
-            }
-          }
-          assert_equal expected, relationships
-        end
-
-        def test_underscore_model_namespace_with_namespace_separator_for_linked_resource_type
-          spammy_post = Post.new(id: 123)
-          spammy_post.related = [Spam::UnrelatedLink.new(id: 456)]
-          serializer = SpammyPostSerializer.new(spammy_post)
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-          relationships = with_namespace_separator '--' do
-            adapter.serializable_hash[:data][:relationships]
-          end
-          expected = {
-            related: {
-              data: [{
-                type: 'spam--unrelated-links',
-                id: '456'
-              }]
-            }
-          }
-          assert_equal expected, relationships
-        end
-
-        def test_multiple_references_to_same_resource
-          serializer = ActiveModel::Serializer::CollectionSerializer.new([@first_comment, @second_comment])
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(
-            serializer,
-            include: [:post]
-          )
-
-          expected = [
-            {
-              id: '10',
-              type: 'posts',
-              attributes: {
-                title: 'Hello!!',
-                body: 'Hello, world!!'
-              },
-              relationships: {
-                comments: {
-                  data: [{ type: 'comments', id: '1' }, { type: 'comments', id: '2' }]
-                },
-                blog: {
-                  data: { type: 'blogs', id: '999' }
-                },
-                author: {
-                  data: { type: 'authors', id: '1' }
-                }
-              }
-            }
-          ]
-
-          assert_equal expected, adapter.serializable_hash[:included]
-        end
-
-        def test_nil_link_with_specified_serializer
-          @first_post.author = nil
-          serializer = PostPreviewSerializer.new(@first_post)
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(
-            serializer,
-            include: [:author]
-          )
-
-          expected = {
-            data: {
-              id: '10',
-              type: 'posts',
-              attributes: {
-                title: 'Hello!!',
-                body: 'Hello, world!!'
-              },
-              relationships: {
-                comments: { data: [{ type: 'comments', id: '1' }, { type: 'comments', id: '2' }] },
-                author: { data: nil }
-              }
-            }
-          }
-          assert_equal expected, adapter.serializable_hash
-        end
-      end
-
-      class NoDuplicatesTest < ActiveSupport::TestCase
-        class Post < ::Model; associations :author end
-        class Author < ::Model; associations :posts, :roles, :bio end
-
-        class PostSerializer < ActiveModel::Serializer
-          type 'posts'
-          belongs_to :author
-        end
-
-        class AuthorSerializer < ActiveModel::Serializer
-          type 'authors'
-          has_many :posts
-        end
-
-        def setup
-          @author = Author.new(id: 1, posts: [], roles: [], bio: nil)
-          @post1 = Post.new(id: 1, author: @author)
-          @post2 = Post.new(id: 2, author: @author)
-          @author.posts << @post1
-          @author.posts << @post2
-
-          @nestedpost1 = NestedPost.new(id: 1, nested_posts: [])
-          @nestedpost2 = NestedPost.new(id: 2, nested_posts: [])
-          @nestedpost1.nested_posts << @nestedpost1
-          @nestedpost1.nested_posts << @nestedpost2
-          @nestedpost2.nested_posts << @nestedpost1
-          @nestedpost2.nested_posts << @nestedpost2
-        end
-
-        def test_no_duplicates
-          hash = ActiveModelSerializers::SerializableResource.new(@post1, adapter: :json_api,
-                                                                          include: '*.*')
-                                                             .serializable_hash
-          expected = [
-            {
-              type: 'authors', id: '1',
-              relationships: {
-                posts: {
-                  data: [
-                    { type: 'posts', id: '1' },
-                    { type: 'posts', id: '2' }
-                  ]
-                }
-              }
-            },
-            {
-              type: 'posts', id: '2',
-              relationships: {
-                author: {
-                  data: { type: 'authors', id: '1' }
-                }
-              }
-            }
-          ]
-          assert_equal(expected, hash[:included])
-        end
-
-        def test_no_duplicates_collection
-          hash = ActiveModelSerializers::SerializableResource.new(
-            [@post1, @post2],
-            adapter: :json_api,
-            include: '*.*'
-          ).serializable_hash
-          expected = [
-            {
-              type: 'authors', id: '1',
-              relationships: {
-                posts: {
-                  data: [
-                    { type: 'posts', id: '1' },
-                    { type: 'posts', id: '2' }
-                  ]
-                }
-              }
-            }
-          ]
-          assert_equal(expected, hash[:included])
-        end
-
-        def test_no_duplicates_global
-          hash = ActiveModelSerializers::SerializableResource.new(
-            @nestedpost1,
-            adapter: :json_api,
-            include: '*'
-          ).serializable_hash
-          expected = [
-            type: 'nested-posts', id: '2',
-            relationships: {
-              :"nested-posts" => {
-                data: [
-                  { type: 'nested-posts', id: '1' },
-                  { type: 'nested-posts', id: '2' }
-                ]
-              }
-            }
-          ]
-          assert_equal(expected, hash[:included])
-        end
-
-        def test_no_duplicates_collection_global
-          hash = ActiveModelSerializers::SerializableResource.new(
-            [@nestedpost1, @nestedpost2],
-            adapter: :json_api,
-            include: '*'
-          ).serializable_hash
-          assert_nil(hash[:included])
-        end
-      end
-    end
-  end
-end