Refactored tests for no EF Core

Author: Bart Koelman

test/NoEntityFrameworkTests/WorkItemTests.cs

@@ -1,167 +1,122 @@
 using System;
 using System.Net;
-using System.Net.Http;
-using System.Net.Http.Headers;
 using System.Threading.Tasks;
-using JsonApiDotNetCore.Middleware;
+using FluentAssertions;
 using JsonApiDotNetCore.Serialization.Objects;
-using Microsoft.AspNetCore.Mvc.Testing;
-using Microsoft.Extensions.DependencyInjection;
-using Newtonsoft.Json;
 using NoEntityFrameworkExample;
 using NoEntityFrameworkExample.Data;
 using NoEntityFrameworkExample.Models;
+using TestBuildingBlocks;
 using Xunit;
 
 namespace NoEntityFrameworkTests
 {
-    public sealed class WorkItemTests : IClassFixture<WebApplicationFactory<Startup>>
+    public sealed class WorkItemTests : IClassFixture<RemoteIntegrationTestContext<Startup, AppDbContext>>
     {
-        private readonly WebApplicationFactory<Startup> _factory;
+        private readonly RemoteIntegrationTestContext<Startup, AppDbContext> _testContext;
 
-        public WorkItemTests(WebApplicationFactory<Startup> factory)
+        public WorkItemTests(RemoteIntegrationTestContext<Startup, AppDbContext> testContext)
         {
-            _factory = factory;
+            _testContext = testContext;
         }
 
         [Fact]
-        public async Task Can_Get_WorkItems()
+        public async Task Can_get_WorkItems()
         {
             // Arrange
-            await ExecuteOnDbContextAsync(async dbContext =>
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
             {
                 dbContext.WorkItems.Add(new WorkItem());
                 await dbContext.SaveChangesAsync();
             });
 
-            var client = _factory.CreateClient();
-
-            var request = new HttpRequestMessage(HttpMethod.Get, "/api/v1/workItems");
+            var route = "/api/v1/workItems";
 
             // Act
-            var response = await client.SendAsync(request);
+            var (httpResponse, responseDocument) = await _testContext.ExecuteGetAsync<Document>(route);
 
             // Assert
-            AssertStatusCode(HttpStatusCode.OK, response);
-
-            string responseBody = await response.Content.ReadAsStringAsync();
-            var document = JsonConvert.DeserializeObject<Document>(responseBody);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
 
-            Assert.NotEmpty(document.ManyData);
+            responseDocument.ManyData.Should().NotBeEmpty();
         }
 
         [Fact]
-        public async Task Can_Get_WorkItem_By_Id()
+        public async Task Can_get_WorkItem_by_ID()
         {
             // Arrange
             var workItem = new WorkItem();
 
-            await ExecuteOnDbContextAsync(async dbContext =>
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
             {
                 dbContext.WorkItems.Add(workItem);
                 await dbContext.SaveChangesAsync();
             });
 
-            var client = _factory.CreateClient();
-
-            var request = new HttpRequestMessage(HttpMethod.Get, "/api/v1/workItems/" + workItem.StringId);
+            var route = "/api/v1/workItems/" + workItem.StringId;
 
             // Act
-            var response = await client.SendAsync(request);
+            var (httpResponse, responseDocument) = await _testContext.ExecuteGetAsync<Document>(route);
 
             // Assert
-            AssertStatusCode(HttpStatusCode.OK, response);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.OK);
 
-            string responseBody = await response.Content.ReadAsStringAsync();
-            var document = JsonConvert.DeserializeObject<Document>(responseBody);
-
-            Assert.NotNull(document.SingleData);
-            Assert.Equal(workItem.StringId, document.SingleData.Id);
+            responseDocument.SingleData.Should().NotBeNull();
+            responseDocument.SingleData.Id.Should().Be(workItem.StringId);
         }
 
         [Fact]
-        public async Task Can_Create_WorkItem()
+        public async Task Can_create_WorkItem()
         {
             // Arrange
-            var title = Guid.NewGuid().ToString();
+            var newTitle = Guid.NewGuid().ToString();
 
-            var requestContent = new
+            var requestBody = new
             {
                 data = new
                 {
                     type = "workItems",
                     attributes = new
                     {
-                        title,
+                        title = newTitle,
                         ordinal = 1
                     }
                 }
             };
 
-            var requestBody = JsonConvert.SerializeObject(requestContent);
-
-            var request = new HttpRequestMessage(HttpMethod.Post, "/api/v1/workItems/")
-            {
-                Content = new StringContent(requestBody)
-            };
-            request.Content.Headers.ContentType = new MediaTypeHeaderValue(HeaderConstants.MediaType);
-
-            var client = _factory.CreateClient();
+            var route = "/api/v1/workItems/";
 
             // Act
-            var response = await client.SendAsync(request);
+            var (httpResponse, responseDocument) = await _testContext.ExecutePostAsync<Document>(route, requestBody);
 
             // Assert
-            AssertStatusCode(HttpStatusCode.Created, response);
-
-            string responseBody = await response.Content.ReadAsStringAsync();
-            var document = JsonConvert.DeserializeObject<Document>(responseBody);
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.Created);
 
-            Assert.NotNull(document.SingleData);
-            Assert.Equal(title, document.SingleData.Attributes["title"]);
+            responseDocument.SingleData.Should().NotBeNull();
+            responseDocument.SingleData.Attributes["title"].Should().Be(newTitle);
         }
 
         [Fact]
