active_model_serializers 0.10.9 → 0.10.13

data/test/active_model_serializers/json_pointer_test.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-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_unknown_data_pointer
-      assert_raises(TypeError) do
-        ActiveModelSerializers::JsonPointer.new(:unknown)
-      end
-    end
-  end
-end

data/test/active_model_serializers/logging_test.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class LoggingTest < ActiveSupport::TestCase
-      class TestLogger < ActiveSupport::Logger
-        def initialize
-          @file = StringIO.new
-          super(@file)
-        end
-
-        def messages
-          @file.rewind
-          @file.read
-        end
-      end
-
-      def setup
-        @author = Author.new(name: 'Steve K.')
-        @post = Post.new(title: 'New Post', body: 'Body')
-        @comment = Comment.new(id: 1, body: 'ZOMG A COMMENT')
-        @post.comments = [@comment]
-        @comment.post = @post
-        @post.author = @author
-        @author.posts = [@post]
-        @post_serializer = PostSerializer.new(@post, custom_options: true)
-
-        @old_logger = ActiveModelSerializers.logger
-        @logger = ActiveSupport::TaggedLogging.new(TestLogger.new)
-        logger @logger
-      end
-
-      def teardown
-        logger @old_logger
-      end
-
-      def logger(logger)
-        ActiveModelSerializers.logger = logger
-      end
-
-      def test_uses_ams_as_tag
-        ActiveModelSerializers::SerializableResource.new(@post).serializable_hash
-        assert_match(/\[active_model_serializers\]/, @logger.messages)
-      end
-
-      def test_logs_when_call_serializable_hash
-        ActiveModelSerializers::SerializableResource.new(@post).serializable_hash
-        assert_match(/Rendered/, @logger.messages)
-      end
-
-      def test_logs_when_call_as_json
-        ActiveModelSerializers::SerializableResource.new(@post).as_json
-        assert_match(/Rendered/, @logger.messages)
-      end
-
-      def test_logs_when_call_to_json
-        ActiveModelSerializers::SerializableResource.new(@post).to_json
-        assert_match(/Rendered/, @logger.messages)
-      end
-
-      def test_logs_correct_serializer
-        ActiveModelSerializers::SerializableResource.new(@post).serializable_hash
-        assert_match(/PostSerializer/, @logger.messages)
-      end
-
-      def test_logs_correct_adapter
-        ActiveModelSerializers::SerializableResource.new(@post).serializable_hash
-        assert_match(/ActiveModelSerializers::Adapter::Attributes/, @logger.messages)
-      end
-
-      def test_logs_the_duration
-        ActiveModelSerializers::SerializableResource.new(@post).serializable_hash
-        assert_match(/\(\d+\.\d+ms\)/, @logger.messages)
-      end
-    end
-  end
-end

