active_model_serializers 0.10.0 → 0.10.9

data/test/adapter/json_api/type_test.rb

@@ -1,60 +1,194 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
-module ActiveModel
-  class Serializer
-    module Adapter
-      class JsonApi
-        class TypeTest < ActiveSupport::TestCase
-          class StringTypeSerializer < ActiveModel::Serializer
-            attribute :name
-            type 'profile'
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class TypeTest < ActiveSupport::TestCase
+        class StringTypeSerializer < ActiveModel::Serializer
+          attribute :name
+          type 'profile'
+        end
+
+        class SymbolTypeSerializer < ActiveModel::Serializer
+          attribute :name
+          type :profile
+        end
+
+        setup do
+          @author = Author.new(id: 1, name: 'Steve K.')
+        end
+
+        def test_config_plural
+          with_jsonapi_inflection :plural do
+            assert_type(@author, 'authors')
           end
+        end
 
-          class SymbolTypeSerializer < ActiveModel::Serializer
-            attribute :name
-            type :profile
+        def test_config_singular
+          with_jsonapi_inflection :singular do
+            assert_type(@author, 'author')
           end
+        end
+
+        def test_explicit_string_type_value
+          assert_type(@author, 'profile', serializer: StringTypeSerializer)
+        end
+
+        def test_explicit_symbol_type_value
+          assert_type(@author, 'profile', serializer: SymbolTypeSerializer)
+        end
+
+        private
+
+        def assert_type(resource, expected_type, opts = {})
+          opts = opts.reverse_merge(adapter: :json_api)
+          hash = serializable(resource, opts).serializable_hash
+          assert_equal(expected_type, hash.fetch(:data).fetch(:type))
+        end
+      end
+      class ResourceIdentifierTest < ActiveSupport::TestCase
+        class WithDefinedTypeSerializer < ActiveModel::Serializer
+          type 'with_defined_types'
+        end
+
+        class WithDefinedIdSerializer < ActiveModel::Serializer
+          def id
+            'special_id'
+          end
+        end
+
+        class FragmentedSerializer < ActiveModel::Serializer
+          cache only: :id
+
+          def id
+            'special_id'
+          end
+        end
 
-          setup do
-            @author = Author.new(id: 1, name: 'Steve K.')
+        setup do
+          @model = Author.new(id: 1, name: 'Steve K.')
+          ActionController::Base.cache_store.clear
+        end
+
+        def test_defined_type
+          actual = with_jsonapi_inflection :plural do
+            actual_resource_identifier_object(WithDefinedTypeSerializer, @model)
           end
+          expected = { id: expected_model_id(@model), type: 'with-defined-types' }
+          assert_equal actual, expected
+        end
 
-          def test_config_plural
-            with_jsonapi_resource_type :plural do
-              assert_type(@author, 'authors')
-            end
+        def test_defined_type_not_inflected
+          actual = with_jsonapi_inflection :singular do
+            actual_resource_identifier_object(WithDefinedTypeSerializer, @model)
           end
+          expected = { id: expected_model_id(@model), type: 'with-defined-types' }
+          assert_equal actual, expected
+        end
 
-          def test_config_singular
-            with_jsonapi_resource_type :singular do
-              assert_type(@author, 'author')
-            end
+        def test_singular_type
+          actual = with_jsonapi_inflection :singular do
+            actual_resource_identifier_object(AuthorSerializer, @model)
           end
+          expected = { id: expected_model_id(@model), type: 'author' }
+          assert_equal actual, expected
+        end
 
-          def test_explicit_string_type_value
-            assert_type(@author, 'profile', serializer: StringTypeSerializer)
+        def test_plural_type
+          actual = with_jsonapi_inflection :plural do
+            actual_resource_identifier_object(AuthorSerializer, @model)
           end
