ditkrg/active_model_serializers
4
0
Fork 0
mirror of https://github.com/ditkrg/active_model_serializers.git synced 2026-01-22 22:06:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

re: RuboCop - Use nested module/class definition instead of compact style.

Browse Source
This commit is contained in:
Alexey Dubovskoy 2016-06-20 21:44:44 +01:00
parent 8a2beacb6f
commit 85f417f8d2
15 changed files with 675 additions and 648 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.rubocop.yml
View File

@ -46,7 +46,7 @@ Style/AlignParameters:
EnforcedStyle: with_fixed_indentation
Style/ClassAndModuleChildren:
EnforcedStyle: compact
EnforcedStyle: nested
Style/Documentation:
Enabled: false

7
.rubocop_todo.yml
View File

@ -12,13 +12,6 @@ Lint/HandleExceptions:
- 'Rakefile'
# Offense count: 271
# Configuration parameters: EnforcedStyle, SupportedStyles.
# SupportedStyles: nested, compact
Style/ClassAndModuleChildren:
Enabled: false
# Offense count: 3
# Configuration parameters: NamePrefix, NamePrefixBlacklist, NameWhitelist.

13
lib/active_model/serializer/array_serializer.rb
View File

@ -1,9 +1,12 @@
require 'active_model/serializer/collection_serializer'
class ActiveModel::Serializer
class ArraySerializer < CollectionSerializer
class << self
extend ActiveModelSerializers::Deprecate
deprecate :new, 'ActiveModel::Serializer::CollectionSerializer.'
module ActiveModel
class Serializer
class ArraySerializer < CollectionSerializer
class << self
extend ActiveModelSerializers::Deprecate
deprecate :new, 'ActiveModel::Serializer::CollectionSerializer.'
end
end
end
end

18
lib/active_model/serializer/error_serializer.rb
View File

@ -1,10 +1,14 @@
class ActiveModel::Serializer::ErrorSerializer < ActiveModel::Serializer
# @return [Hash<field_name,Array<error_message>>]
def as_json
object.errors.messages
end
module ActiveModel
class Serializer
class ErrorSerializer < ActiveModel::Serializer
# @return [Hash<field_name,Array<error_message>>]
def as_json
object.errors.messages
end
def success?
false
def success?
false
end
end
end
end

49
lib/active_model/serializer/errors_serializer.rb
View File

@ -1,27 +1,32 @@
require 'active_model/serializer/error_serializer'
class ActiveModel::Serializer::ErrorsSerializer
include Enumerable
delegate :each, to: :@serializers
attr_reader :object, :root
def initialize(resources, options = {})
@root = options[:root]
@object = resources
@serializers = resources.map do |resource|
serializer_class = options.fetch(:serializer) { ActiveModel::Serializer::ErrorSerializer }
serializer_class.new(resource, options.except(:serializer))
module ActiveModel
class Serializer
class ErrorsSerializer
include Enumerable
delegate :each, to: :@serializers
attr_reader :object, :root
def initialize(resources, options = {})
@root = options[:root]
@object = resources
@serializers = resources.map do |resource|
serializer_class = options.fetch(:serializer) { ActiveModel::Serializer::ErrorSerializer }
serializer_class.new(resource, options.except(:serializer))
end
end
def success?
false
end
def json_key
nil
end
protected
attr_reader :serializers
end
end
def success?
false
end
def json_key
nil
end
protected
attr_reader :serializers
end

264
lib/active_model/serializer/lint.rb
View File