-        public async Task Can_Delete_WorkItem()
+        public async Task Can_delete_WorkItem()
         {
             // Arrange
             var workItem = new WorkItem();
 
-            await ExecuteOnDbContextAsync(async dbContext =>
+            await _testContext.RunOnDatabaseAsync(async dbContext =>
             {
                 dbContext.WorkItems.Add(workItem);
                 await dbContext.SaveChangesAsync();
             });
 
-            var client = _factory.CreateClient();
-
-            var request = new HttpRequestMessage(HttpMethod.Delete, "/api/v1/workItems/" + workItem.StringId);
+            var route = "/api/v1/workItems/" + workItem.StringId;
 
             // Act
-            var response = await client.SendAsync(request);
+            var (httpResponse, responseDocument) = await _testContext.ExecuteDeleteAsync<string>(route);
 
             // Assert
-            AssertStatusCode(HttpStatusCode.NoContent, response);
-
-            string responseBody = await response.Content.ReadAsStringAsync();
-            Assert.Empty(responseBody);
-        }
-
-        private async Task ExecuteOnDbContextAsync(Func<AppDbContext, Task> asyncAction)
-        {
-            using IServiceScope scope = _factory.Services.CreateScope();
-            var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
+            httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
 
-            await asyncAction(dbContext);
-        }
-
-        private static void AssertStatusCode(HttpStatusCode expected, HttpResponseMessage response)
-        {
-            if (expected != response.StatusCode)
-            {
-                var responseBody = response.Content.ReadAsStringAsync().Result;
-                Assert.True(expected == response.StatusCode, $"Got {response.StatusCode} status code instead of {expected}. Response body: {responseBody}");
-            }
+            responseDocument.Should().BeEmpty();
         }
     }
 }

test/TestBuildingBlocks/RemoteIntegrationTestContext.cs

@@ -0,0 +1,18 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace TestBuildingBlocks
+{
+    /// <summary>
+    /// A test context that creates a new database and server instance before running tests and cleans up afterwards.
+    /// You can either use this as a fixture on your tests class (init/cleanup runs once before/after all tests) or
+    /// have your tests class inherit from it (init/cleanup runs once before/after each test). See
+    /// <see href="https://xunit.net/docs/shared-context"/> for details on shared context usage.
+    /// </summary>
+    /// <typeparam name="TStartup">The server Startup class, which MUST be defined in the API project.</typeparam>
+    /// <typeparam name="TDbContext">The EF Core database context, which MUST be defined in the API project.</typeparam>
+    public class RemoteIntegrationTestContext<TStartup, TDbContext> : BaseIntegrationTestContext<TStartup, TStartup, TDbContext>
+        where TStartup : class
+        where TDbContext : DbContext
+    {
+    }
+}