active_model_serializers 0.8.3 → 0.10.0.rc4

data/test/adapter/json_api/parse_test.rb

@@ -0,0 +1,139 @@
+require 'test_helper'
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        module Deserialization
+          class ParseTest < Minitest::Test
+            def setup
+              @hash = {
+                'data' => {
+                  'type' => 'photos',
+                  'id' => 'zorglub',
+                  'attributes' => {
+                    'title' => 'Ember Hamster',
+                    'src' => 'http://example.com/images/productivity.png'
+                  },
+                  'relationships' => {
+                    'author' => {
+                      'data' => nil
+                    },
+                    'photographer' => {
+                      'data' => { 'type' => 'people', 'id' => '9' }
+                    },
+                    'comments' => {
+                      'data' => [
+                        { 'type' => 'comments', 'id' => '1' },
+                        { 'type' => 'comments', 'id' => '2' }
+                      ]
+                    }
+                  }
+                }
+              }
+              @params = ActionController::Parameters.new(@hash)
+              @expected = {
+                id: 'zorglub',
+                title: 'Ember Hamster',
+                src: 'http://example.com/images/productivity.png',
+                author_id: nil,
+                photographer_id: '9',
+                comment_ids: %w(1 2)
+              }
+
+              @illformed_payloads = [nil,
+                                     {},
+                                     {
+                                       'data' => nil
+                                     }, {
+                                       'data' => { 'attributes' => [] }
+                                     }, {
+                                       'data' => { 'relationships' => [] }
+                                     }, {
+                                       'data' => {
+                                         'relationships' => { 'rel' => nil }
+                                       }
+                                     }, {
+                                       'data' => {
+                                         'relationships' => { 'rel' => {} }
+                                       }
+                                     }]
+            end
+
+            def test_hash
+              parsed_hash = ActiveModel::Serializer::Adapter::JsonApi::Deserialization.parse!(@hash)
+              assert_equal(@expected, parsed_hash)
+            end
+
+            def test_actioncontroller_parameters
+              assert_equal(false, @params.permitted?)
+              parsed_hash = ActiveModel::Serializer::Adapter::JsonApi::Deserialization.parse!(@params)
+              assert_equal(@expected, parsed_hash)
+            end
+
+            def test_illformed_payloads_safe
+              @illformed_payloads.each do |p|
+                parsed_hash = ActiveModel::Serializer::Adapter::JsonApi::Deserialization.parse(p)
+                assert_equal({}, parsed_hash)
+              end
+            end
+
+            def test_illformed_payloads_unsafe
+              @illformed_payloads.each do |p|
+                assert_raises(InvalidDocument) do
+                  ActiveModel::Serializer::Adapter::JsonApi::Deserialization.parse!(p)
+                end
+              end
+            end
+
+            def test_filter_fields_only
+              parsed_hash = ActiveModel::Serializer::Adapter::JsonApi::Deserialization.parse!(@hash, only: [:id, :title, :author])
+              expected = {
+                id: 'zorglub',
+                title: 'Ember Hamster',
+                author_id: nil
+              }
+              assert_equal(expected, parsed_hash)
+            end
+
+            def test_filter_fields_except
+              parsed_hash = ActiveModel::Serializer::Adapter::JsonApi::Deserialization.parse!(@hash, except: [:id, :title, :author])
+              expected = {
+                src: 'http://example.com/images/productivity.png',
+                photographer_id: '9',
+                comment_ids: %w(1 2)
+              }
+              assert_equal(expected, parsed_hash)
+            end
+
+            def test_keys
+              parsed_hash = ActiveModel::Serializer::Adapter::JsonApi::Deserialization.parse!(@hash, keys: { author: :user, title: :post_title })
+              expected = {
+                id: 'zorglub',
+                post_title: 'Ember Hamster',
+                src: 'http://example.com/images/productivity.png',
+                user_id: nil,
+                photographer_id: '9',
+                comment_ids: %w(1 2)
+              }
+              assert_equal(expected, parsed_hash)
+            end
+
+            def test_polymorphic
+              parsed_hash = ActiveModel::Serializer::Adapter::JsonApi::Deserialization.parse!(@hash, polymorphic: [:photographer])
+              expected = {
+                id: 'zorglub',
+                title: 'Ember Hamster',
+                src: 'http://example.com/images/productivity.png',
+                author_id: nil,
+                photographer_id: '9',
+                photographer_type: 'people',
+                comment_ids: %w(1 2)
+              }
+              assert_equal(expected, parsed_hash)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/adapter/json_api/resource_type_config_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        class ResourceTypeConfigTest < ActiveSupport::TestCase
+          class ProfileTypeSerializer < ActiveModel::Serializer
+            attributes :name
+            type 'profile'
+          end
+
+          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 with_jsonapi_resource_type type
+            old_type = ActiveModelSerializers.config.jsonapi_resource_type
+            ActiveModelSerializers.config.jsonapi_resource_type = type
+            yield
+          ensure
+            ActiveModelSerializers.config.jsonapi_resource_type = old_type
+          end
+
+          def test_config_plural
+            with_jsonapi_resource_type :plural do
+              hash = serializable(@comment, adapter: :json_api).serializable_hash
+              assert_equal('comments', hash[:data][:type])
+            end
+          end
+
+          def test_config_singular
+            with_jsonapi_resource_type :singular do
+              hash = serializable(@comment, adapter: :json_api).serializable_hash
+              assert_equal('comment', hash[:data][:type])
+            end
+          end
+
+          def test_explicit_type_value
+            hash = serializable(@author, serializer: ProfileTypeSerializer, adapter: :json_api).serializable_hash
+            assert_equal('profile', hash.fetch(:data).fetch(:type))
+          end
+
+          private
+
+          def serializable(resource, options = {})
+            ActiveModel::SerializableResource.new(resource, options)
+          end
+        end
+      end
+    end
+  end
+end

