active_model_serializers 0.10.9 → 0.10.13

data/test/active_model_serializers/test/serializer_test.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Test
-    class SerializerTest < ActionController::TestCase
-      include ActiveModelSerializers::Test::Serializer
-
-      class MyController < ActionController::Base
-        def render_using_serializer
-          render json: Profile.new(name: 'Name 1', description: 'Description 1', comments: 'Comments 1')
-        end
-
-        def render_some_text
-          render(plain: 'ok')
-        end
-      end
-
-      tests MyController
-
-      def test_supports_specifying_serializers_with_a_serializer_class
-        get :render_using_serializer
-        assert_serializer ProfileSerializer
-      end
-
-      def test_supports_specifying_serializers_with_a_regexp
-        get :render_using_serializer
-        assert_serializer(/\AProfile.+\Z/)
-      end
-
-      def test_supports_specifying_serializers_with_a_string
-        get :render_using_serializer
-        assert_serializer 'ProfileSerializer'
-      end
-
-      def test_supports_specifying_serializers_with_a_symbol
-        get :render_using_serializer
-        assert_serializer :profile_serializer
-      end
-
-      def test_supports_specifying_serializers_with_a_nil
-        get :render_some_text
-        assert_serializer nil
-      end
-
-      def test_raises_descriptive_error_message_when_serializer_was_not_rendered
-        get :render_using_serializer
-        e = assert_raise ActiveSupport::TestCase::Assertion do
-          assert_serializer 'PostSerializer'
-        end
-        assert_match 'expecting <"PostSerializer"> but rendering with <["ProfileSerializer"]>', e.message
-      end
-
-      def test_raises_argument_error_when_asserting_with_invalid_object
-        get :render_using_serializer
-        e = assert_raise ArgumentError do
-          assert_serializer Hash
-        end
-        assert_match 'assert_serializer only accepts a String, Symbol, Regexp, ActiveModel::Serializer, or nil', e.message
-      end
-    end
-  end
-end

data/test/active_record_test.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ActiveRecordTest < ActiveSupport::TestCase
-  include ActiveModel::Serializer::Lint::Tests
-
-  def setup
-    @resource = ARModels::Post.new
-  end
-end

data/test/adapter/attributes_test.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class AttributesTest < ActiveSupport::TestCase
-      class Person < ActiveModelSerializers::Model
-        attributes :first_name, :last_name
-      end
-
-      class PersonSerializer < ActiveModel::Serializer
-        attributes :first_name, :last_name
-      end
-
-      def setup
-        ActionController::Base.cache_store.clear
-      end
-
-      def test_serializable_hash
-        person = Person.new(first_name: 'Arthur', last_name: 'Dent')
-        serializer = PersonSerializer.new(person)
-        adapter = ActiveModelSerializers::Adapter::Attributes.new(serializer)
-
-        assert_equal({ first_name: 'Arthur', last_name: 'Dent' },
-          adapter.serializable_hash)
-      end
-
-      def test_serializable_hash_with_transform_key_casing
-        person = Person.new(first_name: 'Arthur', last_name: 'Dent')
-        serializer = PersonSerializer.new(person)
-        adapter = ActiveModelSerializers::Adapter::Attributes.new(
-          serializer,
-          key_transform: :camel_lower
-        )
-
-        assert_equal({ firstName: 'Arthur', lastName: 'Dent' },
-          adapter.serializable_hash)
-      end
-    end
-  end
-end

data/test/adapter/deprecation_test.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-module ActiveModel
-  class Serializer
-    module Adapter
-      class DeprecationTest < ActiveSupport::TestCase
-        class PostSerializer < ActiveModel::Serializer
-          attribute :body
-        end
-        setup do
-          post = Post.new(id: 1, body: 'Hello')
-          @serializer = PostSerializer.new(post)
-        end
-
-        def test_null_adapter_serialization_deprecation
-          expected = {}
-          assert_deprecated do
-            assert_equal(expected, Null.new(@serializer).as_json)
-          end
-        end
-
-        def test_json_adapter_serialization_deprecation
-          expected = { post: { body: 'Hello' } }
-          assert_deprecated do
-            assert_equal(expected, Json.new(@serializer).as_json)
-          end
-        end
-
-        def test_jsonapi_adapter_serialization_deprecation
-          expected = {
-            data: {
-              id: '1',
-              type: 'posts',
-              attributes: {
-                body: 'Hello'
-              }
-            }
-          }
-          assert_deprecated do
-            assert_equal(expected, JsonApi.new(@serializer).as_json)
-          end
-        end
-
-        def test_attributes_adapter_serialization_deprecation
-          expected = { body: 'Hello' }
-          assert_deprecated do
-            assert_equal(expected, Attributes.new(@serializer).as_json)
-          end
-        end
-
-        def test_adapter_create_deprecation
-          assert_deprecated do
-            Adapter.create(@serializer)
-          end
-        end
-
-        def test_adapter_adapter_map_deprecation
-          assert_deprecated do
-            Adapter.adapter_map
-          end
-        end
-
-        def test_adapter_adapters_deprecation
-          assert_deprecated do
-            Adapter.adapters
-          end
-        end
-
-        def test_adapter_adapter_class_deprecation
-          assert_deprecated do
-            Adapter.adapter_class(:json_api)
-          end
-        end
-
-        def test_adapter_register_deprecation
-          assert_deprecated do
-            begin
-              Adapter.register(:test, Class.new)
-            ensure
-              Adapter.adapter_map.delete('test')
-            end
-          end
-        end
-
-        def test_adapter_lookup_deprecation
-          assert_deprecated do
-            Adapter.lookup(:json_api)
-          end
-        end
-
-        private
-
-        def assert_deprecated
-          assert_output(nil, /deprecated/) do
-            yield
-          end
-        end
-      end
-    end
-  end
-end