data/test/active_model_serializers/model_test.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  class ModelTest < ActiveSupport::TestCase
-    include ActiveModel::Serializer::Lint::Tests
-
-    setup do
-      @resource = ActiveModelSerializers::Model.new
-    end
-
-    def test_initialization_with_string_keys
-      klass = Class.new(ActiveModelSerializers::Model) do
-        attributes :key
-      end
-      value = 'value'
-
-      model_instance = klass.new('key' => value)
-
-      assert_equal model_instance.read_attribute_for_serialization(:key), value
-    end
-
-    def test_attributes_can_be_read_for_serialization
-      klass = Class.new(ActiveModelSerializers::Model) do
-        attributes :one, :two, :three
-      end
-      original_attributes = { one: 1, two: 2, three: 3 }
-      original_instance = klass.new(original_attributes)
-
-      # Initial value
-      instance = original_instance
-      expected_attributes = { one: 1, two: 2, three: 3 }.with_indifferent_access
-      assert_equal expected_attributes, instance.attributes
-      assert_equal 1, instance.one
-      assert_equal 1, instance.read_attribute_for_serialization(:one)
-
-      # FIXME: Change via accessor has no effect on attributes.
-      instance = original_instance.dup
-      instance.one = :not_one
-      assert_equal expected_attributes, instance.attributes
-      assert_equal :not_one, instance.one
-      assert_equal :not_one, instance.read_attribute_for_serialization(:one)
-
-      # FIXME: Change via mutating attributes
-      instance = original_instance.dup
-      instance.attributes[:one] = :not_one
-      expected_attributes = { one: :not_one, two: 2, three: 3 }.with_indifferent_access
-      assert_equal expected_attributes, instance.attributes
-      assert_equal 1, instance.one
-      assert_equal 1, instance.read_attribute_for_serialization(:one)
-    end
-
-    def test_attributes_can_be_read_for_serialization_with_attributes_accessors_fix
-      klass = Class.new(ActiveModelSerializers::Model) do
-        derive_attributes_from_names_and_fix_accessors
-        attributes :one, :two, :three
-      end
-      original_attributes = { one: 1, two: 2, three: 3 }
-      original_instance = klass.new(original_attributes)
-
-      # Initial value
-      instance = original_instance
-      expected_attributes = { one: 1, two: 2, three: 3 }.with_indifferent_access
-      assert_equal expected_attributes, instance.attributes
-      assert_equal 1, instance.one
-      assert_equal 1, instance.read_attribute_for_serialization(:one)
-
-      expected_attributes = { one: :not_one, two: 2, three: 3 }.with_indifferent_access
-      # Change via accessor
-      instance = original_instance.dup
-      instance.one = :not_one
-      assert_equal expected_attributes, instance.attributes
-      assert_equal :not_one, instance.one
-      assert_equal :not_one, instance.read_attribute_for_serialization(:one)
-
-      # Attributes frozen
-      assert instance.attributes.frozen?
-    end
-
-    def test_id_attribute_can_be_read_for_serialization
-      klass = Class.new(ActiveModelSerializers::Model) do
-        attributes :id, :one, :two, :three
-      end
-      self.class.const_set(:SomeTestModel, klass)
-      original_attributes = { id: :ego, one: 1, two: 2, three: 3 }
-      original_instance = klass.new(original_attributes)
-
-      # Initial value
-      instance = original_instance.dup
-      expected_attributes = { id: :ego, one: 1, two: 2, three: 3 }.with_indifferent_access
-      assert_equal expected_attributes, instance.attributes
-      assert_equal :ego, instance.id
-      assert_equal :ego, instance.read_attribute_for_serialization(:id)
-
-      # FIXME: Change via accessor has no effect on attributes.
-      instance = original_instance.dup
-      instance.id = :superego
-      assert_equal expected_attributes, instance.attributes
-      assert_equal :superego, instance.id
-      assert_equal :superego, instance.read_attribute_for_serialization(:id)
-
-      # FIXME: Change via mutating attributes
-      instance = original_instance.dup
-      instance.attributes[:id] = :superego
-      expected_attributes = { id: :superego, one: 1, two: 2, three: 3 }.with_indifferent_access
-      assert_equal expected_attributes, instance.attributes
-      assert_equal :ego, instance.id
-      assert_equal :ego, instance.read_attribute_for_serialization(:id)
-    ensure
-      self.class.send(:remove_const, :SomeTestModel)
-    end
-
-    def test_id_attribute_can_be_read_for_serialization_with_attributes_accessors_fix
-      klass = Class.new(ActiveModelSerializers::Model) do
-        derive_attributes_from_names_and_fix_accessors
-        attributes :id, :one, :two, :three
-      end
-      self.class.const_set(:SomeTestModel, klass)
-      original_attributes = { id: :ego, one: 1, two: 2, three: 3 }
-      original_instance = klass.new(original_attributes)
-
-      # Initial value
-      instance = original_instance.dup
-      expected_attributes = { id: :ego, one: 1, two: 2, three: 3 }.with_indifferent_access
-      assert_equal expected_attributes, instance.attributes
-      assert_equal :ego, instance.id
-      assert_equal :ego, instance.read_attribute_for_serialization(:id)
-
-      expected_attributes = { id: :superego, one: 1, two: 2, three: 3 }.with_indifferent_access
-      # Change via accessor
-      instance = original_instance.dup
-      instance.id = :superego
-      assert_equal expected_attributes, instance.attributes
-      assert_equal :superego, instance.id
-      assert_equal :superego, instance.read_attribute_for_serialization(:id)
-
-      # Attributes frozen
-      assert instance.attributes.frozen?
-    ensure
-      self.class.send(:remove_const, :SomeTestModel)
-    end
-  end
-end

