active_model_serializers 0.10.0 → 0.10.13

data/test/collection_serializer_test.rb

@@ -1,110 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class CollectionSerializerTest < ActiveSupport::TestCase
-      MessagesSerializer = Class.new(ActiveModel::Serializer) do
-        type 'messages'
-      end
-
-      def setup
-        @comment = Comment.new
-        @post = Post.new
-        @resource = build_named_collection @comment, @post
-        @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 CommentSerializer, serializers.first
-        assert_kind_of Comment, serializers.first.object
-
-        assert_kind_of PostSerializer, serializers.last
-        assert_kind_of Post, 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([@post], { serializer: PostSerializer }).to_a
-
-        refute serializers.first.custom_options.key?(:serializer)
-      end
-
-      def test_root_default
-        @serializer = collection_serializer.new([@comment, @post])
-        assert_nil @serializer.root
-      end
-
-      def test_root
-        expected =  'custom_root'
-        @serializer = collection_serializer.new([@comment, @post], 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_nil serializer.json_key
-      end
-
-      def test_json_key_with_resource_without_name_and_no_serializers
-        serializer = collection_serializer.new([])
-        assert_nil serializer.json_key
-      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,78 +0,0 @@
-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 Comment < ActiveRecord::Base
-    belongs_to :post
-    belongs_to :author
-  end
-
-  class Author < ActiveRecord::Base
-    has_many :posts
-  end
-
-  class PostSerializer < ActiveModel::Serializer
-    attributes :id, :title, :body
-
-    has_many :comments
-    belongs_to :author
-  end
-
-  class CommentSerializer < ActiveModel::Serializer
-    attributes :id, :contents
-
-    belongs_to :author
-  end
-
-  class AuthorSerializer < ActiveModel::Serializer
-    attributes :id, :name
-
-    has_many :posts
-  end
-end

data/test/fixtures/poro.rb

@@ -1,282 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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