active_model_serializers 0.8.3 → 0.10.0.rc2

data/test/fixtures/poro.rb

@@ -0,0 +1,230 @@
+class Model
+  FILE_DIGEST = Digest::MD5.hexdigest(File.open(__FILE__).read)
+
+  def self.model_name
+    @_model_name ||= ActiveModel::Name.new(self)
+  end
+
+  def initialize(hash={})
+    @attributes = hash
+  end
+
+  def cache_key
+    "#{self.class.name.downcase}/#{self.id}-#{self.updated_at}"
+  end
+
+  def cache_key_with_digest
+    "#{cache_key}/#{FILE_DIGEST}"
+  end
+
+  def updated_at
+    @attributes[:updated_at] ||= DateTime.now.to_time.to_i
+  end
+
+  def read_attribute_for_serialization(name)
+    if name == :id || name == 'id'
+      id
+    else
+      @attributes[name]
+    end
+  end
+
+  def id
+    @attributes[:id] || @attributes['id'] || object_id
+  end
+
+  def to_param
+    id
+  end
+
+  def method_missing(meth, *args)
+    if meth.to_s =~ /^(.*)=$/
+      @attributes[$1.to_sym] = args[0]
+    elsif @attributes.key?(meth)
+      @attributes[meth]
+    else
+      super
+    end
+  end
+end
+
+class Profile < Model
+end
+
+class ProfileSerializer < ActiveModel::Serializer
+  attributes :name, :description
+
+  urls :posts, :comments
+
+  def arguments_passed_in?
+    options[:my_options] == :accessible
+  end
+end
+
+class ProfilePreviewSerializer < ActiveModel::Serializer
+  attributes :name
+
+  urls :posts, :comments
+end
+
+Post     = Class.new(Model)
+Like     = Class.new(Model)
+Comment  = Class.new(Model)
+Author   = Class.new(Model)
+Bio      = Class.new(Model)
+Blog     = Class.new(Model)
+Role     = Class.new(Model)
+User     = Class.new(Model)
+Location = Class.new(Model)
+Place    = Class.new(Model)
+
+module Spam; end
+Spam::UnrelatedLink = Class.new(Model)
+
+PostSerializer = Class.new(ActiveModel::Serializer) do
+  cache key:'post', expires_in: 0.1, skip_digest: true
+  attributes :id, :title, :body
+
+  has_many :comments
+  belongs_to :blog
+  belongs_to :author
+  url :comments
+
+  def blog
+    Blog.new(id: 999, name: "Custom blog")
+  end
+
+  def custom_options
+    options
+  end
+end
+
+SpammyPostSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+  has_many :related
+
+  def self.root_name
+    'posts'
+  end
+end
+
+CommentSerializer = Class.new(ActiveModel::Serializer) do
+  cache expires_in: 1.day, skip_digest: true
+  attributes :id, :body
+
+  belongs_to :post
+  belongs_to :author
+
+  def custom_options
+    options
+  end
+end
+
+AuthorSerializer = Class.new(ActiveModel::Serializer) do
+  cache key:'writer', skip_digest: true
+  attributes :id, :name
+
+  has_many :posts, embed: :ids
+  has_many :roles, embed: :ids
+  has_one :bio
+end
+
+RoleSerializer = Class.new(ActiveModel::Serializer) do
+  cache only: [:name], skip_digest: true
+  attributes :id, :name, :description, :slug
+
+  def slug
+    "#{name}-#{id}"
+  end
+
+  belongs_to :author
+end
+
+LikeSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :time
+
+  belongs_to :post
+end
+
+LocationSerializer = Class.new(ActiveModel::Serializer) do
+  cache only: [:place], skip_digest: true
+  attributes :id, :lat, :lng
+
+  belongs_to :place
+
+  def place
+    'Nowhere'
+  end
+end
+
+PlaceSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :name
+
+  has_many :locations
+end
+
+BioSerializer = Class.new(ActiveModel::Serializer) do
+  cache except: [:content], skip_digest: true
+  attributes :id, :content, :rating
+
+  belongs_to :author
+end
+
+BlogSerializer = Class.new(ActiveModel::Serializer) do
+  cache key: 'blog'
+  attributes :id, :name
+
+  belongs_to :writer
+  has_many :articles
+end
+
+PaginatedSerializer = Class.new(ActiveModel::Serializer::ArraySerializer) do
+  def json_key
+    'paginated'
+  end
+end
+
+AlternateBlogSerializer = Class.new(ActiveModel::Serializer) do
+  attribute :id
+  attribute :name, key: :title
+end
+
+CustomBlogSerializer = Class.new(ActiveModel::Serializer) do
+  attribute :id
+  attribute :special_attribute
+
+  has_many :articles
+end
+
+CommentPreviewSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+
+  belongs_to :post
+end
+
+AuthorPreviewSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+
+  has_many :posts
+end
+
+PostPreviewSerializer = Class.new(ActiveModel::Serializer) do
+  def self.root_name
+    'posts'
+  end
+
+  attributes :title, :body, :id
+
+  has_many :comments, serializer: CommentPreviewSerializer
+  belongs_to :author, serializer: AuthorPreviewSerializer
+end
+
+Spam::UnrelatedLinkSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+end
+
+RaiseErrorSerializer = Class.new(ActiveModel::Serializer) do
+  def json_key
+    raise StandardError, 'Intentional error for rescue_from test'
+  end
+end

