active_model_serializers 0.10.0 → 0.10.5

data/test/fixtures/poro.rb

@@ -1,25 +1,28 @@
-verbose = $VERBOSE
-$VERBOSE = nil
 class Model < ActiveModelSerializers::Model
-  FILE_DIGEST = Digest::MD5.hexdigest(File.open(__FILE__).read)
+  rand(2).zero? && derive_attributes_from_names_and_fix_accessors
 
-  ### Helper methods, not required to be serializable
+  attr_writer :id
 
-  # Convenience when not adding @attributes readers and writers
-  def method_missing(meth, *args)
-    if meth.to_s =~ /^(.*)=$/
-      attributes[$1.to_sym] = args[0]
-    elsif attributes.key?(meth)
-      attributes[meth]
-    else
-      super
+  # At this time, just for organization of intent
+  class_attribute :association_names
+  self.association_names = []
+
+  def self.associations(*names)
+    self.association_names |= names.map(&:to_sym)
+    # Silence redefinition of methods warnings
+    ActiveModelSerializers.silence_warnings do
+      attr_accessor(*names)
     end
   end
 
-  # required for ActiveModel::AttributeAssignment#_assign_attribute
-  # in Rails 5
-  def respond_to_missing?(method_name, _include_private = false)
-    attributes.key?(method_name.to_s.tr('=', '').to_sym) || super
+  def associations
+    association_names.each_with_object({}) do |association_name, result|
+      result[association_name] = public_send(association_name).freeze
+    end.with_indifferent_access.freeze
+  end
+
+  def attributes
+    super.except(*association_names)
   end
 end
 
@@ -30,67 +33,60 @@ end
 #   model = ModelWithErrors.new
 #   model.validate!            # => ["cannot be nil"]
 #   model.errors.full_messages # => ["name cannot be nil"]
-class ModelWithErrors < ::ActiveModelSerializers::Model
-  attr_accessor :name
+class ModelWithErrors < Model
+  attributes :name
 end
 
 class Profile < Model
+  attributes :name, :description
+  associations :comments
 end
-
 class ProfileSerializer < ActiveModel::Serializer
   attributes :name, :description
-
-  # TODO: is this used anywhere?
-  def arguments_passed_in?
-    instance_options[:my_options] == :accessible
-  end
 end
-
 class ProfilePreviewSerializer < ActiveModel::Serializer
   attributes :name
 end
 
-Post     = Class.new(Model)
-Like     = 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)
-Tag      = Class.new(Model)
-VirtualValue = Class.new(Model)
-Comment = Class.new(Model) do
-  # Uses a custom non-time-based cache key
-  def cache_key
-    "#{self.class.name.downcase}/#{self.id}"
-  end
+class Author < Model
+  attributes :name
+  associations :posts, :bio, :roles, :comments
 end
+class AuthorSerializer < ActiveModel::Serializer
+  cache key: 'writer', skip_digest: true
+  attribute :id
+  attribute :name
 
-class Employee < ActiveRecord::Base
-  has_many :pictures, as: :imageable
-  has_many :object_tags, as: :taggable
+  has_many :posts
+  has_many :roles
+  has_one :bio
 end
-
-class ObjectTag < ActiveRecord::Base
-  belongs_to :poly_tag
-  belongs_to :taggable, polymorphic: true
+class AuthorPreviewSerializer < ActiveModel::Serializer
+  attributes :id
+  has_many :posts
 end
 
-class Picture < ActiveRecord::Base
-  belongs_to :imageable, polymorphic: true
-  has_many :object_tags, as: :taggable
+class Comment < Model
+  attributes :body, :date
+  associations :post, :author, :likes
 end
-
-class PolyTag < ActiveRecord::Base
-  has_many :object_tags
+class CommentSerializer < ActiveModel::Serializer
+  cache expires_in: 1.day, skip_digest: true
+  attributes :id, :body
+  belongs_to :post
+  belongs_to :author
 end
+class CommentPreviewSerializer < ActiveModel::Serializer
+  attributes :id
 
