active_model_serializers 0.10.0 → 0.10.7

data/test/action_controller/namespace_lookup_test.rb

@@ -0,0 +1,232 @@
+require 'test_helper'
+
+module ActionController
+  module Serialization
+    class NamespaceLookupTest < ActionController::TestCase
+      class Book < ::Model
+        attributes :id, :title, :body
+        associations :writer, :chapters
+      end
+      class Chapter < ::Model
+        attributes :title
+      end
+      class Writer < ::Model
+        attributes :name
+      end
+
+      module Api
+        module V2
+          class BookSerializer < ActiveModel::Serializer
+            attributes :title
+          end
+        end
+
+        module VHeader
+          class BookSerializer < ActiveModel::Serializer
+            attributes :title, :body
+
+            def body
+              'header'
+            end
+          end
+        end
+
+        module V3
+          class BookSerializer < ActiveModel::Serializer
+            attributes :title, :body
+
+            belongs_to :writer
+            has_many :chapters
+          end
+
+          class ChapterSerializer < ActiveModel::Serializer
+            attribute :title do
+              "Chapter - #{object.title}"
+            end
+          end
+
+          class WriterSerializer < ActiveModel::Serializer
+            attributes :name
+          end
+
+          class LookupTestController < ActionController::Base
+            before_action only: [:namespace_set_in_before_filter] do
+              self.namespace_for_serializer = Api::V2
+            end
+
+            def implicit_namespaced_serializer
+              writer = Writer.new(name: 'Bob')
+              book = Book.new(title: 'New Post', body: 'Body', writer: writer, chapters: [])
+
+              render json: book
+            end
+
+            def implicit_namespaced_collection_serializer
+              chapter1 = Chapter.new(title: 'Oh')
+              chapter2 = Chapter.new(title: 'Oh my')
+
+              render json: [chapter1, chapter2]
+            end
+
+            def implicit_has_many_namespaced_serializer
+              chapter1 = Chapter.new(title: 'Odd World')
+              chapter2 = Chapter.new(title: 'New World')
+              book = Book.new(title: 'New Post', body: 'Body', chapters: [chapter1, chapter2])
+
+              render json: book
+            end
+
+            def explicit_namespace_as_module
+              book = Book.new(title: 'New Post', body: 'Body')
+
+              render json: book, namespace: Api::V2
+            end
+
+            def explicit_namespace_as_string
+              book = Book.new(title: 'New Post', body: 'Body')
+
+              # because this is a string, ruby can't auto-lookup the constant, so otherwise
+              # the lookup thinks we mean ::Api::V2
+              render json: book, namespace: 'ActionController::Serialization::NamespaceLookupTest::Api::V2'
+            end
+
+            def explicit_namespace_as_symbol
+              book = Book.new(title: 'New Post', body: 'Body')
+
+              # because this is a string, ruby can't auto-lookup the constant, so otherwise
+              # the lookup thinks we mean ::Api::V2
+              render json: book, namespace: :'ActionController::Serialization::NamespaceLookupTest::Api::V2'
+            end
+
+            def invalid_namespace
+              book = Book.new(id: 'invalid_namespace_book_id', title: 'New Post', body: 'Body')
+
+              render json: book, namespace: :api_v2
+            end
+
+            def namespace_set_in_before_filter
+              book = Book.new(title: 'New Post', body: 'Body')
+              render json: book
+            end
+
+            def namespace_set_by_request_headers
+              book = Book.new(title: 'New Post', body: 'Body')
+              version_from_header = request.headers['X-API_VERSION']
+              namespace = "ActionController::Serialization::NamespaceLookupTest::#{version_from_header}"
+
+              render json: book, namespace: namespace
+            end
+          end
+        end
+      end
+
+      tests Api::V3::LookupTestController
+
+      setup do
+        @test_namespace = self.class.parent
+      end
+
+      test 'uses request headers to determine the namespace' do
+        request.env['X-API_VERSION'] = 'Api::VHeader'
+        get :namespace_set_by_request_headers
+
+        assert_serializer Api::VHeader::BookSerializer
+      end
+
+      test 'implicitly uses namespaced serializer' do
+        get :implicit_namespaced_serializer
+
+        assert_serializer Api::V3::BookSerializer
+
+        expected = { 'title' => 'New Post', 'body' => 'Body', 'writer' => { 'name' => 'Bob' }, 'chapters' => [] }
+        actual = JSON.parse(@response.body)
+
+        assert_equal expected, actual
+      end
+
+      test 'implicitly uses namespaced serializer for collection' do
+        get :implicit_namespaced_collection_serializer
+
+        assert_serializer 'ActiveModel::Serializer::CollectionSerializer'
+
+        expected = [{ 'title' => 'Chapter - Oh' }, { 'title' => 'Chapter - Oh my' }]
+        actual = JSON.parse(@response.body)
+
+        assert_equal expected, actual
+      end
+
+      test 'implicitly uses namespaced serializer for has_many' do
+        get :implicit_has_many_namespaced_serializer
+
+        assert_serializer Api::V3::BookSerializer
+
+        expected = {
+          'title' => 'New Post',
+          'body' => 'Body', 'writer' => nil,
+          'chapters' => [
+            { 'title' => 'Chapter - Odd World' },
+            { 'title' => 'Chapter - New World' }
+          ]
+        }
+        actual = JSON.parse(@response.body)
+
+        assert_equal expected, actual
+      end
+
+      test 'explicit namespace as module' do
+        get :explicit_namespace_as_module
+
+        assert_serializer Api::V2::BookSerializer
+
+        expected = { 'title' => 'New Post' }
+        actual = JSON.parse(@response.body)
+
+        assert_equal expected, actual
+      end
+
+      test 'explicit namespace as string' do
+        get :explicit_namespace_as_string
+
+        assert_serializer Api::V2::BookSerializer
+
+        expected = { 'title' => 'New Post' }
+        actual = JSON.parse(@response.body)
+
+        assert_equal expected, actual
+      end
+
+      test 'explicit namespace as symbol' do
+        get :explicit_namespace_as_symbol
+
+        assert_serializer Api::V2::BookSerializer
+
+        expected = { 'title' => 'New Post' }
+        actual = JSON.parse(@response.body)
+
+        assert_equal expected, actual
+      end
+
+      test 'invalid namespace' do
+        get :invalid_namespace
+
+        assert_serializer ActiveModel::Serializer::Null
+
+        expected = { 'id' => 'invalid_namespace_book_id', 'title' => 'New Post', 'body' => 'Body' }
+        actual = JSON.parse(@response.body)
+
+        assert_equal expected, actual
+      end
+
+      test 'namespace set in before filter' do
+        get :namespace_set_in_before_filter
+
+        assert_serializer Api::V2::BookSerializer
+
+        expected = { 'title' => 'New Post' }
+        actual = JSON.parse(@response.body)
+
+        assert_equal expected, actual
+      end
+    end
+  end
+end