data/test/active_model_serializers/railtie_test_isolated.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-# Execute this test in isolation
-require 'support/isolated_unit'
-
-class RailtieTest < ActiveSupport::TestCase
-  include ActiveSupport::Testing::Isolation
-
-  class WithRailsRequiredFirst < RailtieTest
-    setup do
-      require 'rails'
-      require 'active_model_serializers'
-      make_basic_app do |app|
-        app.config.action_controller.perform_caching = true
-      end
-    end
-
-    test 'mixes ActionController::Serialization into ActionController::Base' do
-      assert ActionController.const_defined?(:Serialization),
-        "ActionController::Serialization should be defined, but isn't"
-      assert ::ActionController::Base.included_modules.include?(::ActionController::Serialization),
-        "ActionController::Serialization should be included in ActionController::Base, but isn't"
-    end
-
-    test 'prepares url_helpers for SerializationContext' do
-      assert ActiveModelSerializers::SerializationContext.url_helpers.respond_to? :url_for
-      assert_equal Rails.application.routes.default_url_options,
-        ActiveModelSerializers::SerializationContext.default_url_options
-    end
-
-    test 'sets the ActiveModelSerializers.logger to Rails.logger' do
-      refute_nil Rails.logger
-      refute_nil ActiveModelSerializers.logger
-      assert_equal Rails.logger, ActiveModelSerializers.logger
-    end
-
-    test 'it is configured for caching' do
-      assert_equal ActionController::Base.cache_store, ActiveModelSerializers.config.cache_store
-      assert_equal true, Rails.configuration.action_controller.perform_caching
-      assert_equal true, ActiveModelSerializers.config.perform_caching
-    end
-  end
-
-  class WithoutRailsRequiredFirst < RailtieTest
-    setup do
-      require 'active_model_serializers'
-      make_basic_app do |app|
-        app.config.action_controller.perform_caching = true
-      end
-    end
-
-    test 'does not mix ActionController::Serialization into ActionController::Base' do
-      refute ActionController.const_defined?(:Serialization),
-        'ActionController::Serialization should not be defined, but is'
-    end
-
-    test 'has its own logger at ActiveModelSerializers.logger' do
-      refute_nil Rails.logger
-      refute_nil ActiveModelSerializers.logger
-      refute_equal Rails.logger, ActiveModelSerializers.logger
-    end
-
-    test 'it is not configured for caching' do
-      refute_nil ActionController::Base.cache_store
-      assert_nil ActiveModelSerializers.config.cache_store
-      assert_equal true, Rails.configuration.action_controller.perform_caching
-      assert_nil ActiveModelSerializers.config.perform_caching
-    end
-  end
-end

