active_model_serializers 0.1.0

data/lib/generators/serializer/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Generates a serializer for the given resource with tests.
+
+Example:
+    `rails generate serializer Account name created_at`
+
+    For TestUnit it creates:
+        Serializer:  app/serializers/account_serializer.rb
+        TestUnit:    test/unit/account_serializer_test.rb

data/lib/generators/serializer/serializer_generator.rb

@@ -0,0 +1,41 @@
+module Rails
+  module Generators
+    class SerializerGenerator < NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+      check_class_collision :suffix => "Serializer"
+
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+      class_option :parent, :type => :string, :desc => "The parent class for the generated serializer"
+
+      def create_serializer_file
+        template 'serializer.rb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
+      end
+
+      # hook_for :test_framework
+
+      private
+
+      def attributes_names
+        attributes.select { |attr| !attr.reference? }.map { |a| a.name.to_sym }
+      end
+
+      def association_names
+        attributes.select { |attr| attr.reference? }.map { |a| a.name.to_sym }
+      end
+
+      def parent_class_name
+        if options[:parent]
+          options[:parent]
+        # Only works on 3.2
+        # elsif (n = Rails::Generators.namespace) && n.const_defined?(:ApplicationSerializer)
+        #   "ApplicationSerializer"
+        elsif Object.const_defined?(:ApplicationSerializer)
+          "ApplicationSerializer"
+        else
+          "ActiveModel::Serializer"
+        end
+      end
+    end
+  end
+end

data/lib/generators/serializer/templates/serializer.rb

@@ -0,0 +1,9 @@
+<% module_namespacing do -%>
+class <%= class_name %>Serializer < <%= parent_class_name %>
+<% if attributes.any? -%>  attributes <%= attributes_names.map(&:inspect).join(", ") %>
+<% end -%>
+<% association_names.each do |attribute| -%>
+  has_one :<%= attribute %>
+<% end -%>
+end
+<% end -%>

