active_model_serializers 0.8.3 → 0.10.0.rc4

data/test/active_model_serializers/logging_test.rb

@@ -0,0 +1,77 @@
+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
+        ActiveModel::SerializableResource.new(@post).serializable_hash
+        assert_match(/\[active_model_serializers\]/, @logger.messages)
+      end
+
+      def test_logs_when_call_serializable_hash
+        ActiveModel::SerializableResource.new(@post).serializable_hash
+        assert_match(/Rendered/, @logger.messages)
+      end
+
+      def test_logs_when_call_as_json
+        ActiveModel::SerializableResource.new(@post).as_json
+        assert_match(/Rendered/, @logger.messages)
+      end
+
+      def test_logs_when_call_to_json
+        ActiveModel::SerializableResource.new(@post).to_json
+        assert_match(/Rendered/, @logger.messages)
+      end
+
+      def test_logs_correct_serializer
+        ActiveModel::SerializableResource.new(@post).serializable_hash
+        assert_match(/PostSerializer/, @logger.messages)
+      end
+
+      def test_logs_correct_adapter
+        ActiveModel::SerializableResource.new(@post).serializable_hash
+        assert_match(/ActiveModel::Serializer::Adapter::Attributes/, @logger.messages)
+      end
+
+      def test_logs_the_duration
+        ActiveModel::SerializableResource.new(@post).serializable_hash
+        assert_match(/\(\d+\.\d+ms\)/, @logger.messages)
+      end
+    end
+  end
+end

data/test/active_model_serializers/model_test.rb

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

data/test/active_model_serializers/railtie_test_isolated.rb

@@ -0,0 +1,57 @@
+# Execute this test in isolation
+require 'support/isolated_unit'
+
+class RailtieTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  class WithRails < RailtieTest
+    setup do
+      require 'rails'
+      require 'active_model_serializers'
+      make_basic_app
+    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 '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 Rails.configuration.action_controller.perform_caching, ActiveModelSerializers.config.perform_caching
+    end
+  end
+
+  class WithoutRails < RailtieTest
+    setup do
+      require 'active_model_serializers'
+      make_basic_app
+    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
+      refute Rails.configuration.action_controller.perform_caching
+      refute ActiveModelSerializers.config.perform_caching
+    end
+  end
+end

data/test/active_model_serializers/serialization_context_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class ActiveModelSerializers::SerializationContextTest < ActiveSupport::TestCase
+  def create_context
+    request = Minitest::Mock.new
+    request.expect(:original_url, 'original_url')
+    request.expect(:query_parameters, 'query_parameters')
+
+    ActiveModelSerializers::SerializationContext.new(request)
+  end
+
+  def test_create_context_with_request_url_and_query_parameters
+    context = create_context
+
+    assert_equal context.request_url, 'original_url'
+    assert_equal context.query_parameters, 'query_parameters'
+  end
+end

data/test/active_model_serializers/test/schema_test.rb