data/test/adapter/json/belongs_to_test.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class Json
-      class BelongsToTest < ActiveSupport::TestCase
-        def setup
-          @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
-          @anonymous_post.author = nil
-          @blog = Blog.new(id: 1, name: 'My Blog!!')
-          @post.blog = @blog
-          @anonymous_post.blog = nil
-
-          @serializer = CommentSerializer.new(@comment)
-          @adapter = ActiveModelSerializers::Adapter::Json.new(@serializer)
-          ActionController::Base.cache_store.clear
-        end
-
-        def test_includes_post
-          assert_equal({ id: 42, title: 'New Post', body: 'Body' }, @adapter.serializable_hash[:comment][:post])
-        end
-
-        def test_include_nil_author
-          serializer = PostSerializer.new(@anonymous_post)
-          adapter = ActiveModelSerializers::Adapter::Json.new(serializer)
-
-          assert_equal({ post: { title: 'Hello!!', body: 'Hello, world!!', id: 43, comments: [], blog: { id: 999, name: 'Custom blog' }, author: nil } }, adapter.serializable_hash)
-        end
-
-        def test_include_nil_author_with_specified_serializer
-          serializer = PostPreviewSerializer.new(@anonymous_post)
-          adapter = ActiveModelSerializers::Adapter::Json.new(serializer)
-
-          assert_equal({ post: { title: 'Hello!!', body: 'Hello, world!!', id: 43, comments: [], author: nil } }, adapter.serializable_hash)
-        end
-      end
-    end
-  end
-end

data/test/adapter/json/collection_test.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class Json
-      class Collection < ActiveSupport::TestCase
-        def setup
-          @author = Author.new(id: 1, name: 'Steve K.')
-          @first_post = Post.new(id: 1, title: 'Hello!!', body: 'Hello, world!!')
-          @second_post = Post.new(id: 2, title: 'New Post', body: 'Body')
-          @first_post.comments = []
-          @second_post.comments = []
-          @first_post.author = @author
-          @second_post.author = @author
-          @blog = Blog.new(id: 1, name: 'My Blog!!')
-          @first_post.blog = @blog
-          @second_post.blog = nil
-
-          ActionController::Base.cache_store.clear
-        end
-
-        def test_with_serializer_option
-          @blog.special_attribute = 'Special'
-          @blog.articles = [@first_post, @second_post]
-          serializer = ActiveModel::Serializer::CollectionSerializer.new([@blog], serializer: CustomBlogSerializer)
-          adapter = ActiveModelSerializers::Adapter::Json.new(serializer)
-
-          expected = { blogs: [{
-            id: 1,
-            special_attribute: 'Special',
-            articles: [{ id: 1, title: 'Hello!!', body: 'Hello, world!!' }, { id: 2, title: 'New Post', body: 'Body' }]
-          }] }
-          assert_equal expected, adapter.serializable_hash
-        end
-
-        def test_include_multiple_posts
-          serializer = ActiveModel::Serializer::CollectionSerializer.new([@first_post, @second_post])
-          adapter = ActiveModelSerializers::Adapter::Json.new(serializer)
-
-          expected = { posts: [{
-            title: 'Hello!!',
-            body: 'Hello, world!!',
-            id: 1,
-            comments: [],
-            author: {
-              id: 1,
-              name: 'Steve K.'
-            },
-            blog: {
-              id: 999,
-              name: 'Custom blog'
-            }
-          }, {
-            title: 'New Post',
-            body: 'Body',
-            id: 2,
-            comments: [],
-            author: {
-              id: 1,
-              name: 'Steve K.'
-            },
-            blog: {
-              id: 999,
-              name: 'Custom blog'
-            }
-          }] }
-          assert_equal expected, adapter.serializable_hash
-        end
-
-        def test_root_is_underscored
-          virtual_value = VirtualValue.new(id: 1)
-          serializer = ActiveModel::Serializer::CollectionSerializer.new([virtual_value])
-          adapter = ActiveModelSerializers::Adapter::Json.new(serializer)
-
-          assert_equal 1, adapter.serializable_hash[:virtual_values].length
-        end
-
-        def test_include_option
-          serializer = ActiveModel::Serializer::CollectionSerializer.new([@first_post, @second_post])
-          adapter = ActiveModelSerializers::Adapter::Json.new(serializer, include: '')
-          actual = adapter.serializable_hash
-          expected = { posts: [{ id: 1, title: 'Hello!!', body: 'Hello, world!!' },
-                               { id: 2, title: 'New Post', body: 'Body' }] }
-
-          assert_equal(expected, actual)
-        end
-
-        def test_fields_with_no_associations_include_option
-          actual = ActiveModelSerializers::SerializableResource.new(
-            [@first_post, @second_post], adapter: :json, fields: [:id], include: []
-          ).as_json
-
-          expected = { posts: [{
-            id: 1
-          }, {
-            id: 2
-          }] }
-
-          assert_equal(expected, actual)
-        end
-      end
-    end
-  end
-end