data/test/adapter/json_api/toplevel_jsonapi_test.rb

@@ -0,0 +1,84 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    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
+end

data/test/adapter/json_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonTest < 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
+
+          @serializer = PostSerializer.new(@post)
+          @adapter = ActiveModel::Serializer::Adapter::Json.new(@serializer)
+        end
+
+        def test_has_many
+          assert_equal([
+                         { id: 1, body: 'ZOMG A COMMENT' },
+                         { id: 2, body: 'ZOMG ANOTHER COMMENT' }
+                       ], @adapter.serializable_hash[:post][:comments])
+        end
+
+        def test_custom_keys
+          serializer = PostWithCustomKeysSerializer.new(@post)
+          adapter = ActiveModel::Serializer::Adapter::Json.new(serializer)
+
+          assert_equal({
+            id: 1,
+            reviews: [{ id: 1, body: 'ZOMG A COMMENT' },
+                      { id: 2, body: 'ZOMG ANOTHER COMMENT' }
+                    ],
+            writer: { id: 1, name: 'Steve K.' },
+            site: { id: 1, name: 'My Blog!!' }
+            }, adapter.serializable_hash[:post])
+        end
+      end
+    end
+  end
+end

data/test/adapter/null_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class NullTest < ActiveSupport::TestCase
+        def setup
+          profile = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+          serializer = ProfileSerializer.new(profile)
+
+          @adapter = Null.new(serializer)
+        end
+
+        def test_serializable_hash
+          assert_equal({}, @adapter.serializable_hash)
+        end
+
+        def test_it_returns_empty_json
+          assert_equal('{}', @adapter.to_json)
+        end
+      end
+    end
+  end
+end
+

data/test/adapter_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AdapterTest < ActiveSupport::TestCase
+      def setup
+        profile = Profile.new
+        @serializer = ProfileSerializer.new(profile)
+        @adapter = ActiveModel::Serializer::Adapter::Base.new(@serializer)
+      end
+
+      def test_serializable_hash_is_abstract_method
+        assert_raises(NotImplementedError) do
+          @adapter.serializable_hash(only: [:name])
+        end
+      end
+
+      def test_serializer
+        assert_equal @serializer, @adapter.serializer
+      end
+
+      def test_create_adapter
+        adapter = ActiveModel::Serializer::Adapter.create(@serializer)
+        assert_equal ActiveModel::Serializer::Adapter::Attributes, adapter.class
+      end
+
+      def test_create_adapter_with_override
+        adapter = ActiveModel::Serializer::Adapter.create(@serializer, { adapter: :json_api })
+        assert_equal ActiveModel::Serializer::Adapter::JsonApi, adapter.class
+      end
+
+      def test_inflected_adapter_class_for_known_adapter
+        ActiveSupport::Inflector.inflections(:en) { |inflect| inflect.acronym 'API' }
+        klass = ActiveModel::Serializer::Adapter.adapter_class(:json_api)
+
+        ActiveSupport::Inflector.inflections.acronyms.clear
+
+        assert_equal ActiveModel::Serializer::Adapter::JsonApi, klass
+      end
+    end
+  end
+end