data/test/generators/scaffold_controller_generator_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+# require 'active_model/serializer/railtie'
+
+class ResourceGeneratorTest < Rails::Generators::TestCase
+  destination File.expand_path('../../../tmp/generators', __FILE__)
+  setup :prepare_destination, :copy_routes
+
+  tests Rails::Generators::ResourceGenerator
+  arguments %w(account)
+
+  def test_serializer_file_is_generated
+    run_generator
+
+    assert_file 'app/serializers/account_serializer.rb', /class AccountSerializer < ActiveModel::Serializer/
+  end
+
+  private
+
+  def copy_routes
+    config_dir = File.join(destination_root, 'config')
+    FileUtils.mkdir_p(config_dir)
+    File.write(File.join(config_dir, 'routes.rb'), 'Rails.application.routes.draw { }')
+  end
+end

data/test/{generators_test.rb → generators/serializer_generator_test.rb}

@@ -1,18 +1,8 @@
 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__)
+  destination File.expand_path("../../../tmp/generators", __FILE__)
   setup :prepare_destination
 
   tests Rails::Generators::SerializerGenerator
@@ -36,30 +26,6 @@ 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)
-  #   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"]
@@ -72,7 +38,7 @@ class SerializerGeneratorTest < Rails::Generators::TestCase
     run_generator
     assert_file "app/serializers/account_serializer.rb" do |serializer|
       assert_match(/^  attributes :id, :name, :description$/, serializer)
-      assert_match(/^  has_one :business$/, serializer)
+      assert_match(/^  attribute :business$/, serializer)
     end
   end
 

data/test/serializers/adapter_for_test.rb

@@ -0,0 +1,50 @@
+module ActiveModel
+  class Serializer
+    class AdapterForTest < Minitest::Test
+      def setup
+        @previous_adapter = ActiveModel::Serializer.config.adapter
+      end
+
+      def teardown
+        ActiveModel::Serializer.config.adapter = @previous_adapter
+      end
+
+      def test_returns_default_adapter
+        adapter = ActiveModel::Serializer.adapter
+        assert_equal ActiveModel::Serializer::Adapter::FlattenJson, adapter
+      end
+
+      def test_overwrite_adapter_with_symbol
+        ActiveModel::Serializer.config.adapter = :null
+
+        adapter = ActiveModel::Serializer.adapter
+        assert_equal ActiveModel::Serializer::Adapter::Null, adapter
+      ensure
+
+      end
+
+      def test_overwrite_adapter_with_class
+        ActiveModel::Serializer.config.adapter = ActiveModel::Serializer::Adapter::Null
+
+        adapter = ActiveModel::Serializer.adapter
+        assert_equal ActiveModel::Serializer::Adapter::Null, adapter
+      end
+
+      def test_raises_exception_if_invalid_symbol_given
+        ActiveModel::Serializer.config.adapter = :unknown
+
+        assert_raises ArgumentError do
+          ActiveModel::Serializer.adapter
+        end
+      end
+
+      def test_raises_exception_if_it_does_not_know_hot_to_infer_adapter
+        ActiveModel::Serializer.config.adapter = 42
+
+        assert_raises ArgumentError do
+          ActiveModel::Serializer.adapter
+        end
+      end
+    end
+  end
+end