data/test/action_controller/serialization_scope_name_test.rb

@@ -2,16 +2,16 @@ require 'test_helper'
 
 module SerializationScopeTesting
   class User < ActiveModelSerializers::Model
-    attr_accessor :id, :name, :admin
+    attributes :id, :name, :admin
     def admin?
       admin
     end
   end
   class Comment < ActiveModelSerializers::Model
-    attr_accessor :id, :body
+    attributes :id, :body
   end
   class Post < ActiveModelSerializers::Model
-    attr_accessor :id, :title, :body, :comments
+    attributes :id, :title, :body, :comments
   end
   class PostSerializer < ActiveModel::Serializer
     attributes :id, :title, :body, :comments
@@ -33,7 +33,8 @@ module SerializationScopeTesting
     end
   end
   class PostTestController < ActionController::Base
-    attr_accessor :current_user
+    attr_writer :current_user
+
     def render_post_by_non_admin
       self.current_user = User.new(id: 3, name: 'Pete', admin: false)
       render json: new_post, serializer: serializer, adapter: :json
@@ -44,6 +45,10 @@ module SerializationScopeTesting
       render json: new_post, serializer: serializer, adapter: :json
     end
 
+    def current_user
+      defined?(@current_user) ? @current_user : :current_user_not_set
+    end
+
     private
 
     def new_post
@@ -75,7 +80,8 @@ module SerializationScopeTesting
     end
 
     def test_default_serialization_scope_object
