active_model_serializers 0.7.0 → 0.8.0

data/test/caching_test.rb

@@ -0,0 +1,96 @@
+require "test_helper"
+
+class CachingTest < ActiveModel::TestCase
+  class NullStore
+    def fetch(key)
+      return store[key] if store[key]
+
+      store[key] = yield
+    end
+
+    def clear
+      store.clear
+    end
+
+    def store
+      @store ||= {}
+    end
+
+    def read(key)
+      store[key]
+    end
+  end
+
+  class Programmer
+    def name
+      'Adam'
+    end
+
+    def skills
+      %w(ruby)
+    end
+
+    def read_attribute_for_serialization(name)
+      send name
+    end
+  end
+
+  def test_serializers_have_a_cache_store
+    ActiveModel::Serializer.cache = NullStore.new
+
+    assert_kind_of NullStore, ActiveModel::Serializer.cache
+  end
+
+  def test_serializers_can_enable_caching
+    serializer = Class.new(ActiveModel::Serializer) do
+      cached true
+    end
+
+    assert serializer.perform_caching
+  end
+
+  def test_serializers_use_cache
+    serializer = Class.new(ActiveModel::Serializer) do
+      cached true
+      attributes :name, :skills
+
+      def self.to_s
+        'serializer'
+      end
+
+      def cache_key
+        object.name
+      end
+    end
+
+    serializer.cache = NullStore.new
+    instance = serializer.new Programmer.new
+
+    instance.to_json
+
+    assert_equal(instance.serializable_hash, serializer.cache.read('serializer/Adam/serializable-hash'))
+    assert_equal(instance.to_json, serializer.cache.read('serializer/Adam/to-json'))
+  end
+
+  def test_array_serializer_uses_cache
+    serializer = Class.new(ActiveModel::ArraySerializer) do
+      cached true
+
+      def self.to_s
+        'array_serializer'
+      end
+
+      def cache_key
+        'cache-key'
+      end
+    end
+
+    serializer.cache = NullStore.new
+    instance = serializer.new [Programmer.new]
+
+    instance.to_json
+
+    assert_equal instance.serializable_array, serializer.cache.read('array_serializer/cache-key/serializable-array')
+    assert_equal instance.to_json, serializer.cache.read('array_serializer/cache-key/to-json')
+  end
+end

data/test/generators_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 class Foo < Rails::Application
-  if Rails.version.start_with? '4'
+  if Rails.version.to_s.start_with? '4'
     config.eager_load = false
     config.secret_key_base = 'abc123'
   end
@@ -36,6 +36,18 @@ class SerializerGeneratorTest < Rails::Generators::TestCase
     Object.send :remove_const, :ApplicationSerializer
   end
 
+  def test_serializer_gets_id
+    run_generator
+
+    assert_file "app/serializers/account_serializer.rb" do |content|
+      if RUBY_VERSION =~ /1.8/
+        assert_match    /def id/, content
+      else
+        assert_no_match /def id/, content
+      end
+    end
+  end
+
   # def test_uses_namespace_application_serializer_if_one_exists
   #   Object.const_set(:SerializerNamespace, Module.new)
   #   SerializerNamespace.const_set(:ApplicationSerializer, Class.new)
@@ -66,6 +78,8 @@ class SerializerGeneratorTest < Rails::Generators::TestCase
 
   def test_with_no_attributes_does_not_add_extra_space
     run_generator ["account"]
-    assert_file "app/serializers/account_serializer.rb", /class AccountSerializer < ActiveModel::Serializer\n  attributes :id\nend/
+    assert_file "app/serializers/account_serializer.rb" do |content|
+      assert_no_match /\n\nend/, content
+    end
   end
 end

data/test/no_serialization_scope_test.rb

@@ -28,7 +28,7 @@ class NoSerializationScopeTest < ActionController::TestCase
   tests NoSerializationScopeController
 
   def test_disabled_serialization_scope
-    get :index
+    get :index, :format => :json
     assert_equal '{"scope":null}', @response.body
   end
 end

