active_model_serializers 0.6.0 → 0.7.0

data/test/generators_test.rb

@@ -1,6 +1,10 @@
 require 'test_helper'
 
 class Foo < Rails::Application
+  if Rails.version.start_with? '4'
+    config.eager_load = false
+    config.secret_key_base = 'abc123'
+  end
 end
 
 Rails.application.load_generators

data/test/serialization_test.rb

@@ -54,6 +54,19 @@ class RenderJsonTest < ActionController::TestCase
     end
   end
 
+  class AnotherCustomSerializer
+    def initialize(*)
+    end
+
+    def as_json(*)
+      { :rails => 'rocks' }
+    end
+  end
+
+  class DummyCustomSerializer < ActiveModel::Serializer
+    attributes :id
+  end
+
   class HypermediaSerializable
     def active_model_serializer
       HypermediaSerializer
@@ -108,6 +121,11 @@ class RenderJsonTest < ActionController::TestCase
       render :json => ActiveSupport::JSON.encode(:hello => 'world')
     end
 
+    def render_json_nil_with_custom_serializer
+      render :json => nil, :serializer => DummyCustomSerializer
+    end
+
+
     def render_json_with_extra_options
       render :json => JsonRenderable.new, :except => [:c, :e]
     end
@@ -152,6 +170,10 @@ class RenderJsonTest < ActionController::TestCase
       render :json => [Object.new], :each_serializer => CustomSerializer
     end
 
+    def render_json_array_with_wrong_option
+      render :json => [Object.new], :serializer => CustomSerializer
+    end
+
     def render_json_with_links
       render :json => HypermediaSerializable.new
     end
@@ -171,9 +193,13 @@ class RenderJsonTest < ActionController::TestCase
 
   private
     def default_serializer_options
-      if params[:check_defaults]
-        { :check_defaults => true }
-      end
+      defaults = {}
+      defaults.merge!(:check_defaults => true) if params[:check_defaults]
+      defaults.merge!(:root => :awesome) if params[:check_default_root]
+      defaults.merge!(:scope => :current_admin) if params[:check_default_scope]
+      defaults.merge!(:serializer => AnotherCustomSerializer) if params[:check_default_serializer]
+      defaults.merge!(:each_serializer => AnotherCustomSerializer) if params[:check_default_each_serializer]
+      defaults
     end
   end
 
@@ -199,6 +225,11 @@ class RenderJsonTest < ActionController::TestCase
     assert_equal '[]', @response.body
   end
 
+  def test_render_json_nil_with_custom_serializer
+    get :render_json_nil_with_custom_serializer
+    assert_equal "{\"dummy_custom\":null}", @response.body
+  end
+
   def test_render_json
     get :render_json_hello_world
     assert_equal '{"hello":"world"}', @response.body
@@ -254,11 +285,26 @@ class RenderJsonTest < ActionController::TestCase
     assert_match '"check_defaults":true', @response.body
   end
 
+  def test_render_json_with_serializer_checking_default_serailizer
+    get :render_json_with_serializer, :check_default_serializer => true
+    assert_match '{"rails":"rocks"}', @response.body
+  end
+
+  def test_render_json_with_serializer_checking_default_scope
+    get :render_json_with_serializer, :check_default_scope => true
+    assert_match '"scope":"current_admin"', @response.body
+  end
+
   def test_render_json_with_serializer_and_implicit_root
     get :render_json_with_serializer_and_implicit_root
     assert_match '"test":[{"serializable_object":true}]', @response.body
   end
 
+  def test_render_json_with_serializer_and_implicit_root_checking_default_each_serailizer
+    get :render_json_with_serializer_and_implicit_root, :check_default_each_serializer => true
+    assert_match '"test":[{"rails":"rocks"}]', @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
@@ -271,6 +317,11 @@ class RenderJsonTest < ActionController::TestCase
     assert_match '"scope":{"current_user":false}', @response.body
   end
 