data/test/array_serializer_test.rb

@@ -1,75 +1,38 @@
-require "test_helper"
-require "test_fakes"
-
-class ArraySerializerTest < ActiveModel::TestCase
-
-  def test_array_items_do_not_have_root
-    array = [
-        BasicActiveModel.new(:name => "First model"),
-        BasicActiveModel.new(:name => "Second model")
-    ]
-    expected = { "root" => [
-        { :name => "First model" },
-        { :name => "Second model" }
-    ] }
-
-    default_serializer = array.active_model_serializer.new(array, :root => "root")
-    each_serializer = array.active_model_serializer.new(array, :root => "root", :each_serializer => BasicSerializer)
-
-    default_json = default_serializer.as_json
-    each_json = each_serializer.as_json
-
-    assert_equal(expected, default_json)
-    assert_equal(expected, each_json)
-  end
-
-  # serialize different typed objects
-  def test_array_serializer
-    model    = Model.new
-    user     = User.new
-    comments = Comment.new(:title => "Comment1", :id => 1)
-
-    array = [model, user, comments]
-    serializer = array.active_model_serializer.new(array, :scope => {:scope => true})
-    assert_equal([
-      { :model => "Model" },
-      { :last_name => "Valim", :ok => true, :first_name => "Jose", :scope => true },
-      { :title => "Comment1" }
-    ], serializer.as_json)
-  end
-
-  def test_array_serializer_with_root
-    comment1 = Comment.new(:title => "Comment1", :id => 1)
-    comment2 = Comment.new(:title => "Comment2", :id => 2)
-
-    array = [ comment1, comment2 ]
-
-    serializer = array.active_model_serializer.new(array, :root => :comments)
-
-    assert_equal({ :comments => [
-      { :title => "Comment1" },
-      { :title => "Comment2" }
-    ]}, serializer.as_json)
-  end
-
-  def test_array_serializer_with_hash
-    hash = {:value => "something"}
-    array = [hash]
-    serializer = array.active_model_serializer.new(array, :root => :items)
-    assert_equal({ :items => [ hash.as_json ]}, serializer.as_json)
-  end
-
-  def test_array_serializer_with_specified_seriailizer
-    post1 = Post.new(:title => "Post1", :author => "Author1", :id => 1)
-    post2 = Post.new(:title => "Post2", :author => "Author2", :id => 2)
-
-    array = [ post1, post2 ]
-
-    serializer = array.active_model_serializer.new array, :each_serializer => CustomPostSerializer
-
-    assert_equal([
-      { :title => "Post1" },
-      { :title => "Post2" }
-    ], serializer.as_json)
+require 'test_helper'
+require_relative 'collection_serializer_test'
+
+module ActiveModel
+  class Serializer
+    # Minitest.run_one_method isn't present in minitest 4
+    if $minitest_version > 4 # rubocop:disable Style/GlobalVars
+      class ArraySerializerTest < CollectionSerializerTest
+        extend ActiveSupport::Testing::Stream
+        def self.run_one_method(*)
+          stderr = (capture(:stderr) do
+            super
+          end)
+          if stderr !~ /Calling deprecated ArraySerializer/
+            fail Minitest::Assertion, stderr
+          end
+        end
+
+        def collection_serializer
+          ArraySerializer
+        end
+      end
+    else
+      class ArraySerializerTest < ActiveSupport::TestCase
+        extend ActiveSupport::Testing::Stream
+        def test_json_key_with_root_warns_when_using_array_serializer
+          stderr = (capture(:stderr) do
+            comment = Comment.new
+            post = Post.new
+            serializer = ArraySerializer.new([comment, post])
+            assert_equal 'comments', serializer.json_key
+          end)
+          assert_match(/Calling deprecated ArraySerializer/, stderr)
+        end
+      end
+    end
   end
 end

