active_model_serializers 0.10.9 → 0.10.10

data/test/adapter_test.rb

@@ -1,69 +0,0 @@
-# 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

@@ -1,24 +0,0 @@
-# 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

@@ -1,67 +0,0 @@
-# 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

@@ -1,69 +0,0 @@
-# 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

@@ -1,83 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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,121 +0,0 @@
-# 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