-module Spam; end
-Spam::UnrelatedLink = Class.new(Model)
+  belongs_to :post
+end
 
-PostSerializer = Class.new(ActiveModel::Serializer) do
+class Post < Model
+  attributes :title, :body
+  associations :author, :comments, :blog, :tags, :related
+end
+class PostSerializer < ActiveModel::Serializer
   cache key: 'post', expires_in: 0.1, skip_digest: true
   attributes :id, :title, :body
 
@@ -101,143 +97,116 @@ PostSerializer = Class.new(ActiveModel::Serializer) do
   def blog
     Blog.new(id: 999, name: 'Custom blog')
   end
-
-  # TODO: is this used anywhere?
-  def custom_options
-    instance_options
-  end
 end
-
-SpammyPostSerializer = Class.new(ActiveModel::Serializer) do
+class SpammyPostSerializer < ActiveModel::Serializer
   attributes :id
   has_many :related
 end
+class PostPreviewSerializer < ActiveModel::Serializer
+  attributes :title, :body, :id
 
-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
-    instance_options
-  end
-end
-
-AuthorSerializer = Class.new(ActiveModel::Serializer) do
-  cache key: 'writer', skip_digest: true
-  attribute :id
-  attribute :name
-
-  has_many :posts
-  has_many :roles
-  has_one :bio
-end
-
-RoleSerializer = Class.new(ActiveModel::Serializer) do
-  cache only: [:name], skip_digest: true
-  attributes :id, :name, :description, :slug
-
-  def slug
-    "#{object.name}-#{object.id}"
-  end
-
-  belongs_to :author
-end
-
-LikeSerializer = Class.new(ActiveModel::Serializer) do
-  attributes :id, :time
-
-  belongs_to :likeable
+  has_many :comments, serializer: ::CommentPreviewSerializer
+  belongs_to :author, serializer: ::AuthorPreviewSerializer
 end
-
-LocationSerializer = Class.new(ActiveModel::Serializer) do
-  cache only: [:place], skip_digest: true
-  attributes :id, :lat, :lng
-
-  belongs_to :place
-
-  def place
-    'Nowhere'
-  end
+class PostWithCustomKeysSerializer < ActiveModel::Serializer
+  attributes :id
+  has_many :comments, key: :reviews
+  belongs_to :author, key: :writer
+  has_one :blog, key: :site
 end
 
-PlaceSerializer = Class.new(ActiveModel::Serializer) do
-  attributes :id, :name
-
-  has_many :locations
+class Bio < Model
+  attributes :content, :rating
+  associations :author
 end
-
-BioSerializer = Class.new(ActiveModel::Serializer) do
+class BioSerializer < ActiveModel::Serializer
   cache except: [:content], skip_digest: true
   attributes :id, :content, :rating
 
   belongs_to :author
 end
 
-BlogSerializer = Class.new(ActiveModel::Serializer) do
+class Blog < Model
+  attributes :name, :type, :special_attribute
+  associations :writer, :articles
+end
+class BlogSerializer < ActiveModel::Serializer
   cache key: 'blog'
   attributes :id, :name
 
   belongs_to :writer
   has_many :articles
 end
-
-PaginatedSerializer = Class.new(ActiveModel::Serializer::CollectionSerializer) do
-  def json_key
-    'paginated'
-  end
-end
-
-AlternateBlogSerializer = Class.new(ActiveModel::Serializer) do
+class AlternateBlogSerializer < ActiveModel::Serializer
   attribute :id
   attribute :name, key: :title
 end
-
-CustomBlogSerializer = Class.new(ActiveModel::Serializer) do
+class CustomBlogSerializer < ActiveModel::Serializer
   attribute :id
   attribute :special_attribute
-
   has_many :articles
 end
 
-CommentPreviewSerializer = Class.new(ActiveModel::Serializer) do
-  attributes :id
-
-  belongs_to :post
+class Role < Model
+  attributes :name, :description, :special_attribute
+  associations :author
 end