+          expected = { id: expected_model_id(@model), type: 'authors' }
+          assert_equal actual, expected
+        end
+
+        def test_type_with_namespace
+          Object.const_set(:Admin, Module.new)
+          model = Class.new(::Model)
+          Admin.const_set(:PowerUser, model)
+          serializer = Class.new(ActiveModel::Serializer)
+          Admin.const_set(:PowerUserSerializer, serializer)
+          with_namespace_separator '--' do
+            admin_user = Admin::PowerUser.new
+            serializer = Admin::PowerUserSerializer.new(admin_user)
+            expected = {
+              id: admin_user.id,
+              type: 'admin--power-users'
+            }
 
-          def test_explicit_symbol_type_value
-            assert_type(@author, 'profile', serializer: SymbolTypeSerializer)
+            identifier = ResourceIdentifier.new(serializer, {})
+            actual = identifier.as_json
+            assert_equal(expected, actual)
           end
+        end
+
+        def test_id_defined_on_object
+          actual = actual_resource_identifier_object(AuthorSerializer, @model)
+          expected = { id: @model.id.to_s, type: expected_model_type(@model) }
+          assert_equal actual, expected
+        end
 
-          private
+        def test_blank_id
+          model = Author.new(id: nil, name: 'Steve K.')
+          actual = actual_resource_identifier_object(AuthorSerializer, model)
+          expected = { type: expected_model_type(model) }
+          assert_equal actual, expected
+        end
+
+        def test_for_type_with_id
+          id = 1
+          actual = ResourceIdentifier.for_type_with_id('admin_user', id, {})
+          expected = { id: '1', type: 'admin-users' }
+          assert_equal actual, expected
+        end
 
-          def assert_type(resource, expected_type, opts = {})
-            opts = opts.reverse_merge(adapter: :json_api)
-            hash = serializable(resource, opts).serializable_hash
-            assert_equal(expected_type, hash.fetch(:data).fetch(:type))
+        def test_for_type_with_id_given_blank_id
+          id = ''
+          actual = ResourceIdentifier.for_type_with_id('admin_user', id, {})
+          expected = { type: 'admin-users' }
+          assert_equal actual, expected
+        end
+
+        def test_for_type_with_id_inflected
+          id = 2
+          actual = with_jsonapi_inflection :singular do
+            ResourceIdentifier.for_type_with_id('admin_users', id, {})
           end
+          expected = { id: '2', type: 'admin-user' }
+          assert_equal actual, expected
+        end
+
+        def test_id_defined_on_serializer
+          actual = actual_resource_identifier_object(WithDefinedIdSerializer, @model)
+          expected = { id: 'special_id', type: expected_model_type(@model) }
+          assert_equal actual, expected
+        end
+
+        def test_id_defined_on_fragmented
+          actual = actual_resource_identifier_object(FragmentedSerializer, @model)
+          expected = { id: 'special_id', type: expected_model_type(@model) }
+          assert_equal actual, expected
+        end
+
+        private
+
+        def actual_resource_identifier_object(serializer_class, model)
+          serializer = serializer_class.new(model)
+          resource_identifier = ResourceIdentifier.new(serializer, nil)
+          resource_identifier.as_json
+        end
 
-          def with_jsonapi_resource_type inflection
-            old_inflection = ActiveModelSerializers.config.jsonapi_resource_type
-            ActiveModelSerializers.config.jsonapi_resource_type = inflection
-            yield
-          ensure
-            ActiveModelSerializers.config.jsonapi_resource_type = old_inflection
+        def expected_model_type(model, inflection = ActiveModelSerializers.config.jsonapi_resource_type)
+          with_jsonapi_inflection inflection do
+            model.class.model_name.send(inflection)
           end
         end
+
+        def expected_model_id(model)
+          model.id.to_s
+        end
       end
     end
   end

data/test/adapter/json_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module ActiveModelSerializers
@@ -32,13 +34,14 @@ module ActiveModelSerializers
         adapter = ActiveModelSerializers::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])
