gpi-active_model_serializers 0.8.2

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/serialize'))
+    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/serialize')
+    assert_equal instance.to_json, serializer.cache.read('array_serializer/cache-key/to-json')
+  end
+end

data/test/generators_test.rb

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

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

@@ -0,0 +1,99 @@
+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
+
+class SerializationActionScopeOverrideTest < 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
+    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, scope: current_admin, scope_name: :current_admin
+    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

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