active_model_serializers 0.10.0 → 0.10.7

data/test/lint_test.rb

@@ -30,7 +30,7 @@ module ActiveModel
         def errors
         end
 
-        def self.human_attribute_name(attr, options = {})
+        def self.human_attribute_name(_, _ = {})
         end
 
         def self.lookup_ancestors

data/test/logger_test.rb

@@ -1,18 +1,20 @@
 require 'test_helper'
 
-class ActiveModelSerializers::LoggerTest < ActiveSupport::TestCase
-  def test_logger_is_set_to_action_controller_logger_when_initializer_runs
-    assert_equal $action_controller_logger, ActionController::Base.logger # rubocop:disable Style/GlobalVars
-  end
+module ActiveModelSerializers
+  class LoggerTest < ActiveSupport::TestCase
+    def test_logger_is_set_to_action_controller_logger_when_initializer_runs
+      assert_equal $action_controller_logger, ActionController::Base.logger # rubocop:disable Style/GlobalVars
+    end
 
-  def test_logger_can_be_set
-    original_logger = ActiveModelSerializers.logger
-    logger = Logger.new(STDOUT)
+    def test_logger_can_be_set
+      original_logger = ActiveModelSerializers.logger
+      logger = Logger.new(STDOUT)
 
-    ActiveModelSerializers.logger = logger
+      ActiveModelSerializers.logger = logger
 
-    assert_equal ActiveModelSerializers.logger, logger
-  ensure
-    ActiveModelSerializers.logger = original_logger
+      assert_equal ActiveModelSerializers.logger, logger
+    ensure
+      ActiveModelSerializers.logger = original_logger
+    end
   end
 end

data/test/serializable_resource_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 module ActiveModelSerializers
   class SerializableResourceTest < ActiveSupport::TestCase
     def setup
-      @resource = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+      @resource = Profile.new(name: 'Name 1', description: 'Description 1', comments: 'Comments 1')
       @serializer = ProfileSerializer.new(@resource)
       @adapter = ActiveModelSerializers::Adapter.create(@serializer)
       @serializable_resource = SerializableResource.new(@resource)
@@ -32,11 +32,11 @@ module ActiveModelSerializers
     end
 
     def test_use_adapter_with_adapter_option
-      assert SerializableResource.new(@resource, { adapter: 'json' }).use_adapter?
+      assert SerializableResource.new(@resource, adapter: 'json').use_adapter?
     end
 
     def test_use_adapter_with_adapter_option_as_false
-      refute SerializableResource.new(@resource, { adapter: false }).use_adapter?
+      refute SerializableResource.new(@resource, adapter: false).use_adapter?
     end
 
     class SerializableResourceErrorsTest < Minitest::Test
@@ -45,15 +45,13 @@ module ActiveModelSerializers
         resource = ModelWithErrors.new
         resource.errors.add(:name, 'must be awesome')
         serializable_resource = ActiveModelSerializers::SerializableResource.new(
-          resource, {
-            serializer: ActiveModel::Serializer::ErrorSerializer,
-            adapter: :json_api
-          })
-        expected_response_document =
-          { :errors =>
-            [
-              { :source => { :pointer => '/data/attributes/name' }, :detail => 'must be awesome' }
-            ]
+          resource,             serializer: ActiveModel::Serializer::ErrorSerializer,
+                                adapter: :json_api
+        )
+        expected_response_document = {
+          errors: [
+            { source: { pointer: '/data/attributes/name' }, detail: 'must be awesome' }
+          ]
         }
         assert_equal serializable_resource.as_json(options), expected_response_document
       end
@@ -65,16 +63,14 @@ module ActiveModelSerializers
         resource.errors.add(:title, 'must be amazing')
         resources << ModelWithErrors.new
         serializable_resource = SerializableResource.new(
-          resources, {
-            serializer: ActiveModel::Serializer::ErrorsSerializer,
-            each_serializer: ActiveModel::Serializer::ErrorSerializer,
-            adapter: :json_api
-          })
-        expected_response_document =
-          { :errors =>
-            [
-              { :source => { :pointer => '/data/attributes/title' }, :detail => 'must be amazing' }
-            ]
+          resources, serializer: ActiveModel::Serializer::ErrorsSerializer,
+                     each_serializer: ActiveModel::Serializer::ErrorSerializer,
+                     adapter: :json_api
+        )
+        expected_response_document = {
+          errors: [
+            { source: { pointer: '/data/attributes/title' }, detail: 'must be amazing' }
+          ]
         }
         assert_equal serializable_resource.as_json(options), expected_response_document
       end

