active_model_serializers 0.8.3 → 0.10.0

data/test/fixtures/poro.rb

@@ -0,0 +1,282 @@
+verbose = $VERBOSE
+$VERBOSE = nil
+class Model < ActiveModelSerializers::Model
+  FILE_DIGEST = Digest::MD5.hexdigest(File.open(__FILE__).read)
+
+  ### Helper methods, not required to be serializable
+
+  # Convenience when not adding @attributes readers and writers
+  def method_missing(meth, *args)
+    if meth.to_s =~ /^(.*)=$/
+      attributes[$1.to_sym] = args[0]
+    elsif attributes.key?(meth)
+      attributes[meth]
+    else
+      super
+    end
+  end
+
+  # required for ActiveModel::AttributeAssignment#_assign_attribute
+  # in Rails 5
+  def respond_to_missing?(method_name, _include_private = false)
+    attributes.key?(method_name.to_s.tr('=', '').to_sym) || super
+  end
+end
+
+# see
+# https://github.com/rails/rails/blob/4-2-stable/activemodel/lib/active_model/errors.rb
+# The below allows you to do:
+#
+#   model = ModelWithErrors.new
+#   model.validate!            # => ["cannot be nil"]
+#   model.errors.full_messages # => ["name cannot be nil"]
+class ModelWithErrors < ::ActiveModelSerializers::Model
+  attr_accessor :name
+end
+
+class Profile < Model
+end
+
+class ProfileSerializer < ActiveModel::Serializer
+  attributes :name, :description
+
+  # TODO: is this used anywhere?
+  def arguments_passed_in?
+    instance_options[:my_options] == :accessible
+  end
+end
+
+class ProfilePreviewSerializer < ActiveModel::Serializer
+  attributes :name
+end
+
+Post     = Class.new(Model)
+Like     = Class.new(Model)
+Author   = Class.new(Model)
+Bio      = Class.new(Model)
+Blog     = Class.new(Model)
+Role     = Class.new(Model)
+User     = Class.new(Model)
+Location = Class.new(Model)
+Place    = Class.new(Model)
+Tag      = Class.new(Model)
+VirtualValue = Class.new(Model)
+Comment = Class.new(Model) do
+  # Uses a custom non-time-based cache key
+  def cache_key
+    "#{self.class.name.downcase}/#{self.id}"
+  end
+end
+
+class Employee < ActiveRecord::Base
+  has_many :pictures, as: :imageable
+  has_many :object_tags, as: :taggable
+end
+
+class ObjectTag < ActiveRecord::Base
+  belongs_to :poly_tag
+  belongs_to :taggable, polymorphic: true
+end
+
+class Picture < ActiveRecord::Base
+  belongs_to :imageable, polymorphic: true
+  has_many :object_tags, as: :taggable
+end
+
+class PolyTag < ActiveRecord::Base
+  has_many :object_tags
+end
+
+module Spam; end
+Spam::UnrelatedLink = Class.new(Model)
+
+PostSerializer = Class.new(ActiveModel::Serializer) do
+  cache key: 'post', expires_in: 0.1, skip_digest: true
+  attributes :id, :title, :body
+
+  has_many :comments
+  belongs_to :blog
+  belongs_to :author
+
+  def blog
+    Blog.new(id: 999, name: 'Custom blog')
+  end
+
+  # TODO: is this used anywhere?
+  def custom_options
+    instance_options
+  end
+end
+
+SpammyPostSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+  has_many :related
+end
+
+CommentSerializer = Class.new(ActiveModel::Serializer) do
+  cache expires_in: 1.day, skip_digest: true
+  attributes :id, :body
+
+  belongs_to :post
+  belongs_to :author
+
+  def custom_options
+    instance_options
+  end
+end
+
+AuthorSerializer = Class.new(ActiveModel::Serializer) do
+  cache key: 'writer', skip_digest: true
+  attribute :id
+  attribute :name
+
+  has_many :posts
+  has_many :roles
+  has_one :bio
+end
+
+RoleSerializer = Class.new(ActiveModel::Serializer) do
+  cache only: [:name], skip_digest: true
+  attributes :id, :name, :description, :slug
+
+  def slug
+    "#{object.name}-#{object.id}"
+  end
+
+  belongs_to :author
+end
+
+LikeSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :time
+
+  belongs_to :likeable
+end
+
+LocationSerializer = Class.new(ActiveModel::Serializer) do
+  cache only: [:place], skip_digest: true
+  attributes :id, :lat, :lng
+
+  belongs_to :place
+
+  def place
+    'Nowhere'
+  end
+end
+
+PlaceSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :name
+
+  has_many :locations
+end
+
+BioSerializer = Class.new(ActiveModel::Serializer) do
+  cache except: [:content], skip_digest: true
+  attributes :id, :content, :rating
+
+  belongs_to :author
+end
+
+BlogSerializer = Class.new(ActiveModel::Serializer) do
+  cache key: 'blog'
+  attributes :id, :name
+
+  belongs_to :writer
+  has_many :articles
+end
+
+PaginatedSerializer = Class.new(ActiveModel::Serializer::CollectionSerializer) do
+  def json_key
+    'paginated'
+  end
+end
+
+AlternateBlogSerializer = Class.new(ActiveModel::Serializer) do
+  attribute :id
+  attribute :name, key: :title
+end
+
+CustomBlogSerializer = Class.new(ActiveModel::Serializer) do
+  attribute :id
+  attribute :special_attribute
+
+  has_many :articles
+end
+
+CommentPreviewSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+
+  belongs_to :post
+end
+
+AuthorPreviewSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+
+  has_many :posts
+end
+
+PostPreviewSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :title, :body, :id
+
+  has_many :comments, serializer: CommentPreviewSerializer
+  belongs_to :author, serializer: AuthorPreviewSerializer
+end
+
+PostWithTagsSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+
+  has_many :tags
+end
+
+PostWithCustomKeysSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+
+  has_many :comments, key: :reviews
+  belongs_to :author, key: :writer
+  has_one :blog, key: :site
+end
+
+VirtualValueSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+
+  has_many :reviews, virtual_value: [{ type: 'reviews', id: '1' },
+                                     { type: 'reviews', id: '2' }]
+  has_one :maker, virtual_value: { type: 'makers', id: '1' }
+
+  def reviews
+  end
+
+  def maker
+  end
+end
+
+PolymorphicHasManySerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :name
+end
+
+PolymorphicBelongsToSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :title
+
+  has_one :imageable, serializer: PolymorphicHasManySerializer, polymorphic: true
+end
+
+PolymorphicSimpleSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+end
+
+PolymorphicObjectTagSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+
+  has_many :taggable, serializer: PolymorphicSimpleSerializer, polymorphic: true
+end
+
+PolymorphicTagSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :phrase
+
+  has_many :object_tags, serializer: PolymorphicObjectTagSerializer
+end
+
+Spam::UnrelatedLinkSerializer = Class.new(ActiveModel::Serializer) do
+  cache only: [:id]
+  attributes :id
+end
+$VERBOSE = verbose

