active_model_serializers 0.10.9 → 0.10.10

data/test/collection_serializer_test.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class CollectionSerializerTest < ActiveSupport::TestCase
-      class SingularModel < ::Model; end
-      class SingularModelSerializer < ActiveModel::Serializer
-      end
-      class HasManyModel < ::Model
-        associations :singular_models
-      end
-      class HasManyModelSerializer < ActiveModel::Serializer
-        has_many :singular_models
-
-        def custom_options
-          instance_options
-        end
-      end
-      class MessagesSerializer < ActiveModel::Serializer
-        type 'messages'
-      end
-
-      def setup
-        @singular_model = SingularModel.new
-        @has_many_model = HasManyModel.new
-        @resource = build_named_collection @singular_model, @has_many_model
-        @serializer = collection_serializer.new(@resource, some: :options)
-      end
-
-      def collection_serializer
-        CollectionSerializer
-      end
-
-      def build_named_collection(*resource)
-        resource.define_singleton_method(:name) { 'MeResource' }
-        resource
-      end
-
-      def test_has_object_reader_serializer_interface
-        assert_equal @serializer.object, @resource
-      end
-
-      def test_respond_to_each
-        assert_respond_to @serializer, :each
-      end
-
-      def test_each_object_should_be_serialized_with_appropriate_serializer
-        serializers =  @serializer.to_a
-
-        assert_kind_of SingularModelSerializer, serializers.first
-        assert_kind_of SingularModel, serializers.first.object
-
-        assert_kind_of HasManyModelSerializer, serializers.last
-        assert_kind_of HasManyModel, serializers.last.object
-
-        assert_equal :options, serializers.last.custom_options[:some]
-      end
-
-      def test_serializer_option_not_passed_to_each_serializer
-        serializers = collection_serializer.new([@has_many_model], serializer: HasManyModelSerializer).to_a
-
-        refute serializers.first.custom_options.key?(:serializer)
-      end
-
-      def test_root_default
-        @serializer = collection_serializer.new([@singular_model, @has_many_model])
-        assert_nil @serializer.root
-      end
-
-      def test_root
-        expected =  'custom_root'
-        @serializer = collection_serializer.new([@singular_model, @has_many_model], root: expected)
-        assert_equal expected, @serializer.root
-      end
-
-      def test_root_with_no_serializers
-        expected =  'custom_root'
-        @serializer = collection_serializer.new([], root: expected)
-        assert_equal expected, @serializer.root
-      end
-
-      def test_json_key_with_resource_with_serializer
-        singular_key = @serializer.send(:serializers).first.json_key
-        assert_equal singular_key.pluralize, @serializer.json_key
-      end
-
-      def test_json_key_with_resource_with_name_and_no_serializers
-        serializer = collection_serializer.new(build_named_collection)
-        assert_equal 'me_resources', serializer.json_key
-      end
-
-      def test_json_key_with_resource_with_nil_name_and_no_serializers
-        resource = []
-        resource.define_singleton_method(:name) { nil }
-        serializer = collection_serializer.new(resource)
-        assert_raise ArgumentError do
-          serializer.json_key
-        end
-      end
-
-      def test_json_key_with_resource_without_name_and_no_serializers
-        serializer = collection_serializer.new([])
-        assert_raise ArgumentError do
-          serializer.json_key
-        end
-      end
-
-      def test_json_key_with_empty_resources_with_serializer
-        resource = []
-        serializer = collection_serializer.new(resource, serializer: MessagesSerializer)
-        assert_equal 'messages', serializer.json_key
-      end
-
-      def test_json_key_with_root
-        expected = 'custom_root'
-        serializer = collection_serializer.new(@resource, root: expected)
-        assert_equal expected, serializer.json_key
-      end
-
-      def test_json_key_with_root_and_no_serializers
-        expected = 'custom_root'
-        serializer = collection_serializer.new(build_named_collection, root: expected)
-        assert_equal expected, serializer.json_key
-      end
-    end
-  end
-end

