active_model_serializers 0.10.0 → 0.10.11

data/test/adapter/json_api/pagination_links_test.rb

@@ -1,166 +0,0 @@
-require 'test_helper'
-require 'will_paginate/array'
-require 'kaminari'
-require 'kaminari/hooks'
-::Kaminari::Hooks.init
-
-module ActiveModelSerializers
-  module Adapter
-    class JsonApi
-      class PaginationLinksTest < ActiveSupport::TestCase
-        URI = 'http://example.com'.freeze
-
-        def setup
-          ActionController::Base.cache_store.clear
-          @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' })
-          ]
-        end
-
-        def mock_request(query_parameters = {}, original_url = URI)
-          context = Minitest::Mock.new
-          context.expect(:request_url, original_url)
-          context.expect(:query_parameters, query_parameters)
-          context.expect(:key_transform, nil)
-        end
-
-        def load_adapter(paginated_collection, mock_request = nil)
-          render_options = { adapter: :json_api }
-          render_options[:serialization_context] = mock_request if mock_request
-          serializable(paginated_collection, render_options)
-        end
-
-        def using_kaminari(page = 2)
-          Kaminari.paginate_array(@array).page(page).per(2)
-        end
-
-        def using_will_paginate(page = 2)
-          @array.paginate(page: page, per_page: 2)
-        end
-
-        def data
-          { data: [
-              { id: '1', type: 'profiles', attributes: { name: 'Name 1', description: 'Description 1' } },
-              { id: '2', type: 'profiles', attributes: { name: 'Name 2', description: 'Description 2' } },
-              { id: '3', type: 'profiles', attributes: { name: 'Name 3', description: 'Description 3' } },
-              { id: '4', type: 'profiles', attributes: { name: 'Name 4', description: 'Description 4' } },
-              { id: '5', type: 'profiles', attributes: { name: 'Name 5', description: 'Description 5' } }
-            ]
-          }
-        end
-
-        def links
-          {
-            links: {
-              self: "#{URI}?page%5Bnumber%5D=2&page%5Bsize%5D=2",
-              first: "#{URI}?page%5Bnumber%5D=1&page%5Bsize%5D=2",
-              prev: "#{URI}?page%5Bnumber%5D=1&page%5Bsize%5D=2",
-              next: "#{URI}?page%5Bnumber%5D=3&page%5Bsize%5D=2",
-              last: "#{URI}?page%5Bnumber%5D=3&page%5Bsize%5D=2"
-            }
-          }
-        end
-
-        def last_page_links
-          {
-            links: {
-              self: "#{URI}?page%5Bnumber%5D=3&page%5Bsize%5D=2",
-              first: "#{URI}?page%5Bnumber%5D=1&page%5Bsize%5D=2",
-              prev: "#{URI}?page%5Bnumber%5D=2&page%5Bsize%5D=2"
-            }
-          }
-        end
-
-        def expected_response_without_pagination_links
-          data
-        end
-
-        def expected_response_with_pagination_links
-          {}.tap do |hash|
-            hash[:data] = data.values.flatten[2..3]
-            hash.merge! links
-          end
-        end
-
-        def expected_response_with_pagination_links_and_additional_params
-          new_links = links[:links].each_with_object({}) { |(key, value), hash| hash[key] = "#{value}&test=test" }
-          {}.tap do |hash|
-            hash[:data] = data.values.flatten[2..3]
-            hash.merge! links: new_links
-          end
-        end
-
-        def expected_response_with_last_page_pagination_links
-          {}.tap do |hash|
-            hash[:data] = [data.values.flatten.last]
-            hash.merge! last_page_links
-          end
-        end
-
-        def expected_response_with_no_data_pagination_links
-          {}.tap do |hash|
-            hash[:data] = []
-            hash[:links] = {}
-          end
-        end
-
-        def test_pagination_links_using_kaminari
-          adapter = load_adapter(using_kaminari, mock_request)
-
-          assert_equal expected_response_with_pagination_links, adapter.serializable_hash
-        end
-
-        def test_pagination_links_using_will_paginate
-          adapter = load_adapter(using_will_paginate, mock_request)
-
-          assert_equal expected_response_with_pagination_links, adapter.serializable_hash
-        end
-
-        def test_pagination_links_with_additional_params
-          adapter = load_adapter(using_will_paginate, mock_request({ test: 'test' }))
-
-          assert_equal expected_response_with_pagination_links_and_additional_params,
-            adapter.serializable_hash
-        end
-
-        def test_pagination_links_when_zero_results_kaminari
-          @array = []
-
-          adapter = load_adapter(using_kaminari(1), mock_request)
-
-          assert_equal expected_response_with_no_data_pagination_links, adapter.serializable_hash
-        end
-
-        def test_pagination_links_when_zero_results_will_paginate
-          @array = []
-
-          adapter = load_adapter(using_will_paginate(1), mock_request)
-
-          assert_equal expected_response_with_no_data_pagination_links, adapter.serializable_hash
-        end
-
-        def test_last_page_pagination_links_using_kaminari
-          adapter = load_adapter(using_kaminari(3), mock_request)
-
-          assert_equal expected_response_with_last_page_pagination_links, adapter.serializable_hash
-        end
-
-        def test_last_page_pagination_links_using_will_paginate
-          adapter = load_adapter(using_will_paginate(3), mock_request)
-
-          assert_equal expected_response_with_last_page_pagination_links, adapter.serializable_hash
-        end
-
-        def test_not_showing_pagination_links
-          adapter = load_adapter(@array, mock_request)
-
-          assert_equal expected_response_without_pagination_links, adapter.serializable_hash
-        end
-      end
-    end
-  end
-end

