Removed .BeCloseTo, now that fakers truncate time to whole milliseconds. Removed runtime casts, because the JSON deserializer now creates the correct types (based on the resource graph).

Bart Koelman · Bart Koelman · commit 677665d40d0b · 2021-12-03T18:51:38.000+01:00
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/Archiving/ArchiveTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/Archiving/ArchiveTests.cs
@@ -54,9 +54,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             responseDocument.Data.SingleValue.ShouldNotBeNull();
             responseDocument.Data.SingleValue.Id.Should().Be(broadcast.StringId);
-
-            responseDocument.Data.SingleValue.Attributes.ShouldContainKey("archivedAt")
-                .With(value => value.As<DateTimeOffset?>().Should().BeCloseTo(broadcast.ArchivedAt!.Value));
+            responseDocument.Data.SingleValue.Attributes.ShouldContainKey("archivedAt").With(value => value.Should().Be(broadcast.ArchivedAt));
         }
 
         [Fact]
@@ -82,7 +80,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             responseDocument.Data.SingleValue.ShouldNotBeNull();
             responseDocument.Data.SingleValue.Id.Should().Be(broadcast.StringId);
-            responseDocument.Data.SingleValue.Attributes.ShouldContainKey("archivedAt").With(value => value.As<DateTimeOffset?>().Should().BeNull());
+            responseDocument.Data.SingleValue.Attributes.ShouldContainKey("archivedAt").With(value => value.Should().BeNull());
         }
 
         [Fact]
@@ -109,7 +107,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             responseDocument.Data.ManyValue.ShouldHaveCount(1);
             responseDocument.Data.ManyValue[0].Id.Should().Be(broadcasts[1].StringId);
-            responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("archivedAt").With(value => value.As<DateTimeOffset?>().Should().BeNull());
+            responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("archivedAt").With(value => value.Should().BeNull());
         }
 
         [Fact]
@@ -136,9 +134,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             responseDocument.Data.ManyValue.ShouldHaveCount(2);
             responseDocument.Data.ManyValue[0].Id.Should().Be(broadcasts[0].StringId);
-
-            responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("archivedAt")
-                .With(value => value.As<DateTimeOffset?>().Should().BeCloseTo(broadcasts[0].ArchivedAt!.Value));
+            responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("archivedAt").With(value => value.Should().Be(broadcasts[0].ArchivedAt));
 
             responseDocument.Data.ManyValue[1].Id.Should().Be(broadcasts[1].StringId);
             responseDocument.Data.ManyValue[1].Attributes.ShouldContainKey("archivedAt").With(value => value.Should().BeNull());
@@ -204,7 +200,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             responseDocument.Included.ShouldHaveCount(2);
             responseDocument.Included[0].Id.Should().Be(station.Broadcasts.ElementAt(0).StringId);
-            responseDocument.Included[0].Attributes.ShouldContainKey("archivedAt").With(value => value.As<DateTimeOffset?>().Should().BeCloseTo(archivedAt0));
+            responseDocument.Included[0].Attributes.ShouldContainKey("archivedAt").With(value => value.Should().Be(archivedAt0));
             responseDocument.Included[1].Id.Should().Be(station.Broadcasts.ElementAt(1).StringId);
             responseDocument.Included[1].Attributes.ShouldContainKey("archivedAt").With(value => value.Should().BeNull());
         }
@@ -232,9 +228,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             responseDocument.Data.SingleValue.ShouldNotBeNull();
             responseDocument.Data.SingleValue.Id.Should().Be(comment.AppliesTo.StringId);
-
-            responseDocument.Data.SingleValue.Attributes.ShouldContainKey("archivedAt")
-                .With(value => value.As<DateTimeOffset?>().Should().BeCloseTo(comment.AppliesTo.ArchivedAt!.Value));
+            responseDocument.Data.SingleValue.Attributes.ShouldContainKey("archivedAt").With(value => value.Should().Be(comment.AppliesTo.ArchivedAt));
         }
 
         [Fact]
@@ -286,11 +280,11 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             // Assert
             httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
 
+            DateTimeOffset archivedAt0 = station.Broadcasts.ElementAt(0).ArchivedAt!.Value;
+
             responseDocument.Data.ManyValue.ShouldHaveCount(2);
             responseDocument.Data.ManyValue[0].Id.Should().Be(station.Broadcasts.ElementAt(0).StringId);