+                       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

data/test/adapter/null_test.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module ActiveModelSerializers
   module Adapter
     class NullTest < ActiveSupport::TestCase
       def setup
-        profile = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+        profile = Profile.new(name: 'Name 1', description: 'Description 1', comments: 'Comments 1')
         serializer = ProfileSerializer.new(profile)
 
         @adapter = Null.new(serializer)
@@ -20,4 +22,3 @@ module ActiveModelSerializers
     end
   end
 end
-

data/test/adapter/polymorphic_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module ActiveModel
@@ -27,11 +29,11 @@ module ActiveModel
               id: 1,
               title: 'headshot-1.jpg',
               imageable: {
-                  type: 'employee',
-                  employee: {
-                    id: 42,
-                    name: 'Zoop Zoopler'
-                  }
+                type: 'employee',
+                employee: {
+                  id: 42,
+                  name: 'Zoop Zoopler'
+                }
               }
             }
 
@@ -165,6 +167,53 @@ module ActiveModel
 
           assert_equal(expected, serialization(@picture, :json_api))
         end
+
+        def test_json_api_serialization_with_polymorphic_belongs_to
+          expected = {
+            data: {
+              id: '1',
+              type: 'poly-tags',
+              attributes: { phrase: 'foo' },
+              relationships: {
+                :"object-tags" => {
+                  data: [
+                    { id: '1', type: 'object-tags' },
+                    { id: '5', type: 'object-tags' }
+                  ]
+                }
+              }
+            },
+            included: [
+              {
+                id: '1',
+                type: 'object-tags',
+                relationships: {
+                  taggable: {
+                    data: { id: '42', type: 'employees' }
+                  }
+                }
+              },
+              {
+                id: '42',
+                type: 'employees'
+              },
+              {
+                id: '5',
+                type: 'object-tags',
+                relationships: {
+                  taggable: {
+                    data: { id: '1', type: 'pictures' }
+                  }
+                }
+              },
+              {
+                id: '1',
+                type: 'pictures'
+              }
+            ]
+          }
+          assert_equal(expected, tag_serialization(:json_api))
+        end
       end
     end
   end

data/test/adapter_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module ActiveModelSerializers
@@ -51,7 +53,7 @@ module ActiveModelSerializers
     end
 
     def test_create_adapter_with_override
-      adapter = ActiveModelSerializers::Adapter.create(@serializer, { adapter: :json_api })
+      adapter = ActiveModelSerializers::Adapter.create(@serializer, adapter: :json_api)
       assert_equal ActiveModelSerializers::Adapter::JsonApi, adapter.class
     end
 

data/test/array_serializer_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require_relative 'collection_serializer_test'
 

data/test/benchmark/app.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # https://github.com/rails-api/active_model_serializers/pull/872
 # approx ref 792fb8a9053f8db3c562dae4f40907a582dd1720 to test against
 require 'bundler/setup'
@@ -43,7 +45,7 @@ class BenchmarkApp < Rails::Application
   config.secret_key_base = 'abc123'
   config.consider_all_requests_local = false
 
-  # otherwise deadlock occured
+  # otherwise deadlock occurred
   config.middleware.delete 'Rack::Lock'
 
   # to disable log files

data/test/benchmark/benchmarking_support.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'benchmark/ips'
 require 'json'
 
@@ -36,7 +38,7 @@ module Benchmark
         version: ::ActiveModel::Serializer::VERSION.to_s,
         rails_version: ::Rails.version.to_s,
         iterations_per_second: entry.ips,
-        iterations_per_second_standard_deviation: entry.stddev_percentage,
+        iterations_per_second_standard_deviation: entry.error_percentage,
         total_allocated_objects_per_iteration: count_total_allocated_objects(&block)
       }.to_json
 

