active_model_serializers_custom 0.10.90

data/test/adapter_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module ActiveModelSerializers
+  class AdapterTest < ActiveSupport::TestCase
+    def setup
+      profile = Profile.new
+      @serializer = ProfileSerializer.new(profile)
+      @adapter = ActiveModelSerializers::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_serialization_options_ensures_option_is_a_hash
+      adapter = Class.new(ActiveModelSerializers::Adapter::Base) do
+        def serializable_hash(options = nil)
+          serialization_options(options)
+        end
+      end.new(@serializer)
+      assert_equal({}, adapter.serializable_hash(nil))
+      assert_equal({}, adapter.serializable_hash({}))
+    ensure
+      ActiveModelSerializers::Adapter.adapter_map.delete_if { |k, _| k =~ /class/ }
+    end
+
+    def test_serialization_options_ensures_option_is_one_of_valid_options
+      adapter = Class.new(ActiveModelSerializers::Adapter::Base) do
+        def serializable_hash(options = nil)
+          serialization_options(options)
+        end
+      end.new(@serializer)
+      filtered_options = { now: :see_me, then: :not }
+      valid_options = ActiveModel::Serializer::SERIALIZABLE_HASH_VALID_KEYS.each_with_object({}) do |option, result|
+        result[option] = option
+      end
+      assert_equal(valid_options, adapter.serializable_hash(filtered_options.merge(valid_options)))
+    ensure
+      ActiveModelSerializers::Adapter.adapter_map.delete_if { |k, _| k =~ /class/ }
+    end
+
+    def test_serializer
+      assert_equal @serializer, @adapter.serializer
+    end
+
+    def test_create_adapter
+      adapter = ActiveModelSerializers::Adapter.create(@serializer)
+      assert_equal ActiveModelSerializers::Adapter::Attributes, adapter.class
+    end
+
+    def test_create_adapter_with_override
+      adapter = ActiveModelSerializers::Adapter.create(@serializer, adapter: :json_api)
+      assert_equal ActiveModelSerializers::Adapter::JsonApi, adapter.class
+    end
+
+    def test_inflected_adapter_class_for_known_adapter
+      ActiveSupport::Inflector.inflections(:en) { |inflect| inflect.acronym 'API' }
+      klass = ActiveModelSerializers::Adapter.adapter_class(:json_api)
+
+      ActiveSupport::Inflector.inflections.acronyms.clear
+
+      assert_equal ActiveModelSerializers::Adapter::JsonApi, klass
+    end
+  end
+end

data/test/array_serializer_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require_relative 'collection_serializer_test'
+
+module ActiveModel
+  class Serializer
+    class ArraySerializerTest < CollectionSerializerTest
+      extend Minitest::Assertions
+      def self.run_one_method(*)
+        _, stderr = capture_io do
+          super
+        end
+        if stderr !~ /NOTE: ActiveModel::Serializer::ArraySerializer.new is deprecated/
+          fail Minitest::Assertion, stderr
+        end
+      end
+
+      def collection_serializer
+        ArraySerializer
+      end
+    end
+  end
+end

data/test/benchmark/app.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# https://github.com/rails-api/active_model_serializers/pull/872
+# approx ref 792fb8a9053f8db3c562dae4f40907a582dd1720 to test against
+require 'bundler/setup'
+
+require 'rails'
+require 'active_model'
+require 'active_support'
+require 'active_support/json'
+require 'action_controller'
+require 'action_controller/test_case'
+require 'action_controller/railtie'
+abort "Rails application already defined: #{Rails.application.class}" if Rails.application
+
+class NullLogger < Logger
+  def initialize(*_args)
+  end
+
+  def add(*_args, &_block)
+  end
+end
+class BenchmarkLogger < ActiveSupport::Logger
+  def initialize
+    @file = StringIO.new
+    super(@file)
+  end
+
+  def messages
+    @file.rewind
+    @file.read
+  end
+end
+# ref: https://gist.github.com/bf4/8744473
+class BenchmarkApp < Rails::Application
+  # Set up production configuration
+  config.eager_load = true
+  config.cache_classes = true
+  # CONFIG: CACHE_ON={on,off}
+  config.action_controller.perform_caching = ENV['CACHE_ON'] != 'off'
+  config.action_controller.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
+
+  config.active_support.test_order = :random
+  config.secret_token = 'S' * 30
+  config.secret_key_base = 'abc123'
+  config.consider_all_requests_local = false
+
+  # otherwise deadlock occurred
+  config.middleware.delete 'Rack::Lock'
+
+  # to disable log files
+  config.logger = NullLogger.new
+  config.active_support.deprecation = :log
+  config.log_level = :info
+end
+
+require 'active_model_serializers'
+
+# Initialize app before any serializers are defined, for running across revisions.
+# ref: https://github.com/rails-api/active_model_serializers/pull/1478
+Rails.application.initialize!
+# HACK: Serializer::cache depends on the ActionController-dependent configs being set.
+ActiveSupport.on_load(:action_controller) do
+  require_relative 'fixtures'
+end
+
+require_relative 'controllers'