+class RoleSerializer < ActiveModel::Serializer
+  cache only: [:name, :slug], skip_digest: true
+  attributes :id, :name, :description
+  attribute :friendly_id, key: :slug
+  belongs_to :author
 
-AuthorPreviewSerializer = Class.new(ActiveModel::Serializer) do
-  attributes :id
+  def friendly_id
+    "#{object.name}-#{object.id}"
+  end
+end
 
-  has_many :posts
+class Location < Model
+  attributes :lat, :lng
+  associations :place
 end
+class LocationSerializer < ActiveModel::Serializer
+  cache only: [:address], skip_digest: true
+  attributes :id, :lat, :lng
 
-PostPreviewSerializer = Class.new(ActiveModel::Serializer) do
-  attributes :title, :body, :id
+  belongs_to :place, key: :address
 
-  has_many :comments, serializer: CommentPreviewSerializer
-  belongs_to :author, serializer: AuthorPreviewSerializer
+  def place
+    'Nowhere'
+  end
 end
 
-PostWithTagsSerializer = Class.new(ActiveModel::Serializer) do
-  attributes :id
-
-  has_many :tags
+class Place < Model
+  attributes :name
+  associations :locations
+end
+class PlaceSerializer < ActiveModel::Serializer
+  attributes :id, :name
+  has_many :locations
 end
 
-PostWithCustomKeysSerializer = Class.new(ActiveModel::Serializer) do
-  attributes :id
+class Like < Model
+  attributes :time
+  associations :likeable
+end
+class LikeSerializer < ActiveModel::Serializer
+  attributes :id, :time
+  belongs_to :likeable
+end
 
-  has_many :comments, key: :reviews
-  belongs_to :author, key: :writer
-  has_one :blog, key: :site
+module Spam
+  class UnrelatedLink < Model
+  end
+  class UnrelatedLinkSerializer < ActiveModel::Serializer
+    cache only: [:id]
+    attributes :id
+  end
 end
 
-VirtualValueSerializer = Class.new(ActiveModel::Serializer) do
+class VirtualValue < Model; end
+class VirtualValueSerializer < ActiveModel::Serializer
   attributes :id
-
   has_many :reviews, virtual_value: [{ type: 'reviews', id: '1' },
                                      { type: 'reviews', id: '2' }]
   has_one :maker, virtual_value: { type: 'makers', id: '1' }
@@ -249,34 +218,8 @@ VirtualValueSerializer = Class.new(ActiveModel::Serializer) do
   end
 end
 
-PolymorphicHasManySerializer = Class.new(ActiveModel::Serializer) do
-  attributes :id, :name
-end
-
-PolymorphicBelongsToSerializer = Class.new(ActiveModel::Serializer) do
-  attributes :id, :title
-
-  has_one :imageable, serializer: PolymorphicHasManySerializer, polymorphic: true
-end
-
-PolymorphicSimpleSerializer = Class.new(ActiveModel::Serializer) do
-  attributes :id
-end
-
-PolymorphicObjectTagSerializer = Class.new(ActiveModel::Serializer) do
-  attributes :id
-
-  has_many :taggable, serializer: PolymorphicSimpleSerializer, polymorphic: true
-end
-
-PolymorphicTagSerializer = Class.new(ActiveModel::Serializer) do
-  attributes :id, :phrase
-
-  has_many :object_tags, serializer: PolymorphicObjectTagSerializer
-end
-
-Spam::UnrelatedLinkSerializer = Class.new(ActiveModel::Serializer) do
-  cache only: [:id]
-  attributes :id
+class PaginatedSerializer < ActiveModel::Serializer::CollectionSerializer
+  def json_key
+    'paginated'
+  end
 end
-$VERBOSE = verbose

data/test/generators/serializer_generator_test.rb

@@ -20,11 +20,10 @@ class SerializerGeneratorTest < Rails::Generators::TestCase
   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
+    stub_safe_constantize(expected: 'ApplicationSerializer') do
+      run_generator
+      assert_file 'app/serializers/account_serializer.rb', /class AccountSerializer < ApplicationSerializer/
+    end
   end
 
   def test_uses_given_parent
