ASP.NET Core Integration Testing with CI/CD Pipeline

All the pre-requisites are discussed in this video to set up the environment for the SUT project.

The ASP.NET 7 Web API project is created step by step in this lecture. This project will be the System Under Test, henceforth known as SUT for the tests.

The students will learn which NuGet Packages need to be installed as dependencies for the SUT.

After going through this lecture, the learners will have a good understanding of why the SQLite In-memory database is being used for creating the SUT?

In this lecture the app domain model or entity class (ToDoItems) is created.

In this lecture, we delve into the pivotal process of creating the Database Context Class in an ASP.NET Core application. The Database Context serves as a crucial bridge between the application and the underlying database, facilitating seamless interactions. Understanding the intricacies of this class is fundamental for developers aiming to design robust and efficient database-driven applications.

By the end of this lecture, participants will have a comprehensive understanding of the Database Context Class, empowering them to establish a robust connection between their ASP.NET Core applications and databases using Entity Framework Core.

The database is seeded with some initial data to the TodoItems table.

This lecture shows the creation of the controller for ToDoItems. This controller is responsible to send the request and get the responses back for different CRUD actions.

The Program class is changed in this lecture to be able to work with the Sqlite In-memory database. It works with the minimal api configuration and replaces the Startup class. The students will learn how the Program class for the TodoApi web application works using in-memory database with SQLite.

The first few lines of code sets up the SQLite connection and adds a new DbContext of type TodoContext to the dependency injection container with the connection string. The AddControllers method adds the MVC controller services to the service container.

The next few lines add Swagger and OpenAPI support for documenting the API, and then the application is built.

The CreateScope method creates a new scope in the service provider and retrieves the TodoContext instance from the scope.

The  EnsureCreated method creates the database if it doesn't exist. Finally, the DbInitializer.Initialize method initializes the database with some initial data.

If the application is running in development mode, the Swagger and SwaggerUI middleware are used to expose the Swagger documentation.

The HttpsRedirection and Authorization middleware are used, and the MapControllers method maps the API endpoints to the controllers.

The Run method starts the application.

This lecture shows how to create and push to a remote repository on GitHub to push the completed source code of the SUT.

In this lecture, we will introduce the concept of Fluent Assertions and discuss their benefits in writing unit tests.

Fluent Assertions is a .NET library that provides a fluent interface for asserting the behavior of code under test. It is an alternative to the traditional NUnit or XUnit assertions and provides a more intuitive and readable way to write assertions.

In this lecture, we will go over the steps required to set up Fluent Assertions in our project. Fluent Assertions is a third-party assertion library that provides a more fluent and expressive syntax for writing assertions in our  unit and integration tests.

In this lecture, we will cover the basics of writing assertions with Fluent Assertions. Assertions are a fundamental part of unit testing, as they allow us to verify that our code behaves as expected. Fluent Assertions provides a wide range of assertion methods that make it easy to write expressive and readable tests.

This is an advanced discussion on fluent assertions for collections, objects, properties, numerics and strings with sample C# code. After attending this lecture, the students will be able to write more complex assertion statements. This will be helpful in the actual integration tests where we shall use fluent library frequently.

In this lecture the students will learn to create Custom Assertions which are made by them and not part of the fluent library. This will help them to be more flexible in designing, developing and testing on their development environment.

In this lecture two tests are described that test the person assertions (custom assertions) created previously.

In this insightful lecture, we explore the best practices for leveraging Fluent Assertions in your testing endeavors. Fluent Assertions is a powerful assertion library that enhances the readability and expressiveness of your test code. Understanding the best practices ensures that you harness the full potential of Fluent Assertions to create clear, concise, and effective test assertions.

By the end of this lecture, participants will not only be adept at using Fluent Assertions for standard assertions but will also grasp the nuanced best practices that contribute to the creation of robust and maintainable test suites.

This lecture discusses the meaning and importance of carrying out integration tests on the database layer. The students will come to appreciate the reason of doing this kind of integration tests for their ASP.NET 7 apps. 

In this lecture we fetch the Todo Api solution code from the GitHub repository as a preparation for writing the integration tests.

This lecture provides step-by-step guidance on creating an xUnit Test Project, ensuring that your testing endeavors are organized, scalable, and maintainable.

This test returns a list of TodoItems from the database and checks if they match the items saved to the database.

Dive into the intricacies of integration testing as we explore the process of validating the retrieval of a Todo item with a specific Id and ensuring a successful HTTP status code.

This is an integration test to return a todoitem from the database that ends up in Not Found or 404 error code.

In this lecture, an integration test to create a Todo Item is shown as walk through. This test creates a new Todo item.

In this lecture, an integration test to edit (PUT verb) a Todo Item is shown as walk through. This test updates an existing Todo item.

This lecture provides hands-on guidance on crafting tests that ensure the accurate removal of existing Todo items within the context of an ASP.NET Core Todo API.

Through practical examples and insights, you'll gain proficiency in ensuring the correctness of delete operations within your API.

Delve into the intricacies of API integration testing as you explore the various types of tests covered in this section. Understanding the classification of tests is crucial for creating a comprehensive testing strategy that ensures the reliability and functionality of your ASP.NET Core Todo API.

This lecture equips you with the knowledge to classify and understand the various types of tests applicable to API integration testing. By the end, you'll have a solid foundation for creating a well-rounded testing strategy that ensures the robustness and reliability of your ASP.NET Core Todo API.