data/test/serializers/association_macros_test.rb

@@ -3,7 +3,8 @@ require 'test_helper'
 module ActiveModel
   class Serializer
     class AssociationMacrosTest < ActiveSupport::TestCase
-      AuthorSummarySerializer = Class.new
+      class AuthorSummarySerializer < ActiveModel::Serializer; end
+
       class AssociationsTestSerializer < Serializer
         belongs_to :author, serializer: AuthorSummarySerializer
         has_many :comments
@@ -11,7 +12,7 @@ module ActiveModel
       end
 
       def before_setup
-        @reflections = AssociationsTestSerializer._reflections
+        @reflections = AssociationsTestSerializer._reflections.values
       end
 
       def test_has_one_defines_reflection

data/test/serializers/associations_test.rb

@@ -1,16 +1,19 @@
 require 'test_helper'
-
 module ActiveModel
   class Serializer
     class AssociationsTest < ActiveSupport::TestCase
+      class ModelWithoutSerializer < ::Model
+        attributes :id, :name
+      end
+
       def setup
         @author = Author.new(name: 'Steve K.')
         @author.bio = nil
         @author.roles = []
-        @blog = Blog.new({ name: 'AMS Blog' })
-        @post = Post.new({ title: 'New Post', body: 'Body' })
-        @tag = Tag.new({ name: '#hashtagged' })
-        @comment = Comment.new({ id: 1, body: 'ZOMG A COMMENT' })
+        @blog = Blog.new(name: 'AMS Blog')
+        @post = Post.new(title: 'New Post', body: 'Body')
+        @tag = ModelWithoutSerializer.new(id: 'tagid', name: '#hashtagged')
+        @comment = Comment.new(id: 1, body: 'ZOMG A COMMENT')
         @post.comments = [@comment]
         @post.tags = [@tag]
         @post.blog = @blog
@@ -19,7 +22,7 @@ module ActiveModel
         @post.author = @author
         @author.posts = [@post]
 
-        @post_serializer = PostSerializer.new(@post, { custom_options: true })
+        @post_serializer = PostSerializer.new(@post, custom_options: true)
         @author_serializer = AuthorSerializer.new(@author)
         @comment_serializer = CommentSerializer.new(@comment)
       end
@@ -27,18 +30,17 @@ module ActiveModel
       def test_has_many_and_has_one
         @author_serializer.associations.each do |association|
           key = association.key
-          serializer = association.serializer
-          options = association.options
+          serializer = association.lazy_association.serializer
 
           case key
           when :posts
-            assert_equal({ include_data: true }, options)
+            assert_equal true, association.include_data?
             assert_kind_of(ActiveModelSerializers.config.collection_serializer, serializer)
           when :bio
-            assert_equal({ include_data: true }, options)
+            assert_equal true, association.include_data?
             assert_nil serializer
           when :roles
-            assert_equal({ include_data: true }, options)
+            assert_equal true, association.include_data?
             assert_kind_of(ActiveModelSerializers.config.collection_serializer, serializer)
           else
             flunk "Unknown association: #{key}"
@@ -47,14 +49,17 @@ module ActiveModel
       end
 
       def test_has_many_with_no_serializer
-        PostWithTagsSerializer.new(@post).associations.each do |association|
+        post_serializer_class = Class.new(ActiveModel::Serializer) do
+          attributes :id
+          has_many :tags
+        end
+        post_serializer_class.new(@post).associations.each do |association|
           key = association.key
-          serializer = association.serializer
-          options = association.options
+          serializer = association.lazy_association.serializer
 
           assert_equal :tags, key
           assert_nil serializer
-          assert_equal [{ name: '#hashtagged' }].to_json, options[:virtual_value].to_json
+          assert_equal [{ id: 'tagid', name: '#hashtagged' }].to_json, association.virtual_value.to_json
         end
       end
 
@@ -63,13 +68,19 @@ module ActiveModel
                       .associations
                       .detect { |assoc| assoc.key == :comments }
 