data/test/generators/scaffold_controller_generator_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+require 'generators/rails/resource_override'
+
+class ResourceGeneratorTest < Rails::Generators::TestCase
+  destination File.expand_path('../../../tmp/generators', __FILE__)
+  setup :prepare_destination, :copy_routes
+
+  tests Rails::Generators::ResourceGenerator
+  arguments %w(account)
+
+  def test_serializer_file_is_generated
+    run_generator
+
+    assert_file 'app/serializers/account_serializer.rb', /class AccountSerializer < ActiveModel::Serializer/
+  end
+
+  private
+
+  def copy_routes
+    config_dir = File.join(destination_root, 'config')
+    FileUtils.mkdir_p(config_dir)
+    File.write(File.join(config_dir, 'routes.rb'), 'Rails.application.routes.draw {}')
+  end
+end

data/test/generators/serializer_generator_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+require 'generators/rails/resource_override'
+require 'generators/rails/serializer_generator'
+
+class SerializerGeneratorTest < Rails::Generators::TestCase
+  destination File.expand_path('../../../tmp/generators', __FILE__)
+  setup :prepare_destination
+
+  tests Rails::Generators::SerializerGenerator
+  arguments %w(account name:string description:text business:references)
+
+  def test_generates_a_serializer
+    run_generator
+    assert_file 'app/serializers/account_serializer.rb', /class AccountSerializer < ActiveModel::Serializer/
+  end
+
+  def test_generates_a_namespaced_serializer
+    run_generator ['admin/account']
+    assert_file 'app/serializers/admin/account_serializer.rb', /class Admin::AccountSerializer < ActiveModel::Serializer/
+  end
+
+  def test_uses_application_serializer_if_one_exists
+    Object.const_set(:ApplicationSerializer, Class.new)
+    run_generator
+    assert_file 'app/serializers/account_serializer.rb', /class AccountSerializer < ApplicationSerializer/
+  ensure
+    Object.send :remove_const, :ApplicationSerializer
+  end
+
+  def test_uses_given_parent
+    Object.const_set(:ApplicationSerializer, Class.new)
+    run_generator ['Account', '--parent=MySerializer']
+    assert_file 'app/serializers/account_serializer.rb', /class AccountSerializer < MySerializer/
+  ensure
+    Object.send :remove_const, :ApplicationSerializer
+  end
+
+  def test_generates_attributes_and_associations
+    run_generator
+    assert_file 'app/serializers/account_serializer.rb' do |serializer|
+      assert_match(/^  attributes :id, :name, :description$/, serializer)
+      assert_match(/^  has_one :business$/, serializer)
+      assert_match(/^end\n*\z/, serializer)
+    end
+  end
+
+  def test_with_no_attributes_does_not_add_extra_space
+    run_generator ['account']
+    assert_file 'app/serializers/account_serializer.rb' do |content|
+      if RUBY_PLATFORM =~ /mingw/
+        assert_no_match(/\r\n\r\nend/, content)
+      else
+        assert_no_match(/\n\nend/, content)
+      end
+    end
+  end
+end