@ -1,146 +1,150 @@
module ActiveModel::Serializer::Lint
# == Active \Model \Serializer \Lint \Tests
#
# You can test whether an object is compliant with the Active \Model \Serializers
# API by including <tt>ActiveModel::Serializer::Lint::Tests</tt> in your TestCase.
# It will include tests that tell you whether your object is fully compliant,
# or if not, which aspects of the API are not implemented.
#
# Note an object is not required to implement all APIs in order to work
# with Active \Model \Serializers. This module only intends to provide guidance in case
# you want all features out of the box.
#
# These tests do not attempt to determine the semantic correctness of the
# returned values. For instance, you could implement <tt>serializable_hash</tt> to
# always return +{}+, and the tests would pass. It is up to you to ensure
# that the values are semantically meaningful.
module Tests
# Passes if the object responds to <tt>serializable_hash</tt> and if it takes
# zero or one arguments.
# Fails otherwise.
#
# <tt>serializable_hash</tt> returns a hash representation of a object's attributes.
# Typically, it is implemented by including ActiveModel::Serialization.
def test_serializable_hash
assert_respond_to resource, :serializable_hash, 'The resource should respond to serializable_hash'
resource.serializable_hash
resource.serializable_hash(nil)
end
module ActiveModel
class Serializer
module Lint
# == Active \Model \Serializer \Lint \Tests
#
# You can test whether an object is compliant with the Active \Model \Serializers
# API by including <tt>ActiveModel::Serializer::Lint::Tests</tt> in your TestCase.
# It will include tests that tell you whether your object is fully compliant,
# or if not, which aspects of the API are not implemented.
#
# Note an object is not required to implement all APIs in order to work
# with Active \Model \Serializers. This module only intends to provide guidance in case
# you want all features out of the box.
#
# These tests do not attempt to determine the semantic correctness of the
# returned values. For instance, you could implement <tt>serializable_hash</tt> to
# always return +{}+, and the tests would pass. It is up to you to ensure
# that the values are semantically meaningful.
module Tests
# Passes if the object responds to <tt>serializable_hash</tt> and if it takes
# zero or one arguments.
# Fails otherwise.
#
# <tt>serializable_hash</tt> returns a hash representation of a object's attributes.
# Typically, it is implemented by including ActiveModel::Serialization.
def test_serializable_hash
assert_respond_to resource, :serializable_hash, 'The resource should respond to serializable_hash'
resource.serializable_hash
resource.serializable_hash(nil)
end
# Passes if the object responds to <tt>read_attribute_for_serialization</tt>
# and if it requires one argument (the attribute to be read).
# Fails otherwise.
#
# <tt>read_attribute_for_serialization</tt> gets the attribute value for serialization
# Typically, it is implemented by including ActiveModel::Serialization.
def test_read_attribute_for_serialization
assert_respond_to resource, :read_attribute_for_serialization, 'The resource should respond to read_attribute_for_serialization'
actual_arity = resource.method(:read_attribute_for_serialization).arity
# using absolute value since arity is:
# 1 for def read_attribute_for_serialization(name); end
# -1 for alias :read_attribute_for_serialization :send
assert_equal 1, actual_arity.abs, "expected #{actual_arity.inspect}.abs to be 1 or -1"
end
# Passes if the object responds to <tt>read_attribute_for_serialization</tt>
# and if it requires one argument (the attribute to be read).
# Fails otherwise.
#
# <tt>read_attribute_for_serialization</tt> gets the attribute value for serialization
# Typically, it is implemented by including ActiveModel::Serialization.
def test_read_attribute_for_serialization
assert_respond_to resource, :read_attribute_for_serialization, 'The resource should respond to read_attribute_for_serialization'
actual_arity = resource.method(:read_attribute_for_serialization).arity
# using absolute value since arity is:
# 1 for def read_attribute_for_serialization(name); end
# -1 for alias :read_attribute_for_serialization :send
assert_equal 1, actual_arity.abs, "expected #{actual_arity.inspect}.abs to be 1 or -1"
end
# Passes if the object responds to <tt>as_json</tt> and if it takes
# zero or one arguments.
# Fails otherwise.
#
# <tt>as_json</tt> returns a hash representation of a serialized object.
# It may delegate to <tt>serializable_hash</tt>
# Typically, it is implemented either by including ActiveModel::Serialization
# which includes ActiveModel::Serializers::JSON.
# or by the JSON gem when required.
def test_as_json
assert_respond_to resource, :as_json
resource.as_json
resource.as_json(nil)
end
# Passes if the object responds to <tt>as_json</tt> and if it takes
# zero or one arguments.
# Fails otherwise.
#
# <tt>as_json</tt> returns a hash representation of a serialized object.
# It may delegate to <tt>serializable_hash</tt>
# Typically, it is implemented either by including ActiveModel::Serialization
# which includes ActiveModel::Serializers::JSON.
# or by the JSON gem when required.
def test_as_json
assert_respond_to resource, :as_json
resource.as_json
resource.as_json(nil)
end
# Passes if the object responds to <tt>to_json</tt> and if it takes
# zero or one arguments.
# Fails otherwise.
#
# <tt>to_json</tt> returns a string representation (JSON) of a serialized object.
# It may be called on the result of <tt>as_json</tt>.
# Typically, it is implemented on all objects when the JSON gem is required.
def test_to_json
assert_respond_to resource, :to_json
resource.to_json
resource.to_json(nil)
end
# Passes if the object responds to <tt>to_json</tt> and if it takes
# zero or one arguments.
# Fails otherwise.
#
# <tt>to_json</tt> returns a string representation (JSON) of a serialized object.
# It may be called on the result of <tt>as_json</tt>.
# Typically, it is implemented on all objects when the JSON gem is required.
def test_to_json
assert_respond_to resource, :to_json
resource.to_json
resource.to_json(nil)
end
# Passes if the object responds to <tt>cache_key</tt>
# Fails otherwise.
#
# <tt>cache_key</tt> returns a (self-expiring) unique key for the object,
# and is part of the (self-expiring) cache_key, which is used by the
# adapter. It is not required unless caching is enabled.
def test_cache_key
assert_respond_to resource, :cache_key
actual_arity = resource.method(:cache_key).arity
assert_includes [-1, 0], actual_arity, "expected #{actual_arity.inspect} to be 0 or -1"
end
# Passes if the object responds to <tt>cache_key</tt>
# Fails otherwise.
#
# <tt>cache_key</tt> returns a (self-expiring) unique key for the object,
# and is part of the (self-expiring) cache_key, which is used by the
# adapter. It is not required unless caching is enabled.
def test_cache_key
assert_respond_to resource, :cache_key
actual_arity = resource.method(:cache_key).arity
assert_includes [-1, 0], actual_arity, "expected #{actual_arity.inspect} to be 0 or -1"
end
# Passes if the object responds to <tt>updated_at</tt> and if it takes no
# arguments.
# Fails otherwise.
#
# <tt>updated_at</tt> returns a Time object or iso8601 string and
# is part of the (self-expiring) cache_key, which is used by the adapter.
# It is not required unless caching is enabled.
def test_updated_at
assert_respond_to resource, :updated_at
actual_arity = resource.method(:updated_at).arity
assert_equal 0, actual_arity
end
# Passes if the object responds to <tt>updated_at</tt> and if it takes no
# arguments.
# Fails otherwise.
#
# <tt>updated_at</tt> returns a Time object or iso8601 string and
# is part of the (self-expiring) cache_key, which is used by the adapter.
# It is not required unless caching is enabled.
def test_updated_at
assert_respond_to resource, :updated_at
actual_arity = resource.method(:updated_at).arity
assert_equal 0, actual_arity
end
# Passes if the object responds to <tt>id</tt> and if it takes no
# arguments.
# Fails otherwise.
#
# <tt>id</tt> returns a unique identifier for the object.
# It is not required unless caching is enabled.
def test_id
assert_respond_to resource, :id
assert_equal 0, resource.method(:id).arity
end
# Passes if the object responds to <tt>id</tt> and if it takes no
# arguments.
# Fails otherwise.
#
# <tt>id</tt> returns a unique identifier for the object.
# It is not required unless caching is enabled.
def test_id
assert_respond_to resource, :id
assert_equal 0, resource.method(:id).arity
end
# Passes if the object's class responds to <tt>model_name</tt> and if it
# is in an instance of +ActiveModel::Name+.
# Fails otherwise.
#
# <tt>model_name</tt> returns an ActiveModel::Name instance.
# It is used by the serializer to identify the object's type.
# It is not required unless caching is enabled.
def test_model_name
resource_class = resource.class
assert_respond_to resource_class, :model_name
assert_instance_of resource_class.model_name, ActiveModel::Name
end
# Passes if the object's class responds to <tt>model_name</tt> and if it
# is in an instance of +ActiveModel::Name+.
# Fails otherwise.
#
# <tt>model_name</tt> returns an ActiveModel::Name instance.
# It is used by the serializer to identify the object's type.
# It is not required unless caching is enabled.
def test_model_name
resource_class = resource.class
assert_respond_to resource_class, :model_name
assert_instance_of resource_class.model_name, ActiveModel::Name
end
def test_active_model_errors
assert_respond_to resource, :errors
end
def test_active_model_errors
assert_respond_to resource, :errors
end
def test_active_model_errors_human_attribute_name
assert_respond_to resource.class, :human_attribute_name
assert_equal(-2, resource.class.method(:human_attribute_name).arity)
end
def test_active_model_errors_human_attribute_name
assert_respond_to resource.class, :human_attribute_name
assert_equal(-2, resource.class.method(:human_attribute_name).arity)
end
def test_active_model_errors_lookup_ancestors
assert_respond_to resource.class, :lookup_ancestors
assert_equal 0, resource.class.method(:lookup_ancestors).arity
end
def test_active_model_errors_lookup_ancestors
assert_respond_to resource.class, :lookup_ancestors
assert_equal 0, resource.class.method(:lookup_ancestors).arity
end
private
private
def resource
@resource or fail "'@resource' must be set as the linted object"
end
def resource
@resource or fail "'@resource' must be set as the linted object"
end
def assert_instance_of(result, name)
assert result.instance_of?(name), "#{result} should be an instance of #{name}"
def assert_instance_of(result, name)
assert result.instance_of?(name), "#{result} should be an instance of #{name}"
end
end
end
end
end