data/test/fixtures/active_record.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_record'
-
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
-ActiveRecord::Schema.define do
-  self.verbose = false
-  create_table :posts, force: true do |t|
-    t.string :title
-    t.text :body
-    t.references :author
-    t.timestamps null: false
-  end
-  create_table :authors, force: true do |t|
-    t.string :name
-    t.timestamps null: false
-  end
-  create_table :comments, force: true do |t|
-    t.text :contents
-    t.references :author
-    t.references :post
-    t.timestamp null: false
-  end
-  create_table :employees, force: true do |t|
-    t.string :name
-    t.string :email
-    t.timestamp null: false
-  end
-  create_table :object_tags, force: true do |t|
-    t.string :poly_tag_id
-    t.string :taggable_type
-    t.string :taggable_id
-    t.timestamp null: false
-  end
-  create_table :poly_tags, force: true do |t|
-    t.string :phrase
-    t.timestamp null: false
-  end
-  create_table :pictures, force: true do |t|
-    t.string :title
-    t.string :imageable_type
-    t.string :imageable_id
-    t.timestamp null: false
-  end
-end
-
-module ARModels
-  class Post < ActiveRecord::Base
-    has_many :comments
-    belongs_to :author
-  end
-  class PostSerializer < ActiveModel::Serializer
-    attributes :id, :title, :body
-
-    has_many :comments
-    belongs_to :author
-  end
-
-  class Comment < ActiveRecord::Base
-    belongs_to :post
-    belongs_to :author
-  end
-  class CommentSerializer < ActiveModel::Serializer
-    attributes :id, :contents
-
-    belongs_to :author
-  end
-
-  class Author < ActiveRecord::Base
-    has_many :posts
-  end
-  class AuthorSerializer < ActiveModel::Serializer
-    attributes :id, :name
-
-    has_many :posts
-  end
-end
-
-class Employee < ActiveRecord::Base
-  has_many :pictures, as: :imageable
-  has_many :object_tags, as: :taggable
-end
-
-class PolymorphicSimpleSerializer < ActiveModel::Serializer
-  attributes :id
-end
-
-class ObjectTag < ActiveRecord::Base
-  belongs_to :poly_tag
-  belongs_to :taggable, polymorphic: true
-end
-class PolymorphicObjectTagSerializer < ActiveModel::Serializer
-  attributes :id
-  belongs_to :taggable, serializer: PolymorphicSimpleSerializer, polymorphic: true
-end
-
-class PolyTag < ActiveRecord::Base
-  has_many :object_tags
-end
-class PolymorphicTagSerializer < ActiveModel::Serializer
-  attributes :id, :phrase
-  has_many :object_tags, serializer: PolymorphicObjectTagSerializer
-end
-
-class Picture < ActiveRecord::Base
-  belongs_to :imageable, polymorphic: true
-  has_many :object_tags, as: :taggable
-end
-class PolymorphicHasManySerializer < ActiveModel::Serializer
-  attributes :id, :name
-end
-class PolymorphicBelongsToSerializer < ActiveModel::Serializer
-  attributes :id, :title
-  belongs_to :imageable, serializer: PolymorphicHasManySerializer, polymorphic: true
-end