-
-            responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("archivedAt").With(value =>
-                value.As<DateTimeOffset?>().Should().BeCloseTo(station.Broadcasts.ElementAt(0).ArchivedAt!.Value));
+            responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("archivedAt").With(value => value.Should().Be(archivedAt0));
 
             responseDocument.Data.ManyValue[1].Id.Should().Be(station.Broadcasts.ElementAt(1).StringId);
             responseDocument.Data.ManyValue[1].Attributes.ShouldContainKey("archivedAt").With(value => value.Should().BeNull());
@@ -357,7 +351,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             responseDocument.Included.ShouldHaveCount(2);
             responseDocument.Included[0].Id.Should().Be(network.Stations.ElementAt(0).Broadcasts.ElementAt(0).StringId);
-            responseDocument.Included[0].Attributes.ShouldContainKey("archivedAt").With(value => value.As<DateTimeOffset?>().Should().BeCloseTo(archivedAt0));
+            responseDocument.Included[0].Attributes.ShouldContainKey("archivedAt").With(value => value.Should().Be(archivedAt0));
             responseDocument.Included[1].Id.Should().Be(network.Stations.ElementAt(0).Broadcasts.ElementAt(1).StringId);
             responseDocument.Included[1].Attributes.ShouldContainKey("archivedAt").With(value => value.Should().BeNull());
         }
@@ -444,10 +438,7 @@ public async Task Can_create_unarchived_resource()
 
             responseDocument.Data.SingleValue.ShouldNotBeNull();
             responseDocument.Data.SingleValue.Attributes.ShouldContainKey("title").With(value => value.Should().Be(newBroadcast.Title));
-
-            responseDocument.Data.SingleValue.Attributes.ShouldContainKey("airedAt")
-                .With(value => value.As<DateTimeOffset>().Should().BeCloseTo(newBroadcast.AiredAt));
-
+            responseDocument.Data.SingleValue.Attributes.ShouldContainKey("airedAt").With(value => value.Should().Be(newBroadcast.AiredAt));
             responseDocument.Data.SingleValue.Attributes.ShouldContainKey("archivedAt").With(value => value.Should().BeNull());
         }
 
@@ -529,7 +520,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             {
                 TelevisionBroadcast broadcastInDatabase = await dbContext.Broadcasts.FirstWithIdAsync(existingBroadcast.Id);
 
-                broadcastInDatabase.ArchivedAt.Should().BeCloseTo(newArchivedAt);
+                broadcastInDatabase.ArchivedAt.Should().Be(newArchivedAt);
             });
         }
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Creating/AtomicCreateResourceTests.cs
@@ -76,7 +76,7 @@ public async Task Can_create_resource()
             {
                 resource.Type.Should().Be("performers");
                 resource.Attributes.ShouldContainKey("artistName").With(value => value.Should().Be(newArtistName));
-                resource.Attributes.ShouldContainKey("bornAt").With(value => value.As<DateTimeOffset>().Should().BeCloseTo(newBornAt));
+                resource.Attributes.ShouldContainKey("bornAt").With(value => value.Should().Be(newBornAt));
                 resource.Relationships.Should().BeNull();
             });
 
@@ -87,7 +87,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 Performer performerInDatabase = await dbContext.Performers.FirstWithIdAsync(newPerformerId);
 
                 performerInDatabase.ArtistName.Should().Be(newArtistName);
-                performerInDatabase.BornAt.Should().BeCloseTo(newBornAt);
+                performerInDatabase.BornAt.Should().Be(newBornAt);
             });
         }
 
@@ -147,9 +147,7 @@ public async Task Can_create_resources()
                         .With(value => value.As<decimal?>().Should().BeApproximately(newTracks[index].LengthInSeconds));
 
                     resource.Attributes.ShouldContainKey("genre").With(value => value.Should().Be(newTracks[index].Genre));
-
-                    resource.Attributes.ShouldContainKey("releasedAt")
-                        .With(value => value.As<DateTimeOffset>().Should().BeCloseTo(newTracks[index].ReleasedAt));
+                    resource.Attributes.ShouldContainKey("releasedAt").With(value => value.Should().Be(newTracks[index].ReleasedAt));
 
                     resource.Relationships.ShouldNotBeEmpty();
                 });