+  def test_render_json_with_serializer_and_scope_option_checking_default_scope
+    get :render_json_with_serializer_and_scope_option, :check_default_scope => true
+    assert_match '"scope":{"current_user":false}', @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
@@ -281,11 +332,27 @@ class RenderJsonTest < ActionController::TestCase
     assert_match '{"hello":true}', @response.body
   end
 
+  def test_render_json_with_custom_serializer_checking_default_serailizer
+    get :render_json_with_custom_serializer, :check_default_serializer => true
+    assert_match '{"hello":true}', @response.body
+  end
+
   def test_render_json_array_with_custom_serializer
     get :render_json_array_with_custom_serializer
     assert_match '{"test":[{"hello":true}]}', @response.body
   end
 
+  def test_render_json_array_with_wrong_option
+    assert_raise ArgumentError do
+      get :render_json_array_with_wrong_option
+    end
+  end
+
+  def test_render_json_array_with_custom_serializer_checking_default_each_serailizer
+    get :render_json_array_with_custom_serializer, :check_default_each_serializer => true
+    assert_match '{"test":[{"hello":true}]}', @response.body
+  end
+
   def test_render_json_with_links
     get :render_json_with_links
     assert_match '{"link":"http://www.nextangle.com/hypermedia"}', @response.body
@@ -296,11 +363,21 @@ class RenderJsonTest < ActionController::TestCase
     assert_equal '[]', @response.body
   end
 
+  def test_render_json_array_with_no_root_checking_default_root
+    get :render_json_array_with_no_root, :check_default_root => true
+    assert_equal '[]', @response.body
+  end
+
   def test_render_json_empty_array
     get :render_json_empty_array
     assert_equal '{"test":[]}', @response.body
   end
 
+  def test_render_json_empty_array_checking_default_root
+    get :render_json_empty_array, :check_default_root => true
+    assert_equal '{"awesome":[]}', @response.body
+  end
+
   def test_render_json_empty_arry_with_array_serializer_root_false
     ActiveModel::ArraySerializer.root = false
     get :render_json_empty_array

data/test/serializer_support_test.rb

@@ -4,6 +4,13 @@ class RandomModel
   include ActiveModel::SerializerSupport
 end
 
+class OtherRandomModel
+  include ActiveModel::SerializerSupport
+end
+
+class OtherRandomModelSerializer
+end
+
 class RandomModelCollection
   include ActiveModel::ArraySerializerSupport
 end
@@ -18,6 +25,10 @@ class SerializerSupportTest < ActiveModel::TestCase
     assert_equal nil, RandomModel.new.active_model_serializer
   end
 
+  test "it returns a deducted serializer if it exists exists" do
+    assert_equal OtherRandomModelSerializer, OtherRandomModel.new.active_model_serializer
+  end
+
   test "it returns ArraySerializer for a collection" do
     assert_equal ActiveModel::ArraySerializer, RandomModelCollection.new.active_model_serializer
   end

data/test/serializer_test.rb

@@ -1,119 +1,64 @@
 require "test_helper"
+require "test_fakes"
 
 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 ||= []
-      self.comments_disabled = false
-      self.author = nil
-    end
-
-    attr_accessor :comments, :comments_disabled, :author
-    def active_model_serializer; PostSerializer; end
+  def test_scope_works_correct
+    serializer = ActiveModel::Serializer.new :foo, :scope => :bar
+    assert_equal serializer.scope, :bar
   end
 
-  class Comment < Model
-    def active_model_serializer; CommentSerializer; end
-  end
+  def test_attributes
+    user = User.new
+    user_serializer = DefaultUserSerializer.new(user, {})
 
-  class UserSerializer < ActiveModel::Serializer
-    attributes :first_name, :last_name
+    hash = user_serializer.as_json
 
-    def serializable_hash
-      attributes.merge(:ok => true).merge(options[:scope])
-    end
+    assert_equal({
+      :default_user => { :first_name => "Jose", :last_name => "Valim" }
+    }, hash)
   end
 
