active_model_serializers 0.1.0 → 0.5.0

data/test/serialization_test.rb

@@ -15,15 +15,20 @@ class RenderJsonTest < ActionController::TestCase
   end
 
   class JsonSerializer
-    def initialize(object, scope, options={})
-      @object, @scope, @options = object, scope, options
+    def initialize(object, options={})
+      @object, @options = object, options
     end
 
     def as_json(*)
-      hash = { :object => @object.as_json, :scope => @scope.as_json }
+      hash = { :object => serializable_hash, :scope => @options[:scope].as_json }
       hash.merge!(:options => true) if @options[:options]
+      hash.merge!(:check_defaults => true) if @options[:check_defaults]
       hash
     end
+
+    def serializable_hash
+      @object.as_json
+    end
   end
 
   class JsonSerializable
@@ -40,6 +45,15 @@ class RenderJsonTest < ActionController::TestCase
     end
   end
 
+  class CustomSerializer
+    def initialize(*)
+    end
+
+    def as_json(*)
+      { :hello => true }
+    end
+  end
+
   class TestController < ActionController::Base
     protect_from_forgery
 
@@ -91,6 +105,11 @@ class RenderJsonTest < ActionController::TestCase
       render :json => JsonSerializable.new
     end
 
+    def render_json_with_serializer_and_implicit_root
+      @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
@@ -100,6 +119,17 @@ class RenderJsonTest < ActionController::TestCase
       @current_user = Struct.new(:as_json).new(:current_user => true)
       render :json => JsonSerializable.new(true)
     end
+
+    def render_json_with_custom_serializer
+      render :json => [], :serializer => CustomSerializer
+    end
+
+  private
+    def default_serializer_options
+      if params[:check_defaults]
+        { :check_defaults => true }
+      end
+    end
   end
 
   tests TestController
@@ -124,7 +154,6 @@ class RenderJsonTest < ActionController::TestCase
     assert_equal '[]', @response.body
   end
 
-
   def test_render_json
     get :render_json_hello_world
     assert_equal '{"hello":"world"}', @response.body
@@ -172,6 +201,18 @@ class RenderJsonTest < ActionController::TestCase
     assert_match '"object":{"serializable_object":true}', @response.body
   end
 
+  def test_render_json_with_serializer
+    get :render_json_with_serializer, :check_defaults => true
+    assert_match '"scope":{"current_user":true}', @response.body
+    assert_match '"object":{"serializable_object":true}', @response.body
+    assert_match '"check_defaults":true', @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_options
     get :render_json_with_serializer_and_options
     assert_match '"scope":{"current_user":true}', @response.body
@@ -183,4 +224,9 @@ class RenderJsonTest < ActionController::TestCase
     get :render_json_with_serializer_api_but_without_serializer
     assert_match '{"serializable_object":true}', @response.body
   end
+
+  def test_render_json_with_custom_serializer
+    get :render_json_with_custom_serializer
+    assert_match '{"hello":true}', @response.body
+  end
 end

data/test/serializer_test.rb

@@ -37,9 +37,10 @@ class SerializerTest < ActiveModel::TestCase
     def initialize(attributes)
       super(attributes)
       self.comments ||= []
+      self.author = nil
     end
 
-    attr_accessor :comments
+    attr_accessor :comments, :author
     def active_model_serializer; PostSerializer; end
   end
 
@@ -51,7 +52,7 @@ class SerializerTest < ActiveModel::TestCase
     attributes :first_name, :last_name
 
     def serializable_hash
-      attributes.merge(:ok => true).merge(scope)
+      attributes.merge(:ok => true).merge(options[:scope])
     end
   end
 
@@ -106,7 +107,7 @@ class SerializerTest < ActiveModel::TestCase
 
   def test_attributes_method
     user = User.new
-    user_serializer = UserSerializer.new(user, {})
+    user_serializer = UserSerializer.new(user, :scope => {})
 
     hash = user_serializer.as_json
 
@@ -117,7 +118,7 @@ class SerializerTest < ActiveModel::TestCase
 
   def test_serializer_receives_scope
     user = User.new
-    user_serializer = UserSerializer.new(user, {:scope => true})
+    user_serializer = UserSerializer.new(user, :scope => {:scope => true})
 
     hash = user_serializer.as_json
 
@@ -134,7 +135,7 @@ class SerializerTest < ActiveModel::TestCase
   def test_pretty_accessors
     user = User.new
     user.superuser = true
-    user_serializer = MyUserSerializer.new(user, nil)
+    user_serializer = MyUserSerializer.new(user)
 
     hash = user_serializer.as_json
 
@@ -152,7 +153,7 @@ class SerializerTest < ActiveModel::TestCase
     comments = [Comment.new(:title => "Comment1"), Comment.new(:title => "Comment2")]
     post.comments = comments
 
