I ❤️ .NET

In this article, let's learn about how to unit test Service Registrations in WebAPI in ASP.NET Core.

Table of Contents

1. Introduction
2. Why Unit Testing?
3. What is a Service Registration?
4. When to use Service Registration?
5. Unit Testing Service Registration
6. Summary

Introduction

In ASP.NET Core, service registration plays a vital role in setting up the dependencies required for an application to function correctly. Unit testing the service registration ensures that the services are registered and configured properly, preventing runtime errors and ensuring the smooth operation of the application. In this article, we will explore the importance of unit testing service registration and provide examples using C# to demonstrate its implementation.

Why Unit Testing ?

Unit testing is a crucial practice in software development as it helps identify issues early in the development process. When it comes to service registration, unit testing offers the following benefits:

• Validation: Unit tests verify that the necessary services are registered correctly, avoiding runtime errors caused by missing or misconfigured dependencies.
• Refactoring: Unit tests provide a safety net when refactoring code by ensuring that service registration remains intact during code changes.
• Documentation: Well-written unit tests serve as living documentation, illustrating how services should be registered and ensuring consistency across the application.

Note: If you have not done so already, I recommend you read the article on Implementing TDD in C# .Net.

What is a Service Registration ?

Service registration involves adding services to the Inversion of Control (IoC) container, allowing them to be resolved and injected throughout an application. The IoC container manages the creation and lifetime of these services, promoting loose coupling and modular architecture. Service registration typically occurs during application startup, configuring dependencies required by various components, such as repositories, services, and middleware.

Note: If you have not done so already, I recommend you read the article on Introducing Dependency Injection in .NET.

When to use Service Registration ?

Service Registration should be used to register services that are required by the application to function correctly. It can be anything from a simple service to a complex service that requires multiple dependencies. The following are some examples of services that should be registered:

• Database Contexts
• Repositories
• Services
• Middleware
• Logging

Unit Testing Service Registration

Service registration should be unit tested when you want to ensure that specific services are correctly registered within the IoC container. This validation can be crucial, especially for critical services that need to be available for the application to function properly. Let's explore an example that demonstrates unit testing service registration:

Consider a scenario where we have a program class responsible for setting up an API. The class contains two extension methods, RegisterBusinessServices and RegisterDataServices, that handle the registration of services for the business and data access layers, respectively.

To unit test the RegisterDataServices method, follow these steps:

1. Create a new test class, let's call it ServiceCollectionTests, and add a test method using the [Fact] attribute.
2. In the test method, instantiate a ServiceCollection from the Microsoft.Extensions.DependencyInjection namespace. This collection will act as the container for our services.
3. Use a ConfigurationBuilder from Microsoft.Extensions.Configuration to create an in-memory instance of IConfiguration. This allows us to mock the configuration required by the RegisterDataServices method.
4. In the configuration, provide a connection string key-value pair that satisfies the method's requirements.
5. Call the RegisterDataServices method, passing the created configuration object.
6. Build a ServiceProvider instance from the ServiceCollection to use for assertions.
7. Perform assertions using the GetService method on the ServiceProvider. Check if the desired service, such as IILoveDotNetRepository, is not null to ensure it has been registered.
8. Optionally, use Assert.IsType to verify that the registered concrete implementation matches a specific type.

In the above code, we have a ServiceRegistration class that contains extension methods for registering services. In the RegisterDataServices method, we register a DbContext and IILoveDotNetRepository using AddScoped.

The ServiceCollectionTests class contains a unit test method, RegisterDataServices_ShouldRegisterIILoveDotNetRepository, which validates the registration of IILoveDotNetRepository. It uses a IConfiguration to provide the required configuration for the test.

By executing this test, you can ensure that the RegisterDataServices method correctly registers the IILoveDotNetRepository service within the ServiceCollection container.

Summary

Unit testing service registration in ASP.NET Core is a crucial step to ensure that services are correctly registered and configured. By writing unit tests, you can validate the registration process, identify issues early on, and maintain a reliable and robust application. The examples and techniques covered in this article provide a solid foundation for performing unit tests on service registration, promoting software quality and maintainability in ASP.NET Core applications.