The following article shows how to implementing SOLID REST API using ASP.NET Core. The solution uses generic repository pattern to perform CRUD operations on database, and also xUnit as test runner.
The solution will contain three key namespace:
- Data access: it will implement information about the domain model and the relationship between entities. It will also contain the information about data context;
- Domain logic: it will implement the repositories and services used by our web APIs;
- API: it will implement controllers and middlewares to manage incoming requests;
The project is available on Github.
Here is a brief schema of the project structure:
Blog.Turnmeup.DAL represents the Data access namespace, the
Blog.Turnmeup.DL represents the Domain Logic namespace, finally the
Blog.Turnmeup.API exposes Rest APIs.
The key parts of the solution are convered by unit tests and integration tests. Test projects will use Moq as mocking library and xUnit as test runner. All tests will be contained in two namespaces:
- DL.Tests: it will contain domain logic tests;
- API.Tests: it will contain APIs tests;
Data access using Entity Framework
Data access layer uses Entity Framework Core as ORM.
The project (
Blog.Turnmeup.DAL) contains entity classes which describe model data. The namespace also defines
BaseEntity model class which contains some common attributes.
BaseEntity is extended by the other entity classes. Domain Logic namespace references models to retrieve data.
Here is a schema of the project:
In order to generate the database schema you need to run the following command inside the directory of the project:
dotnet ef database update
Domain Logic layer overview
This project (
Blog.Turnmeup.DL) implements the Domain logic layer. It uses the Generic repository pattern combined with a generic service class. Here is an overview of the project:
The Domain logic layer is covered by unit tests. The project
Blog.Turnmeup.DL.Tests defines the unit tests inside the
CourseServiceTests class. Here is the source code of tests:
The Domain Logic layer also defines
BaseResponseModel to serialize data throughs HTTP response. The
Blog.Turnmeup.API will useAutomapper to map Data access layer models with Domain logic models.
API namespace overview
Blog.Turnmeup.API defines the Controller class which returns data through HTTP. The
CourseController handles incoming HTTP requests and call Domain logic layer to retrieve or update data. Here is an schema overview of the project:
Dependency injection and class mapping
Blog.Turnmeup.API project uses dependency injection to inject concrete classes to interfaces. It also uses Automapper package to map
Blog.Turnmeup.DL response models. Dependency injection is managed in the
Startup.cs file and classes mapping is managed by the
The Rest APIs layer is covered by unit tests. The project
Blog.Turnmeup.API.Tests defines the unit tests inside the
CourseControllerTests class. Tests use the
TextFixture class to initialize a Test server and retrieve the dependencies services:
You can find the code on Github.
The project can be extended with other model classes and other controller. In the next article will be dicovered the authentication part by using ASP.NET Core Identity:
Unit testing ASP.NET Core Identity
Cover picture by Corrado Zeni.