data/test/benchmark/benchmarking_support.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+require 'json'
+
+# Add benchmarking runner from ruby-bench-suite
+# https://github.com/ruby-bench/ruby-bench-suite/blob/master/rails/benchmarks/support/benchmark_rails.rb
+module Benchmark
+  module ActiveModelSerializers
+    module TestMethods
+      def request(method, path)
+        response = Rack::MockRequest.new(BenchmarkApp).send(method, path)
+        if response.status.in?([404, 500])
+          fail "omg, #{method}, #{path}, '#{response.status}', '#{response.body}'"
+        end
+        response
+      end
+    end
+
+    # extend Benchmark with an `ams` method
+    def ams(label = nil, time:, disable_gc: true, warmup: 3, &block)
+      fail ArgumentError.new, 'block should be passed' unless block_given?
+
+      if disable_gc
+        GC.disable
+      else
+        GC.enable
+      end
+
+      report = Benchmark.ips(time, warmup, true) do |x|
+        x.report(label) { yield }
+      end
+
+      entry = report.entries.first
+
+      output = {
+        label: label,
+        version: ::ActiveModel::Serializer::VERSION.to_s,
+        rails_version: ::Rails.version.to_s,
+        iterations_per_second: entry.ips,
+        iterations_per_second_standard_deviation: entry.error_percentage,
+        total_allocated_objects_per_iteration: count_total_allocated_objects(&block)
+      }.to_json
+
+      puts output
+      output
+    end
+
+    def count_total_allocated_objects
+      if block_given?
+        key =
+          if RUBY_VERSION < '2.2'
+            :total_allocated_object
+          else
+            :total_allocated_objects
+          end
+
+        before = GC.stat[key]
+        yield
+        after = GC.stat[key]
+        after - before
+      else
+        -1
+      end
+    end
+  end
+
+  extend Benchmark::ActiveModelSerializers
+end

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

@@ -0,0 +1,121 @@
+# 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
+  class BadRevisionError < StandardError; end
+
+  def valid?
+    caching = get_caching
+    caching[:body].delete('meta')
+    non_caching = get_non_caching
+    non_caching[:body].delete('meta')
+    assert_responses(caching, non_caching)
+  rescue BadRevisionError => e
+    msg = { error: e.message }
+    STDERR.puts msg
+    STDOUT.puts msg
+    exit 1
+  end
+
+  def get_status(on_off = 'on'.freeze)
+    get("/status/#{on_off}")
+  end
+
+  def clear
+    get('/clear')
+  end
+
+  def get_caching(on_off = 'on'.freeze)
+    get("/caching/#{on_off}")
+  end
+
+  def get_fragment_caching(on_off = 'on'.freeze)
+    get("/fragment_caching/#{on_off}")
+  end
+
+  def get_non_caching(on_off = 'on'.freeze)
+    get("/non_caching/#{on_off}")
+  end
+
+  def debug(msg = '')
+    if block_given? && ENV['DEBUG'] =~ /\Atrue|on|0\z/i
+      STDERR.puts yield
+    else
+      STDERR.puts msg
+    end
+  end
+
+  private
+
+  def assert_responses(caching, non_caching)
+    assert_equal(caching[:code], 200, "Caching response failed: #{caching}")
+    assert_equal(caching[:body], expected, "Caching response format failed: \n+ #{caching[:body]}\n- #{expected}")
+    assert_equal(caching[:content_type], 'application/json; charset=utf-8', "Caching response content type  failed: \n+ #{caching[:content_type]}\n- application/json")
+    assert_equal(non_caching[:code], 200, "Non caching response failed: #{non_caching}")
+    assert_equal(non_caching[:body], expected, "Non Caching response format failed: \n+ #{non_caching[:body]}\n- #{expected}")
+    assert_equal(non_caching[:content_type], 'application/json; charset=utf-8', "Non caching response content type  failed: \n+ #{non_caching[:content_type]}\n- application/json")
+  end
+
+  def get(url)
+    response = request(:get, url)
+    { code: response.status, body: JSON.load(response.body), content_type: response.content_type }
+  end
+
+  def expected
+    @expected ||=
+      {
+        'primary_resource' => {
+          'id' => 1337,
+          'title' => 'New PrimaryResource',
+          'body' =>  'Body',
+          'virtual_attribute' => {
+            'id' => 999,
+            'name' => 'Free-Range Virtual Attribute'
+          },
+          '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)
+    return true if expected == actual
+    if ENV['FAIL_ASSERTION'] =~ /\Atrue|on|0\z/i # rubocop:disable Style/GuardClause
+      fail BadRevisionError, message
+    else
+      STDERR.puts message unless ENV['SUMMARIZE']
+    end
+  end
+end
+assertion = ApiAssertion.new
+assertion.valid?
+assertion.debug { assertion.get_status }
+
+time = 10
+{
+  'caching on: caching serializers: gc off' => { disable_gc: true, send: [:get_caching, 'on'] },
+  'caching on: fragment caching serializers: gc off' => { disable_gc: true, send: [:get_fragment_caching, 'on'] },
+  'caching on: non-caching serializers: gc off' => { disable_gc: true, send: [:get_non_caching, 'on'] },
+  'caching off: caching serializers: gc off' => { disable_gc: true, send: [:get_caching, 'off'] },
+  'caching off: fragment caching serializers: gc off' => { disable_gc: true, send: [:get_fragment_caching, 'off'] },
+  'caching off: non-caching serializers: gc off' => { disable_gc: true, send: [:get_non_caching, 'off'] }
+}.each do |label, options|
+  assertion.clear
+  Benchmark.ams(label, time: time, disable_gc: options[:disable_gc]) do
+    assertion.send(*options[:send])
+  end
+  assertion.debug { assertion.get_status(options[:send][-1]) }
+end