data/test/active_model_serializers/register_jsonapi_renderer_test_isolated.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-require 'support/isolated_unit'
-require 'minitest/mock'
-require 'action_dispatch'
-require 'action_controller'
-
-class JsonApiRendererTest < ActionDispatch::IntegrationTest
-  include ActiveSupport::Testing::Isolation
-
-  class TestController < ActionController::Base
-    class << self
-      attr_accessor :last_request_parameters
-    end
-
-    def render_with_jsonapi_renderer
-      permitted_params = params.permit(data: [:id, :type, attributes: [:name]])
-      permitted_params = permitted_params.to_h.with_indifferent_access
-      attributes =
-        if permitted_params[:data]
-          permitted_params[:data][:attributes].merge(id: permitted_params[:data][:id])
-        else
-          # Rails returns empty params when no mime type can be negotiated.
-          # (Until https://github.com/rails/rails/pull/26632 is reviewed.)
-          permitted_params
-        end
-      author = Author.new(attributes)
-      render jsonapi: author
-    end
-
-    def parse
-      self.class.last_request_parameters = request.request_parameters
-      head :ok
-    end
-  end
-
-  def teardown
-    TestController.last_request_parameters = nil
-  end
-
-  def assert_parses(expected, actual, headers = {})
-    post '/parse', params: actual, headers: headers
-    assert_response :ok
-    assert_equal(expected, TestController.last_request_parameters)
-  end
-
-  def define_author_model_and_serializer
-    TestController.const_set(:Author, Class.new(ActiveModelSerializers::Model) do
-      attributes :id, :name
-    end)
-    TestController.const_set(:AuthorSerializer, Class.new(ActiveModel::Serializer) do
-      type 'users'
-      attribute :id
-      attribute :name
-    end)
-  end
-
-  class WithoutRenderer < JsonApiRendererTest
-    setup do
-      require 'rails'
-      require 'active_record'
-      require 'support/rails5_shims'
-      require 'active_model_serializers'
-      require 'fixtures/poro'
-
-      make_basic_app
-
-      Rails.application.routes.draw do
-        ActiveSupport::Deprecation.silence do
-          match ':action', to: TestController, via: [:get, :post]
-        end
-      end
-      define_author_model_and_serializer
-    end
-
-    def test_jsonapi_parser_not_registered
-      parsers = if Rails::VERSION::MAJOR >= 5
-                  ActionDispatch::Request.parameter_parsers
-                else
-                  ActionDispatch::ParamsParser::DEFAULT_PARSERS
-                end
-      assert_nil parsers[Mime[:jsonapi]]
-    end
-
-    def test_jsonapi_renderer_not_registered
-      payload = '{"data": {"attributes": {"name": "Johnny Rico"}, "type": "users", "id": "36c9c04e-86b1-4636-a5b0-8616672d1765"}}'
-      headers = { 'CONTENT_TYPE' => 'application/vnd.api+json' }
-      post '/render_with_jsonapi_renderer', params: payload, headers: headers
-      assert_equal '', response.body
-      assert_equal 500, response.status
-      assert_equal ActionView::MissingTemplate, request.env['action_dispatch.exception'].class
-    end
-
-    def test_jsonapi_parser
-      assert_parses(
-        {},
-        '',
-        'CONTENT_TYPE' => 'application/vnd.api+json'
-      )
-    end
-  end
-
-  class WithRenderer < JsonApiRendererTest
-    setup do
-      require 'rails'
-      require 'active_record'
-      require 'support/rails5_shims'
-      require 'active_model_serializers'
-      require 'fixtures/poro'
-      require 'active_model_serializers/register_jsonapi_renderer'
-
-      make_basic_app
-
-      Rails.application.routes.draw do
-        ActiveSupport::Deprecation.silence do
-          match ':action', to: TestController, via: [:get, :post]
-        end
-      end
-      define_author_model_and_serializer
-    end
-
-    def test_jsonapi_parser_registered
-      if Rails::VERSION::MAJOR >= 5
-        parsers = ActionDispatch::Request.parameter_parsers
-        assert_equal Proc, parsers[:jsonapi].class
-      else
-        parsers = ActionDispatch::ParamsParser::DEFAULT_PARSERS
-        assert_equal Proc, parsers[Mime[:jsonapi]].class
-      end
-    end
-
-    def test_jsonapi_renderer_registered
-      expected = {
-        'data' => {
-          'id' => '36c9c04e-86b1-4636-a5b0-8616672d1765',
-          'type' => 'users',
-          'attributes' => { 'name' => 'Johnny Rico' }
-        }
-      }
-
-      payload = '{"data": {"attributes": {"name": "Johnny Rico"}, "type": "users", "id": "36c9c04e-86b1-4636-a5b0-8616672d1765"}}'
-      headers = { 'CONTENT_TYPE' => 'application/vnd.api+json' }
-      post '/render_with_jsonapi_renderer', params: payload, headers: headers
-      assert_equal expected.to_json, response.body
-    end
-
-    def test_jsonapi_parser
-      assert_parses(
-        {
-          'data' => {
-            'attributes' => {
-              'name' => 'John Doe'
-            },
-            'type' => 'users',
-            'id' => '36c9c04e-86b1-4636-a5b0-8616672d1765'
-          }
-        },
-        '{"data": {"attributes": {"name": "John Doe"}, "type": "users", "id": "36c9c04e-86b1-4636-a5b0-8616672d1765"}}',
-        'CONTENT_TYPE' => 'application/vnd.api+json'
-      )
-    end
-  end
-end

data/test/active_model_serializers/serialization_context_test_isolated.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-# Execute this test in isolation
-require 'support/isolated_unit'
-require 'minitest/mock'
-
-class SerializationContextTest < ActiveSupport::TestCase
-  include ActiveSupport::Testing::Isolation
-
-  class WithRails < SerializationContextTest
-    def create_request
-      request = ActionDispatch::Request.new({})
-      def request.original_url
-        'http://example.com/articles?page=2'
-      end
-
-      def request.query_parameters
-        { 'page' => 2 }
-      end
-      request
-    end
-
-    setup do
-      require 'rails'
-      require 'active_model_serializers'
-      make_basic_app
-      @context = ActiveModelSerializers::SerializationContext.new(create_request)
-    end
-
-    test 'create context with request url and query parameters' do
-      assert_equal @context.request_url, 'http://example.com/articles'
-      assert_equal @context.query_parameters, 'page' => 2
-    end
-
-    test 'url_helpers is set up for Rails url_helpers' do
-      assert_equal Module, ActiveModelSerializers::SerializationContext.url_helpers.class
-      assert ActiveModelSerializers::SerializationContext.url_helpers.respond_to? :url_for
-    end
-
-    test 'default_url_options returns Rails.application.routes.default_url_options' do
-      assert_equal Rails.application.routes.default_url_options,
-        ActiveModelSerializers::SerializationContext.default_url_options
-    end
-  end
-
-  class WithoutRails < SerializationContextTest
-    def create_request
-      {
-        request_url: 'http://example.com/articles',
-        query_parameters: { 'page' => 2 }
-      }
-    end
-
-    setup do
-      require 'active_model_serializers/serialization_context'
-      @context = ActiveModelSerializers::SerializationContext.new(create_request)
-    end
-
-    test 'create context with request url and query parameters' do
-      assert_equal @context.request_url, 'http://example.com/articles'
-      assert_equal @context.query_parameters, 'page' => 2
-    end
-
-    test 'url_helpers is a module when Rails is not present' do
-      assert_equal Module, ActiveModelSerializers::SerializationContext.url_helpers.class
-      refute ActiveModelSerializers::SerializationContext.url_helpers.respond_to? :url_for
-    end
-
-    test 'default_url_options return a Hash' do
-      assert Hash, ActiveModelSerializers::SerializationContext.default_url_options.class
-    end
-  end
-end