82
lib/active_model_serializers/register_jsonapi_renderer.rb
View File

@ -22,49 +22,51 @@
# render jsonapi: model
#
# No wrapper format needed as it does not apply (i.e. no `wrap_parameters format: [jsonapi]`)
module ActiveModelSerializers::Jsonapi
MEDIA_TYPE = 'application/vnd.api+json'.freeze
HEADERS = {
response: { 'CONTENT_TYPE'.freeze => MEDIA_TYPE },
request: { 'ACCEPT'.freeze => MEDIA_TYPE }
}.freeze
module ActiveModelSerializers
module Jsonapi
MEDIA_TYPE = 'application/vnd.api+json'.freeze
HEADERS = {
response: { 'CONTENT_TYPE'.freeze => MEDIA_TYPE },
request: { 'ACCEPT'.freeze => MEDIA_TYPE }
}.freeze
def self.install
# actionpack/lib/action_dispatch/http/mime_types.rb
Mime::Type.register MEDIA_TYPE, :jsonapi
def self.install
# actionpack/lib/action_dispatch/http/mime_types.rb
Mime::Type.register MEDIA_TYPE, :jsonapi
if Rails::VERSION::MAJOR >= 5
ActionDispatch::Request.parameter_parsers[:jsonapi] = parser
else
ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime[:jsonapi]] = parser
end
# ref https://github.com/rails/rails/pull/21496
ActionController::Renderers.add :jsonapi do |json, options|
json = serialize_jsonapi(json, options).to_json(options) unless json.is_a?(String)
self.content_type ||= Mime[:jsonapi]
self.response_body = json
end
end
# Proposal: should actually deserialize the JSON API params
# to the hash format expected by `ActiveModel::Serializers::JSON`
# actionpack/lib/action_dispatch/http/parameters.rb
def self.parser
lambda do |body|
data = JSON.parse(body)
data = { _json: data } unless data.is_a?(Hash)
data.with_indifferent_access
end
end
module ControllerSupport
def serialize_jsonapi(json, options)
options[:adapter] = :json_api
options.fetch(:serialization_context) do
options[:serialization_context] = ActiveModelSerializers::SerializationContext.new(request)
if Rails::VERSION::MAJOR >= 5
ActionDispatch::Request.parameter_parsers[:jsonapi] = parser
else
ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime[:jsonapi]] = parser
end
# ref https://github.com/rails/rails/pull/21496
ActionController::Renderers.add :jsonapi do |json, options|
json = serialize_jsonapi(json, options).to_json(options) unless json.is_a?(String)
self.content_type ||= Mime[:jsonapi]
self.response_body = json
end
end
# Proposal: should actually deserialize the JSON API params
# to the hash format expected by `ActiveModel::Serializers::JSON`
# actionpack/lib/action_dispatch/http/parameters.rb
def self.parser
lambda do |body|
data = JSON.parse(body)
data = { _json: data } unless data.is_a?(Hash)
data.with_indifferent_access
end
end
module ControllerSupport
def serialize_jsonapi(json, options)
options[:adapter] = :json_api
options.fetch(:serialization_context) do
options[:serialization_context] = ActiveModelSerializers::SerializationContext.new(request)
end
get_serializer(json, options)
end
get_serializer(json, options)
end
end
end

