active_model_serializers 0.9.9 → 0.10.0.rc1

data/test/adapter/null_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class Adapter
+      class NullTest < Minitest::Test
+        def setup
+          profile = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+          serializer = ProfileSerializer.new(profile)
+
+          @adapter = Null.new(serializer)
+        end
+
+        def test_serializable_hash
+          assert_equal({}, @adapter.serializable_hash)
+        end
+
+        def test_it_returns_empty_json
+          assert_equal('{}', @adapter.to_json)
+        end
+      end
+    end
+  end
+end
+

data/test/adapter_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AdapterTest < Minitest::Test
+      def setup
+        profile = Profile.new
+        @serializer = ProfileSerializer.new(profile)
+        @adapter = ActiveModel::Serializer::Adapter.new(@serializer)
+      end
+
+      def test_serializable_hash_is_abstract_method
+        assert_raises(NotImplementedError) do
+          @adapter.serializable_hash(only: [:name])
+        end
+      end
+
+      def test_serializer
+        assert_equal @serializer, @adapter.serializer
+      end
+
+      def test_adapter_class_for_known_adapter
+        klass = ActiveModel::Serializer::Adapter.adapter_class(:json_api)
+        assert_equal ActiveModel::Serializer::Adapter::JsonApi, klass
+      end
+
+      def test_adapter_class_for_unknown_adapter
+        klass = ActiveModel::Serializer::Adapter.adapter_class(:json_simple)
+        assert_nil klass
+      end
+
+      def test_create_adapter
+        adapter = ActiveModel::Serializer::Adapter.create(@serializer)
+        assert_equal ActiveModel::Serializer::Adapter::Json, adapter.class
+      end
+
+      def test_create_adapter_with_override
+        adapter = ActiveModel::Serializer::Adapter.create(@serializer, { adapter: :json_api})
+        assert_equal ActiveModel::Serializer::Adapter::JsonApi, adapter.class
+      end
+    end
+  end
+end

data/test/array_serializer_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class ArraySerializerTest < Minitest::Test
+      def setup
+        @comment = Comment.new
+        @post = Post.new
+        @serializer = ArraySerializer.new([@comment, @post], {some: :options})
+      end
+
+      def test_respond_to_each
+        assert_respond_to @serializer, :each
+      end
+
+      def test_each_object_should_be_serialized_with_appropriate_serializer
+        serializers =  @serializer.to_a
+
+        assert_kind_of CommentSerializer, serializers.first
+        assert_kind_of Comment, serializers.first.object
+
+        assert_kind_of PostSerializer, serializers.last
+        assert_kind_of Post, serializers.last.object
+
+        assert_equal serializers.last.custom_options[:some], :options
+      end
+    end
+  end
+end

data/test/fixtures/poro.rb

@@ -1,254 +1,206 @@
 class Model
-  def initialize(hash = {})
+  def initialize(hash={})
     @attributes = hash
   end
 
+  def cache_key
+    "#{self.class.name.downcase}/#{self.id}-#{self.updated_at}"
+  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'
-      object_id
-    elsif respond_to?(name)
-      send name
+      id
     else
       @attributes[name]
     end
   end
-end
 
-
-###
-## Models
-###
-
-module TestNamespace2
-  class Test < Model
-    attr_writer :sub_test
-
-    def sub_test
-      @sub_test ||= TestNamespace2::SubTest.new(name: 'N1', description: 'D1')
-    end
+  def id
+    @attributes[:id] || @attributes['id'] || object_id
   end
 
-  class SubTest < Model; end
-end
-
-class User < Model
-  def profile
-    @profile ||= Profile.new(name: 'N1', description: 'D1')
+  def to_param
+    id
   end
-end
 
-class UserInfo < Model
-  def user
-    @user ||= User.new(name: 'N1', email: 'E1')
+  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 Category < Model
-  def posts
-    @posts ||= [Post.new(title: 'T1', body: 'B1'),
-                Post.new(title: 'T2', body: 'B2')]
-  end
-end
+class ProfileSerializer < ActiveModel::Serializer
+  attributes :name, :description
 