data/test/adapter/json/has_many_test.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class Json
-      class HasManyTestTest < ActiveSupport::TestCase
-        class ModelWithoutSerializer < ::Model
-          attributes :id, :name
-        end
-
-        def setup
-          ActionController::Base.cache_store.clear
-          @author = Author.new(id: 1, name: 'Steve K.')
-          @post = Post.new(id: 42, 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]
-          @post.author = @author
-          @first_comment.post = @post
-          @second_comment.post = @post
-          @blog = Blog.new(id: 1, name: 'My Blog!!')
-          @post.blog = @blog
-          @tag = ModelWithoutSerializer.new(id: 1, name: '#hash_tag')
-          @post.tags = [@tag]
-        end
-
-        def test_has_many
-          serializer = PostSerializer.new(@post)
-          adapter = ActiveModelSerializers::Adapter::Json.new(serializer)
-          assert_equal([
-                         { id: 1, body: 'ZOMG A COMMENT' },
-                         { id: 2, body: 'ZOMG ANOTHER COMMENT' }
-                       ], adapter.serializable_hash[:post][:comments])
-        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::Json.new(serializer)
-          assert_equal({
-            id: 42,
-            tags: [
-              { 'id' => 1, 'name' => '#hash_tag' }
-            ]
-          }.to_json, adapter.serializable_hash[:post].to_json)
-        end
-      end
-    end
-  end
-end

data/test/adapter/json/transform_test.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class Json
-      class KeyCaseTest < ActiveSupport::TestCase
-        def mock_request(key_transform = nil)
-          context = Minitest::Mock.new
-          context.expect(:request_url, URI)
-          context.expect(:query_parameters, {})
-          options = {}
-          options[:key_transform] = key_transform if key_transform
-          options[:serialization_context] = context
-          serializer = CustomBlogSerializer.new(@blog)
-          @adapter = ActiveModelSerializers::Adapter::Json.new(serializer, options)
-        end
-
-        class Post < ::Model; end
-        class PostSerializer < ActiveModel::Serializer
-          attributes :id, :title, :body, :publish_at
-        end
-
-        setup do
-          ActionController::Base.cache_store.clear
-          @blog = Blog.new(id: 1, name: 'My Blog!!', special_attribute: 'neat')
-        end
-
-        def test_transform_default
-          mock_request
-          assert_equal({
-                         blog: { id: 1, special_attribute: 'neat', articles: nil }
-                       }, @adapter.serializable_hash)
-        end
-
-        def test_transform_global_config
-          mock_request
-          result = with_config(key_transform: :camel_lower) do
-            @adapter.serializable_hash
-          end
-          assert_equal({
-                         blog: { id: 1, specialAttribute: 'neat', articles: nil }
-                       }, result)
-        end
-
-        def test_transform_serialization_ctx_overrides_global_config
-          mock_request(:camel)
-          result = with_config(key_transform: :camel_lower) do
-            @adapter.serializable_hash
-          end
-          assert_equal({
-                         Blog: { Id: 1, SpecialAttribute: 'neat', Articles: nil }
-                       }, result)
-        end
-
-        def test_transform_undefined
-          mock_request(:blam)
-          result = nil
-          assert_raises NoMethodError do
-            result = @adapter.serializable_hash
-          end
-        end
-
-        def test_transform_dash
-          mock_request(:dash)
-          assert_equal({
-                         blog: { id: 1, :"special-attribute" => 'neat', articles: nil }
-                       }, @adapter.serializable_hash)
-        end
-
-        def test_transform_unaltered
-          mock_request(:unaltered)
-          assert_equal({
-                         blog: { id: 1, special_attribute: 'neat', articles: nil }
-                       }, @adapter.serializable_hash)
-        end
-
-        def test_transform_camel
-          mock_request(:camel)
-          assert_equal({
-                         Blog: { Id: 1, SpecialAttribute: 'neat', Articles: nil }
-                       }, @adapter.serializable_hash)
-        end
-
-        def test_transform_camel_lower
-          mock_request(:camel_lower)
-          assert_equal({
-                         blog: { id: 1, specialAttribute: 'neat', articles: nil }
-                       }, @adapter.serializable_hash)
-        end
-      end
-    end
-  end
-end