-      assert_equal @controller.current_user, @controller.serialization_scope
+      assert_equal :current_user_not_set, @controller.current_user
+      assert_equal :current_user_not_set, @controller.serialization_scope
     end
 
     def test_default_scope_non_admin
@@ -125,7 +131,7 @@ module SerializationScopeTesting
     end
 
     def test_defined_serialization_scope_object
-      assert_equal @controller.view_context.class, @controller.serialization_scope.class
+      assert_equal @controller.view_context.controller, @controller.serialization_scope.controller
     end
 
     def test_serialization_scope_non_admin

data/test/action_controller/serialization_test.rb

@@ -74,7 +74,7 @@ module ActionController
         end
 
         def update_and_render_object_with_cache_enabled
-          @post.updated_at = Time.now
+          @post.updated_at = Time.zone.now
 
           generate_cached_serializer(@post)
           render json: @post
@@ -135,7 +135,7 @@ module ActionController
           like = Like.new(id: 1, likeable: comment, time: 3.days.ago)
 
           generate_cached_serializer(like)
-          like.likable = comment2
+          like.likeable = comment2
           like.time = Time.zone.now.to_s
 
           render json: like
@@ -163,7 +163,7 @@ module ActionController
         end
         expected = {
           data: {
-            id: assigns(:profile).id.to_s,
+            id: @controller.instance_variable_get(:@profile).id.to_s,
             type: 'profiles',
             attributes: {
               name: 'Name 1',
@@ -246,7 +246,7 @@ module ActionController
         expected = {
           data: [
             {
-              id: assigns(:profiles).first.id.to_s,
+              id: @controller.instance_variable_get(:@profiles).first.id.to_s,
               type: 'profiles',
               attributes: {
                 name: 'Name 1',
@@ -269,7 +269,7 @@ module ActionController
         expected = {
           data: [
             {
-              id: assigns(:profiles).first.id.to_s,
+              id: @controller.instance_variable_get(:@profiles).first.id.to_s,
               type: 'profiles',
               attributes: {
                 name: 'Name 1',
@@ -294,7 +294,8 @@ module ActionController
           comments: [
             {
               id: 1,
-              body: 'ZOMG A COMMENT' }
+              body: 'ZOMG A COMMENT'
+            }
           ],
           blog: {
             id: 999,
@@ -333,7 +334,8 @@ module ActionController
           comments: [
             {
               id: 1,
-              body: 'ZOMG A COMMENT' }
+              body: 'ZOMG A COMMENT'
+            }
           ],
           blog: {
             id: 999,
@@ -407,7 +409,8 @@ module ActionController
           comments: [
             {
               id: 1,
-              body: 'ZOMG A COMMENT' }
+              body: 'ZOMG A COMMENT'
+            }
           ],
           blog: {
             id: 999,
@@ -453,7 +456,7 @@ module ActionController
         end
       end
 
-      def test_render_event_is_emmited
+      def test_render_event_is_emitted
         subscriber = ::ActiveSupport::Notifications.subscribe('render.active_model_serializers') do |name|
           @name = name
         end

data/test/active_model_serializers/json_pointer_test.rb

@@ -1,20 +1,22 @@
 require 'test_helper'
 
-class ActiveModelSerializers::JsonPointerTest < ActiveSupport::TestCase
-  def test_attribute_pointer
-    attribute_name = 'title'
-    pointer = ActiveModelSerializers::JsonPointer.new(:attribute, attribute_name)
-    assert_equal '/data/attributes/title', pointer
-  end
+module ActiveModelSerializers
+  class JsonPointerTest < ActiveSupport::TestCase
+    def test_attribute_pointer
+      attribute_name = 'title'
+      pointer = ActiveModelSerializers::JsonPointer.new(:attribute, attribute_name)
+      assert_equal '/data/attributes/title', pointer
+    end
 
-  def test_primary_data_pointer
-    pointer = ActiveModelSerializers::JsonPointer.new(:primary_data)
-    assert_equal '/data', pointer
-  end
+    def test_primary_data_pointer
+      pointer = ActiveModelSerializers::JsonPointer.new(:primary_data)
+      assert_equal '/data', pointer
+    end
 
-  def test_unkown_data_pointer
-    assert_raises(TypeError) do
-      ActiveModelSerializers::JsonPointer.new(:unknown)
+    def test_unknown_data_pointer
+      assert_raises(TypeError) do
+        ActiveModelSerializers::JsonPointer.new(:unknown)
+      end
     end
   end
 end

data/test/active_model_serializers/model_test.rb

@@ -1,9 +1,142 @@
 require 'test_helper'
 
-class ActiveModelSerializers::ModelTest < ActiveSupport::TestCase
-  include ActiveModel::Serializer::Lint::Tests
+module ActiveModelSerializers
+  class ModelTest < ActiveSupport::TestCase
+    include ActiveModel::Serializer::Lint::Tests
 
-  def setup
-    @resource = ActiveModelSerializers::Model.new
+    setup do
+      @resource = ActiveModelSerializers::Model.new
+    end
+
+    def test_initialization_with_string_keys
+      klass = Class.new(ActiveModelSerializers::Model) do
+        attributes :key
+      end
+      value = 'value'
+
+      model_instance = klass.new('key' => value)
+
+      assert_equal model_instance.read_attribute_for_serialization(:key), value
+    end
+
+    def test_attributes_can_be_read_for_serialization
+      klass = Class.new(ActiveModelSerializers::Model) do
+        attributes :one, :two, :three
+      end
+      original_attributes = { one: 1, two: 2, three: 3 }
+      original_instance = klass.new(original_attributes)
+
+      # Initial value
+      instance = original_instance
+      expected_attributes = { one: 1, two: 2, three: 3 }.with_indifferent_access
+      assert_equal expected_attributes, instance.attributes
+      assert_equal 1, instance.one
+      assert_equal 1, instance.read_attribute_for_serialization(:one)
+
+      # FIXME: Change via accessor has no effect on attributes.
+      instance = original_instance.dup
+      instance.one = :not_one
+      assert_equal expected_attributes, instance.attributes
+      assert_equal :not_one, instance.one
+      assert_equal :not_one, instance.read_attribute_for_serialization(:one)
+
+      # FIXME: Change via mutating attributes
+      instance = original_instance.dup
+      instance.attributes[:one] = :not_one
+      expected_attributes = { one: :not_one, two: 2, three: 3 }.with_indifferent_access
+      assert_equal expected_attributes, instance.attributes
+      assert_equal 1, instance.one
+      assert_equal 1, instance.read_attribute_for_serialization(:one)
+    end
+
+    def test_attributes_can_be_read_for_serialization_with_attributes_accessors_fix
+      klass = Class.new(ActiveModelSerializers::Model) do
+        derive_attributes_from_names_and_fix_accessors
+        attributes :one, :two, :three
+      end
+      original_attributes = { one: 1, two: 2, three: 3 }
+      original_instance = klass.new(original_attributes)
+
+      # Initial value
+      instance = original_instance
+      expected_attributes = { one: 1, two: 2, three: 3 }.with_indifferent_access
+      assert_equal expected_attributes, instance.attributes
+      assert_equal 1, instance.one
+      assert_equal 1, instance.read_attribute_for_serialization(:one)
+
+      expected_attributes = { one: :not_one, two: 2, three: 3 }.with_indifferent_access
+      # Change via accessor
+      instance = original_instance.dup
+      instance.one = :not_one
+      assert_equal expected_attributes, instance.attributes
+      assert_equal :not_one, instance.one
+      assert_equal :not_one, instance.read_attribute_for_serialization(:one)
+
+      # Attributes frozen
+      assert instance.attributes.frozen?
+    end
+
+    def test_id_attribute_can_be_read_for_serialization
+      klass = Class.new(ActiveModelSerializers::Model) do
+        attributes :id, :one, :two, :three
+      end
+      self.class.const_set(:SomeTestModel, klass)
+      original_attributes = { id: :ego, one: 1, two: 2, three: 3 }
+      original_instance = klass.new(original_attributes)
+
+      # Initial value
+      instance = original_instance.dup
+      expected_attributes = { id: :ego, one: 1, two: 2, three: 3 }.with_indifferent_access
+      assert_equal expected_attributes, instance.attributes
+      assert_equal :ego, instance.id
+      assert_equal :ego, instance.read_attribute_for_serialization(:id)
+
+      # FIXME: Change via accessor has no effect on attributes.
+      instance = original_instance.dup
+      instance.id = :superego
+      assert_equal expected_attributes, instance.attributes
+      assert_equal :superego, instance.id
+      assert_equal :superego, instance.read_attribute_for_serialization(:id)
+
+      # FIXME: Change via mutating attributes
+      instance = original_instance.dup
+      instance.attributes[:id] = :superego
+      expected_attributes = { id: :superego, one: 1, two: 2, three: 3 }.with_indifferent_access
+      assert_equal expected_attributes, instance.attributes
+      assert_equal :ego, instance.id
+      assert_equal :ego, instance.read_attribute_for_serialization(:id)
+    ensure
+      self.class.send(:remove_const, :SomeTestModel)
+    end
+
+    def test_id_attribute_can_be_read_for_serialization_with_attributes_accessors_fix
+      klass = Class.new(ActiveModelSerializers::Model) do
+        derive_attributes_from_names_and_fix_accessors
+        attributes :id, :one, :two, :three
+      end
+      self.class.const_set(:SomeTestModel, klass)
+      original_attributes = { id: :ego, one: 1, two: 2, three: 3 }
+      original_instance = klass.new(original_attributes)
+
+      # Initial value
+      instance = original_instance.dup
+      expected_attributes = { id: :ego, one: 1, two: 2, three: 3 }.with_indifferent_access
+      assert_equal expected_attributes, instance.attributes
+      assert_equal :ego, instance.id
+      assert_equal :ego, instance.read_attribute_for_serialization(:id)
+
+      expected_attributes = { id: :superego, one: 1, two: 2, three: 3 }.with_indifferent_access
+      # Change via accessor
+      instance = original_instance.dup
+      instance.id = :superego
+      assert_equal expected_attributes, instance.attributes
+      assert_equal :superego, instance.id
+      assert_equal :superego, instance.read_attribute_for_serialization(:id)
+
+      # Attributes frozen
+      assert instance.attributes.frozen?
+    ensure
+      self.class.send(:remove_const, :SomeTestModel)
+    end
   end
 end

data/test/active_model_serializers/railtie_test_isolated.rb

@@ -4,11 +4,13 @@ require 'support/isolated_unit'
 class RailtieTest < ActiveSupport::TestCase
   include ActiveSupport::Testing::Isolation
 
-  class WithRails < RailtieTest
+  class WithRailsRequiredFirst < RailtieTest
     setup do
       require 'rails'
       require 'active_model_serializers'
-      make_basic_app
+      make_basic_app do |app|
+        app.config.action_controller.perform_caching = true
+      end
     end
 
     test 'mixes ActionController::Serialization into ActionController::Base' do
@@ -32,14 +34,17 @@ class RailtieTest < ActiveSupport::TestCase
 
     test 'it is configured for caching' do
       assert_equal ActionController::Base.cache_store, ActiveModelSerializers.config.cache_store
-      assert_equal Rails.configuration.action_controller.perform_caching, ActiveModelSerializers.config.perform_caching
+      assert_equal true, Rails.configuration.action_controller.perform_caching
+      assert_equal true, ActiveModelSerializers.config.perform_caching
     end
   end
 
-  class WithoutRails < RailtieTest
+  class WithoutRailsRequiredFirst < RailtieTest
     setup do
       require 'active_model_serializers'
-      make_basic_app
+      make_basic_app do |app|
+        app.config.action_controller.perform_caching = true
+      end
     end
 
     test 'does not mix ActionController::Serialization into ActionController::Base' do
@@ -56,8 +61,8 @@ class RailtieTest < ActiveSupport::TestCase
     test 'it is not configured for caching' do
       refute_nil ActionController::Base.cache_store
       assert_nil ActiveModelSerializers.config.cache_store
-      refute Rails.configuration.action_controller.perform_caching
-      refute ActiveModelSerializers.config.perform_caching
+      assert_equal true, Rails.configuration.action_controller.perform_caching
+      assert_nil ActiveModelSerializers.config.perform_caching
     end
   end
 end