In order to move the setup out of the controller tests, again use a test fixture. This time, create a new class named ServerFixture. This will be where the setup will live for the controller tests:

public class ServerFixture : IDisposable
{
  public TestServer Server { get; }
  public HttpClient Client { get; }

  public ServerFixture()
  {
    Server = new TestServer(new WebHostBuilder()
             .UseStartup<Startup>()
             .ConfigureServices(services =>
             {
               services.AddDbContext<SpeakerMeetContext>(o =>
                 o.UseInMemoryDatabase("SpeakerMeetContext"));
             }));

    if (Server.Host.Services.GetService(typeof(SpeakerMeetContext)) is SpeakerMeetContext context)
    {
      context.Speakers.Add(new Speaker {Id = 1, Name = "Test"...});
      context.SaveChanges();
    }

    Client = Server.CreateClient();
  }

  public void Dispose()
  {

    Server.Dispose();
    Client.Dispose();
  }
}

Now, return to the previous test. Modify the test class to use the ServerFixture:

[Collection("Controllers")]
[Trait("Category", "Integration")]
public class GetAll : IClassFixture<ServerFixture>
{
  private readonly HttpClient _client;

  public GetAll(ServerFixture fixture)
  {
    _client = fixture.Client;
  }

  [Fact]
  public async void ItShouldCallGetSpeakers()
  {
    // Act
    var response = await _client.GetAsync("/api/speaker");

    Assert.NotNull(response);
  }
}

Now, verify that the response returns an OK status code by creating a new test:

[Fact]
public async void ItShouldReturnSuccess()
{
  // Act
  var response = await _client.GetAsync("/api/speaker/");
  response.EnsureSuccessStatusCode();

  // Assert
  Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}

And finally, ensure that the proper speaker is returned:

[Fact]
public async void ItShouldReturnSpeakers()
{
  // Act
  var response = await _client.GetAsync("/api/speaker");
  response.EnsureSuccessStatusCode();

  var responseString = await response.Content.ReadAsStringAsync();
  var speakers = JsonConvert.DeserializeObject<List<SpeakerSummary>>(responseString);

  // Assert
  Assert.Equal(1, speakers[0].Id);
}

Remember, you want to make sure your test suite is clean and well maintained. To clean this test up a bit, you might want to consider creating a ReadAsJsonAsync extension. Here's what that might look like:

public static class Extensions
{
  public static async Task<T> ReadAsJsonAsync<T>(this HttpContent content)
  {
    var json = await content.ReadAsStringAsync();

    return JsonConvert.DeserializeObject<T>(json);
  }
}

And now, modify the test to use the new extension method:

[Fact]
public async void ItShouldReturnSpeakers()
{
  // Act
  var response = await _client.GetAsync("/api/speaker");
  response.EnsureSuccessStatusCode();

  var speakers = await response.Content.ReadAsJsonAsync<List<SpeakerSummary>>();

  // Assert
  Assert.Equal(1, speakers[0].Id);
}

That's much better. Now this extension can be used and reused over and over, and its first use has now been documented in the ItShouldReturnSpeakers test.

Now, move on to testing that the single speaker endpoint can be called. Create a test named ItShouldCallGetSpeaker and ensure that a response is returned:

[Fact]
public async void ItShouldCallGetSpeaker()
{
  // Act
  var response = await _client.GetAsync("/api/speaker/-1");

  Assert.NotNull(response);
}

Now, test that the proper response code is returned if a Speaker with the given ID does not exist:

[Fact]
public async void ItShouldReturnError()
{
  // Act
  var response = await _client.GetAsync("/api/speaker/-1");

  // Assert
  Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}

Now validate that OK status code is returned when a speaker with the supplied ID exists:

[Fact]
public async void ItShouldReturnSuccess()
{
  // Act
  var response = await _client.GetAsync("/api/speaker/1");
  response.EnsureSuccessStatusCode();

  // Assert
  Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}

And finally, confirm that the speaker returned is the one that is expected. Note that the ReadAsJsonAsync can be used here:

[Fact]
public async void ItShouldReturnSpeaker()
{
  // Act
  var response = await _client.GetAsync("/api/speaker/1");
  response.EnsureSuccessStatusCode();

  var speakerSummary = await response.Content.ReadAsJsonAsync<SpeakerDetail>();

  // Assert
  Assert.Equal(1, speakerSummary.Id);
}

Only the Get and GetAll methods for speakers have been tested in the preceding pages. Feel free to add tests for the Search methods to grow your integration test suite.