-        assert association.serializer.first.custom_options[:custom_options]
+        comment_serializer = association.lazy_association.serializer.first
+        class << comment_serializer
+          def custom_options
+            instance_options
+          end
+        end
+        assert comment_serializer.custom_options.fetch(:custom_options)
       end
 
       def test_belongs_to
         @comment_serializer.associations.each do |association|
           key = association.key
-          serializer = association.serializer
+          serializer = association.lazy_association.serializer
 
           case key
           when :post
@@ -80,7 +91,7 @@ module ActiveModel
             flunk "Unknown association: #{key}"
           end
 
-          assert_equal({ include_data: true }, association.options)
+          assert_equal true, association.include_data?
         end
       end
 
@@ -104,13 +115,13 @@ module ActiveModel
         end
 
         assert(
-          PostSerializer._reflections.all? do |reflection|
-            inherited_klass._reflections.include?(reflection)
+          PostSerializer._reflections.values.all? do |reflection|
+            inherited_klass._reflections.values.include?(reflection)
           end
         )
 
         assert(
-          inherited_klass._reflections.any? do |reflection|
+          inherited_klass._reflections.values.any? do |reflection|
             reflection.name == :top_comments
           end
         )
@@ -126,6 +137,78 @@ module ActiveModel
         assert expected_association_keys.include? :site
       end
 
+      class BelongsToBlogModel < ::Model
+        attributes :id, :title
+        associations :blog
+      end
+      class BelongsToBlogModelSerializer < ActiveModel::Serializer
+        type :posts
+        belongs_to :blog
+      end
+
+      def test_belongs_to_doesnt_load_record
+        attributes = { id: 1, title: 'Belongs to Blog', blog: Blog.new(id: 5) }
+        post = BelongsToBlogModel.new(attributes)
+        class << post
+          def blog
+            fail 'should use blog_id'
+          end
+
+          def blog_id
+            5
+          end
+        end
+
+        actual =
+          begin
+            original_option = BelongsToBlogModelSerializer.config.jsonapi_use_foreign_key_on_belongs_to_relationship
+            BelongsToBlogModelSerializer.config.jsonapi_use_foreign_key_on_belongs_to_relationship = true
+            serializable(post, adapter: :json_api, serializer: BelongsToBlogModelSerializer).as_json
+          ensure
+            BelongsToBlogModelSerializer.config.jsonapi_use_foreign_key_on_belongs_to_relationship = original_option
+          end
+        expected = { data: { id: '1', type: 'posts', relationships: { blog: { data: { id: '5', type: 'blogs' } } } } }
+
+        assert_equal expected, actual
+      end
+
+      class ExternalBlog < Blog
+        attributes :external_id
+      end
+      class BelongsToExternalBlogModel < ::Model
+        attributes :id, :title, :external_blog_id
+        associations :external_blog
+      end
+      class BelongsToExternalBlogModelSerializer < ActiveModel::Serializer
+        type :posts
+        belongs_to :external_blog
+
+        def external_blog_id
+          object.external_blog.external_id
+        end
+      end
+
+      def test_belongs_to_allows_id_overwriting
+        attributes = {
+          id: 1,
+          title: 'Title',
+          external_blog: ExternalBlog.new(id: 5, external_id: 6)
+        }
+        post = BelongsToExternalBlogModel.new(attributes)
+
+        actual =
+          begin
+            original_option = BelongsToExternalBlogModelSerializer.config.jsonapi_use_foreign_key_on_belongs_to_relationship
+            BelongsToExternalBlogModelSerializer.config.jsonapi_use_foreign_key_on_belongs_to_relationship = true
+            serializable(post, adapter: :json_api, serializer: BelongsToExternalBlogModelSerializer).as_json
+          ensure
+            BelongsToExternalBlogModelSerializer.config.jsonapi_use_foreign_key_on_belongs_to_relationship = original_option
+          end
+        expected = { data: { id: '1', type: 'posts', relationships: { :'external-blog' => { data: { id: '6', type: 'external-blogs' } } } } }
+
+        assert_equal expected, actual
+      end
+
       class InlineAssociationTestPostSerializer < ActiveModel::Serializer
         has_many :comments
         has_many :comments, key: :last_comments do