-  class DefaultUserSerializer < ActiveModel::Serializer
-    attributes :first_name, :last_name
-  end
+  def test_attributes_method
+    user = User.new
+    user_serializer = UserSerializer.new(user, :scope => {})
 
-  class MyUserSerializer < ActiveModel::Serializer
-    attributes :first_name, :last_name
+    hash = user_serializer.as_json
 
-    def serializable_hash
-      hash = attributes
-      hash = hash.merge(:super_user => true) if my_user.super_user?
-      hash
-    end
+    assert_equal({
+      :user => { :first_name => "Jose", :last_name => "Valim", :ok => true }
+    }, hash)
   end
 
-  class CommentSerializer
-    def initialize(comment, options={})
-      @comment = comment
-    end
-
-    def serializable_hash
-      { :title => @comment.read_attribute_for_serialization(:title) }
-    end
+  def test_attributes_method_specifying_keys
+    user = User.new
+    user_serializer = UserAttributesWithKeySerializer.new(user, :scope => {})
 
-    def as_json(options=nil)
-      options ||= {}
-      if options[:root] == false
-        serializable_hash
-      else
-        { :comment => serializable_hash }
-      end
-    end
-  end
+    hash = user_serializer.as_json
 
-  def test_scope_works_correct
-    serializer = ActiveModel::Serializer.new :foo, :scope => :bar
-    assert_equal serializer.scope, :bar
+    assert_equal({
+      :user_attributes_with_key => { :f_name => "Jose", :l_name => "Valim", :ok => true }
+    }, hash)
   end
 
-  def test_attributes
+  def test_attributes_method_specifying_some_keys
     user = User.new
-    user_serializer = DefaultUserSerializer.new(user, {})
+    user_serializer = UserAttributesWithSomeKeySerializer.new(user, :scope => {})
 
     hash = user_serializer.as_json
 
     assert_equal({
-      :default_user => { :first_name => "Jose", :last_name => "Valim" }
+      :user_attributes_with_some_key => { :first_name => "Jose", :l_name => "Valim", :ok => true }
     }, hash)
   end
 
-  def test_attributes_method
-    user = User.new
-    user_serializer = UserSerializer.new(user, :scope => {})
+  def test_attribute_method_with_name_as_serializer_prefix
+    object = SomeObject.new("something")
+    object_serializer = SomeSerializer.new(object, {})
 
-    hash = user_serializer.as_json
+    hash = object_serializer.as_json
 
     assert_equal({
-      :user => { :first_name => "Jose", :last_name => "Valim", :ok => true }
+      :some => { :some => "something" }
     }, hash)
   end
 
@@ -159,11 +104,6 @@ class SerializerTest < ActiveModel::TestCase
     }, hash)
   end
 
-  class PostSerializer < ActiveModel::Serializer
-    attributes :title, :body
-    has_many :comments, :serializer => CommentSerializer
-  end
-
   def test_has_many
     user = User.new
 
@@ -185,16 +125,6 @@ class SerializerTest < ActiveModel::TestCase
     }, post_serializer.as_json)
   end
 
-  class PostWithConditionalCommentsSerializer < ActiveModel::Serializer
-    root :post
-    attributes :title, :body
-    has_many :comments, :serializer => CommentSerializer
-
-    def include_associations!
-      include! :comments unless object.comments_disabled
-    end
-  end
-
   def test_conditionally_included_associations
     user = User.new
 
@@ -227,20 +157,6 @@ class SerializerTest < ActiveModel::TestCase
     }, post_serializer.as_json)
   end
 
-  class PostWithMultipleConditionalsSerializer < ActiveModel::Serializer
-    root :post
-    attributes :title, :body, :author
-    has_many :comments, :serializer => CommentSerializer
-
-    def include_comments?
-      !object.comments_disabled
-    end
-
-    def include_author?
-      scope.super_user?
-    end
-  end
-
   def test_conditionally_included_associations_and_attributes
     user = User.new
 