12
lib/grape/active_model_serializers.rb
View File

@ -4,11 +4,13 @@ require 'active_model_serializers'
require 'grape/formatters/active_model_serializers'
require 'grape/helpers/active_model_serializers'
module Grape::ActiveModelSerializers
extend ActiveSupport::Concern
module Grape
module ActiveModelSerializers
extend ActiveSupport::Concern
included do
formatter :json, Grape::Formatters::ActiveModelSerializers
helpers Grape::Helpers::ActiveModelSerializers
included do
formatter :json, Grape::Formatters::ActiveModelSerializers
helpers Grape::Helpers::ActiveModelSerializers
end
end
end

28
test/active_model_serializers/json_pointer_test.rb
View File

@ -1,20 +1,22 @@
require 'test_helper'
class ActiveModelSerializers::JsonPointerTest < ActiveSupport::TestCase
def test_attribute_pointer
attribute_name = 'title'
pointer = ActiveModelSerializers::JsonPointer.new(:attribute, attribute_name)
assert_equal '/data/attributes/title', pointer
end
module ActiveModelSerializers
class JsonPointerTest < ActiveSupport::TestCase
def test_attribute_pointer
attribute_name = 'title'
pointer = ActiveModelSerializers::JsonPointer.new(:attribute, attribute_name)
assert_equal '/data/attributes/title', pointer
end
def test_primary_data_pointer
pointer = ActiveModelSerializers::JsonPointer.new(:primary_data)
assert_equal '/data', pointer
end
def test_primary_data_pointer
pointer = ActiveModelSerializers::JsonPointer.new(:primary_data)
assert_equal '/data', pointer
end
def test_unkown_data_pointer
assert_raises(TypeError) do
ActiveModelSerializers::JsonPointer.new(:unknown)
def test_unkown_data_pointer
assert_raises(TypeError) do
ActiveModelSerializers::JsonPointer.new(:unknown)
end
end
end
end

506
test/active_model_serializers/key_transform_test.rb
View File