@@ -170,7 +168,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                     trackInDatabase.Title.Should().Be(newTracks[index].Title);
                     trackInDatabase.LengthInSeconds.Should().BeApproximately(newTracks[index].LengthInSeconds);
                     trackInDatabase.Genre.Should().Be(newTracks[index].Genre);
-                    trackInDatabase.ReleasedAt.Should().BeCloseTo(newTracks[index].ReleasedAt);
+                    trackInDatabase.ReleasedAt.Should().Be(newTracks[index].ReleasedAt);
                 }
             });
         }
@@ -214,7 +212,7 @@ public async Task Can_create_resource_without_attributes_or_relationships()
             {
                 resource.Type.Should().Be("performers");
                 resource.Attributes.ShouldContainKey("artistName").With(value => value.Should().BeNull());
-                resource.Attributes.ShouldContainKey("bornAt").With(value => value.As<DateTimeOffset>().Should().BeCloseTo(default));
+                resource.Attributes.ShouldContainKey("bornAt").With(value => value.Should().Be(default(DateTimeOffset)));
                 resource.Relationships.Should().BeNull();
             });
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/LocalIds/AtomicLocalIdTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/LocalIds/AtomicLocalIdTests.cs
@@ -188,7 +188,7 @@ public async Task Can_create_resource_with_OneToMany_relationship_using_local_ID
                 resource.Type.Should().Be("performers");
                 resource.Lid.Should().BeNull();
                 resource.Attributes.ShouldContainKey("artistName").With(value => value.Should().Be(newPerformer.ArtistName));
-                resource.Attributes.ShouldContainKey("bornAt").With(value => value.As<DateTimeOffset>().Should().BeCloseTo(newPerformer.BornAt));
+                resource.Attributes.ShouldContainKey("bornAt").With(value => value.Should().Be(newPerformer.BornAt));
             });
 
             responseDocument.Results[1].Data.SingleValue.ShouldNotBeNull().With(resource =>
@@ -210,7 +210,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 trackInDatabase.Performers.ShouldHaveCount(1);
                 trackInDatabase.Performers[0].Id.Should().Be(newPerformerId);
                 trackInDatabase.Performers[0].ArtistName.Should().Be(newPerformer.ArtistName);
-                trackInDatabase.Performers[0].BornAt.Should().BeCloseTo(newPerformer.BornAt);
+                trackInDatabase.Performers[0].BornAt.Should().Be(newPerformer.BornAt);
             });
         }
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicUpdateResourceTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/AtomicOperations/Updating/Resources/AtomicUpdateResourceTests.cs
@@ -434,7 +434,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 trackInDatabase.Title.Should().Be(existingTrack.Title);
                 trackInDatabase.LengthInSeconds.Should().BeApproximately(existingTrack.LengthInSeconds);
                 trackInDatabase.Genre.Should().Be(newGenre);
-                trackInDatabase.ReleasedAt.Should().BeCloseTo(existingTrack.ReleasedAt);
+                trackInDatabase.ReleasedAt.Should().Be(existingTrack.ReleasedAt);
 
                 trackInDatabase.OwnedBy.ShouldNotBeNull();
                 trackInDatabase.OwnedBy.Id.Should().Be(existingTrack.OwnedBy.Id);
@@ -499,7 +499,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 trackInDatabase.Title.Should().Be(newTitle);
                 trackInDatabase.LengthInSeconds.Should().BeApproximately(newLengthInSeconds);
                 trackInDatabase.Genre.Should().Be(newGenre);
-                trackInDatabase.ReleasedAt.Should().BeCloseTo(newReleasedAt);
+                trackInDatabase.ReleasedAt.Should().Be(newReleasedAt);
 
                 trackInDatabase.OwnedBy.ShouldNotBeNull();
                 trackInDatabase.OwnedBy.Id.Should().Be(existingTrack.OwnedBy.Id);
@@ -700,7 +700,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
                 Performer performerInDatabase = await dbContext.Performers.FirstWithIdAsync(existingPerformer.Id);
 
                 performerInDatabase.ArtistName.Should().Be(newArtistName);
-                performerInDatabase.BornAt.Should().BeCloseTo(existingPerformer.BornAt);
+                performerInDatabase.BornAt.Should().Be(existingPerformer.BornAt);
             });
         }
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Filtering/FilterDataTypeTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Filtering/FilterDataTypeTests.cs
@@ -160,7 +160,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.Data.ManyValue.ShouldHaveCount(1);
 
             responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("someDateTimeInLocalZone")
