Merge branch 'master' into feat/simplification-hooks

Author: maurei

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -326,10 +326,14 @@ private IList GetTrackedManyRelationshipValue(IEnumerable<IIdentifiable> relatio
         {
             if (relationshipValueList == null) return null;
             bool _wasAlreadyAttached = false;
-            Type entityType = null;
+            /// if we're not using entity resource separation, we can just read off the related type
+            /// from the RelationshipAttribute. If we DO use separation, RelationshipAttribute.DependentType
+            /// will point to the Resource, not the Entity, which is not the one we need here.
+            bool entityResourceSeparation = relationshipAttr.EntityPropertyName != null;
+            Type entityType = entityResourceSeparation ?  null : relationshipAttr.DependentType;
             var trackedPointerCollection = relationshipValueList.Select(pointer =>
             {
-                /// todo: we can't just use relationshipAttr.Type because
+                /// todo: we can't just use relationshipAttr.DependentType because
                 /// this will point to the Resource type in the case of entity resource
                 /// separation. We should consider to store entity type on 
                 /// the relationship attribute too.

src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs

@@ -242,7 +242,9 @@ private void SetHasOneForeignKeyValue(object entity, HasOneAttribute hasOneAttr,
 
                 // e.g. PATCH /articles
                 // {... { "relationships":{ "Owner": { "data": null } } } }
-                if (rio == null && Nullable.GetUnderlyingType(foreignKeyProperty.PropertyType) == null)
+                bool foreignKeyPropertyIsNullableType = Nullable.GetUnderlyingType(foreignKeyProperty.PropertyType) != null
+                    || foreignKeyProperty.PropertyType == typeof(string);
+                if (rio == null && !foreignKeyPropertyIsNullableType)
                     throw new JsonApiException(400, $"Cannot set required relationship identifier '{hasOneAttr.IdentifiablePropertyName}' to null because it is a non-nullable type.");
 
                 var convertedValue = TypeHelper.ConvertType(foreignKeyPropertyValue, foreignKeyProperty.PropertyType);

src/JsonApiDotNetCore/Services/EntityResourceService.cs

@@ -220,7 +220,6 @@ public virtual async Task<TResource> UpdateAsync(TId id, TResource resource)
                 _hookExecutor.AfterUpdate(AsList(entity), ResourcePipeline.Patch);
                 entity = _hookExecutor.OnReturn(AsList(entity), ResourcePipeline.Patch).SingleOrDefault();
             }
-
             return MapOut(entity);
         }
 

test/JsonApiDotNetCoreExampleTests/Acceptance/Spec/UpdatingRelationshipsTests.cs

@@ -528,7 +528,7 @@ public async Task Can_Update_ToOne_Relationship_ThroughLink()
         }
 
         [Fact]
-        public async Task Can_Delete_Relationship_By_Patching_Resource()
+        public async Task Can_Delete_ToOne_Relationship_By_Patching_Resource()
         {
             // arrange
             var person = _personFaker.Generate();
@@ -580,6 +580,64 @@ public async Task Can_Delete_Relationship_By_Patching_Resource()
             Assert.Null(todoItemResult.Owner);
         }
 
+
+        [Fact]
+        public async Task Can_Delete_ToMany_Relationship_By_Patching_Resource()
+        {
+            // arrange
+            var person = _personFaker.Generate();
+            var todoItem = _todoItemFaker.Generate();
+            person.TodoItems = new List<TodoItem>() { todoItem };
+            _context.People.Add(person);
+            _context.SaveChanges();
+
+            var builder = new WebHostBuilder()
+                .UseStartup<Startup>();
+
+            var server = new TestServer(builder);
+            var client = server.CreateClient();
+
+            var content = new
+            {
+                data = new
+                {
+                    id = person.Id,
+                    type = "people",
+                    relationships = new Dictionary<string, object>
+                    {
+                         { "todo-items", new
+                            {
+                                data = new List<object>
+                                {
+
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            var httpMethod = new HttpMethod("PATCH");
+            var route = $"/api/v1/people/{person.Id}";
+            var request = new HttpRequestMessage(httpMethod, route);
+
+            string serializedContent = JsonConvert.SerializeObject(content);
+            request.Content = new StringContent(serializedContent);
+            request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/vnd.api+json");
+
+            // Act
+            var response = await _fixture.Client.SendAsync(request);
+
+            // Assert
+            var personResult = _context.People
+                .AsNoTracking()
+                .Include(p => p.TodoItems)
+                .Single(p => p.Id == person.Id);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.Empty(personResult.TodoItems);
+        }
+
         [Fact]
         public async Task Can_Delete_Relationship_By_Patching_Relationship()
         {

test/UnitTests/Serialization/JsonApiDeSerializerTests.cs

@@ -222,6 +222,51 @@ public void Can_Deserialize_Independent_Side_Of_One_To_One_Relationship()
             Assert.Equal(property, result.Property);
         }
 
+        [Fact]
+        public void Can_Deserialize_Independent_Side_Of_One_To_One_Relationship_With_String_Keys()
+        {
+            // arrange
+            var resourceGraphBuilder = new ResourceGraphBuilder();
+            resourceGraphBuilder.AddResource<IndependentWithStringKey, string>("independents");
+            resourceGraphBuilder.AddResource<DependentWithStringKey, string>("dependents");
+            var resourceGraph = resourceGraphBuilder.Build();
+
+            var jsonApiContextMock = new Mock<IJsonApiContext>();
+            jsonApiContextMock.SetupAllProperties();
+            jsonApiContextMock.Setup(m => m.ResourceGraph).Returns(resourceGraph);
+            jsonApiContextMock.Setup(m => m.AttributesToUpdate).Returns(new Dictionary<AttrAttribute, object>());
+            jsonApiContextMock.Setup(m => m.HasOneRelationshipPointers).Returns(new HasOneRelationshipPointers());
+
+            var jsonApiOptions = new JsonApiOptions();
+            jsonApiContextMock.Setup(m => m.Options).Returns(jsonApiOptions);
+
+            var deserializer = new JsonApiDeSerializer(jsonApiContextMock.Object);
+
+            var property = Guid.NewGuid().ToString();
+            var content = new Document
+            {
+                Data = new ResourceObject
+                {
+                    Type = "independents",
+                    Id = "natural-key",
+                    Attributes = new Dictionary<string, object> { { "property", property } },
+                    Relationships = new Dictionary<string, RelationshipData>
+                    {
+                        { "dependent" , new RelationshipData { } }
+                    }
+                }
+            };
+
+            var contentString = JsonConvert.SerializeObject(content);
+
+            // act
+            var result = deserializer.Deserialize<IndependentWithStringKey>(contentString);
+
+            // assert
+            Assert.NotNull(result);
+            Assert.Equal(property, result.Property);
+        }
+
         [Fact]
         public void Can_Deserialize_Independent_Side_Of_One_To_One_Relationship_With_Relationship_Body()
         {
@@ -348,6 +393,19 @@ private class Dependent : Identifiable
             public int IndependentId { get; set; }
         }
 
+        private class IndependentWithStringKey : Identifiable<string>
+        {
+            [Attr("property")] public string Property { get; set; }
+            [HasOne("dependent")] public Dependent Dependent { get; set; }
+            public string DependentId { get; set; }
+        }
+
+        private class DependentWithStringKey : Identifiable<string>
+        {
+            [HasOne("independent")] public Independent Independent { get; set; }
+            public string IndependentId { get; set; }
+        }
+
         [Fact]
         public void Can_Deserialize_Object_With_HasManyRelationship()
         {
@@ -538,7 +596,7 @@ public void Can_Deserialize_Nested_Included_HasMany_Relationships()
             resourceGraphBuilder.AddResource<ManyToManyNested>("many-to-manys");
 
             var deserializer = GetDeserializer(resourceGraphBuilder);
-          
+
             var contentString =
             @"{
                 ""data"": {