active_model_serializers 0.10.7 → 0.10.10

data/test/action_controller/namespace_lookup_test.rb

@@ -1,232 +0,0 @@
-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

@@ -1,235 +0,0 @@
-require 'test_helper'
-
-module SerializationScopeTesting
-  class User < ActiveModelSerializers::Model
-    attributes :id, :name, :admin
-    def admin?
-      admin
-    end
-  end
-  class Comment < ActiveModelSerializers::Model
-    attributes :id, :body
-  end
-  class Post < ActiveModelSerializers::Model
-    attributes :id, :title, :body, :comments
-  end
-  class PostSerializer < ActiveModel::Serializer
-    attributes :id, :title, :body, :comments
-
-    def body
-      "The 'scope' is the 'current_user': #{scope == current_user}"
-    end
-
-    def comments
-      if current_user.admin?
-        [Comment.new(id: 1, body: 'Admin')]
-      else
-        [Comment.new(id: 2, body: 'Scoped')]
-      end
-    end
-
-    def json_key
-      'post'
-    end
-  end
-  class PostTestController < ActionController::Base
-    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
-    end
-
-    def render_post_by_admin
-      self.current_user = User.new(id: 3, name: 'Pete', admin: true)
-      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
-      Post.new(id: 4, title: 'Title')
-    end
-
-    def serializer
-      PostSerializer
-    end
-  end
-  class PostViewContextSerializer < PostSerializer
-    def body
-      "The 'scope' is the 'view_context': #{scope == view_context}"
-    end
-
-    def comments
-      if view_context.controller.current_user.admin?
-        [Comment.new(id: 1, body: 'Admin')]
-      else
-        [Comment.new(id: 2, body: 'Scoped')]
-      end
-    end
-  end
-  class DefaultScopeTest < ActionController::TestCase
-    tests PostTestController
-
-    def test_default_serialization_scope
-      assert_equal :current_user, @controller._serialization_scope
-    end
-
-    def test_default_serialization_scope_object
-      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
-      get :render_post_by_non_admin
-      expected_json = {
-        post: {
-          id: 4,
-          title: 'Title',
-          body: "The 'scope' is the 'current_user': true",
-          comments: [
-            { id: 2, body: 'Scoped' }
-          ]
-        }
-      }.to_json
-      assert_equal expected_json, @response.body
-    end
-
-    def test_default_scope_admin
-      get :render_post_by_admin
-      expected_json = {
-        post: {
-          id: 4,
-          title: 'Title',
-          body: "The 'scope' is the 'current_user': true",
-          comments: [
-            { id: 1, body: 'Admin' }
-          ]
-        }
-      }.to_json
-      assert_equal expected_json, @response.body
-    end
-  end
-  class SerializationScopeTest < ActionController::TestCase
-    class PostViewContextTestController < PostTestController
-      serialization_scope :view_context
-
-      private
-
-      def serializer
-        PostViewContextSerializer
-      end
-    end
-    tests PostViewContextTestController
-
-    def test_defined_serialization_scope
-      assert_equal :view_context, @controller._serialization_scope
-    end
-
-    def test_defined_serialization_scope_object
-      assert_equal @controller.view_context.controller, @controller.serialization_scope.controller
-    end
-
-    def test_serialization_scope_non_admin
-      get :render_post_by_non_admin
-      expected_json = {
-        post: {
-          id: 4,
-          title: 'Title',
-          body: "The 'scope' is the 'view_context': true",
-          comments: [
-            { id: 2, body: 'Scoped' }
-          ]
-        }
-      }.to_json
-      assert_equal expected_json, @response.body
-    end
-
-    def test_serialization_scope_admin
-      get :render_post_by_admin
-      expected_json = {
-        post: {
-          id: 4,
-          title: 'Title',
-          body: "The 'scope' is the 'view_context': true",
-          comments: [
-            { id: 1, body: 'Admin' }
-          ]
-        }
-      }.to_json
-      assert_equal expected_json, @response.body
-    end
-  end
-  class NilSerializationScopeTest < ActionController::TestCase
-    class PostViewContextTestController < ActionController::Base
-      serialization_scope nil
-
-      attr_accessor :current_user
-
-      def render_post_with_no_scope
-        self.current_user = User.new(id: 3, name: 'Pete', admin: false)
-        render json: new_post, serializer: PostSerializer, adapter: :json
-      end
-
-      def render_post_with_passed_in_scope
-        self.current_user = User.new(id: 3, name: 'Pete', admin: false)
-        render json: new_post, serializer: PostSerializer, adapter: :json, scope: current_user, scope_name: :current_user
-      end
-
-      def render_post_with_passed_in_scope_without_scope_name
-        self.current_user = User.new(id: 3, name: 'Pete', admin: false)
-        render json: new_post, serializer: PostSerializer, adapter: :json, scope: current_user
-      end
-
-      private
-
-      def new_post
-        Post.new(id: 4, title: 'Title')
-      end
-    end
-    tests PostViewContextTestController
-
-    def test_nil_serialization_scope
-      assert_nil @controller._serialization_scope
-    end
-
-    def test_nil_serialization_scope_object
-      assert_nil @controller.serialization_scope
-    end
-
-    def test_nil_scope
-      exception_matcher = /current_user/
-      exception = assert_raises(NameError) do
-        get :render_post_with_no_scope
-      end
-      assert_match exception_matcher, exception.message
-    end
-
-    def test_serialization_scope_is_and_nil_scope_passed_in_current_user
-      get :render_post_with_passed_in_scope
-      expected_json = {
-        post: {
-          id: 4,
-          title: 'Title',
-          body: "The 'scope' is the 'current_user': true",
-          comments: [
-            { id: 2, body: 'Scoped' }
-          ]
-        }
-      }.to_json
-      assert_equal expected_json, @response.body
-    end
-
-    def test_serialization_scope_is_nil_and_scope_passed_in_current_user_without_scope_name
-      exception_matcher = /current_user/
-      exception = assert_raises(NameError) do
-        get :render_post_with_passed_in_scope_without_scope_name
-      end
-      assert_match exception_matcher, exception.message
-    end
-  end
-end