data/test/benchmark/bm_active_record.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative './benchmarking_support'
+require_relative './app'
+
+time = 10
+disable_gc = true
+
+# This is to disable any key transform effects that may impact performance
+ActiveModelSerializers.config.key_transform = :unaltered
+
+###########################################
+# Setup active record models
+##########################################
+require 'active_record'
+require 'sqlite3'
+
+# For debugging SQL output
+# ActiveRecord::Base.logger = Logger.new(STDERR)
+
+# Change the following to reflect your database settings
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: ':memory:'
+)
+
+# Don't show migration output when constructing fake db
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+  create_table :authors, force: true do |t|
+    t.string :name
+  end
+
+  create_table :posts, force: true do |t|
+    t.text :body
+    t.string :title
+    t.references :author
+  end
+
+  create_table :profiles, force: true do |t|
+    t.text :project_url
+    t.text :bio
+    t.date :birthday
+    t.references :author
+  end
+end
+
+class Author < ActiveRecord::Base
+  has_one :profile
+  has_many :posts
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :author
+end
+
+class Profile < ActiveRecord::Base
+  belongs_to :author
+end
+
+# Build out the data to serialize
+author = Author.create(name: 'Preston Sego')
+Profile.create(project_url: 'https://github.com/NullVoxPopuli', author: author)
+50.times do
+  Post.create(
+    body: 'something about how password restrictions are evil, and less secure, and with the math to prove it.',
+    title: 'Your bank is does not know how to do security',
+    author: author
+  )
+end
+
+Benchmark.ams('AR: attributes', time: time, disable_gc: disable_gc) do
+  ActiveModelSerializers::SerializableResource.new(author, adapter: :attributes, include: 'profile,posts').serializable_hash
+end
+
+Benchmark.ams('AR: json', time: time, disable_gc: disable_gc) do
+  ActiveModelSerializers::SerializableResource.new(author, adapter: :json, include: 'profile,posts').serializable_hash
+end
+
+Benchmark.ams('AR: JSON API', time: time, disable_gc: disable_gc) do
+  ActiveModelSerializers::SerializableResource.new(author, adapter: :json_api, include: 'profile,posts').serializable_hash
+end

data/test/benchmark/bm_adapter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative './benchmarking_support'
+require_relative './app'
+
+time = 10
+disable_gc = true
+ActiveModelSerializers.config.key_transform = :unaltered
+has_many_relationships = (0..60).map do |i|
+  HasManyRelationship.new(id: i, body: 'ZOMG A HAS MANY RELATIONSHIP')
+end
+has_one_relationship = HasOneRelationship.new(
+  id: 42,
+  first_name: 'Joao',
+  last_name: 'Moura'
+)
+primary_resource = PrimaryResource.new(
+  id: 1337,
+  title: 'New PrimaryResource',
+  virtual_attribute: nil,
+  body: 'Body',
+  has_many_relationships: has_many_relationships,
+  has_one_relationship: has_one_relationship
+)
+serializer = PrimaryResourceSerializer.new(primary_resource)
+
+Benchmark.ams('attributes', time: time, disable_gc: disable_gc) do
+  attributes = ActiveModelSerializers::Adapter::Attributes.new(serializer)
+  attributes.as_json
+end
+
+Benchmark.ams('json_api', time: time, disable_gc: disable_gc) do
+  json_api = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
+  json_api.as_json
+end
+
+Benchmark.ams('json', time: time, disable_gc: disable_gc) do
+  json = ActiveModelSerializers::Adapter::Json.new(serializer)
+  json.as_json
+end

data/test/benchmark/bm_caching.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require_relative './benchmarking_support'
 require_relative './app'
 
 # https://github.com/ruby-bench/ruby-bench-suite/blob/8ad567f7e43a044ae48c36833218423bb1e2bd9d/rails/benchmarks/actionpack_router.rb
 class ApiAssertion
   include Benchmark::ActiveModelSerializers::TestMethods
