active_model_serializers 0.10.0 → 0.10.11

data/test/adapter/polymorphic_test.rb

@@ -1,171 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    module Adapter
-      class PolymorphicTest < ActiveSupport::TestCase
-        setup do
-          @employee = Employee.new(id: 42, name: 'Zoop Zoopler', email: 'zoop@example.com')
-          @picture = @employee.pictures.new(id: 1, title: 'headshot-1.jpg')
-          @picture.imageable = @employee
-        end
-
-        def serialization(resource, adapter = :attributes)
-          serializable(resource, adapter: adapter, serializer: PolymorphicBelongsToSerializer).as_json
-        end
-
-        def tag_serialization(adapter = :attributes)
-          tag = PolyTag.new(id: 1, phrase: 'foo')
-          tag.object_tags << ObjectTag.new(id: 1, poly_tag_id: 1, taggable: @employee)
-          tag.object_tags << ObjectTag.new(id: 5, poly_tag_id: 1, taggable: @picture)
-          serializable(tag, adapter: adapter, serializer: PolymorphicTagSerializer, include: '*.*').as_json
-        end
-
-        def test_attributes_serialization
-          expected =
-            {
-              id: 1,
-              title: 'headshot-1.jpg',
-              imageable: {
-                  type: 'employee',
-                  employee: {
-                    id: 42,
-                    name: 'Zoop Zoopler'
-                  }
-              }
-            }
-
-          assert_equal(expected, serialization(@picture))
-        end
-
-        def test_attributes_serialization_without_polymorphic_association
-          expected =
-            {
-              id: 2,
-              title: 'headshot-2.jpg',
-              imageable: nil
-            }
-
-          simple_picture = Picture.new(id: 2, title: 'headshot-2.jpg')
-          assert_equal(expected, serialization(simple_picture))
-        end
-
-        def test_attributes_serialization_with_polymorphic_has_many
-          expected =
-            {
-              id: 1,
-              phrase: 'foo',
-              object_tags: [
-                {
-                  id: 1,
-                  taggable: {
-                    type: 'employee',
-                    employee: {
-                      id: 42
-                    }
-                  }
-                },
-                {
-                  id: 5,
-                  taggable: {
-                    type: 'picture',
-                    picture: {
-                      id: 1
-                    }
-                  }
-                }
-              ]
-            }
-          assert_equal(expected, tag_serialization)
-        end
-
-        def test_json_serialization
-          expected =
-            {
-              picture: {
-                id: 1,
-                title: 'headshot-1.jpg',
-                imageable: {
-                  type: 'employee',
-                  employee: {
-                    id: 42,
-                    name: 'Zoop Zoopler'
-                  }
-                }
-              }
-            }
-
-          assert_equal(expected, serialization(@picture, :json))
-        end
-
-        def test_json_serialization_without_polymorphic_association
-          expected =
-            {
-              picture: {
-                id: 2,
-                title: 'headshot-2.jpg',
-                imageable: nil
-              }
-            }
-
-          simple_picture = Picture.new(id: 2, title: 'headshot-2.jpg')
-          assert_equal(expected, serialization(simple_picture, :json))
-        end
-
-        def test_json_serialization_with_polymorphic_has_many
-          expected =
-            {
-              poly_tag: {
-                id: 1,
-                phrase: 'foo',
-                object_tags: [
-                  {
-                    id: 1,
-                    taggable: {
-                      type: 'employee',
-                      employee: {
-                        id: 42
-                      }
-                    }
-                  },
-                  {
-                    id: 5,
-                    taggable: {
-                      type: 'picture',
-                      picture: {
-                        id: 1
-                      }
-                    }
-                  }
-                ]
-              }
-            }
-          assert_equal(expected, tag_serialization(:json))
-        end
-
-        def test_json_api_serialization
-          expected =
-            {
-              data: {
-                id: '1',
-                type: 'pictures',
-                attributes: {
-                  title: 'headshot-1.jpg'
-                },
-                relationships: {
-                  imageable: {
-                    data: {
-                      id: '42',
-                      type: 'employees'
-                    }
-                  }
-                }
-              }
-            }
-
-          assert_equal(expected, serialization(@picture, :json_api))
-        end
-      end
-    end
-  end
-end

data/test/adapter_test.rb

@@ -1,67 +0,0 @@
-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,22 +0,0 @@
-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,65 +0,0 @@
-# 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 occured
-  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,67 +0,0 @@
-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.stddev_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_caching.rb

@@ -1,119 +0,0 @@
-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)
-
-  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 ||=
-      {
-        'post' =>  {
-          'id' =>  1337,
-          'title' => 'New Post',
-          'body' =>  'Body',
-          'comments' => [
-            {
-              'id' => 1,
-              'body' => 'ZOMG A COMMENT'
-            }
-          ],
-          'blog' =>  {
-            'id' =>  999,
-            'name' => 'Custom blog'
-          },
-          'author' => {
-            'id' => 42,
-            'first_name' => 'Joao',
-            'last_name' => 'Moura'
-          }
-        }
-    }
-  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

data/test/benchmark/bm_transform.rb