@@ -0,0 +1,128 @@
+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'
+
+        get :show
+
+        error = assert_raises Minitest::Assertion do
+          assert_response_schema(nil, message)
+        end
+        assert_equal(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 = %r{.* - 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_match(message, error.message)
+      end
+
+      def test_that_raises_with_a_invalid_json_body
+        message = 'A JSON text must at least contain two octets!'
+
+        get :invalid_json_body
+
+        error = assert_raises ActiveModelSerializers::Test::Schema::InvalidSchemaError do
+          assert_response_schema('custom/show.json')
+        end
+
+        assert_equal(message, error.message)
+      end
+    end
+  end
+end

data/test/active_model_serializers/test/serializer_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  module Test
+    class SerializerTest < ActionController::TestCase
+      include ActiveModelSerializers::Test::Serializer
+
+      class MyController < ActionController::Base
+        def render_using_serializer
+          render json: Profile.new(name: 'Name 1', description: 'Description 1', comments: 'Comments 1')
+        end
+
+        # For Rails4.0
+        def render_some_text
+          Rails.version > '4.1' ? render(plain: 'ok') : render(text: 'ok')
+        end
+      end
+
+      tests MyController
+
+      def test_supports_specifying_serializers_with_a_serializer_class
+        get :render_using_serializer
+        assert_serializer ProfileSerializer
+      end
+
+      def test_supports_specifying_serializers_with_a_regexp
+        get :render_using_serializer
+        assert_serializer(/\AProfile.+\Z/)
+      end
+
+      def test_supports_specifying_serializers_with_a_string
+        get :render_using_serializer
+        assert_serializer 'ProfileSerializer'
+      end
+
+      def test_supports_specifying_serializers_with_a_symbol
+        get :render_using_serializer
+        assert_serializer :profile_serializer
+      end
+
+      def test_supports_specifying_serializers_with_a_nil
+        get :render_some_text
+        assert_serializer nil
+      end
+
+      def test_raises_descriptive_error_message_when_serializer_was_not_rendered
+        get :render_using_serializer
+        e = assert_raise ActiveSupport::TestCase::Assertion do
+          assert_serializer 'PostSerializer'
+        end
+        assert_match 'expecting <"PostSerializer"> but rendering with <["ProfileSerializer"]>', e.message
+      end
+
+      def test_raises_argument_error_when_asserting_with_invalid_object
+        get :render_using_serializer
+        e = assert_raise ArgumentError do
+          assert_serializer Hash
+        end
+        assert_match 'assert_serializer only accepts a String, Symbol, Regexp, ActiveModel::Serializer, or nil', e.message
+      end
+    end
+  end
+end

data/test/active_record_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class ActiveRecordTest < ActiveSupport::TestCase
+  include ActiveModel::Serializer::Lint::Tests
+
+  def setup
+    @resource = ARModels::Post.new
+  end
+end

data/test/adapter/fragment_cache_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+module ActiveModel
+  class Serializer
+    module Adapter
+      class FragmentCacheTest < ActiveSupport::TestCase
+        def setup
+          super
+          @spam            = Spam::UnrelatedLink.new(id: 'spam-id-1')
+          @author          = Author.new(name: 'Joao M. D. Moura')
+          @role            = Role.new(name: 'Great Author', description: nil)
+          @role.author     = [@author]
+          @role_serializer = RoleSerializer.new(@role)
+          @spam_serializer = Spam::UnrelatedLinkSerializer.new(@spam)
+          @role_hash       = FragmentCache.new(RoleSerializer.adapter.new(@role_serializer), @role_serializer, {})
+          @spam_hash       = FragmentCache.new(Spam::UnrelatedLinkSerializer.adapter.new(@spam_serializer), @spam_serializer, {})
+        end
+
+        def test_fragment_fetch_with_virtual_attributes
+          expected_result = {
+            id: @role.id,
+            description: @role.description,
+            slug: "#{@role.name}-#{@role.id}",
+            name: @role.name
+          }
+          assert_equal(@role_hash.fetch, expected_result)
+        end
+
+        def test_fragment_fetch_with_namespaced_object
+          expected_result = {
+            id: @spam.id
+          }
+          assert_equal(@spam_hash.fetch, expected_result)
+        end
+      end
+    end
+  end
+end
+

data/test/adapter/json/belongs_to_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Json
+        class BelongsToTest < ActiveSupport::TestCase
+          def setup
+            @post = Post.new(id: 42, title: 'New Post', body: 'Body')
+            @anonymous_post = Post.new(id: 43, title: 'Hello!!', body: 'Hello, world!!')
+            @comment = Comment.new(id: 1, body: 'ZOMG A COMMENT')
+            @post.comments = [@comment]
+            @anonymous_post.comments = []
+            @comment.post = @post
+            @comment.author = nil
+            @anonymous_post.author = nil
+            @blog = Blog.new(id: 1, name: 'My Blog!!')
+            @post.blog = @blog
+            @anonymous_post.blog = nil
+
+            @serializer = CommentSerializer.new(@comment)
+            @adapter = ActiveModel::Serializer::Adapter::Json.new(@serializer)
+            ActionController::Base.cache_store.clear
+          end
+
+          def test_includes_post
+            assert_equal({ id: 42, title: 'New Post', body: 'Body' }, @adapter.serializable_hash[:comment][:post])
+          end
+
+          def test_include_nil_author
+            serializer = PostSerializer.new(@anonymous_post)
+            adapter = ActiveModel::Serializer::Adapter::Json.new(serializer)
+
+            assert_equal({ post: { title: 'Hello!!', body: 'Hello, world!!', id: 43, comments: [], blog: { id: 999, name: 'Custom blog' }, author: nil } }, adapter.serializable_hash)
+          end
+
+          def test_include_nil_author_with_specified_serializer
+            serializer = PostPreviewSerializer.new(@anonymous_post)
+            adapter = ActiveModel::Serializer::Adapter::Json.new(serializer)
+
+            assert_equal({ post: { title: 'Hello!!', body: 'Hello, world!!', id: 43, comments: [], author: nil } }, adapter.serializable_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/adapter/json/collection_test.rb

@@ -0,0 +1,92 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Json
+        class Collection < ActiveSupport::TestCase
+          def setup
+            @author = Author.new(id: 1, name: 'Steve K.')
+            @first_post = Post.new(id: 1, title: 'Hello!!', body: 'Hello, world!!')
+            @second_post = Post.new(id: 2, title: 'New Post', body: 'Body')
+            @first_post.comments = []
+            @second_post.comments = []
+            @first_post.author = @author
+            @second_post.author = @author
+            @blog = Blog.new(id: 1, name: 'My Blog!!')
+            @first_post.blog = @blog
+            @second_post.blog = nil
+
+            ActionController::Base.cache_store.clear
+          end
+
+          def test_with_serializer_option
+            @blog.special_attribute = 'Special'
+            @blog.articles = [@first_post, @second_post]
+            serializer = CollectionSerializer.new([@blog], serializer: CustomBlogSerializer)
+            adapter = ActiveModel::Serializer::Adapter::Json.new(serializer)
+
+            expected = { blogs: [{
+              id: 1,
+              special_attribute: 'Special',
+              articles: [{ id: 1, title: 'Hello!!', body: 'Hello, world!!' }, { id: 2, title: 'New Post', body: 'Body' }]
+            }] }
+            assert_equal expected, adapter.serializable_hash
+          end
+
+          def test_include_multiple_posts
+            serializer = CollectionSerializer.new([@first_post, @second_post])
+            adapter = ActiveModel::Serializer::Adapter::Json.new(serializer)
+
+            expected = { posts: [{
+              title: 'Hello!!',
+              body: 'Hello, world!!',
+              id: 1,
+              comments: [],
+              author: {
+                id: 1,
+                name: 'Steve K.'
+              },
+              blog: {
+                id: 999,
+                name: 'Custom blog'
+              }
+            }, {
+              title: 'New Post',
+              body: 'Body',
+              id: 2,
+              comments: [],
+              author: {
+                id: 1,
+                name: 'Steve K.'
+              },
+              blog: {
+                id: 999,
+                name: 'Custom blog'
+              }
+            }] }
+            assert_equal expected, adapter.serializable_hash
+          end
+
+          def test_root_is_underscored
+            virtual_value = VirtualValue.new(id: 1)
+            serializer = CollectionSerializer.new([virtual_value])
+            adapter = ActiveModel::Serializer::Adapter::Json.new(serializer)
+
+            assert_equal 1, adapter.serializable_hash[:virtual_values].length
+          end
+
+          def test_include_option
+            serializer = CollectionSerializer.new([@first_post, @second_post])
+            adapter = ActiveModel::Serializer::Adapter::Json.new(serializer, include: '')
+            actual = adapter.serializable_hash
+            expected = { posts: [{ id: 1, title: 'Hello!!', body: 'Hello, world!!' },
+                                 { id: 2, title: 'New Post', body: 'Body' }] }
+
+            assert_equal(expected, actual)
+          end
+        end
+      end
+    end
+  end
+end

data/test/adapter/json/has_many_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class Json
+        class HasManyTestTest < ActiveSupport::TestCase
+          def setup
+            ActionController::Base.cache_store.clear
+            @author = Author.new(id: 1, name: 'Steve K.')
+            @post = Post.new(id: 42, title: 'New Post', body: 'Body')
+            @first_comment = Comment.new(id: 1, body: 'ZOMG A COMMENT')
+            @second_comment = Comment.new(id: 2, body: 'ZOMG ANOTHER COMMENT')
+            @post.comments = [@first_comment, @second_comment]
+            @post.author = @author
+            @first_comment.post = @post
+            @second_comment.post = @post
+            @blog = Blog.new(id: 1, name: 'My Blog!!')
+            @post.blog = @blog
+            @tag = Tag.new(id: 1, name: '#hash_tag')
+            @post.tags = [@tag]
+          end
+
+          def test_has_many
+            serializer = PostSerializer.new(@post)
+            adapter = ActiveModel::Serializer::Adapter::Json.new(serializer)
+            assert_equal([
+                           { id: 1, body: 'ZOMG A COMMENT' },
+                           { id: 2, body: 'ZOMG ANOTHER COMMENT' }
+                         ], adapter.serializable_hash[:post][:comments])
+          end
+
+          def test_has_many_with_no_serializer
+            serializer = PostWithTagsSerializer.new(@post)
+            adapter = ActiveModel::Serializer::Adapter::Json.new(serializer)
+            assert_equal({
+              id: 42,
+              tags: [
+                { 'id' => 1, 'name' => '#hash_tag' }
+              ]
+            }.to_json, adapter.serializable_hash[:post].to_json)
+          end
+        end
+      end
+    end
+  end
+end