active_model_serializers 0.8.3 → 0.10.8

data/test/generators_test.rb

@@ -1,85 +0,0 @@
-require 'test_helper'
-
-class Foo < Rails::Application
-  if Rails.version.to_s.start_with? '4'
-    config.eager_load = false
-    config.secret_key_base = 'abc123'
-  end
-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_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)
-  #   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 :id, :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" do |content|
-      assert_no_match /\n\nend/, content
-    end
-  end
-end

data/test/no_serialization_scope_test.rb

@@ -1,34 +0,0 @@
-require "test_helper"
-
-class NoSerializationScopeTest < ActionController::TestCase
-  class ScopeSerializer
-    def initialize(object, options)
-      @object, @options = object, options
-    end
-
-    def as_json(*)
-      { :scope => @options[:scope].as_json }
-    end
-  end
-
-  class ScopeSerializable
-    def active_model_serializer
-      ScopeSerializer
-    end
-  end
-
-  class NoSerializationScopeController < ActionController::Base
-    serialization_scope nil
-
-    def index
-      render :json => ScopeSerializable.new
-    end
-  end
-
-  tests NoSerializationScopeController
-
-  def test_disabled_serialization_scope
-    get :index, :format => :json
-    assert_equal '{"scope":null}', @response.body
-  end
-end

data/test/serialization_scope_name_test.rb

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

@@ -1,392 +0,0 @@
-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, options={})
-      @object, @options = object, options
-    end
-
-    def 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
-    def initialize(skip=false)
-      @skip = skip
-    end
-
-    def active_model_serializer
-      JsonSerializer unless @skip
-    end
-
-    def as_json(*)
-      { :serializable_object => true }
-    end
-  end
-
-  class CustomSerializer
-    def initialize(*)
-    end
-
-    def as_json(*)
-      { :hello => true }
-    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
-    end
-  end
-
-  class HypermediaSerializer < ActiveModel::Serializer
-    def as_json(*)
-      { :link => hypermedia_url }
-    end
-  end
-
-  class CustomArraySerializer < ActiveModel::ArraySerializer
-    self.root = "items"
-  end
-
-  class TestController < ActionController::Base
-    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_nil_with_custom_serializer
-      render :json => nil, :serializer => DummyCustomSerializer
-    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_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
-    end
-
-    def render_json_with_serializer_and_scope_option
-      @current_user = Struct.new(:as_json).new(:current_user => true)
-      scope = Struct.new(:as_json).new(:current_user => false)
-      render :json => JsonSerializable.new, :scope => scope
-    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
-
-    # To specify a custom serializer for an object, use :serializer.
-    def render_json_with_custom_serializer
-      render :json => Object.new, :serializer => CustomSerializer
-    end
-
-    # To specify a custom serializer for each item in the Array, use :each_serializer.
-    def render_json_array_with_custom_serializer
-      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
-
-    def render_json_array_with_no_root
-      render :json => [], :root => false
-    end
-
-    def render_json_empty_array
-      render :json => []
-    end
-
-    def render_json_array_with_custom_array_serializer
-      render :json => [], :serializer => CustomArraySerializer
-    end
-
-
-  private
-    def default_serializer_options
-      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
-
-  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_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
-    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
-    # For JSONP, Rails 3 uses application/json, but Rails 4 uses text/javascript
-    assert_match %r(application/json|text/javascript), @response.content_type.to_s
-  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_checking_defaults
-    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_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
-    assert_match '"object":{"serializable_object":true}', @response.body
-    assert_match '"options":true', @response.body
-  end
-
-  def test_render_json_with_serializer_and_scope_option
-    get :render_json_with_serializer_and_scope_option
-    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
-  end
-
-  def test_render_json_with_custom_serializer
-    get :render_json_with_custom_serializer
-    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
-  end
-
-  def test_render_json_array_with_no_root
-    get :render_json_array_with_no_root
-    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_array_with_array_serializer_root_false
-    ActiveModel::ArraySerializer.root = false
-    get :render_json_empty_array
-    assert_equal '[]', @response.body
-  ensure # teardown
-    ActiveModel::ArraySerializer.root = nil
-  end
-
-  def test_render_json_array_with_custom_array_serializer
-    get :render_json_array_with_custom_array_serializer
-    assert_equal '{"items":[]}', @response.body
-  end
-
-end

data/test/serializer_support_test.rb

@@ -1,51 +0,0 @@
-require "test_helper"
-
-class RandomModel
-  include ActiveModel::SerializerSupport
-end
-
-class OtherRandomModel
-  include ActiveModel::SerializerSupport
-end
-
-class OtherRandomModelSerializer
-end
-
-class RandomModelCollection
-  include ActiveModel::ArraySerializerSupport
-end
-
-module ActiveRecord
-  class Relation
-  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
-  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
-
-  test "it automatically includes array_serializer in active_record/relation" do
-    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
-