data/test/grape_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+require 'grape'
+require 'grape/active_model_serializers'
+
+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')
+    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
+  end
+
+  class GrapeTest < Grape::API
+    format :json
+    include Grape::ActiveModelSerializers
+
+    resources :grape do
+      get '/render' do
+        render Models.model1
+      end
+
+      get '/render_with_json_api' do
+        post = Models.model1
+        render post, meta: { page: 1, total_pages: 2 }, adapter: :json_api
+      end
+
+      get '/render_array_with_json_api' do
+        posts = Models.all
+        render posts, adapter: :json_api
+      end
+    end
+  end
+
+  def app
+    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
+    ARModels::Post.delete_all
+  end
+end

data/test/include_tree/from_include_args_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class IncludeTree
+      class FromStringTest < ActiveSupport::TestCase
+        def test_simple_array
+          input = [:comments, :author]
+          actual = ActiveModel::Serializer::IncludeTree.from_include_args(input)
+          assert(actual.key?(:author))
+          assert(actual.key?(:comments))
+        end
+
+        def test_nested_array
+          input = [:comments, posts: [:author, comments: [:author]]]
+          actual = ActiveModel::Serializer::IncludeTree.from_include_args(input)
+          assert(actual.key?(:posts))
+          assert(actual[:posts].key?(:author))
+          assert(actual[:posts].key?(:comments))
+          assert(actual[:posts][:comments].key?(:author))
+          assert(actual.key?(:comments))
+        end
+      end
+    end
+  end
+end