@@ -283,18 +199,6 @@ class SerializerTest < ActiveModel::TestCase
     }, 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
@@ -372,6 +276,28 @@ class SerializerTest < ActiveModel::TestCase
     assert_equal({ :my_blog => { :author => nil } }, serializer.new(blog, :scope => user).as_json)
   end
 
+  def test_nil_root_object
+    user = User.new
+    blog = nil
+
+    serializer = Class.new(BlogSerializer) do
+      root false
+    end
+
+    assert_equal(nil, serializer.new(blog, :scope => user).as_json)
+  end
+
+  def test_custom_root_with_nil_root_object
+    user = User.new
+    blog = nil
+
+    serializer = Class.new(BlogSerializer) do
+      root :my_blog
+    end
+
+    assert_equal({ :my_blog => nil }, serializer.new(blog, :scope => user).as_json)
+  end
+
   def test_false_root
     user = User.new
     blog = Blog.new
@@ -380,13 +306,35 @@ class SerializerTest < ActiveModel::TestCase
       root false
     end
 
+    another_serializer = Class.new(BlogSerializer) do
+      self.root = false
+    end
+
     assert_equal({ :author => nil }, serializer.new(blog, :scope => user).as_json)
+    assert_equal({ :author => nil }, another_serializer.new(blog, :scope => user).as_json)
 
     # test inherited false root
     serializer = Class.new(serializer)
     assert_equal({ :author => nil }, serializer.new(blog, :scope => user).as_json)
   end
 
+  def test_root_false_on_load_active_model_serializers
+    begin
+      ActiveSupport.on_load(:active_model_serializers) do
+        self.root = false
+      end
+
+      blog = Blog.new
+      serializer = BlogSerializer.new(blog)
+
+      assert_equal({ :author => nil }, serializer.as_json)
+    ensure
+      ActiveSupport.on_load(:active_model_serializers) do
+        self.root = nil
+      end
+    end
+  end
+
   def test_embed_ids
     serializer = post_serializer
 
@@ -405,8 +353,8 @@ class SerializerTest < ActiveModel::TestCase
       :post => {
         :title => "New Post",
         :body => "Body of new post",
-        :comments => [1, 2],
-        :author => nil
+        :comment_ids => [1, 2],
+        :author_id => nil
       }
     }, serializer.as_json)
   end
@@ -429,8 +377,8 @@ class SerializerTest < ActiveModel::TestCase
       :post => {
         :title => "New Post",
         :body => "Body of new post",
-        :comments => [1, 2],
-        :author => nil
+        :comment_ids => [1, 2],
+        :author_id => nil
       },
       :comments => [
         { :title => "Comment1" },
@@ -447,8 +395,8 @@ class SerializerTest < ActiveModel::TestCase
       :post => {
         :title => "New Post",
         :body => "Body of new post",
-        :comments => [1, 2],
-        :author => 1
+        :comment_ids => [1, 2],
+        :author_id => 1
       },
       :comments => [
         { :title => "Comment1" },
@@ -485,60 +433,6 @@ class SerializerTest < ActiveModel::TestCase
     }, serializer.as_json)
   end
 