-class Post < Model
-  def comments
-    @comments ||= [Comment.new(content: 'C1'),
-                   Comment.new(content: 'C2')]
-  end
-end
+  urls :posts, :comments
 
-class SpecialPost < Post
-  def special_comment
-    @special_comment ||= Comment.new(content: 'special')
+  def arguments_passed_in?
+    options[:my_options] == :accessible
   end
 end
 
-class Type < Model
-end
+class ProfilePreviewSerializer < ActiveModel::Serializer
+  attributes :name
 
-class SelfReferencingUser < Model
-  def type
-    @type ||= Type.new(name: 'N1')
-  end
-  def parent
-    @parent ||= SelfReferencingUserParent.new(name: 'N1')
-  end
+  urls :posts, :comments
 end
 
-class SelfReferencingUserParent < Model
-  def type
-    @type ||= Type.new(name: 'N2')
-  end
-  def parent
-  end
-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)
 
-class Comment < Model
-end
+module Spam; end
+Spam::UnrelatedLink = Class.new(Model)
 
-class WebLog < Model
-end
+PostSerializer = Class.new(ActiveModel::Serializer) do
+  cache key:'post', expires_in: 0.1
+  attributes :id, :title, :body
 
-class Interview < Model
-  def attachment
-    @attachment ||= Image.new(url: 'U1')
-  end
-end
+  has_many :comments
+  belongs_to :blog
+  belongs_to :author
+  url :comments
 
-class Mail < Model
-  def attachments
-    @attachments ||= [Image.new(url: 'U1'),
-                      Video.new(html: 'H1')]
+  def blog
+    Blog.new(id: 999, name: "Custom blog")
   end
-end
-
-class Image < Model
-end
 
-class Video < Model
+  def custom_options
+    options
+  end
 end
 
-###
-## Serializers
-###
-
-module TestNamespace2
-  class TestSerializer < ActiveModel::Serializer
-    attributes :name, :email
+SpammyPostSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+  has_many :related
 
-    has_one :sub_test
-  end
-
-  class SubTestSerializer < ActiveModel::Serializer
-    def description
-      description = object.read_attribute_for_serialization(:description)
-      scope ? "#{description} - #{scope}" : description
-    end
-
-    attributes :name, :description
+  def self.root_name
+    'posts'
   end
 end
 
-class UserSerializer < ActiveModel::Serializer
-  attributes :name, :email
-
-  has_one :profile
-end
+CommentSerializer = Class.new(ActiveModel::Serializer) do
+  cache expires_in: 1.day
+  attributes :id, :body
 
-class TypeSerializer < ActiveModel::Serializer
-  attributes :name
-end
+  belongs_to :post
+  belongs_to :author
 
-class SelfReferencingUserParentSerializer < ActiveModel::Serializer
-  attributes :name
-  has_one :type, serializer: TypeSerializer, embed: :ids, include: true
+  def custom_options
+    options
+  end
 end
 
-class SelfReferencingUserSerializer < ActiveModel::Serializer
-  attributes :name
+AuthorSerializer = Class.new(ActiveModel::Serializer) do
+  cache key:'writer'
+  attributes :id, :name
 
-  has_one :type, serializer: TypeSerializer, embed: :ids, include: true
-  has_one :parent, serializer: SelfReferencingUserSerializer, embed: :ids, include: true
+  has_many :posts, embed: :ids
+  has_many :roles, embed: :ids
+  has_one :bio
 end
 
-class UserInfoSerializer < ActiveModel::Serializer
-  has_one :user, serializer: UserSerializer
-end
+RoleSerializer = Class.new(ActiveModel::Serializer) do
+  cache only: [:name]
+  attributes :id, :name, :description, :slug
 
-class ProfileSerializer < ActiveModel::Serializer
-  def description
-    description = object.read_attribute_for_serialization(:description)
-    scope ? "#{description} - #{scope}" : description
+  def slug
+    "#{name}-#{id}"
   end
 
