Fix: ResourceIdentifier.for_type_with_id can serialize unpersisted resources

Author: bf4

lib/active_model_serializers/adapter/json_api/resource_identifier.rb

@@ -8,12 +8,13 @@ def self.type_for(serializer, serializer_type = nil, transform_options = {})
         end
 
         def self.for_type_with_id(type, id, options)
-          return nil if id.blank?
           type = inflect_type(type)
-          {
-            id: id.to_s,
-            type: type_for(:no_class_needed, type, options)
-          }
+          type = type_for(:no_class_needed, type, options)
+          if id.blank?
+            { type: type }
+          else
+            { id: id.to_s, type: type }
+          end
         end
 
         def self.raw_type_from_serializer_object(object)

test/adapter/json_api/type_test.rb

@@ -72,33 +72,33 @@ def id
 
         def test_defined_type
           actual = with_jsonapi_inflection :plural do
-            actual_resource_identifier_object(WithDefinedTypeSerializer)
+            actual_resource_identifier_object(WithDefinedTypeSerializer, @model)
           end
-          expected = { id: expected_model_id, type: 'with-defined-types' }
+          expected = { id: expected_model_id(@model), type: 'with-defined-types' }
           assert_equal actual, expected
         end
 
         def test_defined_type_not_inflected
           actual = with_jsonapi_inflection :singular do
-            actual_resource_identifier_object(WithDefinedTypeSerializer)
+            actual_resource_identifier_object(WithDefinedTypeSerializer, @model)
           end
-          expected = { id: expected_model_id, type: 'with-defined-types' }
+          expected = { id: expected_model_id(@model), type: 'with-defined-types' }
           assert_equal actual, expected
         end
 
         def test_singular_type
           actual = with_jsonapi_inflection :singular do
-            actual_resource_identifier_object(AuthorSerializer)
+            actual_resource_identifier_object(AuthorSerializer, @model)
           end
-          expected = { id: expected_model_id, type: 'author' }
+          expected = { id: expected_model_id(@model), type: 'author' }
           assert_equal actual, expected
         end
 
         def test_plural_type
           actual = with_jsonapi_inflection :plural do
-            actual_resource_identifier_object(AuthorSerializer)
+            actual_resource_identifier_object(AuthorSerializer, @model)
           end
-          expected = { id: expected_model_id, type: 'authors' }
+          expected = { id: expected_model_id(@model), type: 'authors' }
           assert_equal actual, expected
         end
 
@@ -123,45 +123,69 @@ def test_type_with_namespace
         end
 
         def test_id_defined_on_object
-          actual = actual_resource_identifier_object(AuthorSerializer)
-          expected = { id: @model.id.to_s, type: expected_model_type }
+          actual = actual_resource_identifier_object(AuthorSerializer, @model)
+          expected = { id: @model.id.to_s, type: expected_model_type(@model) }
           assert_equal actual, expected
         end
 
         def test_blank_id
-          @model.id = nil
-          actual = actual_resource_identifier_object(AuthorSerializer)
-          expected = { type: expected_model_type }
+          model = Author.new(id: nil, name: 'Steve K.')
+          actual = actual_resource_identifier_object(AuthorSerializer, model)
+          expected = { type: expected_model_type(model) }
+          assert_equal actual, expected
+        end
+
+        def test_for_type_with_id
+          id = 1
+          actual = ResourceIdentifier.for_type_with_id('admin_user', id, {})
+          expected = { id: "1", type: 'admin-users' }
+          assert_equal actual, expected
+        end
+
+        def test_for_type_with_id_given_blank_id
+          id = ""
+          actual = ResourceIdentifier.for_type_with_id('admin_user', id, {})
+          expected = { type: 'admin-users' }
+          assert_equal actual, expected
+        end
+
+        def test_for_type_with_id_inflected
+          id = 2
+          actual = with_jsonapi_inflection :singular do
+            ResourceIdentifier.for_type_with_id('admin_users', id, {})
+          end
+          expected = { id: "2", type: 'admin-user' }
           assert_equal actual, expected
         end
 
         def test_id_defined_on_serializer
-          actual = actual_resource_identifier_object(WithDefinedIdSerializer)
-          expected = { id: 'special_id', type: expected_model_type }
+          actual = actual_resource_identifier_object(WithDefinedIdSerializer, @model)
+          expected = { id: 'special_id', type: expected_model_type(@model) }
           assert_equal actual, expected
         end
 
         def test_id_defined_on_fragmented
-          actual = actual_resource_identifier_object(FragmentedSerializer)
-          expected = { id: 'special_id', type: expected_model_type }
+          actual = actual_resource_identifier_object(FragmentedSerializer, @model)
+          expected = { id: 'special_id', type: expected_model_type(@model) }
           assert_equal actual, expected
         end
 
         private
 
-        def actual_resource_identifier_object(serializer_class)
-          serializer = serializer_class.new(@model)
+        def actual_resource_identifier_object(serializer_class, model)
+          serializer = serializer_class.new(model)
           resource_identifier = ResourceIdentifier.new(serializer, nil)
           resource_identifier.as_json
         end
 
-        def expected_model_type
-          inflection = ActiveModelSerializers.config.jsonapi_resource_type
-          @model.class.model_name.send(inflection)
+        def expected_model_type(model, inflection = ActiveModelSerializers.config.jsonapi_resource_type)
+          with_jsonapi_inflection inflection do
+            model.class.model_name.send(inflection)
+          end
         end
 
-        def expected_model_id
-          @model.id.to_s
+        def expected_model_id(model)
+          model.id.to_s
         end
       end
     end