-  # serialize different typed objects
-  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 => {:scope => true})
-    assert_equal([
-      { :model => "Model" },
-      { :last_name => "Valim", :ok => true, :first_name => "Jose", :scope => true },
-      { :title => "Comment1" }
-    ], serializer.as_json)
-  end
-
-  def test_array_serializer_with_root
-    comment1 = Comment.new(:title => "Comment1", :id => 1)
-    comment2 = Comment.new(:title => "Comment2", :id => 2)
-
-    array = [ comment1, comment2 ]
-
-    serializer = array.active_model_serializer.new(array, :root => :comments)
-
-    assert_equal({ :comments => [
-      { :title => "Comment1" },
-      { :title => "Comment2" }
-    ]}, serializer.as_json)
-  end
-
-  def test_array_serializer_with_hash
-    hash = {:value => "something"}
-    array = [hash]
-    serializer = array.active_model_serializer.new(array, :root => :items)
-    assert_equal({ :items => [ hash.as_json ]}, serializer.as_json)
-  end
-
-  class CustomPostSerializer < ActiveModel::Serializer
-    attributes :title
-  end
-
-  def test_array_serializer_with_specified_seriailizer
-    post1 = Post.new(:title => "Post1", :author => "Author1", :id => 1)
-    post2 = Post.new(:title => "Post2", :author => "Author2", :id => 2)
-
-    array = [ post1, post2 ]
-
-    serializer = array.active_model_serializer.new array, :each_serializer => CustomPostSerializer
-
-    assert_equal([
-      { :title => "Post1" },
-      { :title => "Post2" }
-    ], serializer.as_json)
-  end
-
   def test_sets_can_be_serialized
     post1 = Post.new(:title => "Post1", :author => "Author1", :id => 1)
     post2 = Post.new(:title => "Post2", :author => "Author2", :id => 2)
@@ -555,18 +449,9 @@ class SerializerTest < ActiveModel::TestCase
     assert as_json.include?({ :title => "Post2" })
   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 => 'First Post', :body => 'text'),
       Post.new(:title => 'Second Post', :body => 'text')
     ]
     user = User.new
@@ -584,15 +469,15 @@ class SerializerTest < ActiveModel::TestCase
           {:title => 'Second Post', :body => 'text', :comments => []}
         ],
         :user => {
-          :first_name => "Jose", 
-          :last_name => "Valim", :ok => true, 
+          :first_name => "Jose",
+          :last_name => "Valim", :ok => true,
           :scope => true
         }
       }
     }, serializer.as_json)
   end
 
-  def test_implicity_detection_for_association_serializers 
+  def test_implicity_detection_for_association_serializers
     implicit_serializer = Class.new(ActiveModel::Serializer) do
       root :custom_blog
       const_set(:UserSerializer, UserSerializer)
@@ -603,7 +488,7 @@ class SerializerTest < ActiveModel::TestCase
     end
 
     posts = [
-      Post.new(:title => 'First Post', :body => 'text', :comments => []), 
+      Post.new(:title => 'First Post', :body => 'text', :comments => []),
       Post.new(:title => 'Second Post', :body => 'text', :comments => [])
     ]
     user = User.new
@@ -621,8 +506,8 @@ class SerializerTest < ActiveModel::TestCase
           {:title => 'Second Post', :body => 'text', :comments => []}
         ],
         :user => {
-          :first_name => "Jose", 
-          :last_name => "Valim", :ok => true, 
+          :first_name => "Jose",
+          :last_name => "Valim", :ok => true,
           :scope => true
         }
       }
@@ -676,15 +561,21 @@ class SerializerTest < ActiveModel::TestCase
         define_method(:model_class) do model end
       end
 
-      attributes :name, :age
+      # Computed attributes (not real columns or associations).
+      def can_edit; end
+      def drafts; end
+
+      attributes :name, :age, :can_edit
       has_many :posts, :serializer => Class.new
+      has_many :drafts, :serializer => Class.new
       has_one :parent, :serializer => Class.new
     end
 
     assert_equal serializer.schema, {
-      :attributes => { :name => :string, :age => :integer },
+      :attributes => { :name => :string, :age => :integer, :can_edit => nil },
       :associations => {
         :posts => { :has_many => :posts },
+        :drafts => nil,
         :parent => { :belongs_to => :parent }
       }
     }
@@ -739,7 +630,7 @@ class SerializerTest < ActiveModel::TestCase
       :post => {
         :title => "New Post",
         :body => "It's a new post!",
-        :author => 5
+        :author_id => 5
       }
     }, hash.as_json)
   end
@@ -860,7 +751,7 @@ class SerializerTest < ActiveModel::TestCase
     expected = serializer_class.new(post).as_json
     assert_equal expected, hash_object
   end
