diff --git a/src/JsonApiDotNetCore/Builders/DocumentBuilder.cs b/src/JsonApiDotNetCore/Builders/DocumentBuilder.cs index ce060f57b7..15e46ffd6f 100644 --- a/src/JsonApiDotNetCore/Builders/DocumentBuilder.cs +++ b/src/JsonApiDotNetCore/Builders/DocumentBuilder.cs @@ -192,24 +192,62 @@ private RelationshipData GetRelationshipData(RelationshipAttribute attr, Context return relationshipData; } - private List GetIncludedEntities(List included, ContextEntity contextEntity, IIdentifiable entity) + private List GetIncludedEntities(List included, ContextEntity rootContextEntity, IIdentifiable rootResource) { - contextEntity.Relationships.ForEach(r => + if(_jsonApiContext.IncludedRelationships != null) { - if (!RelationshipIsIncluded(r.PublicRelationshipName)) return; + foreach(var relationshipName in _jsonApiContext.IncludedRelationships) + { + var relationshipChain = relationshipName.Split('.'); - var navigationEntity = _jsonApiContext.ContextGraph.GetRelationship(entity, r.InternalRelationshipName); + var contextEntity = rootContextEntity; + var entity = rootResource; + included = IncludeRelationshipChain(included, rootContextEntity, rootResource, relationshipChain, 0); + } + } - if (navigationEntity is IEnumerable hasManyNavigationEntity) - foreach (IIdentifiable includedEntity in hasManyNavigationEntity) - included = AddIncludedEntity(included, includedEntity); - else - included = AddIncludedEntity(included, (IIdentifiable)navigationEntity); - }); + return included; + } + private List IncludeRelationshipChain( + List included, ContextEntity parentEntity, IIdentifiable parentResource, string[] relationshipChain, int relationshipChainIndex) + { + var requestedRelationship = relationshipChain[relationshipChainIndex]; + var relationship = parentEntity.Relationships.FirstOrDefault(r => r.PublicRelationshipName == requestedRelationship); + var navigationEntity = _jsonApiContext.ContextGraph.GetRelationship(parentResource, relationship.InternalRelationshipName); + if (navigationEntity is IEnumerable hasManyNavigationEntity) + { + foreach (IIdentifiable includedEntity in hasManyNavigationEntity) + { + included = AddIncludedEntity(included, includedEntity); + included = IncludeSingleResourceRelationships(included, includedEntity, relationship, relationshipChain, relationshipChainIndex); + } + } + else + { + included = AddIncludedEntity(included, (IIdentifiable)navigationEntity); + included = IncludeSingleResourceRelationships(included, (IIdentifiable)navigationEntity, relationship, relationshipChain, relationshipChainIndex); + } + + return included; + } + + private List IncludeSingleResourceRelationships( + List included, IIdentifiable navigationEntity, RelationshipAttribute relationship, string[] relationshipChain, int relationshipChainIndex) + { + if(relationshipChainIndex < relationshipChain.Length) + { + var nextContextEntity = _jsonApiContext.ContextGraph.GetContextEntity(relationship.Type); + var resource = (IIdentifiable)navigationEntity; + // recursive call + if(relationshipChainIndex < relationshipChain.Length - 1) + included = IncludeRelationshipChain(included, nextContextEntity, resource, relationshipChain, relationshipChainIndex + 1); + } + return included; } + private List AddIncludedEntity(List entities, IIdentifiable entity) { var includedEntity = GetIncludedEntity(entity); @@ -245,12 +283,6 @@ private DocumentData GetIncludedEntity(IIdentifiable entity) return data; } - private bool RelationshipIsIncluded(string relationshipName) - { - return _jsonApiContext.IncludedRelationships != null && - _jsonApiContext.IncludedRelationships.Contains(relationshipName); - } - private List GetRelationships(IEnumerable entities) { var objType = entities.GetElementType(); diff --git a/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs b/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs index 862079aeee..512f45fe3c 100644 --- a/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs +++ b/src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs @@ -203,20 +203,38 @@ public virtual async Task DeleteAsync(TId id) /// public virtual IQueryable Include(IQueryable entities, string relationshipName) { + if(string.IsNullOrWhiteSpace(relationshipName)) throw new JsonApiException(400, "Include parameter must not be empty if provided"); + + var relationshipChain = relationshipName.Split('.'); + + // variables mutated in recursive loop + // TODO: make recursive method + string internalRelationshipPath = null; var entity = _jsonApiContext.RequestEntity; - var relationship = entity.Relationships.FirstOrDefault(r => r.PublicRelationshipName == relationshipName); - if (relationship == null) + for(var i = 0; i < relationshipChain.Length; i++) { - throw new JsonApiException(400, $"Invalid relationship {relationshipName} on {entity.EntityName}", - $"{entity.EntityName} does not have a relationship named {relationshipName}"); - } + var requestedRelationship = relationshipChain[i]; + var relationship = entity.Relationships.FirstOrDefault(r => r.PublicRelationshipName == requestedRelationship); + if (relationship == null) + { + throw new JsonApiException(400, $"Invalid relationship {requestedRelationship} on {entity.EntityName}", + $"{entity.EntityName} does not have a relationship named {requestedRelationship}"); + } - if (!relationship.CanInclude) - { - throw new JsonApiException(400, $"Including the relationship {relationshipName} on {entity.EntityName} is not allowed"); + if (relationship.CanInclude == false) + { + throw new JsonApiException(400, $"Including the relationship {requestedRelationship} on {entity.EntityName} is not allowed"); + } + + internalRelationshipPath = (internalRelationshipPath == null) + ? relationship.InternalRelationshipName + : $"{internalRelationshipPath}.{relationship.InternalRelationshipName}"; + + if(i < relationshipChain.Length) + entity = _jsonApiContext.ContextGraph.GetContextEntity(relationship.Type); } - return entities.Include(relationship.InternalRelationshipName); + return entities.Include(internalRelationshipPath); } /// diff --git a/src/JsonApiDotNetCore/Models/RelationshipAttribute.cs b/src/JsonApiDotNetCore/Models/RelationshipAttribute.cs index f6ca5b5d2a..7408df0998 100644 --- a/src/JsonApiDotNetCore/Models/RelationshipAttribute.cs +++ b/src/JsonApiDotNetCore/Models/RelationshipAttribute.cs @@ -54,6 +54,11 @@ public bool TryGetHasMany(out HasManyAttribute result) public abstract void SetValue(object entity, object newValue); + public object GetValue(object entity) => entity + ?.GetType() + .GetProperty(InternalRelationshipName) + .GetValue(entity); + public override string ToString() { return base.ToString() + ":" + PublicRelationshipName; diff --git a/src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs b/src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs index 29569f43e9..bd2a25b0ad 100644 --- a/src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs +++ b/src/JsonApiDotNetCore/Serialization/JsonApiDeSerializer.cs @@ -214,6 +214,19 @@ private object SetHasOneRelationship(object entity, SetHasOneForeignKeyValue(entity, attr, foreignKeyProperty, rio); SetHasOneNavigationPropertyValue(entity, attr, rio, included); + // recursive call ... + if(included != null) + { + var navigationPropertyValue = attr.GetValue(entity); + var contextGraphEntity = _jsonApiContext.ContextGraph.GetContextEntity(attr.Type); + if(navigationPropertyValue != null && contextGraphEntity != null) + { + var includedResource = included.SingleOrDefault(r => r.Type == rio.Type && r.Id == rio.Id); + if(includedResource != null) + SetRelationships(navigationPropertyValue, contextGraphEntity, includedResource.Relationships, included); + } + } + return entity; } diff --git a/src/JsonApiDotNetCore/Services/QueryParser.cs b/src/JsonApiDotNetCore/Services/QueryParser.cs index 0a6d4f2c16..b42d616a0c 100644 --- a/src/JsonApiDotNetCore/Services/QueryParser.cs +++ b/src/JsonApiDotNetCore/Services/QueryParser.cs @@ -179,10 +179,6 @@ protected virtual List ParseSortParameters(string value) protected virtual List ParseIncludedRelationships(string value) { - const string NESTED_DELIMITER = "."; - if (value.Contains(NESTED_DELIMITER)) - throw new JsonApiException(400, "Deeply nested relationships are not supported"); - return value .Split(QueryConstants.COMMA) .ToList(); diff --git a/test/JsonApiDotNetCoreExampleTests/Acceptance/Spec/DeeplyNestedInclusionTests.cs b/test/JsonApiDotNetCoreExampleTests/Acceptance/Spec/DeeplyNestedInclusionTests.cs new file mode 100644 index 0000000000..5e4754c7c5 --- /dev/null +++ b/test/JsonApiDotNetCoreExampleTests/Acceptance/Spec/DeeplyNestedInclusionTests.cs @@ -0,0 +1,316 @@ +using System.Collections.Generic; +using System.Net; +using System.Net.Http; +using System.Threading.Tasks; +using Bogus; +using JsonApiDotNetCore.Models; +using JsonApiDotNetCoreExample; +using JsonApiDotNetCoreExample.Data; +using JsonApiDotNetCoreExample.Models; +using JsonApiDotNetCoreExampleTests.Helpers.Extensions; +using Microsoft.AspNetCore.Hosting; +using Newtonsoft.Json; +using Xunit; +using Person = JsonApiDotNetCoreExample.Models.Person; + +namespace JsonApiDotNetCoreExampleTests.Acceptance.Spec +{ + [Collection("WebHostCollection")] + public class DeeplyNestedInclusionTests + { + private TestFixture _fixture; + + public DeeplyNestedInclusionTests(TestFixture fixture) + { + _fixture = fixture; + } + + private void ResetContext(AppDbContext context) + { + context.TodoItems.RemoveRange(context.TodoItems); + context.TodoItemCollections.RemoveRange(context.TodoItemCollections); + context.People.RemoveRange(context.People); + context.PersonRoles.RemoveRange(context.PersonRoles); + } + + [Fact] + public async Task Can_Include_Nested_Relationships() + { + // arrange + const string route = "/api/v1/todo-items?include=collection.owner"; + + var todoItem = new TodoItem { + Collection = new TodoItemCollection { + Owner = new Person() + } + }; + + var context = _fixture.GetService(); + context.TodoItems.RemoveRange(context.TodoItems); + context.TodoItems.Add(todoItem); + await context.SaveChangesAsync(); + + // act + var response = await _fixture.Client.GetAsync(route); + + // assert + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + + var body = await response.Content.ReadAsStringAsync(); + var todoItems = _fixture.DeSerializer.DeserializeList(body); + + var responseTodoItem = Assert.Single(todoItems); + Assert.NotNull(responseTodoItem); + Assert.NotNull(responseTodoItem.Collection); + Assert.NotNull(responseTodoItem.Collection.Owner); + } + + [Fact] + public async Task Can_Include_Nested_HasMany_Relationships() + { + // arrange + const string route = "/api/v1/todo-items?include=collection.todo-items"; + + var todoItem = new TodoItem { + Collection = new TodoItemCollection { + Owner = new Person(), + TodoItems = new List { + new TodoItem(), + new TodoItem() + } + } + }; + + + var context = _fixture.GetService(); + ResetContext(context); + + context.TodoItems.Add(todoItem); + await context.SaveChangesAsync(); + + // act + var response = await _fixture.Client.GetAsync(route); + + // assert + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + + var body = await response.Content.ReadAsStringAsync(); + var documents = JsonConvert.DeserializeObject(body); + var included = documents.Included; + + Assert.Equal(4, included.Count); + + Assert.Equal(3, included.CountOfType("todo-items")); + Assert.Equal(1, included.CountOfType("todo-collections")); + } + + [Fact] + public async Task Can_Include_Nested_HasMany_Relationships_BelongsTo() + { + // arrange + const string route = "/api/v1/todo-items?include=collection.todo-items.owner"; + + var todoItem = new TodoItem { + Collection = new TodoItemCollection { + Owner = new Person(), + TodoItems = new List { + new TodoItem { + Owner = new Person() + }, + new TodoItem() + } + } + }; + + var context = _fixture.GetService(); + ResetContext(context); + + context.TodoItems.Add(todoItem); + await context.SaveChangesAsync(); + + // act + var response = await _fixture.Client.GetAsync(route); + + // assert + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + + var body = await response.Content.ReadAsStringAsync(); + var documents = JsonConvert.DeserializeObject(body); + var included = documents.Included; + + Assert.Equal(5, included.Count); + + Assert.Equal(3, included.CountOfType("todo-items")); + Assert.Equal(1, included.CountOfType("people")); + Assert.Equal(1, included.CountOfType("todo-collections")); + } + + [Fact] + public async Task Can_Include_Nested_Relationships_With_Multiple_Paths() + { + // arrange + const string route = "/api/v1/todo-items?include=collection.owner.role,collection.todo-items.owner"; + + var todoItem = new TodoItem { + Collection = new TodoItemCollection { + Owner = new Person { + Role = new PersonRole() + }, + TodoItems = new List { + new TodoItem { + Owner = new Person() + }, + new TodoItem() + } + } + }; + + var context = _fixture.GetService(); + ResetContext(context); + + context.TodoItems.Add(todoItem); + await context.SaveChangesAsync(); + + // act + var response = await _fixture.Client.GetAsync(route); + + // assert + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + + var body = await response.Content.ReadAsStringAsync(); + var documents = JsonConvert.DeserializeObject(body); + var included = documents.Included; + + Assert.Equal(7, included.Count); + + Assert.Equal(3, included.CountOfType("todo-items")); + Assert.Equal(2, included.CountOfType("people")); + Assert.Equal(1, included.CountOfType("person-roles")); + Assert.Equal(1, included.CountOfType("todo-collections")); + } + + [Fact] + public async Task Included_Resources_Are_Correct() + { + // arrange + var role = new PersonRole(); + var assignee = new Person { Role = role }; + var collectionOwner = new Person(); + var someOtherOwner = new Person(); + var collection = new TodoItemCollection { Owner = collectionOwner }; + var todoItem1 = new TodoItem { Collection = collection, Assignee = assignee }; + var todoItem2 = new TodoItem { Collection = collection, Assignee = assignee }; + var todoItem3 = new TodoItem { Collection = collection, Owner = someOtherOwner }; + var todoItem4 = new TodoItem { Collection = collection, Owner = assignee }; + + var context = _fixture.GetService(); + ResetContext(context); + + context.TodoItems.Add(todoItem1); + context.TodoItems.Add(todoItem2); + context.TodoItems.Add(todoItem3); + context.TodoItems.Add(todoItem4); + context.PersonRoles.Add(role); + context.People.Add(assignee); + context.People.Add(collectionOwner); + context.People.Add(someOtherOwner); + context.TodoItemCollections.Add(collection); + + + await context.SaveChangesAsync(); + + string route = + "/api/v1/todo-items/" + todoItem1.Id + "?include=" + + "collection.owner," + + "assignee.role," + + "assignee.assigned-todo-items"; + + // act + var response = await _fixture.Client.GetAsync(route); + + // assert + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + + var body = await response.Content.ReadAsStringAsync(); + var documents = JsonConvert.DeserializeObject(body); + var included = documents.Included; + + // 1 collection, 1 owner, + // 1 assignee, 1 assignee role, + // 2 assigned todo items (including the primary resource) + Assert.Equal(6, included.Count); + + var collectionDocument = included.FindResource("todo-collections", collection.Id); + var ownerDocument = included.FindResource("people", collectionOwner.Id); + var assigneeDocument = included.FindResource("people", assignee.Id); + var roleDocument = included.FindResource("person-roles", role.Id); + var assignedTodo1 = included.FindResource("todo-items", todoItem1.Id); + var assignedTodo2 = included.FindResource("todo-items", todoItem2.Id); + + Assert.NotNull(assignedTodo1); + Assert.Equal(todoItem1.Id.ToString(), assignedTodo1.Id); + + Assert.NotNull(assignedTodo2); + Assert.Equal(todoItem2.Id.ToString(), assignedTodo2.Id); + + Assert.NotNull(collectionDocument); + Assert.Equal(collection.Id.ToString(), collectionDocument.Id); + + Assert.NotNull(ownerDocument); + Assert.Equal(collectionOwner.Id.ToString(), ownerDocument.Id); + + Assert.NotNull(assigneeDocument); + Assert.Equal(assignee.Id.ToString(), assigneeDocument.Id); + + Assert.NotNull(roleDocument); + Assert.Equal(role.Id.ToString(), roleDocument.Id); + } + + [Fact] + public async Task Can_Include_Doubly_HasMany_Relationships() + { + // arrange + var person = new Person { + TodoItemCollections = new List { + new TodoItemCollection { + TodoItems = new List { + new TodoItem(), + new TodoItem() + } + }, + new TodoItemCollection { + TodoItems = new List { + new TodoItem(), + new TodoItem(), + new TodoItem() + } + } + } + }; + + var context = _fixture.GetService(); + ResetContext(context); + + context.People.Add(person); + + await context.SaveChangesAsync(); + + string route = "/api/v1/people/" + person.Id + "?include=todo-collections.todo-items"; + + // act + var response = await _fixture.Client.GetAsync(route); + + // assert + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + + var body = await response.Content.ReadAsStringAsync(); + var documents = JsonConvert.DeserializeObject(body); + var included = documents.Included; + + Assert.Equal(7, included.Count); + + Assert.Equal(5, included.CountOfType("todo-items")); + Assert.Equal(2, included.CountOfType("todo-collections")); + } + } +} \ No newline at end of file diff --git a/test/JsonApiDotNetCoreExampleTests/Helpers/Extensions/DocumentExtensions.cs b/test/JsonApiDotNetCoreExampleTests/Helpers/Extensions/DocumentExtensions.cs new file mode 100644 index 0000000000..f467e17f5b --- /dev/null +++ b/test/JsonApiDotNetCoreExampleTests/Helpers/Extensions/DocumentExtensions.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using JsonApiDotNetCore.Models; +using Microsoft.EntityFrameworkCore.Internal; +using Microsoft.EntityFrameworkCore.Query; +using Microsoft.EntityFrameworkCore.Query.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using Database = Microsoft.EntityFrameworkCore.Storage.Database; + +namespace JsonApiDotNetCoreExampleTests.Helpers.Extensions +{ + public static class DocumentExtensions + { + public static DocumentData FindResource(this List included, string type, TId id) + { + var document = included.Where(documentData => ( + documentData.Type == type + && documentData.Id == id.ToString() + )).FirstOrDefault(); + + return document; + } + + public static int CountOfType(this List included, string type) { + return included.Where(documentData => documentData.Type == type).Count(); + } + } +} \ No newline at end of file diff --git a/test/UnitTests/Serialization/JsonApiDeSerializerTests.cs b/test/UnitTests/Serialization/JsonApiDeSerializerTests.cs index 18d4b0ee6b..bf003bcecf 100644 --- a/test/UnitTests/Serialization/JsonApiDeSerializerTests.cs +++ b/test/UnitTests/Serialization/JsonApiDeSerializerTests.cs @@ -532,17 +532,186 @@ public void Sets_Attribute_Values_On_Included_HasOne_Relationships() Assert.Equal(expectedName, result.Independent.Name); } + + [Fact] + public void Can_Deserialize_Nested_Included_HasMany_Relationships() + { + // arrange + var contextGraphBuilder = new ContextGraphBuilder(); + contextGraphBuilder.AddResource("independents"); + contextGraphBuilder.AddResource("dependents"); + contextGraphBuilder.AddResource("many-to-manys"); + + var deserializer = GetDeserializer(contextGraphBuilder); + + var contentString = + @"{ + ""data"": { + ""type"": ""independents"", + ""id"": ""1"", + ""attributes"": { }, + ""relationships"": { + ""many-to-manys"": { + ""data"": [{ + ""type"": ""many-to-manys"", + ""id"": ""2"" + }, { + ""type"": ""many-to-manys"", + ""id"": ""3"" + }] + } + } + }, + ""included"": [ + { + ""type"": ""many-to-manys"", + ""id"": ""2"", + ""attributes"": {}, + ""relationships"": { + ""dependent"": { + ""data"": { + ""type"": ""dependents"", + ""id"": ""4"" + } + }, + ""independent"": { + ""data"": { + ""type"": ""independents"", + ""id"": ""5"" + } + } + } + }, + { + ""type"": ""many-to-manys"", + ""id"": ""3"", + ""attributes"": {}, + ""relationships"": { + ""dependent"": { + ""data"": { + ""type"": ""dependents"", + ""id"": ""4"" + } + }, + ""independent"": { + ""data"": { + ""type"": ""independents"", + ""id"": ""6"" + } + } + } + }, + { + ""type"": ""dependents"", + ""id"": ""4"", + ""attributes"": {}, + ""relationships"": { + ""many-to-manys"": { + ""data"": [{ + ""type"": ""many-to-manys"", + ""id"": ""2"" + }, { + ""type"": ""many-to-manys"", + ""id"": ""3"" + }] + } + } + } + , + { + ""type"": ""independents"", + ""id"": ""5"", + ""attributes"": {}, + ""relationships"": { + ""many-to-manys"": { + ""data"": [{ + ""type"": ""many-to-manys"", + ""id"": ""2"" + }] + } + } + } + , + { + ""type"": ""independents"", + ""id"": ""6"", + ""attributes"": {}, + ""relationships"": { + ""many-to-manys"": { + ""data"": [{ + ""type"": ""many-to-manys"", + ""id"": ""3"" + }] + } + } + } + ] + }"; + + // act + var result = deserializer.Deserialize(contentString); + + // assert + Assert.NotNull(result); + Assert.Equal(1, result.Id); + Assert.NotNull(result.ManyToManys); + Assert.Equal(2, result.ManyToManys.Count); + + // TODO: not sure if this should be a thing that works? + // could this cause cycles in the graph? + // Assert.NotNull(result.ManyToManys[0].Dependent); + // Assert.NotNull(result.ManyToManys[0].Independent); + // Assert.NotNull(result.ManyToManys[1].Dependent); + // Assert.NotNull(result.ManyToManys[1].Independent); + + // Assert.Equal(result.ManyToManys[0].Dependent, result.ManyToManys[1].Dependent); + // Assert.NotEqual(result.ManyToManys[0].Independent, result.ManyToManys[1].Independent); + } + + private JsonApiDeSerializer GetDeserializer(ContextGraphBuilder contextGraphBuilder) + { + var contextGraph = contextGraphBuilder.Build(); + + var jsonApiContextMock = new Mock(); + jsonApiContextMock.SetupAllProperties(); + jsonApiContextMock.Setup(m => m.ContextGraph).Returns(contextGraph); + jsonApiContextMock.Setup(m => m.AttributesToUpdate).Returns(new Dictionary()); + jsonApiContextMock.Setup(m => m.RelationshipsToUpdate).Returns(new Dictionary()); + jsonApiContextMock.Setup(m => m.HasManyRelationshipPointers).Returns(new HasManyRelationshipPointers()); + 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); + + return deserializer; + } + + private class ManyToManyNested : Identifiable + { + [Attr("name")] public string Name { get; set; } + [HasOne("dependent")] public OneToManyDependent Dependent { get; set; } + public int DependentId { get; set; } + [HasOne("independent")] public OneToManyIndependent Independent { get; set; } + public int InependentId { get; set; } + } + private class OneToManyDependent : Identifiable { [Attr("name")] public string Name { get; set; } [HasOne("independent")] public OneToManyIndependent Independent { get; set; } public int IndependentId { get; set; } + + [HasMany("many-to-manys")] public List ManyToManys { get; set; } } private class OneToManyIndependent : Identifiable { [Attr("name")] public string Name { get; set; } [HasMany("dependents")] public List Dependents { get; set; } + + [HasMany("many-to-manys")] public List ManyToManys { get; set; } } } } diff --git a/test/UnitTests/Serialization/JsonApiSerializerTests.cs b/test/UnitTests/Serialization/JsonApiSerializerTests.cs index 8a67b80434..c6b4a09128 100644 --- a/test/UnitTests/Serialization/JsonApiSerializerTests.cs +++ b/test/UnitTests/Serialization/JsonApiSerializerTests.cs @@ -1,9 +1,15 @@ -using JsonApiDotNetCore.Builders; +using System.Collections.Generic; +using System.Linq; +using System.Text.RegularExpressions; +using JsonApiDotNetCore.Builders; using JsonApiDotNetCore.Configuration; +using JsonApiDotNetCore.Extensions; using JsonApiDotNetCore.Internal; using JsonApiDotNetCore.Models; +using JsonApiDotNetCore.Request; using JsonApiDotNetCore.Serialization; using JsonApiDotNetCore.Services; +using Microsoft.Extensions.DependencyInjection; using Moq; using Xunit; @@ -17,19 +23,9 @@ public void Can_Serialize_Complex_Types() // arrange var contextGraphBuilder = new ContextGraphBuilder(); contextGraphBuilder.AddResource("test-resource"); - var contextGraph = contextGraphBuilder.Build(); - - var jsonApiContextMock = new Mock(); - jsonApiContextMock.SetupAllProperties(); - jsonApiContextMock.Setup(m => m.ContextGraph).Returns(contextGraph); - jsonApiContextMock.Setup(m => m.Options).Returns(new JsonApiOptions()); - jsonApiContextMock.Setup(m => m.RequestEntity) - .Returns(contextGraph.GetContextEntity("test-resource")); - jsonApiContextMock.Setup(m => m.MetaBuilder).Returns(new MetaBuilder()); - jsonApiContextMock.Setup(m => m.PageManager).Returns(new PageManager()); + + var serializer = GetSerializer(contextGraphBuilder); - var documentBuilder = new DocumentBuilder(jsonApiContextMock.Object); - var serializer = new JsonApiSerializer(jsonApiContextMock.Object, documentBuilder); var resource = new TestResource { ComplexMember = new ComplexType @@ -43,18 +39,235 @@ public void Can_Serialize_Complex_Types() // assert Assert.NotNull(result); - Assert.Equal("{\"data\":{\"attributes\":{\"complex-member\":{\"compound-name\":\"testname\"}},\"type\":\"test-resource\",\"id\":\"\"}}", result); + + var expectedFormatted = + @"{ + ""data"": { + ""attributes"": { + ""complex-member"": { + ""compound-name"": ""testname"" + } + }, + ""relationships"": { + ""children"": { + ""links"": { + ""self"": ""/test-resource//relationships/children"", + ""related"": ""/test-resource//children"" + } + } + }, + ""type"": ""test-resource"", + ""id"": """" + } + }"; + var expected = Regex.Replace(expectedFormatted, @"\s+", ""); + + Assert.Equal(expected, result); + } + + [Fact] + public void Can_Serialize_Deeply_Nested_Relationships() + { + // arrange + var contextGraphBuilder = new ContextGraphBuilder(); + contextGraphBuilder.AddResource("test-resource"); + contextGraphBuilder.AddResource("children"); + contextGraphBuilder.AddResource("infections"); + + var serializer = GetSerializer( + contextGraphBuilder, + included: new List { "children.infections" } + ); + + var resource = new TestResource + { + Id = 1, + Children = new List { + new ChildResource { + Id = 2, + Infections = new List { + new InfectionResource { Id = 4 }, + new InfectionResource { Id = 5 }, + } + }, + new ChildResource { + Id = 3 + } + } + }; + + // act + var result = serializer.Serialize(resource); + + // assert + Assert.NotNull(result); + + var expectedFormatted = + @"{ + ""data"": { + ""attributes"": { + ""complex-member"": null + }, + ""relationships"": { + ""children"": { + ""links"": { + ""self"": ""/test-resource/1/relationships/children"", + ""related"": ""/test-resource/1/children"" + }, + ""data"": [{ + ""type"": ""children"", + ""id"": ""2"" + }, { + ""type"": ""children"", + ""id"": ""3"" + }] + } + }, + ""type"": ""test-resource"", + ""id"": ""1"" + }, + ""included"": [ + { + ""attributes"": {}, + ""relationships"": { + ""infections"": { + ""links"": { + ""self"": ""/children/2/relationships/infections"", + ""related"": ""/children/2/infections"" + }, + ""data"": [{ + ""type"": ""infections"", + ""id"": ""4"" + }, { + ""type"": ""infections"", + ""id"": ""5"" + }] + }, + ""parent"": { + ""links"": { + ""self"": ""/children/2/relationships/parent"", + ""related"": ""/children/2/parent"" + } + } + }, + ""type"": ""children"", + ""id"": ""2"" + }, + { + ""attributes"": {}, + ""relationships"": { + ""infected"": { + ""links"": { + ""self"": ""/infections/4/relationships/infected"", + ""related"": ""/infections/4/infected"" + } + } + }, + ""type"": ""infections"", + ""id"": ""4"" + }, + { + ""attributes"": {}, + ""relationships"": { + ""infected"": { + ""links"": { + ""self"": ""/infections/5/relationships/infected"", + ""related"": ""/infections/5/infected"" + } + } + }, + ""type"": ""infections"", + ""id"": ""5"" + }, + { + ""attributes"": {}, + ""relationships"": { + ""infections"": { + ""links"": { + ""self"": ""/children/3/relationships/infections"", + ""related"": ""/children/3/infections"" + } + }, + ""parent"": { + ""links"": { + ""self"": ""/children/3/relationships/parent"", + ""related"": ""/children/3/parent"" + } + } + }, + ""type"": ""children"", + ""id"": ""3"" + } + ] + }"; + var expected = Regex.Replace(expectedFormatted, @"\s+", ""); + + Assert.Equal(expected, result); + } + + private JsonApiSerializer GetSerializer( + ContextGraphBuilder contextGraphBuilder, + List included = null) + { + var contextGraph = contextGraphBuilder.Build(); + + var jsonApiContextMock = new Mock(); + jsonApiContextMock.SetupAllProperties(); + jsonApiContextMock.Setup(m => m.ContextGraph).Returns(contextGraph); + jsonApiContextMock.Setup(m => m.Options).Returns(new JsonApiOptions()); + jsonApiContextMock.Setup(m => m.RequestEntity).Returns(contextGraph.GetContextEntity("test-resource")); + // jsonApiContextMock.Setup(m => m.AttributesToUpdate).Returns(new Dictionary()); + // jsonApiContextMock.Setup(m => m.RelationshipsToUpdate).Returns(new Dictionary()); + // jsonApiContextMock.Setup(m => m.HasManyRelationshipPointers).Returns(new HasManyRelationshipPointers()); + // jsonApiContextMock.Setup(m => m.HasOneRelationshipPointers).Returns(new HasOneRelationshipPointers()); + jsonApiContextMock.Setup(m => m.MetaBuilder).Returns(new MetaBuilder()); + jsonApiContextMock.Setup(m => m.PageManager).Returns(new PageManager()); + + if (included != null) + jsonApiContextMock.Setup(m => m.IncludedRelationships).Returns(included); + + var jsonApiOptions = new JsonApiOptions(); + jsonApiContextMock.Setup(m => m.Options).Returns(jsonApiOptions); + + var services = new ServiceCollection(); + + var mvcBuilder = services.AddMvcCore(); + + services + .AddJsonApiInternals(jsonApiOptions); + + var provider = services.BuildServiceProvider(); + var scoped = new TestScopedServiceProvider(provider); + + var documentBuilder = new DocumentBuilder(jsonApiContextMock.Object, scopedServiceProvider: scoped); + var serializer = new JsonApiSerializer(jsonApiContextMock.Object, documentBuilder); + + return serializer; } private class TestResource : Identifiable { [Attr("complex-member")] public ComplexType ComplexMember { get; set; } + + [HasMany("children")] public List Children { get; set; } } private class ComplexType { public string CompoundName { get; set; } } + + private class ChildResource : Identifiable + { + [HasMany("infections")] public List Infections { get; set;} + + [HasOne("parent")] public TestResource Parent { get; set; } + } + + private class InfectionResource : Identifiable + { + [HasOne("infected")] public ChildResource Infected { get; set; } + } } }