active_model_serializers 0.8.3 → 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

@@ -1,75 +1,29 @@
-require "test_helper"
-require "test_fakes"
+require 'test_helper'
 
-class ArraySerializerTest < ActiveModel::TestCase
+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_array_items_do_not_have_root
-    array = [
-        BasicActiveModel.new(:name => "First model"),
-        BasicActiveModel.new(:name => "Second model")
-    ]
-    expected = { "root" => [
-        { :name => "First model" },
-        { :name => "Second model" }
-    ] }
+      def test_respond_to_each
+        assert_respond_to @serializer, :each
+      end
 
-    default_serializer = array.active_model_serializer.new(array, :root => "root")
-    each_serializer = array.active_model_serializer.new(array, :root => "root", :each_serializer => BasicSerializer)
+      def test_each_object_should_be_serialized_with_appropriate_serializer
+        serializers =  @serializer.to_a
 
-    default_json = default_serializer.as_json
-    each_json = each_serializer.as_json
+        assert_kind_of CommentSerializer, serializers.first
+        assert_kind_of Comment, serializers.first.object
 
-    assert_equal(expected, default_json)
-    assert_equal(expected, each_json)
-  end
-
-  # serialize different typed objects
-  def test_array_serializer
-    model    = Model.new
-    user     = User.new
-    comments = Comment.new(:title => "Comment1", :id => 1)
-
-    array = [model, user, comments]
-    serializer = array.active_model_serializer.new(array, :scope => {:scope => true})
-    assert_equal([
-      { :model => "Model" },
-      { :last_name => "Valim", :ok => true, :first_name => "Jose", :scope => true },
-      { :title => "Comment1" }
-    ], serializer.as_json)
-  end
-
-  def test_array_serializer_with_root
-    comment1 = Comment.new(:title => "Comment1", :id => 1)
-    comment2 = Comment.new(:title => "Comment2", :id => 2)
-
-    array = [ comment1, comment2 ]
-
-    serializer = array.active_model_serializer.new(array, :root => :comments)
-
-    assert_equal({ :comments => [
-      { :title => "Comment1" },
-      { :title => "Comment2" }
-    ]}, serializer.as_json)
-  end
-
-  def test_array_serializer_with_hash
-    hash = {:value => "something"}
-    array = [hash]
-    serializer = array.active_model_serializer.new(array, :root => :items)
-    assert_equal({ :items => [ hash.as_json ]}, serializer.as_json)
-  end
-
-  def test_array_serializer_with_specified_seriailizer
-    post1 = Post.new(:title => "Post1", :author => "Author1", :id => 1)
-    post2 = Post.new(:title => "Post2", :author => "Author2", :id => 2)
-
-    array = [ post1, post2 ]
-
-    serializer = array.active_model_serializer.new array, :each_serializer => CustomPostSerializer
+        assert_kind_of PostSerializer, serializers.last
+        assert_kind_of Post, serializers.last.object
 
-    assert_equal([
-      { :title => "Post1" },
-      { :title => "Post2" }
-    ], serializer.as_json)
+        assert_equal serializers.last.custom_options[:some], :options
+      end
+    end
   end
 end

data/test/fixtures/poro.rb

@@ -0,0 +1,206 @@
+class Model
+  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'
+      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
+  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
+  attributes :id, :body
+
+  belongs_to :post
+  belongs_to :author
+
+  def custom_options
+    options
+  end
+end
+
+AuthorSerializer = Class.new(ActiveModel::Serializer) do
+  cache key:'writer'
+  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]
+  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]
+  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]
+  attributes :id, :content, :rating
+
+  belongs_to :author
+end
+
+BlogSerializer = Class.new(ActiveModel::Serializer) do
+  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
+
+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

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