agi_active_model_serializers 0.10.7

data/test/adapter/json_api/links_test.rb

@@ -0,0 +1,95 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class LinksTest < ActiveSupport::TestCase
+        class LinkAuthor < ::Model; associations :posts end
+        class LinkAuthorSerializer < ActiveModel::Serializer
+          link :self do
+            href "http://example.com/link_author/#{object.id}"
+            meta stuff: 'value'
+          end
+          link(:author) { link_author_url(object.id) }
+          link(:link_authors) { url_for(controller: 'link_authors', action: 'index', only_path: false) }
+          link(:posts) { link_author_posts_url(object.id) }
+          link :resource, 'http://example.com/resource'
+          link :yet_another do
+            "http://example.com/resource/#{object.id}"
+          end
+          link(:nil) { nil }
+        end
+
+        def setup
+          Rails.application.routes.draw do
+            resources :link_authors do
+              resources :posts
+            end
+          end
+          @post = Post.new(id: 1337, comments: [], author: nil)
+          @author = LinkAuthor.new(id: 1337, posts: [@post])
+        end
+
+        def test_toplevel_links
+          hash = ActiveModelSerializers::SerializableResource.new(
+            @post,
+            adapter: :json_api,
+            links: {
+              self: {
+                href: 'http://example.com/posts',
+                meta: {
+                  stuff: 'value'
+                }
+              }
+            }
+          ).serializable_hash
+          expected = {
+            self: {
+              href: 'http://example.com/posts',
+              meta: {
+                stuff: 'value'
+              }
+            }
+          }
+          assert_equal(expected, hash[:links])
+        end
+
+        def test_nil_toplevel_links
+          hash = ActiveModelSerializers::SerializableResource.new(
+            @post,
+            adapter: :json_api,
+            links: nil
+          ).serializable_hash
+          refute hash.key?(:links), 'No links key to be output'
+        end
+
+        def test_nil_toplevel_links_json_adapter
+          hash = ActiveModelSerializers::SerializableResource.new(
+            @post,
+            adapter: :json,
+            links: nil
+          ).serializable_hash
+          refute hash.key?(:links), 'No links key to be output'
+        end
+
+        def test_resource_links
+          hash = serializable(@author, adapter: :json_api).serializable_hash
+          expected = {
+            self: {
+              href: 'http://example.com/link_author/1337',
+              meta: {
+                stuff: 'value'
+              }
+            },
+            author: 'http://example.com/link_authors/1337',
+            :"link-authors" => 'http://example.com/link_authors',
+            resource: 'http://example.com/resource',
+            posts: 'http://example.com/link_authors/1337/posts',
+            :"yet-another" => 'http://example.com/resource/1337'
+          }
+          assert_equal(expected, hash[:data][:links])
+        end
+      end
+    end
+  end
+end

data/test/adapter/json_api/pagination_links_test.rb

