ASP.NET Core And EF Core 2.0 Testing

Problem

How to perform unit and integration testing of ASP.NET Core and EF Core.

Solution

The sample code contain a lot more tests, I would suggest you download and play with it. Here I will list a few tests to demonstrate how testing works.

Testing MVC

Add MVC controller with action methods,

public IActionResult Index()
{
var model = service.GetMovies();
var viewModel = ToViewModel(model);
return View(viewModel);
}
public IActionResult Edit(int id)
{
var model = service.GetMovie(id);
if (model == null)
return NotFound();
var viewModel = ToViewModel(model);
return View("CreateOrEdit", viewModel);
}
[HttpPost]
public IActionResult Save(int id, MovieViewModel viewModel)
{
if (viewModel == null)
return BadRequest();
if (!ModelState.IsValid)
return View("CreateOrEdit", viewModel);
var model = ToDomainModel(viewModel);
if (viewModel.IsNew)
service.AddMovie(model);
else
service.UpdateMovie(model);
return RedirectToAction("Index");
}

Add test to verify ViewResult is returned,

[Fact(DisplayName = "Index_returns_ViewResult_and_model")]
public void Index_returns_ViewResult_and_model()
{
// Arrange
var mockService = new Mock<IMovieService>();
mockService.Setup(service =>
service.GetMovies()).Returns(new List<Movie>());
var sut = new HomeController(mockService.Object);
// Act
var result = sut.Index();
// Assert
var viewResult = Assert.IsType<ViewResult>(result);
var viewModel = Assert.IsType<List<MovieInfoViewModel>>(viewResult.Model);
}

Add test to verify status code result (e.g. NotFound) is returned,

[Fact(DisplayName = "Edit_with_invalid_Id_returns_NotFound")]
public void Edit_with_invalid_Id_returns_NotFound()
{
// Arrange
var mockService = new Mock<IMovieService>();
mockService.Setup(service =>
service.GetMovie(It.IsAny<int>())).Returns((Movie)null);
var sut = new HomeController(mockService.Object);
// Act
var result = sut.Edit(0);
// Assert
Assert.IsType<NotFoundResult>(result);
}

Add test to verify RedirectToAction is returned,

[Fact(DisplayName =
"Save_with_new_model_calls_AddMovie_and_returns_RedirectToAction")]
public void Save_with_new_model_calls_AddMovie_and_returns_RedirectToAction()
{
// Arrange
var mockService = new Mock<IMovieService>();
var sut = new HomeController(mockService.Object);
// Act
var result = sut.Save(1, new MovieViewModel() { IsNew = true });
// Assert
mockService.Verify(service =>
service.AddMovie(It.IsAny<Movie>()), Times.Once);
var redirectResult = Assert.IsType<RedirectToActionResult>(result);
Assert.Equal(expected: "Index", actual: redirectResult.ActionName);
}

Add a test to verify ModelState errors don’t save and return back the view,

[Fact(DisplayName =
"Save_with_invalid_model_state_returns_ViewResult_and_model")]
public void Save_with_invalid_model_state_returns_ViewResult_and_model()
{
// Arrange
var mockService = new Mock<IMovieService>();
var sut = new HomeController(mockService.Object);
sut.ModelState.AddModelError("Title", "Title is required");
// Act
var result = sut.Save(1, new MovieViewModel());
// Assert
var viewResult = Assert.IsType<ViewResult>(result);
var viewModel = Assert.IsType<MovieViewModel>(viewResult.Model);
}

Testing API

Add API controller with action methods,

[HttpGet]
public IActionResult Get()
{
var model = service.GetMovies();
var outputModel = ToOutputModel(model);
return Ok(outputModel);
}
[HttpPost]
public IActionResult Create([FromBody]MovieInputModel inputModel)
{
if (inputModel == null)
return BadRequest();
if (!ModelState.IsValid)
return Unprocessable(ModelState);
var model = ToDomainModel(inputModel);
service.AddMovie(model);
var outputModel = ToOutputModel(model);
return CreatedAtRoute("GetMovie",
new { id = outputModel.Id }, outputModel);
}

Add a test to verify OkObjectResult is returned,

[Fact(DisplayName = "Get_retruns_OkObjectResult_and_model")]
public void Get_retruns_Ok_result_and_model()
{
// Arrange
var mockService = new Mock<IMovieService>();
mockService.Setup(service =>
service.GetMovies()).Returns(new List<Movie>());
var sut = new MoviesController(mockService.Object);
// Act
var result = sut.Get();
// Assert
var okObjectResult = Assert.IsType<OkObjectResult>(result);
var outputModel =
Assert.IsType<List<MovieOutputModel>>(okObjectResult.Value);
}

Add a test to verify CreatedAtRouteResult is returned,