-    post_serializer = PostSerializer.new(post, user)
+    post_serializer = PostSerializer.new(post, :scope => user)
 
     assert_equal({
       :post => {
@@ -183,7 +184,7 @@ class SerializerTest < ActiveModel::TestCase
     blog = Blog.new
     blog.author = user
 
-    json = BlogSerializer.new(blog, user).as_json
+    json = BlogSerializer.new(blog, :scope => user).as_json
     assert_equal({
       :blog => {
         :author => {
@@ -211,7 +212,7 @@ class SerializerTest < ActiveModel::TestCase
     blog = Blog.new
     blog.author = user
 
-    json = blog_serializer.new(blog, user).as_json
+    json = blog_serializer.new(blog, :scope => user).as_json
     assert_equal({
       :person => {
         :first_name => "Jose"
@@ -219,84 +220,28 @@ class SerializerTest < ActiveModel::TestCase
     }, json)
   end
 
-  def post_serializer(type)
+  def post_serializer
     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
+      has_one :author, :serializer => DefaultUserSerializer
     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
+    json = BlogSerializer.new(blog, :scope => 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
+    json = serializer.new(blog, :scope => user).as_json
     assert_equal({ :blog =>  { :author => nil } }, json)
   end
 
@@ -308,7 +253,7 @@ class SerializerTest < ActiveModel::TestCase
       root :my_blog
     end
 
-    assert_equal({ :my_blog => { :author => nil } }, serializer.new(blog, user).as_json)
+    assert_equal({ :my_blog => { :author => nil } }, serializer.new(blog, :scope => user).as_json)
   end
 
   def test_false_root
@@ -319,15 +264,15 @@ class SerializerTest < ActiveModel::TestCase
       root false
     end
 
-    assert_equal({ :author => nil }, serializer.new(blog, user).as_json)
+    assert_equal({ :author => nil }, serializer.new(blog, :scope => user).as_json)
 
     # test inherited false root
     serializer = Class.new(serializer)
-    assert_equal({ :author => nil }, serializer.new(blog, user).as_json)
+    assert_equal({ :author => nil }, serializer.new(blog, :scope => user).as_json)
   end
 
   def test_embed_ids
-    serializer = post_serializer(:super)
+    serializer = post_serializer
 
     serializer.class_eval do
       root :post
@@ -338,21 +283,22 @@ class SerializerTest < ActiveModel::TestCase
     comments = [Comment.new(:title => "Comment1", :id => 1), Comment.new(:title => "Comment2", :id => 2)]
     post.comments = comments
 
-    serializer = serializer.new(post, nil)
+    serializer = serializer.new(post)
 
     assert_equal({
       :post => {
         :title => "New Post",
         :body => "Body of new post",
-        :comments => [1, 2]
+        :comments => [1, 2],
+        :author => nil
       }
     }, serializer.as_json)
   end
 
   def test_embed_ids_include_true
-    serializer = post_serializer(:super)
+    serializer_class = post_serializer
 
-    serializer.class_eval do
+    serializer_class.class_eval do
       root :post
       embed :ids, :include => true
     end
@@ -361,23 +307,43 @@ class SerializerTest < ActiveModel::TestCase
     comments = [Comment.new(:title => "Comment1", :id => 1), Comment.new(:title => "Comment2", :id => 2)]
     post.comments = comments
 
-    serializer = serializer.new(post, nil)
+    serializer = serializer_class.new(post)
 
     assert_equal({
       :post => {
         :title => "New Post",
         :body => "Body of new post",
-        :comments => [1, 2]
+        :comments => [1, 2],
+        :author => nil
       },
       :comments => [
         { :title => "Comment1" },
         { :title => "Comment2" }
-      ]
+      ],
+      :authors => []
+    }, serializer.as_json)
+
+    post.author = User.new(:id => 1)
+
+    serializer = serializer_class.new(post)
+
+    assert_equal({
+      :post => {
+        :title => "New Post",
+        :body => "Body of new post",
+        :comments => [1, 2],
+        :author => 1
+      },
+      :comments => [
+        { :title => "Comment1" },
+        { :title => "Comment2" }
+      ],
+      :authors => [{ :first_name => "Jose", :last_name => "Valim" }]
     }, serializer.as_json)
   end
 
   def test_embed_objects
-    serializer = post_serializer(:super)
+    serializer = post_serializer
 
     serializer.class_eval do
       root :post
@@ -388,12 +354,13 @@ class SerializerTest < ActiveModel::TestCase
     comments = [Comment.new(:title => "Comment1", :id => 1), Comment.new(:title => "Comment2", :id => 2)]
     post.comments = comments
 
-    serializer = serializer.new(post, nil)
+    serializer = serializer.new(post)
 
     assert_equal({
       :post => {
         :title => "New Post",
         :body => "Body of new post",
+        :author => nil,
         :comments => [
           { :title => "Comment1" },
           { :title => "Comment2" }
@@ -416,6 +383,20 @@ class SerializerTest < ActiveModel::TestCase
     ], serializer.as_json)
   end
 
+  def test_array_serializer
+    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
+
   class CustomBlog < Blog
     attr_accessor :public_posts, :public_user
   end
@@ -436,7 +417,7 @@ class SerializerTest < ActiveModel::TestCase
     custom_blog.public_posts = posts
     custom_blog.public_user = user
 
-    serializer = CustomBlogSerializer.new(custom_blog, :scope => true)
+    serializer = CustomBlogSerializer.new(custom_blog, :scope => { :scope => true })
 
     assert_equal({
       :custom_blog => {
@@ -473,7 +454,7 @@ class SerializerTest < ActiveModel::TestCase
     custom_blog.public_posts = posts
     custom_blog.public_user = user
 
-    serializer = implicit_serializer.new(custom_blog, :scope => true)
+    serializer = implicit_serializer.new(custom_blog, :scope => { :scope => true })
 
     assert_equal({
       :custom_blog => {
@@ -499,7 +480,7 @@ class SerializerTest < ActiveModel::TestCase
       attribute :password
     end
 
-    serializer = serializer_class.new(User.new, nil)
+    serializer = serializer_class.new(User.new)
 
     assert_equal({
       :user => {
@@ -594,7 +575,7 @@ class SerializerTest < ActiveModel::TestCase
     author = author_class.new(:id => 5)
     post.author = author
 
-    hash = serializer_class.new(post, nil)
+    hash = serializer_class.new(post)
 
     assert_equal({
       :post => {
@@ -627,7 +608,7 @@ class SerializerTest < ActiveModel::TestCase
     author = author_class.new(:id => 5, :name => "Tom Dale")
     post.author = author
 
-    hash = serializer_class.new(post, nil)
+    hash = serializer_class.new(post)
 
     assert_equal({
       :post => {
@@ -666,13 +647,13 @@ class SerializerTest < ActiveModel::TestCase
         :body => "It's a new post!",
         :author => { :id => 5, :name => "Tom Dale" }
       }
-    }, serializer_class.new(post, nil, :root => :blog_post).as_json)
+    }, serializer_class.new(post, :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)
+    }, serializer_class.new(post, :root => false).as_json)
 
     assert_equal({
       :blog_post => {
@@ -680,13 +661,13 @@ class SerializerTest < ActiveModel::TestCase
         :body => "It's a new post!",
         :author => { :id => 5, :name => "Tom Dale" }
       }
-    }, serializer_class.new(post, nil).as_json(:root => :blog_post))
+    }, serializer_class.new(post).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))
+    }, serializer_class.new(post).as_json(:root => false))
   end
 
   def test_serializer_has_access_to_root_object
@@ -696,7 +677,7 @@ class SerializerTest < ActiveModel::TestCase
       attributes :id, :name
 
       define_method :serializable_hash do
-        hash_object = @hash
+        hash_object = @options[:hash]
         super()
       end
     end
@@ -718,10 +699,59 @@ class SerializerTest < ActiveModel::TestCase
     author = author_class.new(:id => 5, :name => "Tom Dale")
     post.author = author
 
-    expected = serializer_class.new(post, nil).as_json
+    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
 
+    serializer_class.class_eval do
+      root :post
+      embed :ids, :include => true
+      has_many :comments, :key => :comment_ids, :root => :comments
+      has_one :author, :serializer => DefaultUserSerializer, :key => :author_id, :root => :author
+    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_class.new(post)
+
+    assert_equal({
+    :post => {
+      :title => "New Post",
+      :body => "Body of new post",
+      :comment_ids => [1, 2],
+      :author_id => nil
+    },
+    :comments => [
+      { :title => "Comment1" },
+      { :title => "Comment2" }
+    ],
+    :author => []
+    }, serializer.as_json)
+
+    post.author = User.new(:id => 1)
+
+    serializer = serializer_class.new(post)
+
+    assert_equal({
+    :post => {
+      :title => "New Post",
+      :body => "Body of new post",
+      :comment_ids => [1, 2],
+      :author_id => 1
+    },
+    :comments => [
+      { :title => "Comment1" },
+      { :title => "Comment2" }
+    ],
+    :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
@@ -766,7 +796,7 @@ class SerializerTest < ActiveModel::TestCase
     comment1.tags = [tag1, tag3]
     comment2.tags = [tag1, tag2]
 
-    actual = ActiveModel::ArraySerializer.new([post], nil, :root => :posts).as_json
+    actual = ActiveModel::ArraySerializer.new([post], :root => :posts).as_json
     assert_equal({
       :posts => [
         { :title => "New Post", :body => "NEW POST", :id => 1, :comments => [1,2] }