@ -1,263 +1,265 @@
require 'test_helper'
class ActiveModelSerializers::KeyTransformTest < ActiveSupport::TestCase
def test_camel
obj = Object.new
scenarios = [
{
value: { "some-key": 'value' },
expected: { SomeKey: 'value' }
},
{
value: { someKey: 'value' },
expected: { SomeKey: 'value' }
},
{
value: { some_key: 'value' },
expected: { SomeKey: 'value' }
},
{
value: { 'some-key' => 'value' },
expected: { 'SomeKey' => 'value' }
},
{
value: { 'someKey' => 'value' },
expected: { 'SomeKey' => 'value' }
},
{
value: { 'some_key' => 'value' },
expected: { 'SomeKey' => 'value' }
},
{
value: :"some-value",
expected: :SomeValue
},
{
value: :some_value,
expected: :SomeValue
},
{
value: :someValue,
expected: :SomeValue
},
{
value: 'some-value',
expected: 'SomeValue'
},
{
value: 'someValue',
expected: 'SomeValue'
},
{
value: 'some_value',
expected: 'SomeValue'
},
{
value: obj,
expected: obj
},
{
value: nil,
expected: nil
}
]
scenarios.each do |s|
result = ActiveModelSerializers::KeyTransform.camel(s[:value])
assert_equal s[:expected], result
module ActiveModelSerializers
class KeyTransformTest < ActiveSupport::TestCase
def test_camel
obj = Object.new
scenarios = [
{
value: { "some-key": 'value' },
expected: { SomeKey: 'value' }
},
{
value: { someKey: 'value' },
expected: { SomeKey: 'value' }
},
{
value: { some_key: 'value' },
expected: { SomeKey: 'value' }
},
{
value: { 'some-key' => 'value' },
expected: { 'SomeKey' => 'value' }
},
{
value: { 'someKey' => 'value' },
expected: { 'SomeKey' => 'value' }
},
{
value: { 'some_key' => 'value' },
expected: { 'SomeKey' => 'value' }
},
{
value: :"some-value",
expected: :SomeValue
},
{
value: :some_value,
expected: :SomeValue
},
{
value: :someValue,
expected: :SomeValue
},
{
value: 'some-value',
expected: 'SomeValue'
},
{
value: 'someValue',
expected: 'SomeValue'
},
{
value: 'some_value',
expected: 'SomeValue'
},
{
value: obj,
expected: obj
},
{
value: nil,
expected: nil
}
]
scenarios.each do |s|
result = ActiveModelSerializers::KeyTransform.camel(s[:value])
assert_equal s[:expected], result
end
end
end
def test_camel_lower
obj = Object.new
scenarios = [
{
value: { "some-key": 'value' },
expected: { someKey: 'value' }
},
{
value: { SomeKey: 'value' },
expected: { someKey: 'value' }
},
{
value: { some_key: 'value' },
expected: { someKey: 'value' }
},
{
value: { 'some-key' => 'value' },
expected: { 'someKey' => 'value' }
},
{
value: { 'SomeKey' => 'value' },
expected: { 'someKey' => 'value' }
},
{
value: { 'some_key' => 'value' },
expected: { 'someKey' => 'value' }
},
{
value: :"some-value",
expected: :someValue
},
{
value: :SomeValue,
expected: :someValue
},
{
value: :some_value,
expected: :someValue
},
{
value: 'some-value',
expected: 'someValue'
},
{
value: 'SomeValue',
expected: 'someValue'
},
{
value: 'some_value',
expected: 'someValue'
},
{
value: obj,
expected: obj
},
{
value: nil,
expected: nil
}
]
scenarios.each do |s|
result = ActiveModelSerializers::KeyTransform.camel_lower(s[:value])
assert_equal s[:expected], result
def test_camel_lower
obj = Object.new
scenarios = [
{
value: { "some-key": 'value' },
expected: { someKey: 'value' }
},
{
value: { SomeKey: 'value' },
expected: { someKey: 'value' }
},
{
value: { some_key: 'value' },
expected: { someKey: 'value' }
},
{
value: { 'some-key' => 'value' },
expected: { 'someKey' => 'value' }
},
{
value: { 'SomeKey' => 'value' },
expected: { 'someKey' => 'value' }
},
{
value: { 'some_key' => 'value' },
expected: { 'someKey' => 'value' }
},
{
value: :"some-value",
expected: :someValue
},
{
value: :SomeValue,
expected: :someValue
},
{
value: :some_value,
expected: :someValue
},
{
value: 'some-value',
expected: 'someValue'
},
{
value: 'SomeValue',
expected: 'someValue'
},
{
value: 'some_value',
expected: 'someValue'
},
{
value: obj,
expected: obj
},
{
value: nil,
expected: nil
}
]
scenarios.each do |s|
result = ActiveModelSerializers::KeyTransform.camel_lower(s[:value])
assert_equal s[:expected], result
end
end
end
def test_dash
obj = Object.new
scenarios = [
{
value: { some_key: 'value' },
expected: { "some-key": 'value' }
},
{
value: { 'some_key' => 'value' },
expected: { 'some-key' => 'value' }
},
{
value: { SomeKey: 'value' },
expected: { "some-key": 'value' }
},
{
value: { 'SomeKey' => 'value' },
expected: { 'some-key' => 'value' }
},
{
value: { someKey: 'value' },
expected: { "some-key": 'value' }
},
{
value: { 'someKey' => 'value' },
expected: { 'some-key' => 'value' }
},
{
value: :some_value,
expected: :"some-value"
},
{
value: :SomeValue,
expected: :"some-value"
},
{
value: 'SomeValue',
expected: 'some-value'
},
{
value: :someValue,
expected: :"some-value"
},
{
value: 'someValue',
expected: 'some-value'
},
{
value: obj,
expected: obj
},
{
value: nil,
expected: nil
}
]
scenarios.each do |s|
result = ActiveModelSerializers::KeyTransform.dash(s[:value])
assert_equal s[:expected], result
def test_dash
obj = Object.new
scenarios = [
{
value: { some_key: 'value' },
expected: { "some-key": 'value' }
},
{
value: { 'some_key' => 'value' },
expected: { 'some-key' => 'value' }
},
{
value: { SomeKey: 'value' },
expected: { "some-key": 'value' }
},
{
value: { 'SomeKey' => 'value' },
expected: { 'some-key' => 'value' }
},
{
value: { someKey: 'value' },
expected: { "some-key": 'value' }
},
{
value: { 'someKey' => 'value' },
expected: { 'some-key' => 'value' }
},
{
value: :some_value,
expected: :"some-value"
},
{
value: :SomeValue,
expected: :"some-value"
},
{
value: 'SomeValue',
expected: 'some-value'
},
{
value: :someValue,
expected: :"some-value"
},
{
value: 'someValue',
expected: 'some-value'
},
{
value: obj,
expected: obj
},
{
value: nil,
expected: nil
}
]
scenarios.each do |s|
result = ActiveModelSerializers::KeyTransform.dash(s[:value])
assert_equal s[:expected], result
end
end
end
def test_underscore
obj = Object.new
scenarios = [
{
value: { "some-key": 'value' },
expected: { some_key: 'value' }
},
{
value: { 'some-key' => 'value' },
expected: { 'some_key' => 'value' }
},
{
value: { SomeKey: 'value' },
expected: { some_key: 'value' }
},
{
value: { 'SomeKey' => 'value' },
expected: { 'some_key' => 'value' }
},
{
value: { someKey: 'value' },
expected: { some_key: 'value' }
},
{
value: { 'someKey' => 'value' },
expected: { 'some_key' => 'value' }
},
{
value: :"some-value",
expected: :some_value
},
{
value: :SomeValue,
expected: :some_value
},
{
value: :someValue,
expected: :some_value
},
{
value: 'some-value',
expected: 'some_value'
},
{
value: 'SomeValue',
expected: 'some_value'
},
{
value: 'someValue',
expected: 'some_value'
},
{
value: obj,
expected: obj
},
{
value: nil,
expected: nil
}
]
scenarios.each do |s|
result = ActiveModelSerializers::KeyTransform.underscore(s[:value])
assert_equal s[:expected], result
def test_underscore
obj = Object.new
scenarios = [
{
value: { "some-key": 'value' },
expected: { some_key: 'value' }
},
{
value: { 'some-key' => 'value' },
expected: { 'some_key' => 'value' }
},
{
value: { SomeKey: 'value' },
expected: { some_key: 'value' }
},
{
value: { 'SomeKey' => 'value' },
expected: { 'some_key' => 'value' }
},
{
value: { someKey: 'value' },
expected: { some_key: 'value' }
},
{
value: { 'someKey' => 'value' },
expected: { 'some_key' => 'value' }
},
{
value: :"some-value",
expected: :some_value
},
{
value: :SomeValue,
expected: :some_value
},
{
value: :someValue,
expected: :some_value
},
{
value: 'some-value',
expected: 'some_value'
},
{
value: 'SomeValue',
expected: 'some_value'
},
{
value: 'someValue',
expected: 'some_value'
},
{
value: obj,
expected: obj
},
{
value: nil,
expected: nil
}
]
scenarios.each do |s|
result = ActiveModelSerializers::KeyTransform.underscore(s[:value])
assert_equal s[:expected], result
end
end
end
end