[Fact(DisplayName =
"Create_with_valid_model_calls_AddMovie_and_returns_CreatedAtRoute")]
public void
Create_with_valid_model_calls_AddMovie_and_returns_CreatedAtRoute()
{
// Arrange
var mockService = new Mock<IMovieService>();
var sut = new MoviesController(mockService.Object);
// Act
var result = sut.Create(new MovieInputModel());
// Assert
mockService.Verify(service =>
service.AddMovie(It.IsAny<Movie>()), Times.Once);
var createAtRouteResult = Assert.IsType<CreatedAtRouteResult>(result);
Assert.Equal(expected: "GetMovie", actual: createAtRouteResult.RouteName);
}

Testing EF

Add a repository (implementation in sample code),

public interface IMovieRepository
{
void Delete(int id);
MovieEntity GetItem(int id);
List<MovieEntity> GetList();
void Insert(MovieEntity entity);
void Update(MovieEntity entity);
}

The repository will work with a DbContext,

public class Database : DbContext
{
public Database(
DbContextOptions<Database> options) : base(options) { }
public DbSet<MovieEntity> Movies { get; set; }
}

Initialize with test data,

private void InitDbContext(Database context)
{
context.Movies.Add(new MovieEntity { ... });
context.Movies.Add(new MovieEntity { ... });
context.Movies.Add(new MovieEntity { ... });
context.SaveChanges();
}

Now you could test various methods of repository, e.g. test GetList() method,

[Fact(DisplayName = "GetList_returns_correct_count")]
public void GetList_returns_correct_count()
{
// Arrange
var builder = new DbContextOptionsBuilder<Database>();
builder.UseInMemoryDatabase(databaseName:
"GetList_returns_correct_count");
var context = new Database(builder.Options);
InitDbContext(context);
var repo = new MovieRepository(context);
// Act
var result = repo.GetList();
// Assert
Assert.Equal(expected: 3, actual: result.Count);
}

Integration Testing

Create a base class for integration test classes,

public class IntegrationTestsBase<TStartup> : IDisposable
where TStartup : class
{
private readonly TestServer server;
public IntegrationTestsBase()
{
var host = new WebHostBuilder()
.UseStartup<TStartup>()
.ConfigureServices(ConfigureServices);
this.server = new TestServer(host);
this.Client = this.server.CreateClient();
}
public HttpClient Client { get; }
public void Dispose()
{
this.Client.Dispose();
this.server.Dispose();
}
protected virtual void ConfigureServices(IServiceCollection services)
{ }
}

Create a controller to test MVC/API,

public class MoviesControllerIntegration : IntegrationTestsBase<Startup>
{
[Fact(DisplayName = "Get_retruns_Ok")]
public async Task Get_retruns_Ok_status_code()
{
// Arrange
// Act
var response = await this.Client.GetAsync("api/movies");
// Assert
Assert.Equal(expected: HttpStatusCode.OK, actual: response.StatusCode);
var outputModel = response.ContentAsType<List<MovieOutputModel>>();
Assert.Equal(expected: 2, actual: outputModel.Count);
}

Discussion

The single biggest selling point of MVC architecture in general and ASP.NET Core in particular is that it makes testing much simpler. ASP.NET team has done a great job in making a framework that is pluggable, thus enabling testing of controllers, repositories and even the entire application a breeze.

Unit Testing

Unit Testing ASP.NET Core and API controllers is not that much different than testing any other class in your application. The sample code contain a lot more tests to show examples of type of tests you could perform e.g.,

Verify correct IActionResult is returned, e.g. ViewResult, RedirectAtRouteResult
Verify correct view name is returned
Verify correct model is returned
Verify correct HTTP status code is returned e.g. NotFoundResult, BadRequestResult
Verify model state behaviour e.g. not saving record and returning the view.
Verify controller dependencies are being called.

Testing Entity Framework

You could test EF using in-memory database, you’ll need package Microsoft.EntityFrameworkCore.InMemory that gives you UseInMemoryDatabase extension method on DbContextOptionsBuilder. With these pieces in place you could now create an in-memory DbContext,

var builder = new DbContextOptionsBuilder<Database>();
builder.UseInMemoryDatabase(
databaseName: "GetList_returns_correct_count");
var context = new Database(builder.Options);
InitDbContext(context);
var repo = new MovieRepository(context);

Integration Testing

Remember that ASP.NET Core application is just a console application that sets up web server to listen to HTTP requests. We can set up a test web server using TestServer class and use HttpClient to send requests to it,

public IntegrationTestsBase()
{
var host = new WebHostBuilder()
.UseStartup<TStartup>()
.ConfigureServices(ConfigureServices);
this.server = new TestServer(host);
this.Client = this.server.CreateClient();
}
public HttpClient Client { get; }

Source Code

GitHub