data/test/adapter/json_api/parse_test.rb

@@ -1,137 +0,0 @@
-require 'test_helper'
-module ActiveModelSerializers
-  module Adapter
-    class JsonApi
-      module Deserialization
-        class ParseTest < Minitest::Test
-          def setup
-            @hash = {
-              'data' => {
-                'type' => 'photos',
-                'id' => 'zorglub',
-                'attributes' => {
-                  'title' => 'Ember Hamster',
-                  'src' => 'http://example.com/images/productivity.png'
-                },
-                'relationships' => {
-                  'author' => {
-                    'data' => nil
-                  },
-                  'photographer' => {
-                    'data' => { 'type' => 'people', 'id' => '9' }
-                  },
-                  'comments' => {
-                    'data' => [
-                      { 'type' => 'comments', 'id' => '1' },
-                      { 'type' => 'comments', 'id' => '2' }
-                    ]
-                  }
-                }
-              }
-            }
-            @params = ActionController::Parameters.new(@hash)
-            @expected = {
-              id: 'zorglub',
-              title: 'Ember Hamster',
-              src: 'http://example.com/images/productivity.png',
-              author_id: nil,
-              photographer_id: '9',
-              comment_ids: %w(1 2)
-            }
-
-            @illformed_payloads = [nil,
-                                   {},
-                                   {
-                                     'data' => nil
-                                   }, {
-                                     'data' => { 'attributes' => [] }
-                                   }, {
-                                     'data' => { 'relationships' => [] }
-                                   }, {
-                                     'data' => {
-                                       'relationships' => { 'rel' => nil }
-                                     }
-                                   }, {
-                                     'data' => {
-                                       'relationships' => { 'rel' => {} }
-                                     }
-                                   }]
-          end
-
-          def test_hash
-            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(@hash)
-            assert_equal(@expected, parsed_hash)
-          end
-
-          def test_actioncontroller_parameters
-            assert_equal(false, @params.permitted?)
-            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(@params)
-            assert_equal(@expected, parsed_hash)
-          end
-
-          def test_illformed_payloads_safe
-            @illformed_payloads.each do |p|
-              parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse(p)
-              assert_equal({}, parsed_hash)
-            end
-          end
-
-          def test_illformed_payloads_unsafe
-            @illformed_payloads.each do |p|
-              assert_raises(InvalidDocument) do
-                ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(p)
-              end
-            end
-          end
-
-          def test_filter_fields_only
-            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(@hash, only: [:id, :title, :author])
-            expected = {
-              id: 'zorglub',
-              title: 'Ember Hamster',
-              author_id: nil
-            }
-            assert_equal(expected, parsed_hash)
-          end
-
-          def test_filter_fields_except
-            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(@hash, except: [:id, :title, :author])
-            expected = {
-              src: 'http://example.com/images/productivity.png',
-              photographer_id: '9',
-              comment_ids: %w(1 2)
-            }
-            assert_equal(expected, parsed_hash)
-          end
-
-          def test_keys
-            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(@hash, keys: { author: :user, title: :post_title })
-            expected = {
-              id: 'zorglub',
-              post_title: 'Ember Hamster',
-              src: 'http://example.com/images/productivity.png',
-              user_id: nil,
-              photographer_id: '9',
-              comment_ids: %w(1 2)
-            }
-            assert_equal(expected, parsed_hash)
-          end
-
-          def test_polymorphic
-            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(@hash, polymorphic: [:photographer])
-            expected = {
-              id: 'zorglub',
-              title: 'Ember Hamster',
-              src: 'http://example.com/images/productivity.png',
-              author_id: nil,
-              photographer_id: '9',
-              photographer_type: 'people',
-              comment_ids: %w(1 2)
-            }
-            assert_equal(expected, parsed_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/adapter/json_api/relationship_test.rb

@@ -1,161 +0,0 @@
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class JsonApi
-      class RelationshipTest < ActiveSupport::TestCase
-        setup do
-          @blog = Blog.new(id: 1)
-          @author = Author.new(id: 1, name: 'Steve K.', blog: @blog)
-          @serializer = BlogSerializer.new(@blog)
-          ActionController::Base.cache_store.clear
-        end
-
-        def test_relationship_with_data
-          expected = {
-            data: {
-              id: '1',
-              type: 'blogs'
-            }
-          }
-          test_relationship(expected, options: { include_data: true })
-        end
-
-        def test_relationship_with_nil_model
-          @serializer = BlogSerializer.new(nil)
-          expected = { data: nil }
-          test_relationship(expected, options: { include_data: true })
-        end
-
-        def test_relationship_with_nil_serializer
-          @serializer = nil
-          expected = { data: nil }
-          test_relationship(expected, options: { include_data: true })
-        end
-
-        def test_relationship_with_data_array
-          posts = [Post.new(id: 1), Post.new(id: 2)]
-          @serializer = ActiveModel::Serializer::CollectionSerializer.new(posts)
-          @author.posts = posts
-          @author.blog = nil
-          expected = {
-            data: [
-              {
-                id: '1',
-                type: 'posts'
-              },
-              {
-                id: '2',
-                type: 'posts'
-              }
-            ]
-          }
-          test_relationship(expected, options: { include_data: true })
-        end
-
-        def test_relationship_data_not_included
-          test_relationship({}, options: { include_data: false })
-        end
-
-        def test_relationship_simple_link
-          links = { self: 'a link' }
-          test_relationship({ links: { self: 'a link' } }, links: links)
-        end
-
-        def test_relationship_many_links
-          links = {
-            self: 'a link',
-            related: 'another link'
-          }
-          expected = {
-            links: {
-              self: 'a link',
-              related: 'another link'
-            }
-          }
-          test_relationship(expected, links: links)
-        end
-
-        def test_relationship_block_link
-          links = { self: proc { object.id.to_s } }
-          expected = { links: { self: @blog.id.to_s } }
-          test_relationship(expected, links: links)
-        end
-
-        def test_relationship_block_link_with_meta
-          links = {
-            self: proc do
-              href object.id.to_s
-              meta(id: object.id)
-            end
-          }
-          expected = {
-            links: {
-              self: {
-                href: @blog.id.to_s,
-                meta: { id: @blog.id }
-              }
-            }
-          }
-          test_relationship(expected, links: links)
-        end
-
-        def test_relationship_simple_meta
-          meta = { id: '1' }
-          expected = { meta: meta }
-          test_relationship(expected, meta: meta)
-        end
-
-        def test_relationship_block_meta
-          meta =  proc do
-            { id: object.id }
-          end
-          expected = {
-            meta: {
-              id: @blog.id
-            }
-          }
-          test_relationship(expected, meta: meta)
-        end
-
-        def test_relationship_with_everything
-          links = {
-            self: 'a link',
-            related: proc do
-              href object.id.to_s
-              meta object.id
-            end
-
-          }
-          meta = proc do
-            { id: object.id }
-          end
-          expected = {
-            data: {
-              id: '1',
-              type: 'blogs'
-            },
-            links: {
-              self: 'a link',
-              related: {
-                href: '1', meta: 1
-              }
-            },
-            meta: {
-              id: @blog.id
-            }
-          }
-          test_relationship(expected, meta: meta, options: { include_data: true }, links: links)
-        end
-
-        private
-
-        def test_relationship(expected, params = {})
-          parent_serializer = AuthorSerializer.new(@author)
-          relationship = Relationship.new(parent_serializer, @serializer, nil, params)
-          assert_equal(expected, relationship.as_json)
-        end
-      end
-    end
-  end
-end

data/test/adapter/json_api/relationships_test.rb

@@ -1,199 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    module Adapter
-      class JsonApi
-        class RelationshipTest < ActiveSupport::TestCase
-          RelationshipAuthor = Class.new(::Model)
-          class RelationshipAuthorSerializer < ActiveModel::Serializer
-            has_one :bio do
-              link :self, '//example.com/link_author/relationships/bio'
-            end
-
-            has_one :profile do
-              link :related do
-                "//example.com/profiles/#{object.profile.id}"
-              end
-            end
-
-            has_many :locations do
-              link :related do
-                ids = object.locations.map(&:id).join(',')
-                href "//example.com/locations/#{ids}"
-              end
-            end
-
-            has_many :posts do
-              link :related do
-                ids = object.posts.map(&:id).join(',')
-                href "//example.com/posts/#{ids}"
-                meta ids: ids
-              end
-            end
-
-            has_many :comments do
-              link :self do
-                meta ids: [1]
-              end
-            end
-
-            has_many :roles do |serializer|
-              meta count: object.posts.count
-              serializer.cached_roles
-            end
-
-            has_one :blog do
-              link :self, '//example.com/link_author/relationships/blog'
-              include_data false
-            end
-
-            belongs_to :reviewer do
-              meta name: 'Dan Brown'
-              include_data true
-            end
-
-            has_many :likes do
-              link :related do
-                ids = object.likes.map(&:id).join(',')
-                href "//example.com/likes/#{ids}"
-                meta ids: ids
-              end
-              meta liked: object.likes.any?
-            end
-
-            def cached_roles
-              [
-                Role.new(id: 'from-serializer-method')
-              ]
-            end
-          end
-
-          def setup
-            @post = Post.new(id: 1337, comments: [], author: nil)
-            @blog = Blog.new(id: 1337, name: 'extra')
-            @bio = Bio.new(id: 1337)
-            @like = Like.new(id: 1337)
-            @role = Role.new(id: 'from-record')
-            @profile = Profile.new(id: 1337)
-            @location = Location.new(id: 1337)
-            @reviewer = Author.new(id: 1337)
-            @comment = Comment.new(id: 1337)
-            @author = RelationshipAuthor.new(
-              id: 1337,
-              posts: [@post],
-              blog: @blog,
-              reviewer: @reviewer,
-              bio: @bio,
-              likes: [@like],
-              roles: [@role],
-              locations: [@location],
-              profile: @profile,
-              comments: [@comment]
-            )
-          end
-
-          def test_relationship_simple_link
-            expected = {
-              data: {
-                id: '1337',
-                type: 'bios'
-              },
-              links: {
-                self: '//example.com/link_author/relationships/bio'
-              }
-            }
-            assert_relationship(:bio, expected)
-          end
-
-          def test_relationship_block_link
-            expected = {
-              data: { id: '1337', type: 'profiles' },
-              links: { related: '//example.com/profiles/1337' }
-            }
-            assert_relationship(:profile, expected)
-          end
-
-          def test_relationship_block_link_href
-            expected = {
-              data: [{ id: '1337', type: 'locations' }],
-              links: {
-                related: { href: '//example.com/locations/1337' }
-              }
-            }
-            assert_relationship(:locations, expected)
-          end
-
-          def test_relationship_block_link_href_and_meta
-            expected = {
-              data: [{ id: '1337', type: 'posts' }],
-              links: {
-                related: {
-                  href: '//example.com/posts/1337',
-                  meta: { ids: '1337' }
-                }
-              }
-            }
-            assert_relationship(:posts, expected)
-          end
-
-          def test_relationship_block_link_meta
-            expected = {
-              data: [{ id: '1337', type: 'comments' }],
-              links: {
-                self: {
-                  meta: { ids: [1] }
-                }
-              }
-            }
-            assert_relationship(:comments, expected)
-          end
-
-          def test_relationship_meta
-            expected = {
-              data: [{ id: 'from-serializer-method', type: 'roles' }],
-              meta: { count: 1 }
-            }
-            assert_relationship(:roles, expected)
-          end
-
-          def test_relationship_not_including_data
-            expected = {
-              links: { self: '//example.com/link_author/relationships/blog' }
-            }
-            assert_relationship(:blog, expected)
-          end
-
-          def test_relationship_including_data_explicit
-            expected = {
-              data: { id: '1337', type: 'authors' },
-              meta: { name: 'Dan Brown' }
-            }
-            assert_relationship(:reviewer, expected)
-          end
-
-          def test_relationship_with_everything
-            expected = {
-              data: [{ id: '1337', type: 'likes' }],
-              links: {
-                related: {
-                  href: '//example.com/likes/1337',
-                  meta: { ids: '1337' }
-                }
-              },
-              meta: { liked: true }
-            }
-            assert_relationship(:likes, expected)
-          end
-
-          private
-
-          def assert_relationship(relationship_name, expected)
-            hash = serializable(@author, adapter: :json_api).serializable_hash
-            assert_equal(expected, hash[:data][:relationships][relationship_name])
-          end
-        end
-      end
-    end
-  end
-end