active_model_serializers 0.10.9 → 0.10.10

data/test/adapter/json_api/has_many_test.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class JsonApi
-      class HasManyTest < ActiveSupport::TestCase
-        class ModelWithoutSerializer < ::Model
-          attributes :id, :name
-        end
-
-        def setup
-          ActionController::Base.cache_store.clear
-          @author = Author.new(id: 1, name: 'Steve K.')
-          @author.posts = []
-          @author.bio = nil
-          @post = Post.new(id: 1, title: 'New Post', body: 'Body')
-          @post_without_comments = Post.new(id: 2, title: 'Second Post', body: 'Second')
-          @first_comment = Comment.new(id: 1, body: 'ZOMG A COMMENT')
-          @first_comment.author = nil
-          @second_comment = Comment.new(id: 2, body: 'ZOMG ANOTHER COMMENT')
-          @second_comment.author = nil
-          @post.comments = [@first_comment, @second_comment]
-          @post_without_comments.comments = []
-          @first_comment.post = @post
-          @second_comment.post = @post
-          @post.author = @author
-          @post_without_comments.author = nil
-          @blog = Blog.new(id: 1, name: 'My Blog!!')
-          @blog.writer = @author
-          @blog.articles = [@post]
-          @post.blog = @blog
-          @post_without_comments.blog = nil
-          @tag = ModelWithoutSerializer.new(id: 1, name: '#hash_tag')
-          @post.tags = [@tag]
-          @serializer = PostSerializer.new(@post)
-          @adapter = ActiveModelSerializers::Adapter::JsonApi.new(@serializer)
-
-          @virtual_value = VirtualValue.new(id: 1)
-        end
-
-        def test_includes_comment_ids
-          expected = { data: [{ type: 'comments', id: '1' }, { type: 'comments', id: '2' }] }
-
-          assert_equal(expected, @adapter.serializable_hash[:data][:relationships][:comments])
-        end
-
-        test 'relationships can be whitelisted via fields' do
-          @adapter = ActiveModelSerializers::Adapter::JsonApi.new(@serializer, fields: { posts: [:author] })
-          result = @adapter.serializable_hash
-          expected = {
-            data: {
-              id: '1',
-              type: 'posts',
-              relationships: {
-                author: {
-                  data: {
-                    id: '1',
-                    type: 'authors'
-                  }
-                }
-              }
-            }
-          }
-
-          assert_equal expected, result
-        end
-
-        def test_includes_linked_comments
-          @adapter = ActiveModelSerializers::Adapter::JsonApi.new(@serializer, include: [:comments])
-          expected = [{
-            id: '1',
-            type: 'comments',
-            attributes: {
-              body: 'ZOMG A COMMENT'
-            },
-            relationships: {
-              post: { data: { type: 'posts', id: '1' } },
-              author: { data: nil }
-            }
-          }, {
-            id: '2',
-            type: 'comments',
-            attributes: {
-              body: 'ZOMG ANOTHER COMMENT'
-            },
-            relationships: {
-              post: { data: { type: 'posts', id: '1' } },
-              author: { data: nil }
-            }
-          }]
-          assert_equal expected, @adapter.serializable_hash[:included]
-        end
-
-        def test_limit_fields_of_linked_comments
-          @adapter = ActiveModelSerializers::Adapter::JsonApi.new(@serializer, include: [:comments], fields: { comment: [:id, :post, :author] })
-          expected = [{
-            id: '1',
-            type: 'comments',
-            relationships: {
-              post: { data: { type: 'posts', id: '1' } },
-              author: { data: nil }
-            }
-          }, {
-            id: '2',
-            type: 'comments',
-            relationships: {
-              post: { data: { type: 'posts', id: '1' } },
-              author: { data: nil }
-            }
-          }]
-          assert_equal expected, @adapter.serializable_hash[:included]
-        end
-
-        def test_no_include_linked_if_comments_is_empty
-          serializer = PostSerializer.new(@post_without_comments)
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-
-          assert_nil adapter.serializable_hash[:linked]
-        end
-
-        def test_include_type_for_association_when_different_than_name
-          serializer = BlogSerializer.new(@blog)
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-          actual = adapter.serializable_hash[:data][:relationships][:articles]
-
-          expected = {
-            data: [{
-              type: 'posts',
-              id: '1'
-            }]
-          }
-          assert_equal expected, actual
-        end
-
-        def test_has_many_with_no_serializer
-          post_serializer_class = Class.new(ActiveModel::Serializer) do
-            attributes :id
-            has_many :tags
-          end
-          serializer = post_serializer_class.new(@post)
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-
-          assert_equal({
-                         data: {
-                           id: '1',
-                           type: 'posts',
-                           relationships: {
-                             tags: { data: [@tag.as_json] }
-                           }
-                         }
-                       }, adapter.serializable_hash)
-        end
-
-        def test_has_many_with_virtual_value
-          serializer = VirtualValueSerializer.new(@virtual_value)
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-
-          assert_equal({
-                         data: {
-                           id: '1',
-                           type: 'virtual-values',
-                           relationships: {
-                             maker: { data: { type: 'makers', id: '1' } },
-                             reviews: { data: [{ type: 'reviews', id: '1' },
-                                               { type: 'reviews', id: '2' }] }
-                           }
-                         }
-                       }, adapter.serializable_hash)
-        end
-      end
-    end
-  end
-end

data/test/adapter/json_api/has_one_test.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class JsonApi
-      class HasOneTest < ActiveSupport::TestCase
-        def setup
-          @author = Author.new(id: 1, name: 'Steve K.')
-          @bio = Bio.new(id: 43, content: 'AMS Contributor')
-          @author.bio = @bio
-          @bio.author = @author
-          @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]
-          @anonymous_post.comments = []
-          @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 = []
-          @author.roles = []
-
-          @virtual_value = VirtualValue.new(id: 1)
-
-          @serializer = AuthorSerializer.new(@author)
-          @adapter = ActiveModelSerializers::Adapter::JsonApi.new(@serializer, include: [:bio, :posts])
-        end
-
-        def test_includes_bio_id
-          expected = { data: { type: 'bios', id: '43' } }
-
-          assert_equal(expected, @adapter.serializable_hash[:data][:relationships][:bio])
-        end
-
-        def test_includes_linked_bio
-          @adapter = ActiveModelSerializers::Adapter::JsonApi.new(@serializer, include: [:bio])
-
-          expected = [
-            {
-              id: '43',
-              type: 'bios',
-              attributes: {
-                content: 'AMS Contributor',
-                rating: nil
-              },
-              relationships: {
-                author: { data: { type: 'authors', id: '1' } }
-              }
-            }
-          ]
-
-          assert_equal(expected, @adapter.serializable_hash[:included])
-        end
-
-        def test_has_one_with_virtual_value
-          serializer = VirtualValueSerializer.new(@virtual_value)
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-
-          expected = {
-            data: {
-              id: '1',
-              type: 'virtual-values',
-              relationships: {
-                maker: { data: { type: 'makers', id: '1' } },
-                reviews: { data: [{ type: 'reviews', id: '1' },
-                                  { type: 'reviews', id: '2' }] }
-              }
-            }
-          }
-
-          assert_equal(expected, adapter.serializable_hash)
-        end
-      end
-    end
-  end
-end

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