-                .With(value => value.As<DateTime>().Should().BeCloseTo(resource.SomeDateTimeInLocalZone));
+                .With(value => value.Should().Be(resource.SomeDateTimeInLocalZone));
         }
 
         [Fact]
@@ -190,7 +190,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.Data.ManyValue.ShouldHaveCount(1);
 
             responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("someDateTimeInUtcZone")
-                .With(value => value.As<DateTime>().Should().BeCloseTo(resource.SomeDateTimeInUtcZone));
+                .With(value => value.Should().Be(resource.SomeDateTimeInUtcZone));
         }
 
         [Fact]
@@ -218,9 +218,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
 
             responseDocument.Data.ManyValue.ShouldHaveCount(1);
-
-            responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("someDateTimeOffset")
-                .With(value => value.As<DateTimeOffset>().Should().BeCloseTo(resource.SomeDateTimeOffset));
+            responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("someDateTimeOffset").With(value => value.Should().Be(resource.SomeDateTimeOffset));
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Filtering/FilterOperatorTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Filtering/FilterOperatorTests.cs
@@ -384,7 +384,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.Data.ManyValue.ShouldHaveCount(1);
 
             responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("someDateTimeInLocalZone")
-                .With(value => value.As<DateTime>().Should().BeCloseTo(resource.SomeDateTimeInLocalZone));
+                .With(value => value.Should().Be(resource.SomeDateTimeInLocalZone));
         }
 
         [Theory]
@@ -428,7 +428,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.Data.ManyValue.ShouldHaveCount(1);
 
             responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("someDateTimeInUtcZone")
-                .With(value => value.As<DateTime>().Should().BeCloseTo(resource.SomeDateTimeInUtcZone));
+                .With(value => value.Should().Be(resource.SomeDateTimeInUtcZone));
         }
 
         [Theory]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Includes/IncludeTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/Includes/IncludeTests.cs
@@ -225,7 +225,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
             responseDocument.Included.ShouldHaveCount(1);
             responseDocument.Included[0].Type.Should().Be("comments");
             responseDocument.Included[0].Id.Should().Be(post.Comments.Single().StringId);
-            responseDocument.Included[0].Attributes.ShouldContainKey("createdAt").With(value => value.As<DateTime>().Should().BeCloseTo(createdAt));
+            responseDocument.Included[0].Attributes.ShouldContainKey("createdAt").With(value => value.Should().Be(createdAt));
         }
 
         [Fact]
@@ -371,7 +371,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             responseDocument.Included[1].Type.Should().Be("comments");
             responseDocument.Included[1].Id.Should().Be(blog.Posts[0].Comments.Single().StringId);
-            responseDocument.Included[1].Attributes.ShouldContainKey("createdAt").With(value => value.As<DateTime>().Should().BeCloseTo(createdAt));
+            responseDocument.Included[1].Attributes.ShouldContainKey("createdAt").With(value => value.Should().Be(createdAt));
         }
 
         [Fact]
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/QueryStringFakers.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/QueryStringFakers.cs
@@ -40,13 +40,14 @@ internal sealed class QueryStringFakers : FakerContainer
                 .RuleFor(webAccount => webAccount.UserName, faker => faker.Person.UserName)
                 .RuleFor(webAccount => webAccount.Password, faker => faker.Internet.Password())
                 .RuleFor(webAccount => webAccount.DisplayName, faker => faker.Person.FullName)