10
test/active_model_serializers/model_test.rb
View File

@ -1,9 +1,11 @@
require 'test_helper'
class ActiveModelSerializers::ModelTest < ActiveSupport::TestCase
include ActiveModel::Serializer::Lint::Tests
module ActiveModelSerializers
class ModelTest < ActiveSupport::TestCase
include ActiveModel::Serializer::Lint::Tests
def setup
@resource = ActiveModelSerializers::Model.new
def setup
@resource = ActiveModelSerializers::Model.new
end
end
end

290
test/grape_test.rb
View File

@ -5,172 +5,174 @@ require 'kaminari'
require 'kaminari/hooks'
::Kaminari::Hooks.init
class ActiveModelSerializers::GrapeTest < ActiveSupport::TestCase
include Rack::Test::Methods
module Models
def self.model1
ARModels::Post.new(id: 1, title: 'Dummy Title', body: 'Lorem Ipsum')
module ActiveModelSerializers
class GrapeTest < ActiveSupport::TestCase
include Rack::Test::Methods
module Models
def self.model1
ARModels::Post.new(id: 1, title: 'Dummy Title', body: 'Lorem Ipsum')
end
def self.model2
ARModels::Post.new(id: 2, title: 'Second Dummy Title', body: 'Second Lorem Ipsum')
end
def self.all
@all ||=
begin
model1.save!
model2.save!
ARModels::Post.all
end
end
def self.reset_all
ARModels::Post.delete_all
@all = nil
end
def self.collection_per
2
end
def self.collection
@collection ||=
begin
Kaminari.paginate_array(
[
Profile.new(id: 1, name: 'Name 1', description: 'Description 1', comments: 'Comments 1'),
Profile.new(id: 2, name: 'Name 2', description: 'Description 2', comments: 'Comments 2'),
Profile.new(id: 3, name: 'Name 3', description: 'Description 3', comments: 'Comments 3'),
Profile.new(id: 4, name: 'Name 4', description: 'Description 4', comments: 'Comments 4'),
Profile.new(id: 5, name: 'Name 5', description: 'Description 5', comments: 'Comments 5')
]
).page(1).per(collection_per)
end
end
end
def self.model2
ARModels::Post.new(id: 2, title: 'Second Dummy Title', body: 'Second Lorem Ipsum')
end
class GrapeTest < Grape::API
format :json
include Grape::ActiveModelSerializers
def self.all
@all ||=
begin
model1.save!
model2.save!
ARModels::Post.all
resources :grape do
get '/render' do
render Models.model1
end
end
def self.reset_all
ARModels::Post.delete_all
@all = nil
end
def self.collection_per
2
end
def self.collection
@collection ||=
begin
Kaminari.paginate_array(
[
Profile.new(id: 1, name: 'Name 1', description: 'Description 1', comments: 'Comments 1'),
Profile.new(id: 2, name: 'Name 2', description: 'Description 2', comments: 'Comments 2'),
Profile.new(id: 3, name: 'Name 3', description: 'Description 3', comments: 'Comments 3'),
Profile.new(id: 4, name: 'Name 4', description: 'Description 4', comments: 'Comments 4'),
Profile.new(id: 5, name: 'Name 5', description: 'Description 5', comments: 'Comments 5')
]
).page(1).per(collection_per)
get '/render_with_json_api' do
post = Models.model1
render post, meta: { page: 1, total_pages: 2 }, adapter: :json_api
end
end
end
class GrapeTest < Grape::API
format :json
include Grape::ActiveModelSerializers
get '/render_array_with_json_api' do
posts = Models.all
render posts, adapter: :json_api
end
resources :grape do
get '/render' do
render Models.model1
end
get '/render_collection_with_json_api' do
posts = Models.collection
render posts, adapter: :json_api
end
get '/render_with_json_api' do
post = Models.model1
render post, meta: { page: 1, total_pages: 2 }, adapter: :json_api
end
get '/render_with_implicit_formatter' do
Models.model1
end
get '/render_array_with_json_api' do
posts = Models.all
render posts, adapter: :json_api
end
get '/render_array_with_implicit_formatter' do
Models.all
end
get '/render_collection_with_json_api' do
posts = Models.collection
render posts, adapter: :json_api
end
get '/render_with_implicit_formatter' do
Models.model1
end
get '/render_array_with_implicit_formatter' do
Models.all
end
get '/render_collection_with_implicit_formatter' do
Models.collection
get '/render_collection_with_implicit_formatter' do
Models.collection
end
end
end
end
def app
Grape::Middleware::Globals.new(GrapeTest.new)
end
def test_formatter_returns_json
get '/grape/render'
post = Models.model1
serializable_resource = serializable(post)
assert last_response.ok?
assert_equal serializable_resource.to_json, last_response.body
end
def test_render_helper_passes_through_options_correctly
get '/grape/render_with_json_api'
post = Models.model1
serializable_resource = serializable(post, serializer: ARModels::PostSerializer, adapter: :json_api, meta: { page: 1, total_pages: 2 })
assert last_response.ok?
assert_equal serializable_resource.to_json, last_response.body
end
def test_formatter_handles_arrays
get '/grape/render_array_with_json_api'
posts = Models.all
serializable_resource = serializable(posts, adapter: :json_api)
assert last_response.ok?
assert_equal serializable_resource.to_json, last_response.body
ensure
Models.reset_all
end
def test_formatter_handles_collections
get '/grape/render_collection_with_json_api'
assert last_response.ok?
representation = JSON.parse(last_response.body)
assert representation.include?('data')
assert representation['data'].count == Models.collection_per
assert representation.include?('links')
assert representation['links'].count > 0
end
def test_implicit_formatter
post = Models.model1
serializable_resource = serializable(post, adapter: :json_api)
with_adapter :json_api do
get '/grape/render_with_implicit_formatter'
def app
Grape::Middleware::Globals.new(GrapeTest.new)
end
assert last_response.ok?
assert_equal serializable_resource.to_json, last_response.body
end
def test_formatter_returns_json
get '/grape/render'
def test_implicit_formatter_handles_arrays
posts = Models.all
serializable_resource = serializable(posts, adapter: :json_api)
post = Models.model1
serializable_resource = serializable(post)
with_adapter :json_api do
get '/grape/render_array_with_implicit_formatter'
assert last_response.ok?
assert_equal serializable_resource.to_json, last_response.body
end
assert last_response.ok?
assert_equal serializable_resource.to_json, last_response.body
ensure
Models.reset_all
end
def test_render_helper_passes_through_options_correctly
get '/grape/render_with_json_api'
def test_implicit_formatter_handles_collections
with_adapter :json_api do
get '/grape/render_collection_with_implicit_formatter'
post = Models.model1
serializable_resource = serializable(post, serializer: ARModels::PostSerializer, adapter: :json_api, meta: { page: 1, total_pages: 2 })
assert last_response.ok?
assert_equal serializable_resource.to_json, last_response.body
end
representation = JSON.parse(last_response.body)
assert last_response.ok?
assert representation.include?('data')
assert representation['data'].count == Models.collection_per
assert representation.include?('links')
assert representation['links'].count > 0
def test_formatter_handles_arrays
get '/grape/render_array_with_json_api'
posts = Models.all
serializable_resource = serializable(posts, adapter: :json_api)
assert last_response.ok?
assert_equal serializable_resource.to_json, last_response.body
ensure
Models.reset_all
end
def test_formatter_handles_collections
get '/grape/render_collection_with_json_api'
assert last_response.ok?
representation = JSON.parse(last_response.body)
assert representation.include?('data')
assert representation['data'].count == Models.collection_per
assert representation.include?('links')
assert representation['links'].count > 0
end
def test_implicit_formatter
post = Models.model1
serializable_resource = serializable(post, adapter: :json_api)
with_adapter :json_api do
get '/grape/render_with_implicit_formatter'
end
assert last_response.ok?
assert_equal serializable_resource.to_json, last_response.body
end
def test_implicit_formatter_handles_arrays
posts = Models.all
serializable_resource = serializable(posts, adapter: :json_api)
with_adapter :json_api do
get '/grape/render_array_with_implicit_formatter'
end
assert last_response.ok?
assert_equal serializable_resource.to_json, last_response.body
ensure
Models.reset_all
end
def test_implicit_formatter_handles_collections
with_adapter :json_api do
get '/grape/render_collection_with_implicit_formatter'
end
representation = JSON.parse(last_response.body)
assert last_response.ok?
assert representation.include?('data')
assert representation['data'].count == Models.collection_per
assert representation.include?('links')
assert representation['links'].count > 0
end
end
end

