active_model_serializers 0.10.0 → 0.10.9

data/test/active_model_serializers/key_transform_test.rb

@@ -1,263 +0,0 @@
-require 'test_helper'
-
-class ActiveModelSerializers::KeyTransformTest < ActiveSupport::TestCase
-  def test_camel
-    obj = Object.new
-    scenarios = [
-      {
-        value: { :"some-key" => 'value' },
-        expected: { :SomeKey => 'value' }
-      },
-      {
-        value: { :someKey => 'value' },
-        expected: { :SomeKey => 'value' }
-      },
-      {
-        value: { :some_key => 'value' },
-        expected: { :SomeKey => 'value' }
-      },
-      {
-        value: { 'some-key' => 'value' },
-        expected: { 'SomeKey' => 'value' }
-      },
-      {
-        value: { 'someKey' => 'value' },
-        expected: { 'SomeKey' => 'value' }
-      },
-      {
-        value: { 'some_key' => 'value' },
-        expected: { 'SomeKey' => 'value' }
-      },
-      {
-        value: :"some-value",
-        expected: :SomeValue
-      },
-      {
-        value: :some_value,
-        expected: :SomeValue
-      },
-      {
-        value: :someValue,
-        expected: :SomeValue
-      },
-      {
-        value: 'some-value',
-        expected: 'SomeValue'
-      },
-      {
-        value: 'someValue',
-        expected: 'SomeValue'
-      },
-      {
-        value: 'some_value',
-        expected: 'SomeValue'
-      },
-      {
-        value: obj,
-        expected: obj
-      },
-      {
-        value: nil,
-        expected: nil
-      }
-    ]
-    scenarios.each do |s|
-      result = ActiveModelSerializers::KeyTransform.camel(s[:value])
-      assert_equal s[:expected], result
-    end
-  end
-
-  def test_camel_lower
-    obj = Object.new
-    scenarios = [
-      {
-        value: { :"some-key" => 'value' },
-        expected: { :someKey => 'value' }
-      },
-      {
-        value: { :SomeKey => 'value' },
-        expected: { :someKey => 'value' }
-      },
-      {
-        value: { :some_key => 'value' },
-        expected: { :someKey => 'value' }
-      },
-      {
-        value: { 'some-key' => 'value' },
-        expected: { 'someKey' => 'value' }
-      },
-      {
-        value: { 'SomeKey' => 'value' },
-        expected: { 'someKey' => 'value' }
-      },
-      {
-        value: { 'some_key' => 'value' },
-        expected: { 'someKey' => 'value' }
-      },
-      {
-        value: :"some-value",
-        expected: :someValue
-      },
-      {
-        value: :SomeValue,
-        expected: :someValue
-      },
-      {
-        value: :some_value,
-        expected: :someValue
-      },
-      {
-        value: 'some-value',
-        expected: 'someValue'
-      },
-      {
-        value: 'SomeValue',
-        expected: 'someValue'
-      },
-      {
-        value: 'some_value',
-        expected: 'someValue'
-      },
-      {
-        value: obj,
-        expected: obj
-      },
-      {
-        value: nil,
-        expected: nil
-      }
-    ]
-    scenarios.each do |s|
-      result = ActiveModelSerializers::KeyTransform.camel_lower(s[:value])
-      assert_equal s[:expected], result
-    end
-  end
-
-  def test_dash
-    obj = Object.new
-    scenarios = [
-      {
-        value: { :some_key => 'value' },
-        expected: { :"some-key" => 'value' }
-      },
-      {
-        value: { 'some_key' => 'value' },
-        expected: { 'some-key' => 'value' }
-      },
-      {
-        value: { :SomeKey => 'value' },
-        expected: { :"some-key" => 'value' }
-      },
-      {
-        value: { 'SomeKey' => 'value' },
-        expected: { 'some-key' => 'value' }
-      },
-      {
-        value: { :someKey => 'value' },
-        expected: { :"some-key" => 'value' }
-      },
-      {
-        value: { 'someKey' => 'value' },
-        expected: { 'some-key' => 'value' }
-      },
-      {
-        value: :some_value,
-        expected: :"some-value"
-      },
-      {
-        value: :SomeValue,
-        expected: :"some-value"
-      },
-      {
-        value: 'SomeValue',
-        expected: 'some-value'
-      },
-      {
-        value: :someValue,
-        expected: :"some-value"
-      },
-      {
-        value: 'someValue',
-        expected: 'some-value'
-      },
-      {
-        value: obj,
-        expected: obj
-      },
-      {
-        value: nil,
-        expected: nil
-      }
-    ]
-    scenarios.each do |s|
-      result = ActiveModelSerializers::KeyTransform.dash(s[:value])
-      assert_equal s[:expected], result
-    end
-  end
-
-  def test_underscore
-    obj = Object.new
-    scenarios = [
-      {
-        value: { :"some-key" => 'value' },
-        expected: { :some_key => 'value' }
-      },
-      {
-        value: { 'some-key' => 'value' },
-        expected: { 'some_key' => 'value' }
-      },
-      {
-        value: { :SomeKey => 'value' },
-        expected: { :some_key => 'value' }
-      },
-      {
-        value: { 'SomeKey' => 'value' },
-        expected: { 'some_key' => 'value' }
-      },
-      {
-        value: { :someKey => 'value' },
-        expected: { :some_key => 'value' }
-      },
-      {
-        value: { 'someKey' => 'value' },
-        expected: { 'some_key' => 'value' }
-      },
-      {
-        value: :"some-value",
-        expected: :some_value
-      },
-      {
-        value: :SomeValue,
-        expected: :some_value
-      },
-      {
-        value: :someValue,
-        expected: :some_value
-      },
-      {
-        value: 'some-value',
-        expected: 'some_value'
-      },
-      {
-        value: 'SomeValue',
-        expected: 'some_value'
-      },
-      {
-        value: 'someValue',
-        expected: 'some_value'
-      },
-      {
-        value: obj,
-        expected: obj
-      },
-      {
-        value: nil,
-        expected: nil
-      }
-    ]
-    scenarios.each do |s|
-      result = ActiveModelSerializers::KeyTransform.underscore(s[:value])
-      assert_equal s[:expected], result
-    end
-  end
-end