data/test/serializers/associations_test.rb

@@ -0,0 +1,127 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AssociationsTest < Minitest::Test
+      class Model
+        def initialize(hash={})
+          @attributes = hash
+        end
+
+        def read_attribute_for_serialization(name)
+          @attributes[name]
+        end
+
+        def method_missing(meth, *args)
+          if meth.to_s =~ /^(.*)=$/
+            @attributes[$1.to_sym] = args[0]
+          elsif @attributes.key?(meth)
+            @attributes[meth]
+          else
+            super
+          end
+        end
+      end
+
+      def setup
+        @author = Author.new(name: 'Steve K.')
+        @author.bio = nil
+        @author.roles = []
+        @blog = Blog.new({ name: 'AMS Blog' })
+        @post = Post.new({ title: 'New Post', body: 'Body' })
+        @comment = Comment.new({ id: 1, body: 'ZOMG A COMMENT' })
+        @post.comments = [@comment]
+        @post.blog = @blog
+        @comment.post = @post
+        @comment.author = nil
+        @post.author = @author
+        @author.posts = [@post]
+
+        @post_serializer = PostSerializer.new(@post, {custom_options: true})
+        @author_serializer = AuthorSerializer.new(@author)
+        @comment_serializer = CommentSerializer.new(@comment)
+      end
+
+      def test_has_many_and_has_one
+        assert_equal(
+          { posts: { type: :has_many, association_options: { embed: :ids } },
+            roles: { type: :has_many, association_options: { embed: :ids } },
+            bio: { type: :has_one, association_options: {} } },
+          @author_serializer.class._associations
+        )
+        @author_serializer.each_association do |name, serializer, options|
+          if name == :posts
+            assert_equal({embed: :ids}, options)
+            assert_kind_of(ActiveModel::Serializer.config.array_serializer, serializer)
+          elsif name == :bio
+            assert_equal({}, options)
+            assert_nil serializer
+          elsif name == :roles
+            assert_equal({embed: :ids}, options)
+            assert_kind_of(ActiveModel::Serializer.config.array_serializer, serializer)
+          else
+            flunk "Unknown association: #{name}"
+          end
+        end
+      end
+
+      def test_serializer_options_are_passed_into_associations_serializers
+        @post_serializer.each_association do |name, association|
+          if name == :comments
+            assert association.first.custom_options[:custom_options]
+          end
+        end
+      end
+
+      def test_belongs_to
+        assert_equal(
+          { post: { type: :belongs_to, association_options: {} },
+            author: { type: :belongs_to, association_options: {} } },
+          @comment_serializer.class._associations
+        )
+        @comment_serializer.each_association do |name, serializer, options|
+          if name == :post
+            assert_equal({}, options)
+            assert_kind_of(PostSerializer, serializer)
+          elsif name == :author
+            assert_equal({}, options)
+            assert_nil serializer
+          else
+            flunk "Unknown association: #{name}"
+          end
+        end
+      end
+
+      def test_belongs_to_with_custom_method
+        blog_is_present = false
+
+        @post_serializer.each_association do |name, serializer, options|
+          blog_is_present = true if name == :blog
+        end
+
+        assert blog_is_present
+      end
+
+      def test_associations_inheritance
+        inherited_klass = Class.new(PostSerializer)
+
+        assert_equal(PostSerializer._associations, inherited_klass._associations)
+      end
+
+      def test_associations_inheritance_with_new_association
+        inherited_klass = Class.new(PostSerializer) do
+          has_many :top_comments, serializer: CommentSerializer
+        end
+        expected_associations = PostSerializer._associations.merge(
+          top_comments: {
+            type: :has_many,
+            association_options: {
+              serializer: CommentSerializer
+            }
+          }
+        )
+        assert_equal(inherited_klass._associations, expected_associations)
+      end
+    end
+  end
+end