This lecture sheds light on alternative approaches and methodologies for handling database interactions within the realm of integration testing in ASP.NET Core.

By the end of this lecture, you'll gain insights into the nuances of handling database interactions in integration tests without relying on dbContext.

This lecture walks through the creation of an interface known as ITodoItemRepository Interface

This lecture gives a walkthrough of the creation of MockTodoItemRepository class that implements the interface created in the previous lecture.

In this lecture, the test class with all the common infrastructure that will be used later by the integration tests are described as well as code walked through

This test case for integration testing verifies the correctness of retrieval of a Todo Item by its Id from the database.

This lecture shows the code walkthrough with complete explanations to create an Item and verify that it was indeed created in the database.

This lecture is a comprehensive guide on crafting effective tests that validate the seamless updating of information, providing a crucial aspect of maintaining a robust ASP.NET Core application.

By the end of this lecture, you'll be equipped with the knowledge and skills to create robust integration tests focused on verifying the accuracy and reliability of updating Todo items within your ASP.NET Core application's database.

This lecture provides comprehensive insights into crafting effective tests, ensuring accurate and secure removal of Todo items from the database.

By the end of this lecture, you'll possess the knowledge and skills to create robust integration tests focused on verifying the accuracy and reliability of deleting Todo items within your ASP.NET Core application's database.

This lecture shows an overview of several edge cases and introduces specialized testing requirements for some performance testing aspects, such as load testing for high server loads, low network connectivity etc.

This lecture discusses the edge case of a Get Request with a non-existing (invalid) Id results in Not Found Error.

This lecture discusses the edge case of a POST Request with invalid input results in Bad Request status.

The lecture discusses the edge case of trying to update with a request to an invalid Id. It returns a NOT FOUND Error (404)

After completing this lecture, the students will be able to install and configure JMeter for special performance testing as part of the integration testing.

This lecture shows how to carry out the GET request concurrency testing on JMeter. We have used the TodoApi solution that we have been working to set the API end point to generate the concurrent users.

The learners will be able to add an assertion to the GET request after going through this lecture.

This lecture shows how to carry out the POST request concurrency testing on JMeter. We have used the TodoApi solution that we have been working to set the API end point to generate the concurrent users.

This lecture shows how to carry out the PUT request concurrency testing on JMeter to update a Todo item. We have used the TodoApi solution that we have been working to set the API end point to generate the concurrent users.

This lecture shows how to carry out the DELETE request concurrency testing on JMeter. This lecture shows when an item with a specific id is deleted subsequent requests show Not Found status as expected.

Here we have demonstrated the use of JMeter for simulating and testing high server load demands. It shows how a full-blown SQL database is more reliable in production scenarios over in-memory databases like SQLite and thereby indicating when we should use one .

An animated video explaining the concept of a CI/CD pipeline in an engaging way.

In this lecture, we'll go over the prerequisites you need to follow along with this course. We'll cover the installation of Docker Desktop, setting up a GitHub repository, and creating an Azure Web App.

This lecture explores the GitHub actions workflow as a part of the CI/CD pipeline. It also shows how to build an action workflow to automate the build and test process of a .NET application through GitHub.

This lecture explains the various parts of the .yaml file that was created as a part of the GitHub Actions workflow for the WebsiteChecker project shown in the previous lecture.

This lecture explains the dockerization to create a container for the Todo Api application. This will be used for continuous integration later in the course.

After going through this lecture, the students will be able to understand the instructions being set by the dockerfile for building the image, in this case, the Todo Api application image as shown earlier.

In this lecture, I have discussed the procedure of tagging and pushing a local image to the remote dockerhub cloud storage.

In this lecture, you'll learn to establish a robust Continuous Integration (CI) pipeline for the Todo API application. By the end of this lecture, you'll have a comprehensive understanding of setting up a CI pipeline for an ASP.NET Core application using GitHub Actions Workflow and Docker, ensuring automated and reliable build and deployment processes.

This lecture shows a complete walkthrough of the deployment process on Microsoft Aure for the Todo Api application. The learners will understand the full process of deployment on the Azure as well as the way its seamlessly integrated with GitHub actions workflow.

This lecture explains the steps in the auto-generated workflow in GitHub Actions when the ToDo Api app was deployed on Azure.

In this lecture, we will focus on validating and testing the complete Continuous Integration/Continuous Deployment (CI/CD) pipeline that we established for the Todo API application. Testing the CI/CD pipeline ensures that every step, from code integration to deployment, functions seamlessly. By the end of this lecture, you will have a hands-on experience testing the complete CI/CD pipeline for your Todo API application. This ensures that your automated build and deployment processes are robust, reliable, and ready for production use.

This is the pointer to the course presentation slide show as a downloadable resource file. This is intended as an add-on for reinforcing the learning taught throughout this course.

The walkthrough to a successful migration to ASP.NET 8.0 (the latest LTS version) is described in this lecture.

New test setup is created to accomodate TestServer. The learners will be able to create an ASP.NET 8 project with a Values Controller (with minimal API) setup.

This lecture shows step by step of setting up the WebApplicationFactory class for integration tests. Tests are run to show the successful setup.

After completing this lecture, the students will be able to setup the TestServer with minimal API program class and test web api end points.

This lecture gives a short comparison on the two methods of testing and draws a conclusion.