data/test/active_model_serializers/test/schema_test.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Test
-    class SchemaTest < ActionController::TestCase
-      include ActiveModelSerializers::Test::Schema
-
-      class MyController < ActionController::Base
-        def index
-          render json: profile
-        end
-
-        def show
-          index
-        end
-
-        def name_as_a_integer
-          profile.name = 1
-          index
-        end
-
-        def render_using_json_api
-          render json: profile, adapter: :json_api
-        end
-
-        def invalid_json_body
-          render json: ''
-        end
-
-        private
-
-        def profile
-          @profile ||= Profile.new(name: 'Name 1', description: 'Description 1', comments: 'Comments 1')
-        end
-      end
-
-      tests MyController
-
-      def test_that_assert_with_a_valid_schema
-        get :index
-        assert_response_schema
-      end
-
-      def test_that_raises_a_minitest_error_with_a_invalid_schema
-        message = "#/name: failed schema #/properties/name: For 'properties/name', \"Name 1\" is not an integer. and #/description: failed schema #/properties/description: For 'properties/description', \"Description 1\" is not a boolean."
-
-        get :show
-
-        error = assert_raises Minitest::Assertion do
-          assert_response_schema
-        end
-        assert_equal(message, error.message)
-      end
-
-      def test_that_raises_error_with_a_custom_message_with_a_invalid_schema
-        message = 'oh boy the show is broken'
-        exception_message = "#/name: failed schema #/properties/name: For 'properties/name', \"Name 1\" is not an integer. and #/description: failed schema #/properties/description: For 'properties/description', \"Description 1\" is not a boolean."
-        expected_message = "#{message}: #{exception_message}"
-
-        get :show
-
-        error = assert_raises Minitest::Assertion do
-          assert_response_schema(nil, message)
-        end
-        assert_equal(expected_message, error.message)
-      end
-
-      def test_that_assert_with_a_custom_schema
-        get :show
-        assert_response_schema('custom/show.json')
-      end
-
-      def test_that_assert_with_a_hyper_schema
-        get :show
-        assert_response_schema('hyper_schema.json')
-      end
-
-      def test_simple_json_pointers
-        get :show
-        assert_response_schema('simple_json_pointers.json')
-      end
-
-      def test_simple_json_pointers_that_doesnt_match
-        get :name_as_a_integer
-
-        assert_raises Minitest::Assertion do
-          assert_response_schema('simple_json_pointers.json')
-        end
-      end
-
-      def test_json_api_schema
-        get :render_using_json_api
-        assert_response_schema('render_using_json_api.json')
-      end
-
-      def test_that_assert_with_a_custom_schema_directory
-        original_schema_path = ActiveModelSerializers.config.schema_path
-        ActiveModelSerializers.config.schema_path = 'test/support/custom_schemas'
-
-        get :index
-        assert_response_schema
-
-        ActiveModelSerializers.config.schema_path = original_schema_path
-      end
-
-      def test_with_a_non_existent_file
-        message = 'No Schema file at test/support/schemas/non-existent.json'
-
-        get :show
-
-        error = assert_raises ActiveModelSerializers::Test::Schema::MissingSchema do
-          assert_response_schema('non-existent.json')
-        end
-        assert_equal(message, error.message)
-      end
-
-      def test_that_raises_with_a_invalid_json_body
-        # message changes from JSON gem 2.0.2 to 2.2.0
-        message = /A JSON text must at least contain two octets!|unexpected token at ''/
-
-        get :invalid_json_body
-
-        error = assert_raises ActiveModelSerializers::Test::Schema::InvalidSchemaError do
-          assert_response_schema('custom/show.json')
-        end
-
-        assert_match(message, error.message)
-      end
-    end
-  end
-end