data/test/collection_serializer_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class CollectionSerializerTest < ActiveSupport::TestCase
+      def setup
+        @comment = Comment.new
+        @post = Post.new
+        @resource = build_named_collection @comment, @post
+        @serializer = collection_serializer.new(@resource, { some: :options })
+      end
+
+      def collection_serializer
+        CollectionSerializer
+      end
+
+      def build_named_collection(*resource)
+        resource.define_singleton_method(:name) { 'MeResource' }
+        resource
+      end
+
+      def test_has_object_reader_serializer_interface
+        assert_equal @serializer.object, @resource
+      end
+
+      def test_respond_to_each
+        assert_respond_to @serializer, :each
+      end
+
+      def test_each_object_should_be_serialized_with_appropriate_serializer
+        serializers =  @serializer.to_a
+
+        assert_kind_of CommentSerializer, serializers.first
+        assert_kind_of Comment, serializers.first.object
+
+        assert_kind_of PostSerializer, serializers.last
+        assert_kind_of Post, serializers.last.object
+
+        assert_equal :options, serializers.last.custom_options[:some]
+      end
+
+      def test_serializer_option_not_passed_to_each_serializer
+        serializers = collection_serializer.new([@post], { serializer: PostSerializer }).to_a
+
+        refute serializers.first.custom_options.key?(:serializer)
+      end
+
+      def test_root_default
+        @serializer = collection_serializer.new([@comment, @post])
+        assert_nil @serializer.root
+      end
+
+      def test_root
+        expected =  'custom_root'
+        @serializer = collection_serializer.new([@comment, @post], root: expected)
+        assert_equal expected, @serializer.root
+      end
+
+      def test_root_with_no_serializers
+        expected =  'custom_root'
+        @serializer = collection_serializer.new([], root: expected)
+        assert_equal expected, @serializer.root
+      end
+
+      def test_json_key_with_resource_with_serializer
+        singular_key = @serializer.send(:serializers).first.json_key
+        assert_equal singular_key.pluralize, @serializer.json_key
+      end
+
+      def test_json_key_with_resource_with_name_and_no_serializers
+        serializer = collection_serializer.new(build_named_collection)
+        assert_equal 'me_resources', serializer.json_key
+      end
+
+      def test_json_key_with_resource_with_nil_name_and_no_serializers
+        resource = []
+        resource.define_singleton_method(:name) { nil }
+        serializer = collection_serializer.new(resource)
+        assert_nil serializer.json_key
+      end
+
+      def test_json_key_with_resource_without_name_and_no_serializers
+        serializer = collection_serializer.new([])
+        assert_nil serializer.json_key
+      end
+
+      def test_json_key_with_root
+        expected = 'custom_root'
+        serializer = collection_serializer.new(@resource, root: expected)
+        assert_equal expected, serializer.json_key
+      end
+
+      def test_json_key_with_root_and_no_serializers
+        expected = 'custom_root'
+        serializer = collection_serializer.new(build_named_collection, root: expected)
+        assert_equal expected, serializer.json_key
+      end
+    end
+  end
+end

data/test/fixtures/active_record.rb

@@ -0,0 +1,56 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ActiveRecord::Schema.define do
+  create_table :posts, force: true do |t|
+    t.string :title
+    t.text :body
+    t.references :author
+    t.timestamps null: false
+  end
+  create_table :authors, force: true do |t|
+    t.string :name
+    t.timestamps null: false
+  end
+  create_table :comments, force: true do |t|
+    t.text :contents
+    t.references :author
+    t.references :post
+    t.timestamp null: false
+  end
+end
+
+module ARModels
+  class Post < ActiveRecord::Base
+    has_many :comments
+    belongs_to :author
+  end
+
+  class Comment < ActiveRecord::Base
+    belongs_to :post
+    belongs_to :author
+  end
+
+  class Author < ActiveRecord::Base
+    has_many :posts
+  end
+
+  class PostSerializer < ActiveModel::Serializer
+    attributes :id, :title, :body
+
+    has_many :comments
+    belongs_to :author
+  end
+
+  class CommentSerializer < ActiveModel::Serializer
+    attributes :id, :contents
+
+    belongs_to :author
+  end
+
+  class AuthorSerializer < ActiveModel::Serializer
+    attributes :id, :name
+
+    has_many :posts
+  end
+end