data/test/adapter/json_api/belongs_to_test.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class JsonApi
-      class BelongsToTest < 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 = []
-
-          @serializer = CommentSerializer.new(@comment)
-          @adapter = ActiveModelSerializers::Adapter::JsonApi.new(@serializer)
-          ActionController::Base.cache_store.clear
-        end
-
-        def test_includes_post_id
-          expected = { data: { type: 'posts', id: '42' } }
-
-          assert_equal(expected, @adapter.serializable_hash[:data][:relationships][:post])
-        end
-
-        def test_includes_linked_post
-          @adapter = ActiveModelSerializers::Adapter::JsonApi.new(@serializer, include: [:post])
-          expected = [{
-            id: '42',
-            type: 'posts',
-            attributes: {
-              title: 'New Post',
-              body: 'Body'
-            },
-            relationships: {
-              comments: { data: [{ type: 'comments', id: '1' }] },
-              blog: { data: { type: 'blogs', id: '999' } },
-              author: { data: { type: 'authors', id: '1' } }
-            }
-          }]
-          assert_equal expected, @adapter.serializable_hash[:included]
-        end
-
-        def test_limiting_linked_post_fields
-          @adapter = ActiveModelSerializers::Adapter::JsonApi.new(@serializer, include: [:post], fields: { post: [:title, :comments, :blog, :author] })
-          expected = [{
-            id: '42',
-            type: 'posts',
-            attributes: {
-              title: 'New Post'
-            },
-            relationships: {
-              comments: { data: [{ type: 'comments', id: '1' }] },
-              blog: { data: { type: 'blogs', id: '999' } },
-              author: { data: { type: 'authors', id: '1' } }
-            }
-          }]
-          assert_equal expected, @adapter.serializable_hash[:included]
-        end
-
-        def test_include_nil_author
-          serializer = PostSerializer.new(@anonymous_post)
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-
-          assert_equal({ comments: { data: [] }, blog: { data: { type: 'blogs', id: '999' } }, author: { data: nil } }, adapter.serializable_hash[:data][:relationships])
-        end
-
-        def test_include_type_for_association_when_different_than_name
-          serializer = BlogSerializer.new(@blog)
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-          relationships = adapter.serializable_hash[:data][:relationships]
-          expected = {
-            writer: {
-              data: {
-                type: 'authors',
-                id: '1'
-              }
-            },
-            articles: {
-              data: [
-                {
-                  type: 'posts',
-                  id: '42'
-                },
-                {
-                  type: 'posts',
-                  id: '43'
-                }
-              ]
-            }
-          }
-          assert_equal expected, relationships
-        end
-
-        def test_include_linked_resources_with_type_name
-          serializer = BlogSerializer.new(@blog)
-          adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer, include: [:writer, :articles])
-          linked = adapter.serializable_hash[:included]
-          expected = [
-            {
-              id: '1',
-              type: 'authors',
-              attributes: {
-                name: 'Steve K.'
-              },
-              relationships: {
-                posts: { data: [] },
-                roles: { data: [] },
-                bio: { data: nil }
-              }
-            }, {
-              id: '42',
-              type: 'posts',
-              attributes: {
-                title: 'New Post',
-                body: 'Body'
-              },
-              relationships: {
-                comments: { data: [{ type: 'comments', id: '1' }] },
-                blog: { data: { type: 'blogs', id: '999' } },
-                author: { data: { type: 'authors', id: '1' } }
-              }
-            }, {
-              id: '43',
-              type: 'posts',
-              attributes: {
-                title: 'Hello!!',
-                body: 'Hello, world!!'
-              },
-              relationships: {
-                comments: { data: [] },
-                blog: { data: { type: 'blogs', id: '999' } },
-                author: { data: nil }
-              }
-            }
-          ]
-          assert_equal expected, linked
-        end
-      end
-    end
-  end
-end