data/test/generators_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+class Foo < Rails::Application
+end
+
+Rails.application.load_generators
+
+require 'generators/serializer/serializer_generator'
+
+class SerializerGeneratorTest < Rails::Generators::TestCase
+  destination File.expand_path("../tmp", __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_namespace_application_serializer_if_one_exists
+  #   Object.const_set(:SerializerNamespace, Module.new)
+  #   SerializerNamespace.const_set(:ApplicationSerializer, Class.new)
+  #   Rails::Generators.namespace = SerializerNamespace
+  #   run_generator
+  #   assert_file "app/serializers/serializer_namespace/account_serializer.rb",
+  #     /module SerializerNamespace\n  class AccountSerializer < ApplicationSerializer/
+  # ensure
+  #   Object.send :remove_const, :SerializerNamespace
+  #   Rails::Generators.namespace = nil
+  # 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 :name, :description$/, serializer)
+      assert_match(/^  has_one :business$/, serializer)
+    end
+  end
+
+  def test_with_no_attributes_does_not_add_extra_space
+    run_generator ["account"]
+    assert_file "app/serializers/account_serializer.rb", /class AccountSerializer < ActiveModel::Serializer\nend/
+  end
+end

data/test/serialization_test.rb

@@ -0,0 +1,186 @@
+require 'test_helper'
+require 'pathname'
+
+class RenderJsonTest < ActionController::TestCase
+  class JsonRenderable
+    def as_json(options={})
+      hash = { :a => :b, :c => :d, :e => :f }
+      hash.except!(*options[:except]) if options[:except]
+      hash
+    end
+
+    def to_json(options = {})
+      super :except => [:c, :e]
+    end
+  end
+
+  class JsonSerializer
+    def initialize(object, scope, options={})
+      @object, @scope, @options = object, scope, options
+    end
+
+    def as_json(*)
+      hash = { :object => @object.as_json, :scope => @scope.as_json }
+      hash.merge!(:options => true) if @options[:options]
+      hash
+    end
+  end
+
+  class JsonSerializable
+    def initialize(skip=false)
+      @skip = skip
+    end
+
+    def active_model_serializer
+      JsonSerializer unless @skip
+    end
+
+    def as_json(*)
+      { :serializable_object => true }
+    end
+  end
+
+  class TestController < ActionController::Base
+    protect_from_forgery
+
+    serialization_scope :current_user
+    attr_reader :current_user
+
+    def self.controller_path
+      'test'
+    end
+
+    def render_json_nil
+      render :json => nil
+    end
+
+    def render_json_render_to_string
+      render :text => render_to_string(:json => '[]')
+    end
+
+    def render_json_hello_world
+      render :json => ActiveSupport::JSON.encode(:hello => 'world')
+    end
+
+    def render_json_hello_world_with_status
+      render :json => ActiveSupport::JSON.encode(:hello => 'world'), :status => 401
+    end
+
+    def render_json_hello_world_with_callback
+      render :json => ActiveSupport::JSON.encode(:hello => 'world'), :callback => 'alert'
+    end
+
+    def render_json_with_custom_content_type
+      render :json => ActiveSupport::JSON.encode(:hello => 'world'), :content_type => 'text/javascript'
+    end
+
+    def render_symbol_json
+      render :json => ActiveSupport::JSON.encode(:hello => 'world')
+    end
+
+    def render_json_with_extra_options
+      render :json => JsonRenderable.new, :except => [:c, :e]
+    end
+
+    def render_json_without_options
+      render :json => JsonRenderable.new
+    end
+
+    def render_json_with_serializer
+      @current_user = Struct.new(:as_json).new(:current_user => true)
+      render :json => JsonSerializable.new
+    end
+
+    def render_json_with_serializer_and_options
+      @current_user = Struct.new(:as_json).new(:current_user => true)
+      render :json => JsonSerializable.new, :options => true
+    end
+
+    def render_json_with_serializer_api_but_without_serializer
+      @current_user = Struct.new(:as_json).new(:current_user => true)
+      render :json => JsonSerializable.new(true)
+    end
+  end
+
+  tests TestController
+
+  def setup
+    # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
+    # a more accurate simulation of what happens in "real life".
+    super
+    @controller.logger = Logger.new(nil)
+
+    @request.host = "www.nextangle.com"
+  end
+
+  def test_render_json_nil
+    get :render_json_nil
+    assert_equal 'null', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
+  def test_render_json_render_to_string
+    get :render_json_render_to_string
+    assert_equal '[]', @response.body
+  end
+
+
+  def test_render_json
+    get :render_json_hello_world
+    assert_equal '{"hello":"world"}', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
+  def test_render_json_with_status
+    get :render_json_hello_world_with_status
+    assert_equal '{"hello":"world"}', @response.body
+    assert_equal 401, @response.status
+  end
+
+  def test_render_json_with_callback
+    get :render_json_hello_world_with_callback
+    assert_equal 'alert({"hello":"world"})', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
+  def test_render_json_with_custom_content_type
+    get :render_json_with_custom_content_type
+    assert_equal '{"hello":"world"}', @response.body
+    assert_equal 'text/javascript', @response.content_type
+  end
+
+  def test_render_symbol_json
+    get :render_symbol_json
+    assert_equal '{"hello":"world"}', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
+  def test_render_json_forwards_extra_options
+    get :render_json_with_extra_options
+    assert_equal '{"a":"b"}', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
+  def test_render_json_calls_to_json_from_object
+    get :render_json_without_options
+    assert_equal '{"a":"b"}', @response.body
+  end
+
+  def test_render_json_with_serializer
+    get :render_json_with_serializer
+    assert_match '"scope":{"current_user":true}', @response.body
+    assert_match '"object":{"serializable_object":true}', @response.body
+  end
+
+  def test_render_json_with_serializer_and_options
+    get :render_json_with_serializer_and_options
+    assert_match '"scope":{"current_user":true}', @response.body
+    assert_match '"object":{"serializable_object":true}', @response.body
+    assert_match '"options":true', @response.body
+  end
+
+  def test_render_json_with_serializer_api_but_without_serializer
+    get :render_json_with_serializer_api_but_without_serializer
+    assert_match '{"serializable_object":true}', @response.body
+  end
+end

data/test/serializer_support_test.rb

@@ -0,0 +1,11 @@
+require "test_helper"
+
+class RandomModel
+  include ActiveModel::SerializerSupport
+end
+
+class SerializerSupportTest < ActiveModel::TestCase
+  test "it returns nil if no serializer exists" do
+    assert_equal nil, RandomModel.new.active_model_serializer
+  end
+end

data/test/serializer_test.rb

@@ -0,0 +1,787 @@
+require "test_helper"
+
+class SerializerTest < ActiveModel::TestCase
+  class Model
+    def initialize(hash={})
+      @attributes = hash
+    end
+
+    def read_attribute_for_serialization(name)
+      @attributes[name]
+    end
+
+    def as_json(*)
+      { :model => "Model" }
+    end
+  end
+
+  class User
+    include ActiveModel::SerializerSupport
+
+    attr_accessor :superuser
+
+    def initialize(hash={})
+      @attributes = hash.merge(:first_name => "Jose", :last_name => "Valim", :password => "oh noes yugive my password")
+    end
+
+    def read_attribute_for_serialization(name)
+      @attributes[name]
+    end
+
+    def super_user?
+      @superuser
+    end
+  end
+
+  class Post < Model
+    def initialize(attributes)
+      super(attributes)
+      self.comments ||= []
+    end
+
+    attr_accessor :comments
+    def active_model_serializer; PostSerializer; end
+  end
+
+  class Comment < Model
+    def active_model_serializer; CommentSerializer; end
+  end
+
+  class UserSerializer < ActiveModel::Serializer
+    attributes :first_name, :last_name
+
+    def serializable_hash
+      attributes.merge(:ok => true).merge(scope)
+    end
+  end
+
+  class DefaultUserSerializer < ActiveModel::Serializer
+    attributes :first_name, :last_name
+  end
+
+  class MyUserSerializer < ActiveModel::Serializer
+    attributes :first_name, :last_name
+
+    def serializable_hash
+      hash = attributes
+      hash = hash.merge(:super_user => true) if my_user.super_user?
+      hash
+    end
+  end
+
+  class CommentSerializer
+    def initialize(comment, scope, options={})
+      @comment, @scope = comment, scope
+    end
+
+    def serializable_hash
+      { :title => @comment.read_attribute_for_serialization(:title) }
+    end
+
+    def as_json(options=nil)
+      options ||= {}
+      if options[:root] == false
+        serializable_hash
+      else
+        { :comment => serializable_hash }
+      end
+    end
+  end
+
+  class PostSerializer < ActiveModel::Serializer
+    attributes :title, :body
+    has_many :comments, :serializer => CommentSerializer
+  end
+
+  def test_attributes
+    user = User.new
+    user_serializer = DefaultUserSerializer.new(user, {})
+
+    hash = user_serializer.as_json
+
+    assert_equal({
+      :default_user => { :first_name => "Jose", :last_name => "Valim" }
+    }, hash)
+  end
+
+  def test_attributes_method
+    user = User.new
+    user_serializer = UserSerializer.new(user, {})
+
+    hash = user_serializer.as_json
+
+    assert_equal({
+      :user => { :first_name => "Jose", :last_name => "Valim", :ok => true }
+    }, hash)
+  end
+
+  def test_serializer_receives_scope
+    user = User.new
+    user_serializer = UserSerializer.new(user, {:scope => true})
+
+    hash = user_serializer.as_json
+
+    assert_equal({
+      :user => {
+        :first_name => "Jose",
+        :last_name => "Valim",
+        :ok => true,
+        :scope => true
+      }
+    }, hash)
+  end
+
+  def test_pretty_accessors
+    user = User.new
+    user.superuser = true
+    user_serializer = MyUserSerializer.new(user, nil)
+
+    hash = user_serializer.as_json
+
+    assert_equal({
+      :my_user => {
+        :first_name => "Jose", :last_name => "Valim", :super_user => true
+      }
+    }, hash)
+  end
+
+  def test_has_many
+    user = User.new
+
+    post = Post.new(:title => "New Post", :body => "Body of new post", :email => "tenderlove@tenderlove.com")
+    comments = [Comment.new(:title => "Comment1"), Comment.new(:title => "Comment2")]
+    post.comments = comments
+
+    post_serializer = PostSerializer.new(post, user)
+
+    assert_equal({
+      :post => {
+        :title => "New Post",
+        :body => "Body of new post",
+        :comments => [
+          { :title => "Comment1" },
+          { :title => "Comment2" }
+        ]
+      }
+    }, post_serializer.as_json)
+  end
+
+  class Blog < Model
+    attr_accessor :author
+  end
+
+  class AuthorSerializer < ActiveModel::Serializer
+    attributes :first_name, :last_name
+  end
+
+  class BlogSerializer < ActiveModel::Serializer
+    has_one :author, :serializer => AuthorSerializer
+  end
+
+  def test_has_one
+    user = User.new
+    blog = Blog.new
+    blog.author = user
+
+    json = BlogSerializer.new(blog, user).as_json
+    assert_equal({
+      :blog => {
+        :author => {
+          :first_name => "Jose",
+          :last_name => "Valim"
+        }
+      }
+    }, json)
+  end
+
+  def test_overridden_associations
+    author_serializer = Class.new(ActiveModel::Serializer) do
+      attributes :first_name
+    end
+
+    blog_serializer = Class.new(ActiveModel::Serializer) do
+      def person
+        object.author
+      end
+
+      has_one :person, :serializer => author_serializer
+    end
+
+    user = User.new
+    blog = Blog.new
+    blog.author = user
+
+    json = blog_serializer.new(blog, user).as_json
+    assert_equal({
+      :person => {
+        :first_name => "Jose"
+      }
+    }, json)
+  end
+
+  def post_serializer(type)
+    Class.new(ActiveModel::Serializer) do
+      attributes :title, :body
+      has_many :comments, :serializer => CommentSerializer
+
+      if type != :super
+        define_method :serializable_hash do
+          post_hash = attributes
+          post_hash.merge!(send(type))
+          post_hash
+        end
+      end
+    end
+  end
+
+  def test_associations
+    post = Post.new(:title => "New Post", :body => "Body of new post", :email => "tenderlove@tenderlove.com")
+    comments = [Comment.new(:title => "Comment1"), Comment.new(:title => "Comment2")]
+    post.comments = comments
+
+    serializer = post_serializer(:associations).new(post, nil)
+
+    assert_equal({
+      :title => "New Post",
+      :body => "Body of new post",
+      :comments => [
+        { :title => "Comment1" },
+        { :title => "Comment2" }
+      ]
+    }, serializer.as_json)
+  end
+
+  def test_association_ids
+    serializer = post_serializer(:association_ids)
+
+    serializer.class_eval do
+      def as_json(*)
+        { :post => serializable_hash }.merge(associations)
+      end
+    end
+
+    post = Post.new(:title => "New Post", :body => "Body of new post", :email => "tenderlove@tenderlove.com")
+    comments = [Comment.new(:title => "Comment1", :id => 1), Comment.new(:title => "Comment2", :id => 2)]
+    post.comments = comments
+
+    serializer = serializer.new(post, nil)
+
+    assert_equal({
+      :post => {
+        :title => "New Post",
+        :body => "Body of new post",
+        :comments => [1, 2]
+      },
+      :comments => [
+        { :title => "Comment1" },
+        { :title => "Comment2" }
+      ]
+    }, serializer.as_json)
+  end
+
+  def test_associations_with_nil_association
+    user = User.new
+    blog = Blog.new
+
+    json = BlogSerializer.new(blog, user).as_json
+    assert_equal({
+      :blog => { :author => nil }
+    }, json)
+
+    serializer = Class.new(BlogSerializer) do
+      root :blog
+
+      def serializable_hash
+        attributes.merge(association_ids)
+      end
+    end
+
+    json = serializer.new(blog, user).as_json
+    assert_equal({ :blog =>  { :author => nil } }, json)
+  end
+
+  def test_custom_root
+    user = User.new
+    blog = Blog.new
+
+    serializer = Class.new(BlogSerializer) do
+      root :my_blog
+    end
+
+    assert_equal({ :my_blog => { :author => nil } }, serializer.new(blog, user).as_json)
+  end
+
+  def test_false_root
+    user = User.new
+    blog = Blog.new
+
+    serializer = Class.new(BlogSerializer) do
+      root false
+    end
+
+    assert_equal({ :author => nil }, serializer.new(blog, user).as_json)
+
+    # test inherited false root
+    serializer = Class.new(serializer)
+    assert_equal({ :author => nil }, serializer.new(blog, user).as_json)
+  end
+
+  def test_embed_ids
+    serializer = post_serializer(:super)
+
+    serializer.class_eval do
+      root :post
+      embed :ids
+    end
+
+    post = Post.new(:title => "New Post", :body => "Body of new post", :email => "tenderlove@tenderlove.com")
+    comments = [Comment.new(:title => "Comment1", :id => 1), Comment.new(:title => "Comment2", :id => 2)]
+    post.comments = comments
+
+    serializer = serializer.new(post, nil)
+
+    assert_equal({
+      :post => {
+        :title => "New Post",
+        :body => "Body of new post",
+        :comments => [1, 2]
+      }
+    }, serializer.as_json)
+  end
+
+  def test_embed_ids_include_true
+    serializer = post_serializer(:super)
+
+    serializer.class_eval do
+      root :post
+      embed :ids, :include => true
+    end
+
+    post = Post.new(:title => "New Post", :body => "Body of new post", :email => "tenderlove@tenderlove.com")
+    comments = [Comment.new(:title => "Comment1", :id => 1), Comment.new(:title => "Comment2", :id => 2)]
+    post.comments = comments
+
+    serializer = serializer.new(post, nil)
+
+    assert_equal({
+      :post => {
+        :title => "New Post",
+        :body => "Body of new post",
+        :comments => [1, 2]
+      },
+      :comments => [
+        { :title => "Comment1" },
+        { :title => "Comment2" }
+      ]
+    }, serializer.as_json)
+  end
+
+  def test_embed_objects
+    serializer = post_serializer(:super)
+
+    serializer.class_eval do
+      root :post
+      embed :objects
+    end
+
+    post = Post.new(:title => "New Post", :body => "Body of new post", :email => "tenderlove@tenderlove.com")
+    comments = [Comment.new(:title => "Comment1", :id => 1), Comment.new(:title => "Comment2", :id => 2)]
+    post.comments = comments
+
+    serializer = serializer.new(post, nil)
+
+    assert_equal({
+      :post => {
+        :title => "New Post",
+        :body => "Body of new post",
+        :comments => [
+          { :title => "Comment1" },
+          { :title => "Comment2" }
+        ]
+      }
+    }, serializer.as_json)
+  end
+
+  def test_array_serializer
+    model    = Model.new
+    user     = User.new
+    comments = Comment.new(:title => "Comment1", :id => 1)
+
+    array = [model, user, comments]
+    serializer = array.active_model_serializer.new(array, {:scope => true})
+    assert_equal([
+      { :model => "Model" },
+      { :user => { :last_name=>"Valim", :ok=>true, :first_name=>"Jose", :scope => true } },
+      { :comment => { :title => "Comment1" } }
+    ], serializer.as_json)
+  end
+
+  class CustomBlog < Blog
+    attr_accessor :public_posts, :public_user
+  end
+
+  class CustomBlogSerializer < ActiveModel::Serializer
+    has_many :public_posts, :key => :posts, :serializer => PostSerializer
+    has_one :public_user, :key => :user, :serializer => UserSerializer
+  end
+
+  def test_associations_with_as
+    posts = [
+      Post.new(:title => 'First Post', :body => 'text'), 
+      Post.new(:title => 'Second Post', :body => 'text')
+    ]
+    user = User.new
+
+    custom_blog = CustomBlog.new
+    custom_blog.public_posts = posts
+    custom_blog.public_user = user
+
+    serializer = CustomBlogSerializer.new(custom_blog, :scope => true)
+
+    assert_equal({
+      :custom_blog => {
+        :posts => [
+          {:title => 'First Post', :body => 'text', :comments => []},
+          {:title => 'Second Post', :body => 'text', :comments => []}
+        ],
+        :user => {
+          :first_name => "Jose", 
+          :last_name => "Valim", :ok => true, 
+          :scope => true
+        }
+      }
+    }, serializer.as_json)
+  end
+
+  def test_implicity_detection_for_association_serializers 
+    implicit_serializer = Class.new(ActiveModel::Serializer) do
+      root :custom_blog
+      const_set(:UserSerializer, UserSerializer)
+      const_set(:PostSerializer, PostSerializer)
+
+      has_many :public_posts, :key => :posts
+      has_one :public_user, :key => :user
+    end
+
+    posts = [
+      Post.new(:title => 'First Post', :body => 'text', :comments => []), 
+      Post.new(:title => 'Second Post', :body => 'text', :comments => [])
+    ]
+    user = User.new
+
+    custom_blog = CustomBlog.new
+    custom_blog.public_posts = posts
+    custom_blog.public_user = user
+
+    serializer = implicit_serializer.new(custom_blog, :scope => true)
+
+    assert_equal({
+      :custom_blog => {
+        :posts => [
+          {:title => 'First Post', :body => 'text', :comments => []},
+          {:title => 'Second Post', :body => 'text', :comments => []}
+        ],
+        :user => {
+          :first_name => "Jose", 
+          :last_name => "Valim", :ok => true, 
+          :scope => true
+        }
+      }
+    }, serializer.as_json)
+  end
+
+  def test_attribute_key
+    serializer_class = Class.new(ActiveModel::Serializer) do
+      root :user
+
+      attribute :first_name, :key => :firstName
+      attribute :last_name, :key => :lastName
+      attribute :password
+    end
+
+    serializer = serializer_class.new(User.new, nil)
+
+    assert_equal({
+      :user => {
+        :firstName => "Jose",
+        :lastName => "Valim",
+        :password => "oh noes yugive my password"
+      }
+    }, serializer.as_json)
+  end
+
+  def setup_model
+    Class.new do
+      class << self
+        def columns_hash
+          { "name" => Struct.new(:type).new(:string), "age" => Struct.new(:type).new(:integer) }
+        end
+
+        def reflect_on_association(name)
+          case name
+          when :posts
+            Struct.new(:macro, :name).new(:has_many, :posts)
+          when :parent
+            Struct.new(:macro, :name).new(:belongs_to, :parent)
+          end
+        end
+      end
+    end
+  end
+
+  def test_schema
+    model = setup_model
+
+    serializer = Class.new(ActiveModel::Serializer) do
+      class << self; self; end.class_eval do
+        define_method(:model_class) do model end
+      end
+
+      attributes :name, :age
+      has_many :posts, :serializer => Class.new
+      has_one :parent, :serializer => Class.new
+    end
+
+    assert_equal serializer.schema, {
+      :attributes => { :name => :string, :age => :integer },
+      :associations => {
+        :posts => { :has_many => :posts },
+        :parent => { :belongs_to => :parent }
+      }
+    }
+  end
+
+  def test_schema_with_as
+    model = setup_model
+
+    serializer = Class.new(ActiveModel::Serializer) do
+      class << self; self; end.class_eval do
+        define_method(:model_class) do model end
+      end
+
+      attributes :name, :age
+      has_many :posts, :key => :my_posts, :serializer => Class.new
+      has_one :parent, :key => :my_parent, :serializer => Class.new
+    end
+
+    assert_equal serializer.schema, {
+      :attributes => { :name => :string, :age => :integer },
+      :associations => {
+        :my_posts => { :has_many => :posts },
+        :my_parent => { :belongs_to => :parent }
+      }
+    }
+  end
+
+  def test_embed_id_for_has_one
+    author_serializer = Class.new(ActiveModel::Serializer)
+
+    serializer_class = Class.new(ActiveModel::Serializer) do
+      embed :ids
+      root :post
+
+      attributes :title, :body
+      has_one :author, :serializer => author_serializer
+    end
+
+    post_class = Class.new(Model) do
+      attr_accessor :author
+    end
+
+    author_class = Class.new(Model)
+
+    post = post_class.new(:title => "New Post", :body => "It's a new post!")
+    author = author_class.new(:id => 5)
+    post.author = author
+
+    hash = serializer_class.new(post, nil)
+
+    assert_equal({
+      :post => {
+        :title => "New Post",
+        :body => "It's a new post!",
+        :author => 5
+      }
+    }, hash.as_json)
+  end
+
+  def test_embed_objects_for_has_one
+    author_serializer = Class.new(ActiveModel::Serializer) do
+      attributes :id, :name
+    end
+
+    serializer_class = Class.new(ActiveModel::Serializer) do
+      root :post
+
+      attributes :title, :body
+      has_one :author, :serializer => author_serializer
+    end
+
+    post_class = Class.new(Model) do
+      attr_accessor :author
+    end
+
+    author_class = Class.new(Model)
+
+    post = post_class.new(:title => "New Post", :body => "It's a new post!")
+    author = author_class.new(:id => 5, :name => "Tom Dale")
+    post.author = author
+
+    hash = serializer_class.new(post, nil)
+
+    assert_equal({
+      :post => {
+        :title => "New Post",
+        :body => "It's a new post!",
+        :author => { :id => 5, :name => "Tom Dale" }
+      }
+    }, hash.as_json)
+  end
+
+  def test_root_provided_in_options
+    author_serializer = Class.new(ActiveModel::Serializer) do
+      attributes :id, :name
+    end
+
+    serializer_class = Class.new(ActiveModel::Serializer) do
+      root :post
+
+      attributes :title, :body
+      has_one :author, :serializer => author_serializer
+    end
+
+    post_class = Class.new(Model) do
+      attr_accessor :author
+    end
+
+    author_class = Class.new(Model)
+
+    post = post_class.new(:title => "New Post", :body => "It's a new post!")
+    author = author_class.new(:id => 5, :name => "Tom Dale")
+    post.author = author
+
+    assert_equal({
+      :blog_post => {
+        :title => "New Post",
+        :body => "It's a new post!",
+        :author => { :id => 5, :name => "Tom Dale" }
+      }
+    }, serializer_class.new(post, nil, :root => :blog_post).as_json)
+
+    assert_equal({
+      :title => "New Post",
+      :body => "It's a new post!",
+      :author => { :id => 5, :name => "Tom Dale" }
+    }, serializer_class.new(post, nil, :root => false).as_json)
+
+    assert_equal({
+      :blog_post => {
+        :title => "New Post",
+        :body => "It's a new post!",
+        :author => { :id => 5, :name => "Tom Dale" }
+      }
+    }, serializer_class.new(post, nil).as_json(:root => :blog_post))
+
+    assert_equal({
+      :title => "New Post",
+      :body => "It's a new post!",
+      :author => { :id => 5, :name => "Tom Dale" }
+    }, serializer_class.new(post, nil).as_json(:root => false))
+  end
+
+  def test_serializer_has_access_to_root_object
+    hash_object = nil
+
+    author_serializer = Class.new(ActiveModel::Serializer) do
+      attributes :id, :name
+
+      define_method :serializable_hash do
+        hash_object = @hash
+        super()
+      end
+    end
+
+    serializer_class = Class.new(ActiveModel::Serializer) do
+      root :post
+
+      attributes :title, :body
+      has_one :author, :serializer => author_serializer
+    end
+
+    post_class = Class.new(Model) do
+      attr_accessor :author
+    end
+
+    author_class = Class.new(Model)
+
+    post = post_class.new(:title => "New Post", :body => "It's a new post!")
+    author = author_class.new(:id => 5, :name => "Tom Dale")
+    post.author = author
+
+    expected = serializer_class.new(post, nil).as_json
+    assert_equal expected, hash_object
+  end
+
+  # the point of this test is to illustrate that deeply nested serializers
+  # still side-load at the root.
+  def test_embed_with_include_inserts_at_root
+    tag_serializer = Class.new(ActiveModel::Serializer) do
+      attributes :id, :name
+    end
+
+    comment_serializer = Class.new(ActiveModel::Serializer) do
+      embed :ids, :include => true
+      attributes :id, :body
+      has_many :tags, :serializer => tag_serializer
+    end
+
+    post_serializer = Class.new(ActiveModel::Serializer) do
+      embed :ids, :include => true
+      attributes :id, :title, :body
+      has_many :comments, :serializer => comment_serializer
+    end
+
+    post_class = Class.new(Model) do
+      attr_accessor :comments
+
+      define_method :active_model_serializer do
+        post_serializer
+      end
+    end
+
+    comment_class = Class.new(Model) do
+      attr_accessor :tags
+    end
+
+    tag_class = Class.new(Model)
+
+    post = post_class.new(:title => "New Post", :body => "NEW POST", :id => 1)
+    comment1 = comment_class.new(:body => "EWOT", :id => 1)
+    comment2 = comment_class.new(:body => "YARLY", :id => 2)
+    tag1 = tag_class.new(:name => "lolcat", :id => 1)
+    tag2 = tag_class.new(:name => "nyancat", :id => 2)
+    tag3 = tag_class.new(:name => "violetcat", :id => 3)
+
+    post.comments = [comment1, comment2]
+    comment1.tags = [tag1, tag3]
+    comment2.tags = [tag1, tag2]
+
+    actual = ActiveModel::ArraySerializer.new([post], nil, :root => :posts).as_json
+    assert_equal({
+      :posts => [
+        { :title => "New Post", :body => "NEW POST", :id => 1, :comments => [1,2] }
+      ],
+
+      :comments => [
+        { :body => "EWOT", :id => 1, :tags => [1,3] },
+        { :body => "YARLY", :id => 2, :tags => [1,2] }
+      ],
+
+      :tags => [
+        { :name => "lolcat", :id => 1 },
+        { :name => "violetcat", :id => 3 },
+        { :name => "nyancat", :id => 2 }
+      ]
+    }, actual)
+  end
+end