@@ -54,4 +53,23 @@ class SerializerGeneratorTest < Rails::Generators::TestCase
       end
     end
   end
+
+  private
+
+  def stub_safe_constantize(expected:)
+    String.class_eval do
+      alias_method :old, :safe_constantize
+    end
+    String.send(:define_method, :safe_constantize) do
+      Class if self == expected
+    end
+
+    yield
+  ensure
+    String.class_eval do
+      undef_method :safe_constantize
+      alias_method :safe_constantize, :old
+      undef_method :old
+    end
+  end
 end

data/test/grape_test.rb

@@ -1,82 +1,196 @@
 require 'test_helper'
-require 'grape'
+TestHelper.silence_warnings do
+  require 'grape'
+end
 require 'grape/active_model_serializers'
+require 'kaminari'
+require 'kaminari/hooks'
+::Kaminari::Hooks.init
+
+module ActiveModelSerializers
+  class GrapeTest < ActiveSupport::TestCase
+    include Rack::Test::Methods
+    module Models
+      def self.model1
+        ARModels::Post.new(id: 1, title: 'Dummy Title', body: 'Lorem Ipsum')
+      end
 
-class ActiveModelSerializers::GrapeTest < ActiveSupport::TestCase
-  include Rack::Test::Methods
-  module Models
-    def self.model1
-      ARModels::Post.new(id: 1, title: 'Dummy Title', body: 'Lorem Ipsum')
-    end
+      def self.model2
+        ARModels::Post.new(id: 2, title: 'Second Dummy Title', body: 'Second Lorem Ipsum')
+      end
 
-    def self.model2
-      ARModels::Post.new(id: 2, title: 'Second Dummy Title', body: 'Second Lorem Ipsum')
-    end
+      def self.all
+        @all ||=
+          begin
+            model1.save!
+            model2.save!
+            ARModels::Post.all
+          end
+      end
 
-    def self.all
-      @all ||=
-        begin
-          model1.save!
-          model2.save!
-          ARModels::Post.all
-        end
+      def self.reset_all
+        ARModels::Post.delete_all
+        @all = nil
+      end
+
+      def self.collection_per
+        2
+      end
+
+      def self.collection
+        @collection ||=
+          begin
+            Kaminari.paginate_array(
+              [
+                Profile.new(id: 1, name: 'Name 1', description: 'Description 1', comments: 'Comments 1'),
+                Profile.new(id: 2, name: 'Name 2', description: 'Description 2', comments: 'Comments 2'),
+                Profile.new(id: 3, name: 'Name 3', description: 'Description 3', comments: 'Comments 3'),
+                Profile.new(id: 4, name: 'Name 4', description: 'Description 4', comments: 'Comments 4'),
+                Profile.new(id: 5, name: 'Name 5', description: 'Description 5', comments: 'Comments 5')
+              ]
+            ).page(1).per(collection_per)
+          end
+      end
     end
-  end
 
-  class GrapeTest < Grape::API
-    format :json
-    include Grape::ActiveModelSerializers
+    class GrapeTest < Grape::API
+      format :json
+      TestHelper.silence_warnings do
+        include Grape::ActiveModelSerializers
+      end
 
-    resources :grape do
-      get '/render' do
-        render Models.model1
+      def self.resources(*)
+        TestHelper.silence_warnings do
+          super
+        end
       end
 
-      get '/render_with_json_api' do
-        post = Models.model1
-        render post, meta: { page: 1, total_pages: 2 }, adapter: :json_api
+      resources :grape do
+        get '/render' do
+          render Models.model1
+        end
+
+        get '/render_with_json_api' do
+          post = Models.model1
+          render post, meta: { page: 1, total_pages: 2 }, adapter: :json_api
+        end
+
+        get '/render_array_with_json_api' do
+          posts = Models.all
+          render posts, adapter: :json_api
+        end
+
+        get '/render_collection_with_json_api' do
+          posts = Models.collection
+          render posts, adapter: :json_api
+        end
+
+        get '/render_with_implicit_formatter' do
+          Models.model1
+        end
+
+        get '/render_array_with_implicit_formatter' do
+          Models.all
+        end
+
+        get '/render_collection_with_implicit_formatter' do
+          Models.collection
+        end
       end