@@ -0,0 +1,193 @@
+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_when_unpaginatable
+          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_without_pagination_links
+          {}.tap do |hash|
+            hash[:data] = data.values.flatten[2..3]
+          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_when_unpaginatable, adapter.serializable_hash
+        end
+
+        def test_raises_descriptive_error_when_serialization_context_unset
+          render_options = { adapter: :json_api }
+          adapter = serializable(using_kaminari, render_options)
+          exception = assert_raises do
+            adapter.as_json
+          end
+          exception_class = ActiveModelSerializers::Adapter::JsonApi::PaginationLinks::MissingSerializationContextError
+          assert_equal exception_class, exception.class
+          assert_match(/CollectionSerializer#paginated\?/, exception.message)
+        end
+
+        def test_pagination_links_not_present_when_disabled
+          ActiveModel::Serializer.config.jsonapi_pagination_links_enabled = false
+          adapter = load_adapter(using_kaminari, mock_request)
+
+          assert_equal expected_response_without_pagination_links, adapter.serializable_hash
+        ensure
+          ActiveModel::Serializer.config.jsonapi_pagination_links_enabled = true
+        end
+      end
+    end
+  end
+end

data/test/adapter/json_api/parse_test.rb

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

@@ -0,0 +1,397 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class RelationshipTest < ActiveSupport::TestCase
+        def test_relationship_with_data
+          expected = {
+            data: {
+              id: '1',
+              type: 'blogs'
+            }
+          }
+
+          model_attributes = { blog: Blog.new(id: 1) }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_with_nil_model
+          expected = { data: nil }
+
+          model_attributes = { blog: nil }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_with_data_array
+          expected = {
+            data: [
+              {
+                id: '1',
+                type: 'posts'
+              },
+              {
+                id: '2',
+                type: 'posts'
+              }
+            ]
+          }
+
+          model_attributes = { posts: [Post.new(id: 1), Post.new(id: 2)] }
+          relationship_name = :posts
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_many :posts
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_data_not_included
+          expected = { meta: {} }
+
+          model_attributes = { blog: :does_not_matter }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog do
+              include_data false
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_many_links
+          expected = {
+            links: {
+              self: 'a link',
+              related: 'another link'
+            }
+          }
+
+          model_attributes = { blog: :does_not_matter }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog do
+              include_data false
+              link :self, 'a link'
+              link :related, 'another link'
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_block_link_with_meta
+          expected = {
+            links: {
+              self: {
+                href: '1',
+                meta: { id: 1 }
+              }
+            }
+          }
+
+          model_attributes = { blog: Blog.new(id: 1) }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog do
+              include_data false
+              link :self do
+                href object.blog.id.to_s
+                meta(id: object.blog.id)
+              end
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_simple_meta
+          expected = { meta: { id: '1' } }
+
+          model_attributes = { blog: Blog.new(id: 1) }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog do
+              include_data false
+              meta(id: object.blog.id.to_s)
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_block_meta
+          expected = {
+            meta: {
+              id: 1
+            }
+          }
+
+          model_attributes = { blog: Blog.new(id: 1) }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog do
+              include_data false
+              meta(id: object.blog.id)
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_simple_link
+          expected = {
+            data: {
+              id: '1337',
+              type: 'bios'
+            },
+            links: {
+              self: '//example.com/link_author/relationships/bio'
+            }
+          }
+
+          model_attributes = { bio: Bio.new(id: 1337) }
+          relationship_name = :bio
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :bio do
+              link :self, '//example.com/link_author/relationships/bio'
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_block_link
+          expected = {
+            data: { id: '1337', type: 'profiles' },
+            links: { related: '//example.com/profiles/1337' }
+          }
+
+          model_attributes = { profile: Profile.new(id: 1337) }
+          relationship_name = :profile
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :profile do
+              id = object.profile.id
+              link :related do
+                "//example.com/profiles/#{id}" if id != 123
+              end
+            end
+          end
+          assert_equal(expected, actual)
+        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 }
+          }
+
+          model_attributes = { likes: [Like.new(id: 1337)] }
+          relationship_name = :likes
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            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
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_nil_link
+          expected = {
+            data: { id: '123', type: 'profiles' }
+          }
+
+          model_attributes = { profile: Profile.new(id: 123) }
+          relationship_name = :profile
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :profile do
+              id = object.profile.id
+              link :related do
+                "//example.com/profiles/#{id}" if id != 123
+              end
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_block_link_href
+          expected = {
+            data: [{ id: '1337', type: 'locations' }],
+            links: {
+              related: { href: '//example.com/locations/1337' }
+            }
+          }
+
+          model_attributes = { locations: [Location.new(id: 1337)] }
+          relationship_name = :locations
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_many :locations do
+              link :related do
+                ids = object.locations.map(&:id).join(',')
+                href "//example.com/locations/#{ids}"
+              end
+            end
+          end
+          assert_equal(expected, actual)
+        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' }
+              }
+            }
+          }
+
+          model_attributes =  { posts: [Post.new(id: 1337, comments: [], author: nil)] }
+          relationship_name = :posts
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_many :posts do
+              link :related do
+                ids = object.posts.map(&:id).join(',')
+                href "//example.com/posts/#{ids}"
+                meta ids: ids
+              end
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_block_link_meta
+          expected = {
+            data: [{ id: '1337', type: 'comments' }],
+            links: {
+              self: {
+                meta: { ids: [1] }
+              }
+            }
+          }
+
+          model_attributes = { comments: [Comment.new(id: 1337)] }
+          relationship_name = :comments
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_many :comments do
+              link :self do
+                meta ids: [1]
+              end
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_meta
+          expected = {
+            data: [{ id: 'from-serializer-method', type: 'roles' }],
+            meta: { count: 1 }
+          }
+
+          model_attributes = { roles: [Role.new(id: 'from-record')] }
+          relationship_name = :roles
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_many :roles do |serializer|
+              meta count: object.roles.count
+              serializer.cached_roles
+            end
+            def cached_roles
+              [
+                Role.new(id: 'from-serializer-method')
+              ]
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_not_including_data
+          expected = {
+            links: { self: '//example.com/link_author/relationships/blog' }
+          }
+
+          model_attributes = { blog: Object }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          model.define_singleton_method(:read_attribute_for_serialization) do |attr|
+            fail 'should not be called' if attr == :blog
+            super(attr)
+          end
+          assert_nothing_raised do
+            actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+              has_one :blog do
+                link :self, '//example.com/link_author/relationships/blog'
+                include_data false
+              end
+            end
+            assert_equal(expected, actual)
+          end
+        end
+
+        def test_relationship_including_data_explicit
+          expected = {
+            data: { id: '1337', type: 'authors' },
+            meta: { name: 'Dan Brown' }
+          }
+
+          model_attributes = { reviewer: Author.new(id: 1337) }
+          relationship_name = :reviewer
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            belongs_to :reviewer do
+              meta name: 'Dan Brown'
+              include_data true
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        private
+
+        def build_serializer_and_serialize_relationship(model, relationship_name, &block)
+          serializer_class = Class.new(ActiveModel::Serializer, &block)
+          hash = serializable(model, serializer: serializer_class, adapter: :json_api).serializable_hash
+          hash[:data][:relationships][relationship_name]
+        end
+
+        def new_model(model_attributes)
+          Class.new(ActiveModelSerializers::Model) do
+            attributes(*model_attributes.keys)
+
+            def self.name
+              'TestModel'
+            end
+          end.new(model_attributes)
+        end
+      end
+    end
+  end
+end