data/test/serialization_scope_name_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+require 'pathname'
+
+class DefaultScopeNameTest < ActionController::TestCase
+  TestUser = Struct.new(:name, :admin)
+
+  class UserSerializer < ActiveModel::Serializer
+    attributes :admin?
+    def admin?
+      current_user.admin
+    end
+  end
+
+  class UserTestController < ActionController::Base
+    protect_from_forgery
+
+    before_filter { request.format = :json }
+
+    def current_user
+      TestUser.new('Pete', false)
+    end
+
+    def render_new_user
+      render :json => TestUser.new('pete', false), :serializer => UserSerializer
+    end
+  end
+
+ tests UserTestController
+
+  def test_default_scope_name
+    get :render_new_user
+    assert_equal '{"user":{"admin":false}}', @response.body
+  end
+end
+
+class SerializationScopeNameTest < ActionController::TestCase
+  TestUser = Struct.new(:name, :admin)
+
+  class AdminUserSerializer < ActiveModel::Serializer
+    attributes :admin?
+    def admin?
+      current_admin.admin
+    end
+  end
+
+  class AdminUserTestController < ActionController::Base
+    protect_from_forgery
+
+    serialization_scope :current_admin
+    before_filter { request.format = :json }
+
+    def current_admin
+      TestUser.new('Bob', true)
+    end
+
+    def render_new_user
+      render :json => TestUser.new('pete', false), :serializer => AdminUserSerializer
+    end
+  end
+
+  tests AdminUserTestController
+
+  def test_override_scope_name_with_controller
+    get :render_new_user
+    assert_equal '{"admin_user":{"admin":true}}', @response.body
+  end
+end

data/test/serialization_test.rb

@@ -378,7 +378,7 @@ class RenderJsonTest < ActionController::TestCase
     assert_equal '{"awesome":[]}', @response.body
   end
 
-  def test_render_json_empty_arry_with_array_serializer_root_false
+  def test_render_json_empty_array_with_array_serializer_root_false
     ActiveModel::ArraySerializer.root = false
     get :render_json_empty_array
     assert_equal '[]', @response.body

data/test/serializer_support_test.rb

@@ -20,6 +20,11 @@ module ActiveRecord
   end
 end
 
+module Mongoid
+  class Criteria
+  end
+end
+
 class SerializerSupportTest < ActiveModel::TestCase
   test "it returns nil if no serializer exists" do
     assert_equal nil, RandomModel.new.active_model_serializer
@@ -37,5 +42,10 @@ class SerializerSupportTest < ActiveModel::TestCase
     ActiveSupport.run_load_hooks(:active_record)
     assert_equal ActiveModel::ArraySerializer, ActiveRecord::Relation.new.active_model_serializer
   end
+
+  test "it automatically includes array_serializer in mongoid/criteria" do
+    ActiveSupport.run_load_hooks(:mongoid)
+    assert_equal ActiveModel::ArraySerializer, Mongoid::Criteria.new.active_model_serializer
+  end
 end
 

data/test/serializer_test.rb

@@ -51,6 +51,17 @@ class SerializerTest < ActiveModel::TestCase
     }, hash)
   end
 
+  def test_attributes_method_with_unsymbolizable_key
+    user = User.new
+    user_serializer = UserAttributesWithUnsymbolizableKeySerializer.new(user, :scope => {})
+
+    hash = user_serializer.as_json
+
+    assert_equal({
+      :user_attributes_with_unsymbolizable_key => { :first_name => "Jose", :"last-name" => "Valim", :ok => true }
+    }, hash)
+  end
+
   def test_attribute_method_with_name_as_serializer_prefix
     object = SomeObject.new("something")
     object_serializer = SomeSerializer.new(object, {})
@@ -318,6 +329,16 @@ class SerializerTest < ActiveModel::TestCase
     assert_equal({ :author => nil }, serializer.new(blog, :scope => user).as_json)
   end
 
+  def test_true_root
+    blog = Blog.new
+
+    assert_equal({
+      :blog_with_root => {
+        :author => nil,
+      }
+    }, BlogWithRootSerializer.new(blog).as_json)
+  end
+
   def test_root_false_on_load_active_model_serializers
     begin
       ActiveSupport.on_load(:active_model_serializers) do
@@ -406,6 +427,33 @@ class SerializerTest < ActiveModel::TestCase
     }, serializer.as_json)
   end
 
+  def test_methods_take_priority_over_associations
+    post_serializer = Class.new(ActiveModel::Serializer) do
+      attributes :title
+      has_many :comments
+      embed :ids
+
+      def comments
+        object.comments[0,1]
+      end
+    end
+
+    post = Post.new(:title => "My Post")
+    comments = [Comment.new(:title => "Comment1", :id => 1), Comment.new(:title => "Comment2", :id => 2)]
+    post.comments = comments
+
+    post.class_eval do
+      define_method :comment_ids, lambda {
+        self.comments.map { |c| c.read_attribute_for_serialization(:id) }
+      }
+    end
+    json = post_serializer.new(post).as_json
+    assert_equal({
+      :title => "My Post",
+      :comment_ids => [1]
+    }, json)
+  end
+
   def test_embed_objects
     serializer = post_serializer
 