+    end
+
+    def app
+      Grape::Middleware::Globals.new(GrapeTest.new)
+    end
 
-      get '/render_array_with_json_api' do
-        posts = Models.all
-        render posts, adapter: :json_api
+    extend Minitest::Assertions
+    def self.run_one_method(*)
+      _, stderr = capture_io do
+        super
       end
+      fail Minitest::Assertion, stderr if stderr !~ /grape/
     end
-  end
 
-  def app
-    GrapeTest.new
-  end
+    def test_formatter_returns_json
+      get '/grape/render'
+
+      post = Models.model1
+      serializable_resource = serializable(post)
 
-  def test_formatter_returns_json
-    get '/grape/render'
+      assert last_response.ok?
+      assert_equal serializable_resource.to_json, last_response.body
+    end
 
-    post = Models.model1
-    serializable_resource = serializable(post)
+    def test_render_helper_passes_through_options_correctly
+      get '/grape/render_with_json_api'
 
-    assert last_response.ok?
-    assert_equal serializable_resource.to_json, last_response.body
-  end
+      post = Models.model1
+      serializable_resource = serializable(post, serializer: ARModels::PostSerializer, adapter: :json_api, meta: { page: 1, total_pages: 2 })
 
-  def test_render_helper_passes_through_options_correctly
-    get '/grape/render_with_json_api'
+      assert last_response.ok?
+      assert_equal serializable_resource.to_json, last_response.body
+    end
 
-    post = Models.model1
-    serializable_resource = serializable(post, serializer: ARModels::PostSerializer, adapter: :json_api, meta: { page: 1, total_pages: 2 })
+    def test_formatter_handles_arrays
+      get '/grape/render_array_with_json_api'
 
-    assert last_response.ok?
-    assert_equal serializable_resource.to_json, last_response.body
-  end
+      posts = Models.all
+      serializable_resource = serializable(posts, adapter: :json_api)
 
-  def test_formatter_handles_arrays
-    get '/grape/render_array_with_json_api'
+      assert last_response.ok?
+      assert_equal serializable_resource.to_json, last_response.body
+    ensure
+      Models.reset_all
+    end
+
+    def test_formatter_handles_collections
+      get '/grape/render_collection_with_json_api'
+      assert last_response.ok?
 
-    posts = Models.all
-    serializable_resource = serializable(posts, adapter: :json_api)
+      representation = JSON.parse(last_response.body)
+      assert representation.include?('data')
+      assert representation['data'].count == Models.collection_per
+      assert representation.include?('links')
+      assert representation['links'].count > 0
+    end
 
-    assert last_response.ok?
-    assert_equal serializable_resource.to_json, last_response.body
-  ensure
-    ARModels::Post.delete_all
+    def test_implicit_formatter
+      post = Models.model1
+      serializable_resource = serializable(post, adapter: :json_api)
+
+      with_adapter :json_api do
+        get '/grape/render_with_implicit_formatter'
+      end
+
+      assert last_response.ok?
+      assert_equal serializable_resource.to_json, last_response.body
+    end
+
+    def test_implicit_formatter_handles_arrays
+      posts = Models.all
+      serializable_resource = serializable(posts, adapter: :json_api)
+
+      with_adapter :json_api do
+        get '/grape/render_array_with_implicit_formatter'
+      end
+
+      assert last_response.ok?
+      assert_equal serializable_resource.to_json, last_response.body
+    ensure
+      Models.reset_all
+    end
+
+    def test_implicit_formatter_handles_collections
+      with_adapter :json_api do
+        get '/grape/render_collection_with_implicit_formatter'
+      end
+
+      representation = JSON.parse(last_response.body)
+      assert last_response.ok?
+      assert representation.include?('data')
+      assert representation['data'].count == Models.collection_per
+      assert representation.include?('links')
+      assert representation['links'].count > 0
+    end
   end
 end