data/test/adapter/json_api/has_many_embed_ids_test.rb

@@ -1,43 +0,0 @@
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class JsonApi
-      class HasManyEmbedIdsTest < ActiveSupport::TestCase
-        def setup
-          @author = Author.new(name: 'Steve K.')
-          @author.bio = nil
-          @author.roles = nil
-          @first_post = Post.new(id: 1, title: 'Hello!!', body: 'Hello, world!!')
-          @second_post = Post.new(id: 2, title: 'New Post', body: 'Body')
-          @author.posts = [@first_post, @second_post]
-          @first_post.author = @author
-          @second_post.author = @author
-          @first_post.comments = []
-          @second_post.comments = []
-          @blog = Blog.new(id: 23, name: 'AMS Blog')
-          @first_post.blog = @blog
-          @second_post.blog = nil
-
-          @serializer = AuthorSerializer.new(@author)
-          @adapter = ActiveModelSerializers::Adapter::JsonApi.new(@serializer)
-        end
-
-        def test_includes_comment_ids
-          expected = {
-            data: [
-              { type: 'posts', id: '1' },
-              { type: 'posts', id: '2' }
-            ]
-          }
-
-          assert_equal(expected, @adapter.serializable_hash[:data][:relationships][:posts])
-        end
-
-        def test_no_includes_linked_comments
-          assert_nil @adapter.serializable_hash[:linked]
-        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

data/test/adapter/json_api/resource_identifier_test.rb

