From 2621afd020063a68e201c31d862464f70c517202 Mon Sep 17 00:00:00 2001
From: Bart Koelman <bart@degreed.com>
Date: Thu, 31 Mar 2022 13:24:04 +0200
Subject: [PATCH 1/2] Ported existing tests from #846 to verify they still work
 against the new implementation in #1142

---
 .../Models/Animal.cs                          |  16 +
 .../LegacyResourceInheritance/Models/Book.cs  |  12 +
 .../LegacyResourceInheritance/Models/Cat.cs   |  17 +
 .../Models/Content.cs                         |  13 +
 .../LegacyResourceInheritance/Models/Dog.cs   |  12 +
 .../Models/Female.cs                          |  12 +
 .../LegacyResourceInheritance/Models/Male.cs  |  12 +
 .../Models/Person.cs                          |  22 ++
 .../LegacyResourceInheritance/Models/Video.cs |  12 +
 .../ResourceInheritanceDbContext.cs           |  45 +++
 .../ResourceInheritanceTests.cs               | 362 ++++++++++++++++++
 .../TestBuildingBlocks/DbContextExtensions.cs |   8 +
 12 files changed, 543 insertions(+)
 create mode 100644 test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Animal.cs
 create mode 100644 test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Book.cs
 create mode 100644 test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Cat.cs
 create mode 100644 test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Content.cs
 create mode 100644 test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Dog.cs
 create mode 100644 test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Female.cs
 create mode 100644 test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Male.cs
 create mode 100644 test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Person.cs
 create mode 100644 test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Video.cs
 create mode 100644 test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/ResourceInheritanceDbContext.cs
 create mode 100644 test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/ResourceInheritanceTests.cs

diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Animal.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Animal.cs
new file mode 100644
index 0000000000..d7c6fbc494
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Animal.cs
@@ -0,0 +1,16 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance.Models;
+
+[UsedImplicitly(ImplicitUseTargetFlags.Members)]
+[Resource(ControllerNamespace = "JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance")]
+public abstract class Animal : Identifiable<long>
+{
+    [Attr]
+    public bool Feline { get; set; }
+
+    [Attr]
+    public bool IsDomesticated { get; set; }
+}
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Book.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Book.cs
new file mode 100644
index 0000000000..a8f8657793
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Book.cs
@@ -0,0 +1,12 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance.Models;
+
+[UsedImplicitly(ImplicitUseTargetFlags.Members)]
+[Resource(ControllerNamespace = "JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance")]
+public sealed class Book : Content
+{
+    [Attr]
+    public int PageCount { get; set; }
+}
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Cat.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Cat.cs
new file mode 100644
index 0000000000..d0ed803ccb
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Cat.cs
@@ -0,0 +1,17 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance.Models;
+
+[Resource(ControllerNamespace = "JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance")]
+[UsedImplicitly(ImplicitUseTargetFlags.Members)]
+public sealed class Cat : Animal
+{
+    [Attr]
+    public bool ScaredOfDogs { get; set; }
+
+    public Cat()
+    {
+        Feline = true;
+    }
+}
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Content.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Content.cs
new file mode 100644
index 0000000000..49876b745d
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Content.cs
@@ -0,0 +1,13 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance.Models;
+
+[UsedImplicitly(ImplicitUseTargetFlags.Members)]
+[Resource(ControllerNamespace = "JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance")]
+public abstract class Content : Identifiable<long>
+{
+    [HasMany]
+    public List<Person> Author { get; set; } = new();
+}
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Dog.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Dog.cs
new file mode 100644
index 0000000000..86b2e12786
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Dog.cs
@@ -0,0 +1,12 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance.Models;
+
+[UsedImplicitly(ImplicitUseTargetFlags.Members)]
+[Resource(ControllerNamespace = "JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance")]
+public sealed class Dog : Animal
+{
+    [Attr]
+    public bool RespondsToName { get; set; }
+}
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Female.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Female.cs
new file mode 100644
index 0000000000..6fe24968de
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Female.cs
@@ -0,0 +1,12 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance.Models;
+
+[UsedImplicitly(ImplicitUseTargetFlags.Members)]
+[Resource(ControllerNamespace = "JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance")]
+public sealed class Female : Person
+{
+    [Attr]
+    public bool IsPregnant { get; set; }
+}
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Male.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Male.cs
new file mode 100644
index 0000000000..ed85c419b0
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Male.cs
@@ -0,0 +1,12 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance.Models;
+
+[UsedImplicitly(ImplicitUseTargetFlags.Members)]
+[Resource(ControllerNamespace = "JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance")]
+public sealed class Male : Person
+{
+    [Attr]
+    public bool HasBeard { get; set; }
+}
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Person.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Person.cs
new file mode 100644
index 0000000000..e248d1f330
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Person.cs
@@ -0,0 +1,22 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance.Models;
+
+[UsedImplicitly(ImplicitUseTargetFlags.Members)]
+[Resource(ControllerNamespace = "JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance")]
+public abstract class Person : Identifiable<long>
+{
+    [Attr]
+    public bool Retired { get; set; }
+
+    [HasOne]
+    public Animal? Pet { get; set; }
+
+    [HasMany]
+    public List<Person> Parents { get; set; } = new();
+
+    [HasMany]
+    public List<Content> FavoriteContent { get; set; } = new();
+}
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Video.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Video.cs
new file mode 100644
index 0000000000..31f8e8fd7f
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/Models/Video.cs
@@ -0,0 +1,12 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance.Models;
+
+[UsedImplicitly(ImplicitUseTargetFlags.Members)]
+[Resource(ControllerNamespace = "JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance")]
+public sealed class Video : Content
+{
+    [Attr]
+    public int Duration { get; set; }
+}
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/ResourceInheritanceDbContext.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/ResourceInheritanceDbContext.cs
new file mode 100644
index 0000000000..8ffb825572
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/ResourceInheritanceDbContext.cs
@@ -0,0 +1,45 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance.Models;
+using Microsoft.EntityFrameworkCore;
+
+// @formatter:wrap_chained_method_calls chop_always
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance;
+
+[UsedImplicitly(ImplicitUseTargetFlags.Members)]
+public sealed class ResourceInheritanceDbContext : DbContext
+{
+    public DbSet<Person> People => Set<Person>();
+    public DbSet<Cat> Cats => Set<Cat>();
+    public DbSet<Dog> Dogs => Set<Dog>();
+    public DbSet<Female> Females => Set<Female>();
+    public DbSet<Male> Males => Set<Male>();
+    public DbSet<Book> FictionBooks => Set<Book>();
+    public DbSet<Video> NonFictionBooks => Set<Video>();
+
+    public ResourceInheritanceDbContext(DbContextOptions<ResourceInheritanceDbContext> options)
+        : base(options)
+    {
+    }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.Entity<Person>()
+            .ToTable("Persons")
+            .HasDiscriminator<int>("Type")
+            .HasValue<Male>(1)
+            .HasValue<Female>(2);
+
+        modelBuilder.Entity<Animal>()
+            .ToTable("Animals")
+            .HasDiscriminator<int>("Type")
+            .HasValue<Cat>(1)
+            .HasValue<Dog>(2);
+
+        modelBuilder.Entity<Content>()
+            .ToTable("Books")
+            .HasDiscriminator<int>("Type")
+            .HasValue<Video>(1)
+            .HasValue<Book>(2);
+    }
+}
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/ResourceInheritanceTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/ResourceInheritanceTests.cs
new file mode 100644
index 0000000000..9f8c441023
--- /dev/null
+++ b/test/JsonApiDotNetCoreTests/IntegrationTests/LegacyResourceInheritance/ResourceInheritanceTests.cs
@@ -0,0 +1,362 @@
+using System.Net;
+using FluentAssertions;
+using JsonApiDotNetCore.Serialization.Objects;
+using JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance.Models;
+using Microsoft.EntityFrameworkCore;
+using TestBuildingBlocks;
+using Xunit;
+
+namespace JsonApiDotNetCoreTests.IntegrationTests.LegacyResourceInheritance;
+
+public sealed class ResourceInheritanceTests
+    : IClassFixture<IntegrationTestContext<TestableStartup<ResourceInheritanceDbContext>, ResourceInheritanceDbContext>>
+{
+    private readonly IntegrationTestContext<TestableStartup<ResourceInheritanceDbContext>, ResourceInheritanceDbContext> _testContext;
+
+    public ResourceInheritanceTests(IntegrationTestContext<TestableStartup<ResourceInheritanceDbContext>, ResourceInheritanceDbContext> testContext)
+    {
+        _testContext = testContext;
+
+        testContext.UseController<AnimalsController>();
+        testContext.UseController<CatsController>();
+        testContext.UseController<DogsController>();
+
+        testContext.UseController<PeopleController>();
+        testContext.UseController<MalesController>();
+        testContext.UseController<FemalesController>();
+
+        testContext.UseController<ContentsController>();
+        testContext.UseController<BooksController>();
+        testContext.UseController<VideosController>();
+
+        _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            await dbContext.ClearTablesAsync<Animal, Content, Person>();
+        }).Wait();
+    }
+
+    [Fact]
+    public async Task Can_create_resource_with_to_one_relationship()
+    {
+        // Arrange
+        var newCat = new Cat();
+
+        await _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            await dbContext.AddAsync(newCat);
+            await dbContext.SaveChangesAsync();
+        });
+
+        var requestBody = new
+        {
+            data = new
+            {
+                type = "males",
+                relationships = new Dictionary<string, object>
+                {
+                    {
+                        "pet", new
+                        {
+                            data = new
+                            {
+                                type = "cats",
+                                id = newCat.StringId
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        const string route = "/people";
+
+        // Act
+        (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+        // Assert
+        httpResponse.Should().HaveStatusCode(HttpStatusCode.Created);
+
+        responseDocument.Data.SingleValue.ShouldNotBeNull();
+
+        long newPersonId = long.Parse(responseDocument.Data.SingleValue.Id!);
+
+        await _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            Person personInDatabase = await dbContext.People.Include(person => person.Pet).FirstWithIdAsync(newPersonId);
+
+            personInDatabase.Pet.Should().NotBeNull();
+            personInDatabase.Pet!.GetType().Should().Be(newCat.GetType());
+        });
+    }
+
+    [Fact]
+    public async Task Can_patch_resource_with_to_one_relationship_through_relationship_link()
+    {
+        // Arrange
+        var existingPerson = new Male();
+        var existingCat = new Cat();
+
+        await _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            await dbContext.AddRangeAsync(existingPerson, existingCat);
+            await dbContext.SaveChangesAsync();
+        });
+
+        var requestBody = new
+        {
+            data = new
+            {
+                type = "cats",
+                id = existingCat.StringId
+            }
+        };
+
+        string route = $"/people/{existingPerson.Id}/relationships/pet";
+
+        // Act
+        (HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecutePatchAsync<string>(route, requestBody);
+
+        // Assert
+        httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
+
+        responseDocument.Should().BeEmpty();
+
+        await _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            Person personInDatabase = await dbContext.People.Include(person => person.Pet).FirstWithIdAsync(existingPerson.Id);
+
+            personInDatabase.Pet.ShouldNotBeNull();
+            personInDatabase.Pet.GetType().Should().Be(existingCat.GetType());
+        });
+    }
+
+    [Fact]
+    public async Task Can_create_resource_with_to_many_relationship()
+    {
+        // Arrange
+        var existingFather = new Male();
+        var existingMother = new Female();
+
+        await _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            await dbContext.AddRangeAsync(existingFather, existingMother);
+            await dbContext.SaveChangesAsync();
+        });
+
+        var requestBody = new
+        {
+            data = new
+            {
+                type = "males",
+                relationships = new Dictionary<string, object>
+                {
+                    {
+                        "parents", new
+                        {
+                            data = new[]
+                            {
+                                new
+                                {
+                                    type = "males",
+                                    id = existingFather.StringId
+                                },
+                                new
+                                {
+                                    type = "females",
+                                    id = existingMother.StringId
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        const string route = "/people";
+
+        // Act
+        (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+        // Assert
+        httpResponse.Should().HaveStatusCode(HttpStatusCode.Created);
+
+        responseDocument.Data.SingleValue.ShouldNotBeNull();
+
+        long newPersonId = long.Parse(responseDocument.Data.SingleValue.Id!);
+
+        await _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            Person personInDatabase = await dbContext.People.Include(person => person.Parents).FirstWithIdAsync(newPersonId);
+
+            personInDatabase.Parents.Should().HaveCount(2);
+            personInDatabase.Parents.Should().ContainSingle(person => person is Male);
+            personInDatabase.Parents.Should().ContainSingle(person => person is Female);
+        });
+    }
+
+    [Fact]
+    public async Task Can_patch_resource_with_to_many_relationship_through_relationship_link()
+    {
+        // Arrange
+        var existingChild = new Male();
+        var existingFather = new Male();
+        var existingMother = new Female();
+
+        await _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            await dbContext.AddRangeAsync(existingChild, existingFather, existingMother);
+            await dbContext.SaveChangesAsync();
+        });
+
+        var requestBody = new
+        {
+            data = new[]
+            {
+                new
+                {
+                    type = "males",
+                    id = existingFather.StringId
+                },
+                new
+                {
+                    type = "females",
+                    id = existingMother.StringId
+                }
+            }
+        };
+
+        string route = $"/people/{existingChild.StringId}/relationships/parents";
+
+        // Act
+        (HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecutePatchAsync<string>(route, requestBody);
+
+        // Assert
+        httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
+
+        responseDocument.Should().BeEmpty();
+
+        await _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            Male childInDatabase = await dbContext.Males.Include(male => male.Parents).FirstWithIdAsync(existingChild.Id);
+
+            childInDatabase.Parents.Should().HaveCount(2);
+            childInDatabase.Parents.Should().ContainSingle(person => person is Male);
+            childInDatabase.Parents.Should().ContainSingle(person => person is Female);
+        });
+    }
+
+    [Fact]
+    public async Task Can_create_resource_with_many_to_many_relationship()
+    {
+        // Arrange
+        var existingBook = new Book();
+        var existingVideo = new Video();
+
+        await _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            await dbContext.AddRangeAsync(existingBook, existingVideo);
+            await dbContext.SaveChangesAsync();
+        });
+
+        var requestBody = new
+        {
+            data = new
+            {
+                type = "males",
+                relationships = new Dictionary<string, object>
+                {
+                    {
+                        "favoriteContent", new
+                        {
+                            data = new[]
+                            {
+                                new
+                                {
+                                    type = "books",
+                                    id = existingBook.StringId
+                                },
+                                new
+                                {
+                                    type = "videos",
+                                    id = existingVideo.StringId
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        const string route = "/males?include=favoriteContent";
+
+        // Act
+        (HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
+
+        // Assert
+        httpResponse.Should().HaveStatusCode(HttpStatusCode.Created);
+
+        responseDocument.Data.SingleValue.ShouldNotBeNull();
+
+        long newPersonId = long.Parse(responseDocument.Data.SingleValue.Id!);
+
+        await _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            Person personInDatabase = await dbContext.People.Include(person => person.FavoriteContent).FirstWithIdAsync(newPersonId);
+
+            personInDatabase.FavoriteContent.Should().HaveCount(2);
+            personInDatabase.FavoriteContent.Should().ContainSingle(content => content is Book);
+            personInDatabase.FavoriteContent.Should().ContainSingle(content => content is Video);
+        });
+    }
+
+    [Fact]
+    public async Task Can_patch_resource_with_many_to_many_relationship_through_relationship_link()
+    {
+        // Arrange
+        var existingNook = new Book();
+        var existingVideo = new Video();
+        var existingPerson = new Male();
+
+        await _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            await dbContext.AddRangeAsync(existingNook, existingVideo, existingPerson);
+            await dbContext.SaveChangesAsync();
+        });
+
+        var requestBody = new
+        {
+            data = new[]
+            {
+                new
+                {
+                    type = "books",
+                    id = existingNook.StringId
+                },
+                new
+                {
+                    type = "videos",
+                    id = existingVideo.StringId
+                }
+            }
+        };
+
+        string route = $"/people/{existingPerson.Id}/relationships/favoriteContent";
+
+        // Act
+        (HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecutePatchAsync<string>(route, requestBody);
+
+        // Assert
+        httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
+
+        responseDocument.Should().BeEmpty();
+
+        await _testContext.RunOnDatabaseAsync(async dbContext =>
+        {
+            Male maleInDatabase = await dbContext.Males.Include(male => male.FavoriteContent).FirstWithIdAsync(existingPerson.Id);
+
+            maleInDatabase.FavoriteContent.Should().HaveCount(2);
+            maleInDatabase.FavoriteContent.Should().ContainSingle(content => content is Book);
+            maleInDatabase.FavoriteContent.Should().ContainSingle(content => content is Video);
+        });
+    }
+}
diff --git a/test/TestBuildingBlocks/DbContextExtensions.cs b/test/TestBuildingBlocks/DbContextExtensions.cs
index b570cbf655..134d1118c8 100644
--- a/test/TestBuildingBlocks/DbContextExtensions.cs
+++ b/test/TestBuildingBlocks/DbContextExtensions.cs
@@ -24,6 +24,14 @@ public static async Task ClearTablesAsync<TEntity1, TEntity2>(this DbContext dbC
         await ClearTablesAsync(dbContext, typeof(TEntity1), typeof(TEntity2));
     }
 
+    public static async Task ClearTablesAsync<TEntity1, TEntity2, TEntity3>(this DbContext dbContext)
+        where TEntity1 : class
+        where TEntity2 : class
+        where TEntity3 : class
+    {
+        await ClearTablesAsync(dbContext, typeof(TEntity1), typeof(TEntity2), typeof(TEntity3));
+    }
+
     private static async Task ClearTablesAsync(this DbContext dbContext, params Type[] models)
     {
         foreach (Type model in models)

From af98da6df8c363b2fae8eb32a4940a35256c6a84 Mon Sep 17 00:00:00 2001
From: Bart Koelman <bart@degreed.com>
Date: Thu, 31 Mar 2022 13:38:30 +0200
Subject: [PATCH 2/2] Trying to get ci-build to validate this PR

---
 Build.ps1    | 9 +++++++++
 appveyor.yml | 1 +
 2 files changed, 10 insertions(+)

diff --git a/Build.ps1 b/Build.ps1
index e2e638fafa..b02e4bb7bb 100644
--- a/Build.ps1
+++ b/Build.ps1
@@ -94,6 +94,15 @@ function CreateNuGetPackage {
     CheckLastExitCode
 }
 
+# In a PR the base branch needs to be fetched in order for regitlint to work.
+function FetchBaseBranchIfNotMaster() {
+    if ($env:APPVEYOR_PULL_REQUEST_NUMBER -And $env:APPVEYOR_REPO_BRANCH -ne "master") {
+        git fetch -q origin ${env:APPVEYOR_REPO_BRANCH}:${env:APPVEYOR_REPO_BRANCH}
+    }
+}
+
+FetchBaseBranchIfNotMaster
+
 dotnet tool restore
 CheckLastExitCode
 
diff --git a/appveyor.yml b/appveyor.yml
index 4a39f6c4e3..376dd4275f 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -15,6 +15,7 @@ environment:
 branches:
   only:
   - master
+  - resource-inheritance
   - develop
   - unstable
   - /release\/.+/