-  
+
   def test_embed_ids_include_true_with_root
     serializer_class = post_serializer
 
@@ -909,7 +800,7 @@ class SerializerTest < ActiveModel::TestCase
     :author => [{ :first_name => "Jose", :last_name => "Valim" }]
     }, serializer.as_json)
   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
@@ -957,12 +848,12 @@ class SerializerTest < ActiveModel::TestCase
     actual = ActiveModel::ArraySerializer.new([post], :root => :posts).as_json
     assert_equal({
       :posts => [
-        { :title => "New Post", :body => "NEW POST", :id => 1, :comments => [1,2] }
+        { :title => "New Post", :body => "NEW POST", :id => 1, :comment_ids => [1,2] }
       ],
 
       :comments => [
-        { :body => "EWOT", :id => 1, :tags => [1,3] },
-        { :body => "YARLY", :id => 2, :tags => [1,2] }
+        { :body => "EWOT", :id => 1, :tag_ids => [1,3] },
+        { :body => "YARLY", :id => 2, :tag_ids => [1,2] }
       ],
 
       :tags => [
@@ -1079,21 +970,6 @@ class SerializerTest < ActiveModel::TestCase
     }, actual)
   end
 
-  # Set up some classes for polymorphic testing
-  class Attachment < Model
-    def attachable
-      @attributes[:attachable]
-    end
-
-    def readable
-      @attributes[:readable]
-    end
-
-    def edible
-      @attributes[:edible]
-    end
-  end
-
   def tests_can_handle_polymorphism
     email_serializer = Class.new(ActiveModel::Serializer) do
       attributes :subject, :body
@@ -1121,7 +997,7 @@ class SerializerTest < ActiveModel::TestCase
     actual = attachment_serializer.new(attachment, {}).as_json
 
     assert_equal({
-      :name => 'logo.png', 
+      :name => 'logo.png',
       :url => 'http://example.com/logo.png',
       :attachable => {
         :type => :email,
@@ -1158,7 +1034,7 @@ class SerializerTest < ActiveModel::TestCase
     actual = attachment_serializer.new(attachment, {}).as_json
 
     assert_equal({
-      :name => 'logo.png', 
+      :name => 'logo.png',
       :url => 'http://example.com/logo.png',
       :attachable => {
         :type => :email,
@@ -1197,7 +1073,7 @@ class SerializerTest < ActiveModel::TestCase
 
     assert_equal({
       :attachment => {
-        :name => 'logo.png', 
+        :name => 'logo.png',
         :url => 'http://example.com/logo.png',
         :attachable => {
           :type => :email, 
@@ -1388,4 +1264,50 @@ class SerializerTest < ActiveModel::TestCase
       }
     }, actual)
   end
+
+  def test_meta_key_serialization
+    tag_serializer = Class.new(ActiveModel::Serializer) do
+      attributes :name
+    end
+
+    tag_class = Class.new(Model) do
+      def name
+        @attributes[:name]
+      end
+
+      define_method :active_model_serializer do
+        tag_serializer
+      end
+    end
+
+    serializable_array = Class.new(Array)
+
+    array = serializable_array.new
+    array << tag_class.new(:name => 'Rails')
+    array << tag_class.new(:name => 'Sinatra')
+
+    actual = array.active_model_serializer.new(array, :root => :tags, :meta => {:total => 10}).as_json
+
+    assert_equal({
+      :meta => {
+        :total => 10,
+      },
+      :tags => [
+        { :name => "Rails" },
+        { :name => "Sinatra" },
+      ]
+    }, actual)
+
+    actual = array.active_model_serializer.new(array, :root => :tags, :meta => {:total => 10}, :meta_key => 'meta_object').as_json
+
+    assert_equal({
+      :meta_object => {
+        :total => 10,
+      },
+      :tags => [
+        { :name => "Rails" },
+        { :name => "Sinatra" },
+      ]
+    }, actual)
+  end
 end