24
test/logger_test.rb
View File

@ -1,18 +1,20 @@
require 'test_helper'
class ActiveModelSerializers::LoggerTest < ActiveSupport::TestCase
def test_logger_is_set_to_action_controller_logger_when_initializer_runs
assert_equal $action_controller_logger, ActionController::Base.logger # rubocop:disable Style/GlobalVars
end
module ActiveModelSerializers
class LoggerTest < ActiveSupport::TestCase
def test_logger_is_set_to_action_controller_logger_when_initializer_runs
assert_equal $action_controller_logger, ActionController::Base.logger # rubocop:disable Style/GlobalVars
end
def test_logger_can_be_set
original_logger = ActiveModelSerializers.logger
logger = Logger.new(STDOUT)
def test_logger_can_be_set
original_logger = ActiveModelSerializers.logger
logger = Logger.new(STDOUT)
ActiveModelSerializers.logger = logger
ActiveModelSerializers.logger = logger
assert_equal ActiveModelSerializers.logger, logger
ensure
ActiveModelSerializers.logger = original_logger
assert_equal ActiveModelSerializers.logger, logger
ensure
ActiveModelSerializers.logger = original_logger
end
end
end

6
test/support/isolated_unit.rb
View File

@ -75,6 +75,8 @@ module TestHelpers
end
end
class ActiveSupport::TestCase
include TestHelpers::Generation
module ActiveSupport
class TestCase
include TestHelpers::Generation
end
end

12
test/support/serialization_testing.rb
View File

@ -44,10 +44,12 @@ module SerializationTesting
end
end
class Minitest::Test
def before_setup
ActionController::Base.cache_store.clear
end
module Minitest
class Test
def before_setup
ActionController::Base.cache_store.clear
end
include SerializationTesting
include SerializationTesting
end
end