@@ -1,34 +0,0 @@
-require_relative './benchmarking_support'
-require_relative './app'
-
-time = 10
-disable_gc = true
-ActiveModelSerializers.config.key_transform = :unaltered
-comments = (0..50).map do |i|
-  Comment.new(id: i, body: 'ZOMG A COMMENT')
-end
-author = Author.new(id: 42, first_name: 'Joao', last_name: 'Moura')
-post = Post.new(id: 1337, title: 'New Post', blog: nil, body: 'Body', comments: comments, author: author)
-serializer = PostSerializer.new(post)
-adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
-serialization = adapter.as_json
-
-Benchmark.ams('camel', time: time, disable_gc: disable_gc) do
-  ActiveModelSerializers::KeyTransform.camel(serialization)
-end
-
-Benchmark.ams('camel_lower', time: time, disable_gc: disable_gc) do
-  ActiveModelSerializers::KeyTransform.camel_lower(serialization)
-end
-
-Benchmark.ams('dash', time: time, disable_gc: disable_gc) do
-  ActiveModelSerializers::KeyTransform.dash(serialization)
-end
-
-Benchmark.ams('unaltered', time: time, disable_gc: disable_gc) do
-  ActiveModelSerializers::KeyTransform.unaltered(serialization)
-end
-
-Benchmark.ams('underscore', time: time, disable_gc: disable_gc) do
-  ActiveModelSerializers::KeyTransform.underscore(serialization)
-end

data/test/benchmark/config.ru

@@ -1,3 +0,0 @@
-require File.expand_path(['..', 'app'].join(File::SEPARATOR), __FILE__)
-
-run Rails.application

data/test/benchmark/controllers.rb

@@ -1,84 +0,0 @@
-class PostController < ActionController::Base
-  POST =
-    begin
-      updated_at = Time.current
-      if ENV['BENCH_STRESS']
-        comments = (0..50).map do |i|
-          Comment.new(id: i, body: 'ZOMG A COMMENT', updated_at: updated_at + i)
-        end
-      else
-        comments = [Comment.new(id: 1, body: 'ZOMG A COMMENT', updated_at: updated_at)]
-      end
-      author = Author.new(id: 42, first_name: 'Joao', last_name: 'Moura')
-      Post.new(id: 1337, title: 'New Post', blog: nil, body: 'Body', comments: comments, author: author)
-    end
-
-  def render_with_caching_serializer
-    toggle_cache_status
-    render json: POST, serializer: CachingPostSerializer, adapter: :json, meta: { caching: perform_caching }
-  end
-
-  def render_with_fragment_caching_serializer
-    toggle_cache_status
-    render json: POST, serializer: FragmentCachingPostSerializer, adapter: :json, meta: { caching: perform_caching }
-  end
-
-  def render_with_non_caching_serializer
-    toggle_cache_status
-    render json: POST, adapter: :json, meta: { caching: perform_caching }
-  end
-
-  def render_cache_status
-    toggle_cache_status
-    # Uncomment to debug
-    # STDERR.puts cache_store.class
-    # STDERR.puts cache_dependencies
-    # ActiveSupport::Cache::Store.logger.debug [ActiveModelSerializers.config.cache_store, ActiveModelSerializers.config.perform_caching, CachingPostSerializer._cache, perform_caching, params].inspect
-    render json: { caching: perform_caching, meta: { cache_log: cache_messages, cache_status: cache_status } }.to_json
-  end
-
-  def clear
-    ActionController::Base.cache_store.clear
-    # Test caching is on
-    # Uncomment to turn on logger; possible performance issue
-    # logger = BenchmarkLogger.new
-    # ActiveSupport::Cache::Store.logger = logger # seems to be the best way
-    #
-    # the below is used in some rails tests but isn't available/working in all versions, so far as I can tell
-    # https://github.com/rails/rails/pull/15943
-    # ActiveSupport::Notifications.subscribe(/^cache_(.*)\.active_support$/) do |*args|
-    #   logger.debug ActiveSupport::Notifications::Event.new(*args)
-    # end
-    render json: 'ok'.to_json
-  end
-
-  private
-
-  def cache_status
-    {
-      controller: perform_caching,
-      app: Rails.configuration.action_controller.perform_caching,
-      serializers: Rails.configuration.serializers.each_with_object({}) { |serializer, data| data[serializer.name] = serializer._cache.present? }
-    }
-  end
-
-  def cache_messages
-    ActiveSupport::Cache::Store.logger.is_a?(BenchmarkLogger) && ActiveSupport::Cache::Store.logger.messages.split("\n")
-  end
-
-  def toggle_cache_status
-    case params[:on]
-    when 'on'.freeze then self.perform_caching = true
-    when 'off'.freeze then self.perform_caching = false
-    else nil # no-op
-    end
-  end
-end
-
-Rails.application.routes.draw do
-  get '/status(/:on)' => 'post#render_cache_status'
-  get '/clear' => 'post#clear'
-  get '/caching(/:on)' => 'post#render_with_caching_serializer'
-  get '/fragment_caching(/:on)' => 'post#render_with_fragment_caching_serializer'
-  get '/non_caching(/:on)' => 'post#render_with_non_caching_serializer'
-end