-  BadRevisionError = Class.new(StandardError)
+  class BadRevisionError < StandardError; end
 
   def valid?
     caching = get_caching
@@ -66,27 +68,27 @@ class ApiAssertion
   def expected
     @expected ||=
       {
-        'post' =>  {
-          'id' =>  1337,
-          'title' => 'New Post',
+        'primary_resource' => {
+          'id' => 1337,
+          'title' => 'New PrimaryResource',
           'body' =>  'Body',
-          'comments' => [
-            {
-              'id' => 1,
-              'body' => 'ZOMG A COMMENT'
-            }
-          ],
-          'blog' =>  {
-            'id' =>  999,
-            'name' => 'Custom blog'
+          'virtual_attribute' => {
+            'id' => 999,
+            'name' => 'Free-Range Virtual Attribute'
           },
-          'author' => {
+          'has_one_relationship' => {
             'id' => 42,
             'first_name' => 'Joao',
             'last_name' => 'Moura'
-          }
+          },
+          'has_many_relationships' => [
+            {
+              'id' => 1,
+              'body' => 'ZOMG A HAS MANY RELATIONSHIP'
+            }
+          ]
         }
-    }
+      }
   end
 
   def assert_equal(expected, actual, message)

data/test/benchmark/bm_lookup_chain.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative './benchmarking_support'
+require_relative './app'
+
+time = 10
+disable_gc = true
+ActiveModelSerializers.config.key_transform = :unaltered
+
+module AmsBench
+  module Api
+    module V1
+      class PrimaryResourceSerializer < ActiveModel::Serializer
+        attributes :title, :body
+
+        has_many :has_many_relationships
+      end
+
+      class HasManyRelationshipSerializer < ActiveModel::Serializer
+        attribute :body
+      end
+    end
+  end
+  class PrimaryResourceSerializer < ActiveModel::Serializer
+    attributes :title, :body
+
+    has_many :has_many_relationships
+
+    class HasManyRelationshipSerializer < ActiveModel::Serializer
+      attribute :body
+    end
+  end
+end
+
+resource = PrimaryResource.new(
+  id: 1,
+  title: 'title',
+  body: 'body',
+  has_many_relationships: [
+    HasManyRelationship.new(id: 1, body: 'body1'),
+    HasManyRelationship.new(id: 2, body: 'body1')
+  ]
+)
+
+serialization = lambda do
+  ActiveModelSerializers::SerializableResource.new(resource, serializer: AmsBench::PrimaryResourceSerializer).as_json
+  ActiveModelSerializers::SerializableResource.new(resource, namespace: AmsBench::Api::V1).as_json
+  ActiveModelSerializers::SerializableResource.new(resource).as_json
+end
+
+def clear_cache
+  AmsBench::PrimaryResourceSerializer.serializers_cache.clear
+  AmsBench::Api::V1::PrimaryResourceSerializer.serializers_cache.clear
+  ActiveModel::Serializer.serializers_cache.clear
+end
+
+configurable = lambda do
+  clear_cache
+  Benchmark.ams('Configurable Lookup Chain', time: time, disable_gc: disable_gc, &serialization)
+end
+
+old = lambda do
+  clear_cache
+  module ActiveModel
+    class Serializer
+      def self.serializer_lookup_chain_for(klass, namespace = nil)
+        chain = []
+
+        resource_class_name = klass.name.demodulize
+        resource_namespace = klass.name.deconstantize
+        serializer_class_name = "#{resource_class_name}Serializer"
+
+        chain.push("#{namespace}::#{serializer_class_name}") if namespace
+        chain.push("#{name}::#{serializer_class_name}") if self != ActiveModel::Serializer
+        chain.push("#{resource_namespace}::#{serializer_class_name}")
+        chain
+      end
+    end
+  end
+
+  Benchmark.ams('Old Lookup Chain (v0.10)', time: time, disable_gc: disable_gc, &serialization)
+end
+
+configurable.call
+old.call