data/test/fixtures/poro.rb

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-
-class Model < ActiveModelSerializers::Model
-  rand(2).zero? && derive_attributes_from_names_and_fix_accessors
-
-  attr_writer :id
-
-  # At this time, just for organization of intent
-  class_attribute :association_names
-  self.association_names = []
-
-  def self.associations(*names)
-    self.association_names |= names.map(&:to_sym)
-    # Silence redefinition of methods warnings
-    ActiveModelSerializers.silence_warnings do
-      attr_accessor(*names)
-    end
-  end
-
-  def associations
-    association_names.each_with_object({}) do |association_name, result|
-      result[association_name] = public_send(association_name).freeze
-    end.with_indifferent_access.freeze
-  end
-
-  def attributes
-    super.except(*association_names)
-  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 < Model
-  attributes :name
-end
-
-class Profile < Model
-  attributes :name, :description
-  associations :comments
-end
-class ProfileSerializer < ActiveModel::Serializer
-  attributes :name, :description
-end
-class ProfilePreviewSerializer < ActiveModel::Serializer
-  attributes :name
-end
-
-class Author < Model
-  attributes :name
-  associations :posts, :bio, :roles, :comments
-end
-class AuthorSerializer < ActiveModel::Serializer
-  cache key: 'writer', skip_digest: true
-  attribute :id
-  attribute :name
-
-  has_many :posts
-  has_many :roles
-  has_one :bio
-end
-class AuthorPreviewSerializer < ActiveModel::Serializer
-  attributes :id
-  has_many :posts
-end
-
-class Comment < Model
-  attributes :body, :date
-  associations :post, :author, :likes
-end
-class CommentSerializer < ActiveModel::Serializer
-  cache expires_in: 1.day, skip_digest: true
-  attributes :id, :body
-  belongs_to :post
-  belongs_to :author
-end
-class CommentPreviewSerializer < ActiveModel::Serializer
-  attributes :id
-
-  belongs_to :post
-end
-
-class Post < Model
-  attributes :title, :body
-  associations :author, :comments, :blog, :tags, :related
-end
-class PostSerializer < ActiveModel::Serializer
-  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
-end
-class SpammyPostSerializer < ActiveModel::Serializer
-  attributes :id
-  has_many :related
-end
-class PostPreviewSerializer < ActiveModel::Serializer
-  attributes :title, :body, :id
-
-  has_many :comments, serializer: ::CommentPreviewSerializer
-  belongs_to :author, serializer: ::AuthorPreviewSerializer
-end
-class PostWithCustomKeysSerializer < ActiveModel::Serializer
-  attributes :id
-  has_many :comments, key: :reviews
-  belongs_to :author, key: :writer
-  has_one :blog, key: :site
-end
-
-class Bio < Model
-  attributes :content, :rating
-  associations :author
-end
-class BioSerializer < ActiveModel::Serializer
-  cache except: [:content], skip_digest: true
-  attributes :id, :content, :rating
-
-  belongs_to :author
-end
-
-class Blog < Model
-  attributes :name, :type, :special_attribute
-  associations :writer, :articles
-end
-class BlogSerializer < ActiveModel::Serializer
-  cache key: 'blog'
-  attributes :id, :name
-
-  belongs_to :writer
-  has_many :articles
-end
-class AlternateBlogSerializer < ActiveModel::Serializer
-  attribute :id
-  attribute :name, key: :title
-end
-class CustomBlogSerializer < ActiveModel::Serializer
-  attribute :id
-  attribute :special_attribute
-  has_many :articles
-end
-
-class Role < Model
-  attributes :name, :description, :special_attribute
-  associations :author
-end
-class RoleSerializer < ActiveModel::Serializer
-  cache only: [:name, :slug], skip_digest: true
-  attributes :id, :name, :description
-  attribute :friendly_id, key: :slug
-  belongs_to :author
-
-  def friendly_id
-    "#{object.name}-#{object.id}"
-  end
-end
-
-class Location < Model
-  attributes :lat, :lng
-  associations :place
-end
-class LocationSerializer < ActiveModel::Serializer
-  cache only: [:address], skip_digest: true
-  attributes :id, :lat, :lng
-
-  belongs_to :place, key: :address
-
-  def place
-    'Nowhere'
-  end
-end
-
-class Place < Model
-  attributes :name
-  associations :locations
-end
-class PlaceSerializer < ActiveModel::Serializer
-  attributes :id, :name
-  has_many :locations
-end
-
-class Like < Model
-  attributes :time
-  associations :likeable
-end
-class LikeSerializer < ActiveModel::Serializer
-  attributes :id, :time
-  belongs_to :likeable
-end
-
-module Spam
-  class UnrelatedLink < Model
-  end
-  class UnrelatedLinkSerializer < ActiveModel::Serializer
-    cache only: [:id]
-    attributes :id
-  end
-end
-
-class VirtualValue < Model; end
-class VirtualValueSerializer < ActiveModel::Serializer
-  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
-
-class PaginatedSerializer < ActiveModel::Serializer::CollectionSerializer
-  def json_key
-    'paginated'
-  end
-end