-  attributes :name, :description
+  belongs_to :author
 end
 
-class CategorySerializer < ActiveModel::Serializer
-  attributes :name
+LikeSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :time
 
-  has_many :posts
+  belongs_to :post
 end
 
-class PostSerializer < ActiveModel::Serializer
-  attributes :title, :body
+LocationSerializer = Class.new(ActiveModel::Serializer) do
+  cache only: [:place]
+  attributes :id, :lat, :lng
 
-  def title
-    keyword = serialization_options[:highlight_keyword]
-    title = object.read_attribute_for_serialization(:title)
-    title = title.gsub(keyword,"'#{keyword}'") if keyword
-    title
-  end
+  belongs_to :place
 
-  has_many :comments
-end
-
-class SpecialPostSerializer < ActiveModel::Serializer
-  attributes :title, :body
-  has_many :comments, root: :comments, embed_in_root: true, embed: :ids
-  has_one :special_comment, root: :comments, embed_in_root: true, embed: :ids
-end
-
-class CommentSerializer < ActiveModel::Serializer
-  attributes :content
+  def place
+    'Nowhere'
+  end
 end
 
-class WebLogSerializer < ActiveModel::Serializer
-  attributes :name, :display_name
-end
+PlaceSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :name
 
-class WebLogLowerCamelSerializer < WebLogSerializer
-  format_keys :lower_camel
+  has_many :locations
 end
 
-class InterviewSerializer < ActiveModel::Serializer
-  attributes :text
+BioSerializer = Class.new(ActiveModel::Serializer) do
+  cache except: [:content]
+  attributes :id, :content, :rating
 
-  has_one :attachment, polymorphic: true
+  belongs_to :author
 end
 
-class MailSerializer < ActiveModel::Serializer
-  attributes :body
+BlogSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :name
 
-  has_many :attachments, polymorphic: true
+  belongs_to :writer
+  has_many :articles
 end
 
-class ImageSerializer < ActiveModel::Serializer
-  attributes :url
+PaginatedSerializer = Class.new(ActiveModel::Serializer::ArraySerializer) do
+  def json_key
+    'paginated'
+  end
 end
 
-class VideoSerializer < ActiveModel::Serializer
-  attributes :html
+AlternateBlogSerializer = Class.new(ActiveModel::Serializer) do
+  attribute :id
+  attribute :name, key: :title
 end
 
-class ShortProfileSerializer < ::ProfileSerializer; end
+CommentPreviewSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
 
-module TestNamespace
-  class ProfileSerializer < ::ProfileSerializer; end
-  class UserSerializer    < ::UserSerializer;    end
+  belongs_to :post
 end
 
-ActiveModel::Serializer.setup do |config|
-  config.default_key_type = :name
-end
-
-class NameKeyUserSerializer < ActiveModel::Serializer
-  attributes :name, :email
+AuthorPreviewSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
 
-  has_one :profile
+  has_many :posts
 end
 
-class NameKeyPostSerializer < ActiveModel::Serializer
-  attributes :title, :body
+PostPreviewSerializer = Class.new(ActiveModel::Serializer) do
+  def self.root_name
+    'posts'
+  end
+
+  attributes :title, :body, :id
 
-  has_many :comments
+  has_many :comments, serializer: CommentPreviewSerializer
+  belongs_to :author, serializer: AuthorPreviewSerializer
 end
 
-ActiveModel::Serializer.setup do |config|
-  config.default_key_type = nil
+Spam::UnrelatedLinkSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
 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::Json, 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,106 @@
+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
+    end
+  end
+end

data/test/serializers/attribute_test.rb

@@ -0,0 +1,23 @@
+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({:id=>1, :title=>"AMS Hints"}, adapter.serializable_hash)
+      end
+    end
+  end
+end
+

data/test/serializers/attributes_test.rb

@@ -0,0 +1,28 @@
+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)
+      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
+    end
+  end
+end