@@ -1,85 +0,0 @@
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class JsonApi
-      class ResourceIdentifierTest < ActiveSupport::TestCase
-        class WithDefinedTypeSerializer < ActiveModel::Serializer
-          type 'with_defined_type'
-        end
-
-        class WithDefinedIdSerializer < ActiveModel::Serializer
-          def id
-            'special_id'
-          end
-        end
-
-        class FragmentedSerializer < ActiveModel::Serializer; end
-
-        setup do
-          @model = Author.new(id: 1, name: 'Steve K.')
-          ActionController::Base.cache_store.clear
-        end
-
-        def test_defined_type
-          test_type(WithDefinedTypeSerializer, 'with-defined-type')
-        end
-
-        def test_singular_type
-          test_type_inflection(AuthorSerializer, 'author', :singular)
-        end
-
-        def test_plural_type
-          test_type_inflection(AuthorSerializer, 'authors', :plural)
-        end
-
-        def test_id_defined_on_object
-          test_id(AuthorSerializer, @model.id.to_s)
-        end
-
-        def test_id_defined_on_serializer
-          test_id(WithDefinedIdSerializer, 'special_id')
-        end
-
-        def test_id_defined_on_fragmented
-          FragmentedSerializer.fragmented(WithDefinedIdSerializer.new(@model))
-          test_id(FragmentedSerializer, 'special_id')
-        end
-
-        private
-
-        def test_type_inflection(serializer_class, expected_type, inflection)
-          original_inflection = ActiveModelSerializers.config.jsonapi_resource_type
-          ActiveModelSerializers.config.jsonapi_resource_type = inflection
-          test_type(serializer_class, expected_type)
-        ensure
-          ActiveModelSerializers.config.jsonapi_resource_type = original_inflection
-        end
-
-        def test_type(serializer_class, expected_type)
-          serializer = serializer_class.new(@model)
-          resource_identifier = ResourceIdentifier.new(serializer, nil)
-          expected = {
-            id: @model.id.to_s,
-            type: expected_type
-          }
-
-          assert_equal(expected, resource_identifier.as_json)
-        end
-
-        def test_id(serializer_class, id)
-          serializer = serializer_class.new(@model)
-          resource_identifier = ResourceIdentifier.new(serializer, nil)
-          inflection = ActiveModelSerializers.config.jsonapi_resource_type
-          type = @model.class.model_name.send(inflection)
-          expected = {
-            id: id,
-            type: type
-          }
-
-          assert_equal(expected, resource_identifier.as_json)
-        end
-      end
-    end
-  end
-end

data/test/include_tree/from_include_args_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class IncludeTree
-      class FromStringTest < ActiveSupport::TestCase
-        def test_simple_array
-          input = [:comments, :author]
-          actual = ActiveModel::Serializer::IncludeTree.from_include_args(input)
-          assert(actual.key?(:author))
-          assert(actual.key?(:comments))
-        end
-
-        def test_nested_array
-          input = [:comments, posts: [:author, comments: [:author]]]
-          actual = ActiveModel::Serializer::IncludeTree.from_include_args(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:author))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:author))
-          assert(actual.key?(:comments))
-        end
-      end
-    end
-  end
-end

data/test/include_tree/from_string_test.rb

@@ -1,94 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class IncludeTree
-      class FromStringTest < ActiveSupport::TestCase
-        def test_single_string
-          input = 'author'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:author))
-        end
-
-        def test_multiple_strings
-          input = 'author,comments'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:author))
-          assert(actual.key?(:comments))
-        end
-
-        def test_multiple_strings_with_space
-          input = 'author, comments'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:author))
-          assert(actual.key?(:comments))
-        end
-
-        def test_nested_string
-          input = 'posts.author'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:author))
-        end
-
-        def test_multiple_nested_string
-          input = 'posts.author,posts.comments.author,comments'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:author))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:author))
-          assert(actual.key?(:comments))
-        end
-
-        def test_toplevel_star_string
-          input = '*'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:comments))
-        end
-
-        def test_nested_star_string
-          input = 'posts.*'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-        end
-
-        def test_nested_star_middle_string
-          input = 'posts.*.author'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:author))
-          refute(actual[:posts][:comments].key?(:unspecified))
-        end
-
-        def test_nested_star_lower_precedence_string
-          input = 'posts.comments.author,posts.*'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:author))
-        end
-
-        def test_toplevel_double_star_string
-          input = '**'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:posts))
-        end
-
-        def test_nested_double_star_string
-          input = 'comments, posts.**'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:comments))
-          refute(actual[:comments].key?(:author))
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:posts))
-        end
-      end
-    end
-  end
-end