From 85f417f8d29a6db5a10340f467b96e99871a8aae Mon Sep 17 00:00:00 2001 From: Alexey Dubovskoy Date: Mon, 20 Jun 2016 21:44:44 +0100 Subject: [PATCH] re: RuboCop - Use nested module/class definition instead of compact style. --- .rubocop.yml | 2 +- .rubocop_todo.yml | 7 - .../serializer/array_serializer.rb | 13 +- .../serializer/error_serializer.rb | 18 +- .../serializer/errors_serializer.rb | 49 +- lib/active_model/serializer/lint.rb | 264 ++++----- .../register_jsonapi_renderer.rb | 82 +-- lib/grape/active_model_serializers.rb | 12 +- .../json_pointer_test.rb | 28 +- .../key_transform_test.rb | 506 +++++++++--------- test/active_model_serializers/model_test.rb | 10 +- test/grape_test.rb | 290 +++++----- test/logger_test.rb | 24 +- test/support/isolated_unit.rb | 6 +- test/support/serialization_testing.rb | 12 +- 15 files changed, 675 insertions(+), 648 deletions(-) diff --git a/.rubocop.yml b/.rubocop.yml index 38e562c1..a536c4dc 100644 --- a/.rubocop.yml +++ b/.rubocop.yml @@ -46,7 +46,7 @@ Style/AlignParameters: EnforcedStyle: with_fixed_indentation Style/ClassAndModuleChildren: - EnforcedStyle: compact + EnforcedStyle: nested Style/Documentation: Enabled: false diff --git a/.rubocop_todo.yml b/.rubocop_todo.yml index 4516266f..9b7307a8 100644 --- a/.rubocop_todo.yml +++ b/.rubocop_todo.yml @@ -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. diff --git a/lib/active_model/serializer/array_serializer.rb b/lib/active_model/serializer/array_serializer.rb index c234bbb4..2e768deb 100644 --- a/lib/active_model/serializer/array_serializer.rb +++ b/lib/active_model/serializer/array_serializer.rb @@ -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 diff --git a/lib/active_model/serializer/error_serializer.rb b/lib/active_model/serializer/error_serializer.rb index c12dfd37..d0e70809 100644 --- a/lib/active_model/serializer/error_serializer.rb +++ b/lib/active_model/serializer/error_serializer.rb @@ -1,10 +1,14 @@ -class ActiveModel::Serializer::ErrorSerializer < ActiveModel::Serializer - # @return [Hash>] - def as_json - object.errors.messages - end +module ActiveModel + class Serializer + class ErrorSerializer < ActiveModel::Serializer + # @return [Hash>] + def as_json + object.errors.messages + end - def success? - false + def success? + false + end + end end end diff --git a/lib/active_model/serializer/errors_serializer.rb b/lib/active_model/serializer/errors_serializer.rb index 4b67bae8..1fd924d5 100644 --- a/lib/active_model/serializer/errors_serializer.rb +++ b/lib/active_model/serializer/errors_serializer.rb @@ -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 diff --git a/lib/active_model/serializer/lint.rb b/lib/active_model/serializer/lint.rb index 3552168e..c40cebeb 100644 --- a/lib/active_model/serializer/lint.rb +++ b/lib/active_model/serializer/lint.rb @@ -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 ActiveModel::Serializer::Lint::Tests 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 serializable_hash 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 serializable_hash and if it takes - # zero or one arguments. - # Fails otherwise. - # - # serializable_hash 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 ActiveModel::Serializer::Lint::Tests 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 serializable_hash 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 serializable_hash and if it takes + # zero or one arguments. + # Fails otherwise. + # + # serializable_hash 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 read_attribute_for_serialization - # and if it requires one argument (the attribute to be read). - # Fails otherwise. - # - # read_attribute_for_serialization 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 read_attribute_for_serialization + # and if it requires one argument (the attribute to be read). + # Fails otherwise. + # + # read_attribute_for_serialization 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 as_json and if it takes - # zero or one arguments. - # Fails otherwise. - # - # as_json returns a hash representation of a serialized object. - # It may delegate to serializable_hash - # 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 as_json and if it takes + # zero or one arguments. + # Fails otherwise. + # + # as_json returns a hash representation of a serialized object. + # It may delegate to serializable_hash + # 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 to_json and if it takes - # zero or one arguments. - # Fails otherwise. - # - # to_json returns a string representation (JSON) of a serialized object. - # It may be called on the result of as_json. - # 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 to_json and if it takes + # zero or one arguments. + # Fails otherwise. + # + # to_json returns a string representation (JSON) of a serialized object. + # It may be called on the result of as_json. + # 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 cache_key - # Fails otherwise. - # - # cache_key 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 cache_key + # Fails otherwise. + # + # cache_key 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 updated_at and if it takes no - # arguments. - # Fails otherwise. - # - # updated_at 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 updated_at and if it takes no + # arguments. + # Fails otherwise. + # + # updated_at 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 id and if it takes no - # arguments. - # Fails otherwise. - # - # id 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 id and if it takes no + # arguments. + # Fails otherwise. + # + # id 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 model_name and if it - # is in an instance of +ActiveModel::Name+. - # Fails otherwise. - # - # model_name 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 model_name and if it + # is in an instance of +ActiveModel::Name+. + # Fails otherwise. + # + # model_name 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 diff --git a/lib/active_model_serializers/register_jsonapi_renderer.rb b/lib/active_model_serializers/register_jsonapi_renderer.rb index 39442959..715c6ab3 100644 --- a/lib/active_model_serializers/register_jsonapi_renderer.rb +++ b/lib/active_model_serializers/register_jsonapi_renderer.rb @@ -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 diff --git a/lib/grape/active_model_serializers.rb b/lib/grape/active_model_serializers.rb index eb7fd1ac..8dc7a314 100644 --- a/lib/grape/active_model_serializers.rb +++ b/lib/grape/active_model_serializers.rb @@ -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 diff --git a/test/active_model_serializers/json_pointer_test.rb b/test/active_model_serializers/json_pointer_test.rb index 64acc7eb..0c8cf58f 100644 --- a/test/active_model_serializers/json_pointer_test.rb +++ b/test/active_model_serializers/json_pointer_test.rb @@ -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 diff --git a/test/active_model_serializers/key_transform_test.rb b/test/active_model_serializers/key_transform_test.rb index 2cd91cfc..57349143 100644 --- a/test/active_model_serializers/key_transform_test.rb +++ b/test/active_model_serializers/key_transform_test.rb @@ -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 diff --git a/test/active_model_serializers/model_test.rb b/test/active_model_serializers/model_test.rb index 3a94e603..8b9dd47d 100644 --- a/test/active_model_serializers/model_test.rb +++ b/test/active_model_serializers/model_test.rb @@ -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 diff --git a/test/grape_test.rb b/test/grape_test.rb index 3f19d7ac..b026021d 100644 --- a/test/grape_test.rb +++ b/test/grape_test.rb @@ -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 diff --git a/test/logger_test.rb b/test/logger_test.rb index 02832ef6..a15227bb 100644 --- a/test/logger_test.rb +++ b/test/logger_test.rb @@ -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 diff --git a/test/support/isolated_unit.rb b/test/support/isolated_unit.rb index d1d18eb6..26948d4a 100644 --- a/test/support/isolated_unit.rb +++ b/test/support/isolated_unit.rb @@ -75,6 +75,8 @@ module TestHelpers end end -class ActiveSupport::TestCase - include TestHelpers::Generation +module ActiveSupport + class TestCase + include TestHelpers::Generation + end end diff --git a/test/support/serialization_testing.rb b/test/support/serialization_testing.rb index 8e4ef43e..d696801d 100644 --- a/test/support/serialization_testing.rb +++ b/test/support/serialization_testing.rb @@ -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