active_model_serializers 0.8.4 → 0.9.0.alpha1

data/test/caching_test.rb

@@ -1,177 +0,0 @@
-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
-
-  class Parent
-    def id
-      'parent1'
-    end
-
-    def name
-      'Kieran'
-    end
-
-    def children
-      [ Child.new ]
-    end
-
-    def read_attribute_for_serialization(name)
-      send name
-    end
-  end
-
-  class Child
-    def id
-      'child1'
-    end
-
-    def name
-      'Joshua'
-    end
-
-    def parent
-      Parent.new
-    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
-
-  def test_cached_serializers_return_associations
-
-    child_serializer = Class.new(ActiveModel::Serializer) do
-      cached true
-      attributes :name
-
-      def self.to_s
-        'child_serializer'
-      end
-
-      def cache_key
-        object.name
-      end
-    end
-
-    parent_serializer = Class.new(ActiveModel::Serializer) do
-      cached true
-      attributes :name
-
-      has_many :children, serializer: child_serializer, embed: :ids, include: true
-
-      def self.to_s
-        'parent_serializer'
-      end
-
-      def cache_key
-        object.name
-      end
-    end
-
-
-    parent_serializer.cache = NullStore.new
-    child_serializer.cache = NullStore.new
-
-    instance = parent_serializer.new Parent.new, root: :parent
-
-    initial_keys = instance.as_json.keys
-
-    assert_equal(initial_keys, [:children, :parent])
-
-    cached_keys = instance.as_json.keys
-
-    assert_equal(cached_keys, [:children, :parent])
-  end
-end

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,396 +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
-    if Rails::VERSION::MAJOR == 3
-      assert_equal 'alert({"hello":"world"})', @response.body
-      assert_match %r(application/json), @response.content_type.to_s
-    else
-      assert_equal '/**/alert({"hello":"world"})', @response.body
-      assert_match %r(text/javascript), @response.content_type.to_s
-    end
-  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