-                .RuleFor(webAccount => webAccount.DateOfBirth, faker => faker.Person.DateOfBirth)
+                .RuleFor(webAccount => webAccount.DateOfBirth, faker => faker.Person.DateOfBirth.TruncateToWholeMilliseconds())
                 .RuleFor(webAccount => webAccount.EmailAddress, faker => faker.Internet.Email()));
 
         private readonly Lazy<Faker<LoginAttempt>> _lazyLoginAttemptFaker = new(() =>
             new Faker<LoginAttempt>()
                 .UseSeed(GetFakerSeed())
-                .RuleFor(loginAttempt => loginAttempt.TriedAt, faker => faker.Date.PastOffset())
+                .RuleFor(loginAttempt => loginAttempt.TriedAt, faker => faker.Date.PastOffset()
+                    .TruncateToWholeMilliseconds())
                 .RuleFor(loginAttempt => loginAttempt.IsSucceeded, faker => faker.Random.Bool()));
 
         private readonly Lazy<Faker<AccountPreferences>> _lazyAccountPreferencesFaker = new(() =>
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/SparseFieldSets/SparseFieldSetTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/QueryStrings/SparseFieldSets/SparseFieldSetTests.cs
@@ -593,13 +593,11 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>
 
             responseDocument.Included.ShouldHaveCount(2);
 
-            DateTime dateOfBirth = blog.Owner.DateOfBirth!.Value;
-
             responseDocument.Included[0].Type.Should().Be("webAccounts");
             responseDocument.Included[0].Id.Should().Be(blog.Owner.StringId);
             responseDocument.Included[0].Attributes.ShouldContainKey("userName").With(value => value.Should().Be(blog.Owner.UserName));
             responseDocument.Included[0].Attributes.ShouldContainKey("displayName").With(value => value.Should().Be(blog.Owner.DisplayName));
-            responseDocument.Included[0].Attributes.ShouldContainKey("dateOfBirth").With(value => value.As<DateTime?>().Should().BeCloseTo(dateOfBirth));
+            responseDocument.Included[0].Attributes.ShouldContainKey("dateOfBirth").With(value => value.Should().Be(blog.Owner.DateOfBirth));
 
             responseDocument.Included[0].Relationships.ShouldContainKey("posts").With(value =>
             {
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Fetching/FetchResourceTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ReadWrite/Fetching/FetchResourceTests.cs
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceConstructorInjection/ResourceInjectionTests.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceConstructorInjection/ResourceInjectionTests.cs
diff --git a/test/TestBuildingBlocks/ObjectAssertionsExtensions.cs b/test/TestBuildingBlocks/ObjectAssertionsExtensions.cs

Original file line number	Diff line number	Diff line change
`@@ -384,7 +384,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>`
`384`	`384`	`responseDocument.Data.ManyValue.ShouldHaveCount(1);`
`385`	`385`
`386`	`386`	`responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("someDateTimeInLocalZone")`
`387`		`- .With(value => value.As<DateTime>().Should().BeCloseTo(resource.SomeDateTimeInLocalZone));`
	`387`	`+ .With(value => value.Should().Be(resource.SomeDateTimeInLocalZone));`
`388`	`388`	`}`
`389`	`389`
`390`	`390`	`[Theory]`
`@@ -428,7 +428,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>`
`428`	`428`	`responseDocument.Data.ManyValue.ShouldHaveCount(1);`
`429`	`429`
`430`	`430`	`responseDocument.Data.ManyValue[0].Attributes.ShouldContainKey("someDateTimeInUtcZone")`
`431`		`- .With(value => value.As<DateTime>().Should().BeCloseTo(resource.SomeDateTimeInUtcZone));`
	`431`	`+ .With(value => value.Should().Be(resource.SomeDateTimeInUtcZone));`
`432`	`432`	`}`
`433`	`433`
`434`	`434`	`[Theory]`
Original file line number	Diff line number	Diff line change
`@@ -225,7 +225,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>`
`225`	`225`	`responseDocument.Included.ShouldHaveCount(1);`
`226`	`226`	`responseDocument.Included[0].Type.Should().Be("comments");`
`227`	`227`	`responseDocument.Included[0].Id.Should().Be(post.Comments.Single().StringId);`
`228`		`- responseDocument.Included[0].Attributes.ShouldContainKey("createdAt").With(value => value.As<DateTime>().Should().BeCloseTo(createdAt));`
	`228`	`+ responseDocument.Included[0].Attributes.ShouldContainKey("createdAt").With(value => value.Should().Be(createdAt));`
`229`	`229`	`}`
`230`	`230`
`231`	`231`	`[Fact]`
`@@ -371,7 +371,7 @@ await _testContext.RunOnDatabaseAsync(async dbContext =>`
`371`	`371`
`372`	`372`	`responseDocument.Included[1].Type.Should().Be("comments");`
`373`	`373`	`responseDocument.Included[1].Id.Should().Be(blog.Posts[0].Comments.Single().StringId);`
`374`		`- responseDocument.Included[1].Attributes.ShouldContainKey("createdAt").With(value => value.As<DateTime>().Should().BeCloseTo(createdAt));`
	`374`	`+ responseDocument.Included[1].Attributes.ShouldContainKey("createdAt").With(value => value.Should().Be(createdAt));`
`375`	`375`	`}`
`376`	`376`
`377`	`377`	`[Fact]`