@@ -143,12 +226,12 @@ module ActiveModel
         )
         actual = serializable(post, adapter: :attributes, serializer: InlineAssociationTestPostSerializer).as_json
         expected = {
-          :comments => [
-            { :id => 1, :contents => 'first comment' },
-            { :id => 2, :contents => 'last comment' }
+          comments: [
+            { id: 1, contents: 'first comment' },
+            { id: 2, contents: 'last comment' }
           ],
-          :last_comments => [
-            { :id => 2, :contents => 'last comment' }
+          last_comments: [
+            { id: 2, contents: 'last comment' }
           ]
         }
 
@@ -160,18 +243,20 @@ module ActiveModel
 
       class NamespacedResourcesTest < ActiveSupport::TestCase
         class ResourceNamespace
-          Post    = Class.new(::Model)
-          Comment = Class.new(::Model)
-          Author  = Class.new(::Model)
-          Description = Class.new(::Model)
+          class Post < ::Model
+            associations :comments, :author, :description
+          end
+          class Comment < ::Model; end
+          class Author  < ::Model; end
+          class Description < ::Model; end
           class PostSerializer < ActiveModel::Serializer
             has_many :comments
             belongs_to :author
             has_one :description
           end
-          CommentSerializer     = Class.new(ActiveModel::Serializer)
-          AuthorSerializer      = Class.new(ActiveModel::Serializer)
-          DescriptionSerializer = Class.new(ActiveModel::Serializer)
+          class CommentSerializer     < ActiveModel::Serializer; end
+          class AuthorSerializer      < ActiveModel::Serializer; end
+          class DescriptionSerializer < ActiveModel::Serializer; end
         end
 
         def setup
@@ -188,11 +273,11 @@ module ActiveModel
           @post_serializer.associations.each do |association|
             case association.key
             when :comments
-              assert_instance_of(ResourceNamespace::CommentSerializer, association.serializer.first)
+              assert_instance_of(ResourceNamespace::CommentSerializer, association.lazy_association.serializer.first)
             when :author
-              assert_instance_of(ResourceNamespace::AuthorSerializer, association.serializer)
+              assert_instance_of(ResourceNamespace::AuthorSerializer, association.lazy_association.serializer)
             when :description
-              assert_instance_of(ResourceNamespace::DescriptionSerializer, association.serializer)
+              assert_instance_of(ResourceNamespace::DescriptionSerializer, association.lazy_association.serializer)
             else
               flunk "Unknown association: #{key}"
             end
@@ -201,17 +286,19 @@ module ActiveModel
       end
 
       class NestedSerializersTest < ActiveSupport::TestCase
-        Post    = Class.new(::Model)
-        Comment = Class.new(::Model)
-        Author  = Class.new(::Model)
-        Description = Class.new(::Model)
+        class Post < ::Model
+          associations :comments, :author, :description
+        end
+        class Comment < ::Model; end
+        class Author  < ::Model; end
+        class Description < ::Model; end
         class PostSerializer < ActiveModel::Serializer
           has_many :comments
-          CommentSerializer = Class.new(ActiveModel::Serializer)
+          class CommentSerializer < ActiveModel::Serializer; end
           belongs_to :author
-          AuthorSerializer = Class.new(ActiveModel::Serializer)
+          class AuthorSerializer < ActiveModel::Serializer; end
           has_one :description
-          DescriptionSerializer = Class.new(ActiveModel::Serializer)
+          class DescriptionSerializer < ActiveModel::Serializer; end
         end
 
         def setup
@@ -228,11 +315,11 @@ module ActiveModel
           @post_serializer.associations.each do |association|
             case association.key
             when :comments
-              assert_instance_of(PostSerializer::CommentSerializer, association.serializer.first)
+              assert_instance_of(PostSerializer::CommentSerializer, association.lazy_association.serializer.first)
             when :author
-              assert_instance_of(PostSerializer::AuthorSerializer, association.serializer)
+              assert_instance_of(PostSerializer::AuthorSerializer, association.lazy_association.serializer)
             when :description
-              assert_instance_of(PostSerializer::DescriptionSerializer, association.serializer)
+              assert_instance_of(PostSerializer::DescriptionSerializer, association.lazy_association.serializer)
             else
               flunk "Unknown association: #{key}"
             end
@@ -241,7 +328,10 @@ module ActiveModel
 
         # rubocop:disable Metrics/AbcSize
         def test_conditional_associations
-          model = ::Model.new(true: true, false: false)
+          model = Class.new(::Model) do
+            attributes :true, :false
+            associations :something
+          end.new(true: true, false: false)
 
           scenarios = [
             { options: { if:     :true  }, included: true  },
@@ -264,7 +354,7 @@ module ActiveModel
 
           scenarios.each do |s|
             serializer = Class.new(ActiveModel::Serializer) do
-              belongs_to :association, s[:options]
+              belongs_to :something, s[:options]
 
               def true
                 true
@@ -276,7 +366,7 @@ module ActiveModel
             end
 
             hash = serializable(model, serializer: serializer).serializable_hash
-            assert_equal(s[:included], hash.key?(:association), "Error with #{s[:options]}")
+            assert_equal(s[:included], hash.key?(:something), "Error with #{s[:options]}")
           end
         end
 
@@ -290,6 +380,89 @@ module ActiveModel
           assert_match(/:if should be a Symbol, String or Proc/, exception.message)
         end
       end
+
+      class InheritedSerializerTest < ActiveSupport::TestCase
+        class PostSerializer < ActiveModel::Serializer
+          belongs_to :author
+          has_many :comments
+          belongs_to :blog
+        end
+
+        class InheritedPostSerializer < PostSerializer
+          belongs_to :author, polymorphic: true
+          has_many :comments, key: :reviews
+        end
+
+        class AuthorSerializer < ActiveModel::Serializer
+          has_many :posts
+          has_many :roles
+          has_one :bio
+        end
+
+        class InheritedAuthorSerializer < AuthorSerializer
+          has_many :roles, polymorphic: true
+          has_one :bio, polymorphic: true
+        end
+
+        def setup
+          @author = Author.new(name: 'Steve K.')
+          @post = Post.new(title: 'New Post', body: 'Body')
+          @post_serializer = PostSerializer.new(@post)
+          @author_serializer = AuthorSerializer.new(@author)
+          @inherited_post_serializer = InheritedPostSerializer.new(@post)
+          @inherited_author_serializer = InheritedAuthorSerializer.new(@author)
+          @author_associations = @author_serializer.associations.to_a.sort_by(&:name)
+          @inherited_author_associations = @inherited_author_serializer.associations.to_a.sort_by(&:name)
+          @post_associations = @post_serializer.associations.to_a
+          @inherited_post_associations = @inherited_post_serializer.associations.to_a
+        end
+
+        test 'an author serializer must have [posts,roles,bio] associations' do
+          expected = [:posts, :roles, :bio].sort
+          result = @author_serializer.associations.map(&:name).sort
+          assert_equal(result, expected)
+        end
+
+        test 'a post serializer must have [author,comments,blog] associations' do
+          expected = [:author, :comments, :blog].sort
+          result = @post_serializer.associations.map(&:name).sort
+          assert_equal(result, expected)
+        end
+
+        test 'a serializer inheriting from another serializer can redefine has_many and has_one associations' do
+          expected = [:roles, :bio].sort
+          result = (@inherited_author_associations.map(&:reflection) - @author_associations.map(&:reflection)).map(&:name)
+          assert_equal(result, expected)
+          assert_equal [true, false, true], @inherited_author_associations.map(&:polymorphic?)
+          assert_equal [false, false, false], @author_associations.map(&:polymorphic?)
+        end
+
+        test 'a serializer inheriting from another serializer can redefine belongs_to associations' do
+          assert_equal [:author, :comments, :blog], @post_associations.map(&:name)
+          assert_equal [:author, :comments, :blog, :comments], @inherited_post_associations.map(&:name)
+
+          refute @post_associations.detect { |assoc| assoc.name == :author }.polymorphic?
+          assert @inherited_post_associations.detect { |assoc| assoc.name == :author }.polymorphic?
+
+          refute @post_associations.detect { |assoc| assoc.name == :comments }.key?
+          original_comment_assoc, new_comments_assoc = @inherited_post_associations.select { |assoc| assoc.name == :comments }
+          refute original_comment_assoc.key?
+          assert_equal :reviews, new_comments_assoc.key
+
+          original_blog = @post_associations.detect { |assoc| assoc.name == :blog }
+          inherited_blog = @inherited_post_associations.detect { |assoc| assoc.name == :blog }
+          original_parent_serializer = original_blog.lazy_association.association_options.delete(:parent_serializer)
+          inherited_parent_serializer = inherited_blog.lazy_association.association_options.delete(:parent_serializer)
+          assert_equal PostSerializer, original_parent_serializer.class
+          assert_equal InheritedPostSerializer, inherited_parent_serializer.class
+        end
+
+        test 'a serializer inheriting from another serializer can have an additional association with the same name but with different key' do
+          expected = [:author, :comments, :blog, :reviews].sort
+          result = @inherited_post_serializer.associations.map(&:key).sort
+          assert_equal(result, expected)
+        end
+      end
     end
   end
 end

data/test/serializers/attribute_test.rb

@@ -22,7 +22,7 @@ module ActiveModel
         inherited_klass = Class.new(AlternateBlogSerializer)
         blog_serializer = inherited_klass.new(@blog)
         adapter = ActiveModelSerializers::Adapter::Attributes.new(blog_serializer)
-        assert_equal({ :id => 1, :title => 'AMS Hints' }, adapter.serializable_hash)
+        assert_equal({ id: 1, title: 'AMS Hints' }, adapter.serializable_hash)
       end
 
       def test_multiple_calls_with_the_same_attribute
@@ -81,7 +81,7 @@ module ActiveModel
         assert_equal('custom', hash[:blog][:id])
       end
 
-      PostWithVirtualAttribute = Class.new(::Model)
+      class PostWithVirtualAttribute < ::Model; attributes :first_name, :last_name end
       class PostWithVirtualAttributeSerializer < ActiveModel::Serializer
         attribute :name do
           "#{object.first_name} #{object.last_name}"
@@ -98,7 +98,9 @@ module ActiveModel
 
       # rubocop:disable Metrics/AbcSize
       def test_conditional_associations
-        model = ::Model.new(true: true, false: false)
+        model = Class.new(::Model) do
+          attributes :true, :false, :attribute
+        end.new(true: true, false: false)
 
         scenarios = [
           { options: { if:     :true  }, included: true  },

data/test/serializers/attributes_test.rb

@@ -4,7 +4,7 @@ module ActiveModel
   class Serializer
     class AttributesTest < ActiveSupport::TestCase
       def setup
-        @profile = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+        @profile = Profile.new(name: 'Name 1', description: 'Description 1', comments: 'Comments 1')
         @profile_serializer = ProfileSerializer.new(@profile)
         @comment = Comment.new(id: 1, body: 'ZOMG!!', date: '2015')
         @serializer_klass = Class.new(CommentSerializer)

data/test/serializers/caching_configuration_test_isolated.rb

@@ -69,9 +69,9 @@ class CachingConfigurationTest < ActiveSupport::TestCase
     end
 
     test 'the non-cached serializer cache_store is nil' do
-      assert_equal nil, @non_cached_serializer._cache
-      assert_equal nil, @non_cached_serializer.cache_store
-      assert_equal nil, @non_cached_serializer._cache
+      assert_nil @non_cached_serializer._cache
+      assert_nil @non_cached_serializer.cache_store
+      assert_nil @non_cached_serializer._cache
     end
 
     test 'the non-cached serializer does not have cache_enabled?' do
@@ -136,9 +136,9 @@ class CachingConfigurationTest < ActiveSupport::TestCase
     end
 
     test 'the non-cached serializer cache_store is nil' do
-      assert_equal nil, @non_cached_serializer._cache
-      assert_equal nil, @non_cached_serializer.cache_store
-      assert_equal nil, @non_cached_serializer._cache
+      assert_nil @non_cached_serializer._cache
+      assert_nil @non_cached_serializer.cache_store
+      assert_nil @non_cached_serializer._cache
     end
 
     test 'the non-cached serializer does not have cache_enabled?' do

data/test/serializers/fieldset_test.rb

@@ -5,7 +5,7 @@ module ActiveModel
     class FieldsetTest < ActiveSupport::TestCase
       def test_fieldset_with_hash
         fieldset = ActiveModel::Serializer::Fieldset.new('post' => %w(id title), 'comment' => ['body'])
-        expected = { :post => [:id, :title], :comment => [:body] }
+        expected = { post: [:id, :title], comment: [:body] }
 
         assert_equal(expected, fieldset.fields)
       end