data/test/include_tree/from_string_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class IncludeTree
+      class FromStringTest < ActiveSupport::TestCase
+        def test_single_string
+          input = 'author'
+          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
+          assert(actual.key?(:author))
+        end
+
+        def test_multiple_strings
+          input = 'author,comments'
+          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
+          assert(actual.key?(:author))
+          assert(actual.key?(:comments))
+        end
+
+        def test_multiple_strings_with_space
+          input = 'author, comments'
+          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
+          assert(actual.key?(:author))
+          assert(actual.key?(:comments))
+        end
+
+        def test_nested_string
+          input = 'posts.author'
+          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
+          assert(actual.key?(:posts))
+          assert(actual[:posts].key?(:author))
+        end
+
+        def test_multiple_nested_string
+          input = 'posts.author,posts.comments.author,comments'
+          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
+          assert(actual.key?(:posts))
+          assert(actual[:posts].key?(:author))
+          assert(actual[:posts].key?(:comments))
+          assert(actual[:posts][:comments].key?(:author))
+          assert(actual.key?(:comments))
+        end
+
+        def test_toplevel_star_string
+          input = '*'
+          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
+          assert(actual.key?(:comments))
+        end
+
+        def test_nested_star_string
+          input = 'posts.*'
+          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
+          assert(actual.key?(:posts))
+          assert(actual[:posts].key?(:comments))
+        end
+
+        def test_nested_star_middle_string
+          input = 'posts.*.author'
+          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
+          assert(actual.key?(:posts))
+          assert(actual[:posts].key?(:comments))
+          assert(actual[:posts][:comments].key?(:author))
+          refute(actual[:posts][:comments].key?(:unspecified))
+        end
+
+        def test_nested_star_lower_precedence_string
+          input = 'posts.comments.author,posts.*'
+          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
+          assert(actual.key?(:posts))
+          assert(actual[:posts].key?(:comments))
+          assert(actual[:posts][:comments].key?(:author))
+        end
+
+        def test_toplevel_double_star_string
+          input = '**'
+          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
+          assert(actual.key?(:posts))
+          assert(actual[:posts].key?(:comments))
+          assert(actual[:posts][:comments].key?(:posts))
+        end
+
+        def test_nested_double_star_string
+          input = 'comments, posts.**'
+          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
+          assert(actual.key?(:comments))
+          refute(actual[:comments].key?(:author))
+          assert(actual.key?(:posts))
+          assert(actual[:posts].key?(:comments))
+          assert(actual[:posts][:comments].key?(:posts))
+        end
+      end
+    end
+  end
+end

data/test/include_tree/include_args_to_hash_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class IncludeTree
+      module Parsing
+        class IncludeArgsToHashTest < MiniTest::Test
+          def test_include_args_to_hash_from_symbol
+            expected = { author: {} }
+            input = :author
+            actual = Parsing.include_args_to_hash(input)
+
+            assert_equal(expected, actual)
+          end
+
+          def test_include_args_to_hash_from_array
+            expected = { author: {}, comments: {} }
+            input = [:author, :comments]
+            actual = Parsing.include_args_to_hash(input)
+
+            assert_equal(expected, actual)
+          end
+
+          def test_include_args_to_hash_from_nested_array
+            expected = { author: {}, comments: { author: {} } }
+            input = [:author, comments: [:author]]
+            actual = Parsing.include_args_to_hash(input)
+
+            assert_equal(expected, actual)
+          end
+
+          def test_include_args_to_hash_from_array_of_hashes
+            expected = {
+              author: {},
+              blogs: { posts: { contributors: {} } },
+              comments: { author: { blogs: { posts: {} } } }
+            }
+            input = [
+              :author,
+              blogs: [posts: :contributors],
+              comments: { author: { blogs: :posts } }
+            ]
+            actual = Parsing.include_args_to_hash(input)
+
+            assert_equal(expected, actual)
+          end
+
+          def test_array_of_string
+            expected = {
+              comments: { author: {}, attachment: {} }
+            }
+            input = [
+              'comments.author',
+              'comments.attachment'
+            ]
+            actual = Parsing.include_args_to_hash(input)
+
+            assert_equal(expected, actual)
+          end
+        end
+      end
+    end
+  end
+end

data/test/lint_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class LintTest < ActiveSupport::TestCase
+      include ActiveModel::Serializer::Lint::Tests
+
+      class CompliantResource
+        def serializable_hash(options = nil)
+        end
+
+        def read_attribute_for_serialization(name)
+        end
+
+        def as_json(options = nil)
+        end
+
+        def to_json(options = nil)
+        end
+
+        def cache_key
+        end
+
+        def id
+        end
+
+        def updated_at
+        end
+
+        def errors
+        end
+
+        def self.human_attribute_name(attr, options = {})
+        end
+
+        def self.lookup_ancestors
+        end
+
+        def self.model_name
+          @_model_name ||= ActiveModel::Name.new(self)
+        end
+      end
+
+      def setup
+        @resource = CompliantResource.new
+      end
+    end
+  end
+end

data/test/logger_test.rb

@@ -0,0 +1,18 @@
+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
+
+  def test_logger_can_be_set
+    original_logger = ActiveModelSerializers.logger
+    logger = Logger.new(STDOUT)
+
+    ActiveModelSerializers.logger = logger
+
+    assert_equal ActiveModelSerializers.logger, logger
+  ensure
+    ActiveModelSerializers.logger = original_logger
+  end
+end

data/test/poro_test.rb

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