data/test/serializers/attribute_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AttributeTest < Minitest::Test
+      def setup
+        @blog = Blog.new({ id: 1, name: 'AMS Hints' })
+        @blog_serializer = AlternateBlogSerializer.new(@blog)
+      end
+
+      def test_attributes_definition
+        assert_equal([:id, :title],
+                     @blog_serializer.class._attributes)
+      end
+
+      def test_json_serializable_hash
+        adapter = ActiveModel::Serializer::Adapter::Json.new(@blog_serializer)
+        assert_equal({alternate_blog: { id:1, title:"AMS Hints"}}, adapter.serializable_hash)
+      end
+
+      def test_attribute_inheritance_with_key
+        inherited_klass = Class.new(AlternateBlogSerializer)
+        blog_serializer = inherited_klass.new(@blog)
+        adapter = ActiveModel::Serializer::Adapter::FlattenJson.new(blog_serializer)
+        assert_equal({:id=>1, :title=>"AMS Hints"}, adapter.serializable_hash)
+      end
+
+      def test_multiple_calls_with_the_same_attribute
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          attribute :title
+          attribute :title
+        end
+
+        assert_equal([:title], serializer_class._attributes)
+      end
+    end
+  end
+end

data/test/serializers/attributes_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AttributesTest < Minitest::Test
+      def setup
+        @profile = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+        @profile_serializer = ProfileSerializer.new(@profile)
+        @comment = Comment.new(id: 1, body: "ZOMG!!", date: "2015")
+        @serializer_klass = Class.new(CommentSerializer)
+        @serializer_klass_with_new_attributes = Class.new(CommentSerializer) do
+          attributes :date, :likes
+        end
+      end
+
+      def test_attributes_definition
+        assert_equal([:name, :description],
+                     @profile_serializer.class._attributes)
+      end
+
+      def test_attributes_with_fields_option
+        assert_equal({name: 'Name 1'},
+                     @profile_serializer.attributes(fields: [:name]))
+      end
+
+      def test_required_fields
+        assert_equal({name: 'Name 1', description: 'Description 1'},
+                     @profile_serializer.attributes(fields: [:name, :description], required_fields: [:name]))
+
+      end
+
+      def test_attributes_inheritance_definition
+        assert_equal([:id, :body], @serializer_klass._attributes)
+      end
+
+      def test_attributes_inheritance
+        serializer = @serializer_klass.new(@comment)
+        assert_equal({id: 1, body: "ZOMG!!"},
+                     serializer.attributes)
+      end
+
+      def test_attribute_inheritance_with_new_attribute_definition
+        assert_equal([:id, :body, :date, :likes], @serializer_klass_with_new_attributes._attributes)
+        assert_equal([:id, :body], CommentSerializer._attributes)
+      end
+
+      def test_attribute_inheritance_with_new_attribute
+        serializer = @serializer_klass_with_new_attributes.new(@comment)
+        assert_equal({id: 1, body: "ZOMG!!", date: "2015", likes: nil},
+                     serializer.attributes)
+      end
+
+      def test_multiple_calls_with_the_same_attribute
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          attributes :id, :title
+          attributes :id, :title, :title, :body
+        end
+
+        assert_equal([:id, :title, :body], serializer_class._attributes)
+      end
+    end
+  end
+end