@@ -563,16 +611,17 @@ class SerializerTest < ActiveModel::TestCase
 
       # Computed attributes (not real columns or associations).
       def can_edit; end
+      def can_view; end
       def drafts; end
 
-      attributes :name, :age, :can_edit
+      attributes :name, :age, {:can_edit => :boolean}, :can_view
       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, :can_edit => nil },
+      :attributes => { :name => :string, :age => :integer, :can_edit => :boolean, :can_view => nil },
       :associations => {
         :posts => { :has_many => :posts },
         :drafts => nil,
@@ -1076,7 +1125,7 @@ class SerializerTest < ActiveModel::TestCase
         :name => 'logo.png',
         :url => 'http://example.com/logo.png',
         :attachable => {
-          :type => :email, 
+          :type => :email,
           :id => 1
         }},
       :emails => [{
@@ -1310,4 +1359,94 @@ class SerializerTest < ActiveModel::TestCase
       ]
     }, actual)
   end
+
+  def test_inheritance_does_not_used_cached_attributes
+    parent = Class.new(ActiveModel::Serializer) do
+      attributes :title
+    end
+
+    child = Class.new(parent) do
+      attributes :body
+    end
+
+    data_class = Class.new do
+      attr_accessor :title, :body
+    end
+
+    item = data_class.new
+    item.title = "title"
+    item.body = "body"
+
+    2.times do
+      assert_equal({:title => "title"},
+                   parent.new(item).attributes)
+      assert_equal({:body => "body", :title => "title"},
+                   child.new(item).attributes)
+    end
+
+  end
+
+  def test_scope_name_method
+    serializer = Class.new(ActiveModel::Serializer) do
+      def has_permission?
+        current_user.super_user?
+      end
+    end
+
+    user = User.new
+    user.superuser = true
+    post = Post.new(:title => 'Foo')
+
+    a_serializer = serializer.new(post, :scope => user, :scope_name => :current_user)
+    assert a_serializer.has_permission?
+  end
+
+  def test_only_option_filters_attributes_and_associations
+    post = Post.new(:title => "New Post", :body => "Body of new post")
+    comments = [Comment.new(:title => "Comment1")]
+    post.comments = comments
+
+    post_serializer = PostSerializer.new(post, :only => :title)
+
+    assert_equal({
+      :post => {
+        :title => "New Post"
+      }
+    }, post_serializer.as_json)
+  end
+
+  def test_except_option_filters_attributes_and_associations
+    post = Post.new(:title => "New Post", :body => "Body of new post")
+    comments = [Comment.new(:title => "Comment1")]
+    post.comments = comments
+
+    post_serializer = PostSerializer.new(post, :except => [:body, :comments])
+
+    assert_equal({
+      :post => {
+        :title => "New Post"
+      }
+    }, post_serializer.as_json)
+  end
+
+  def test_only_option_takes_precedence_over_custom_defined_include_methods
+    user = User.new
+
+    post = Post.new(:title => "New Post", :body => "Body of new post", :author => "Sausage King")
+    comments = [Comment.new(:title => "Comment")]
+    post.comments = comments
+
+    post_serializer = PostWithMultipleConditionalsSerializer.new(post, :scope => user, :only => :title)
+
+    # comments enabled
+    post.comments_disabled = false
+    # superuser - should see author
+    user.superuser = true
+
+    assert_equal({
+      :post => {
+        :title => "New Post"
+      }
+    }, post_serializer.as_json)
+  end
 end

data/test/test_fakes.rb

@@ -70,6 +70,14 @@ class UserAttributesWithSomeKeySerializer < ActiveModel::Serializer
   end
 end
 
+class UserAttributesWithUnsymbolizableKeySerializer < ActiveModel::Serializer
+  attributes :first_name, :last_name => :"last-name"
+
+  def serializable_hash
+    attributes.merge(:ok => true).merge(options[:scope])
+  end
+end
+
 class DefaultUserSerializer < ActiveModel::Serializer
   attributes :first_name, :last_name
 end
@@ -146,6 +154,10 @@ class BlogSerializer < ActiveModel::Serializer
   has_one :author, :serializer => AuthorSerializer
 end
 
+class BlogWithRootSerializer < BlogSerializer
+  root true
+end
+
 class CustomPostSerializer < ActiveModel::Serializer
   attributes :title
 end