Effective Unit Testing

Unit Testing in .NET

Every developer aspires to write code that is not only clean but also functional. However, achieving code that is easily maintainable and consistently operational poses a significant challenge. We will explore the role of unit testing in verifying the correctness of our code and ensuring its continued functionality..

• What every developer wants: Quality code that works; and keeps on working
• Finding bugs: not just in code. - Or how NASA lost a 125.000.000$ Mars orbiter
• What is unit testing? And what is a good unit test?
• Understanding the difference between a unit test and an integration test
• Test Driven Development - Should you be doing it?
• Role-playing: Marge, Homer and Bart
• The Triple-A of unit testing - and what has cooking to do with this?
• Given-When-Then
• The difference between a Fake, a Stub and a Mock

Unit testing with Visual Studio with MSTest and xUnit

When it comes to Unit Testing, you will need to choose frameworks. There are several options available, so which one do you need? Visual Studio comes with a built-in framework called MSTest, but you also have others, such as the popular xUnit.

• MSUnit - Built-in into Visual Studio
• Building and running Unit Tests with MSUnit
• Using the Test Explorer Window
• Using Test Settings
• Live unit testing with Visual Studio
• Unit Testing best practices with xUnit
• Facts and Theories
• Running Unit tests in parallel, or not
• Measuring and improving Code Coverage
• LAB: Implementing a library with testing

More loose coupling using the art of Dependency Injection

When writing code, it's crucial to minimize unnecessary dependencies on other objects. Dependencies can increase maintenance overhead, reduce testability, and limit flexibility. Dependency injection allows you to dynamically determine which implementations to inject into dependencies at runtime, providing greater flexibility and decoupling within your codebase.

• What is tight coupling and how to prevent it?
• Using Inversion of Control (IoC) containers
• Constructor and Property injection
• Microsoft.Extensions.DependencyInjection as an example

Testable Legacy Code

If you aim to make your code testable, you must design it with testing in mind. In this course, you'll discover the concepts of stubs and mocks, and you'll master techniques for substituting dependencies that could disrupt your testing process.

• Testing dependencies - and the art of writing testable code
• How to replace dependencies with stub and mock objects
• The Extract and Override pattern
• Replacing configuration in tests
• LAB: Use Extract and Override to test legacy code

Isolation Frameworks: NSubstitute

Building stubs and mocks can be laborious without an Isolation Framework. NSubstitute is one such framework that simplifies the creation of fake and stub objects required for robust testing.

• Understanding Isolation Frameworks
• Building Stubs and Mocks with NSubstitute
• Checking arguments and return values
• Faking time with TimeProvider and ITimer
• Testing legacy/untestable code
• LAB: Using NSubstitute

Integration Testing

Integration testing verifies that multiple parts of an application work together correctly—especially where your code interacts with external systems or infrastructure. Unlike unit tests (which isolate a single class), integration tests validate real collaboration between components.

• When Should You Write Integration Tests?
• Using WebApplicationFactory for Integration Testing
• Faking data access
• Testing with Real Data Access
• Unit testing your Controllers and Views
• Using AngleSharp for View Verification
• Unit testing ApiControllers
• LAB: Using WebApplicationFactory

End-to-End Testing with Playwright

End-to-end (E2E) testing verifies that a system works from the user`s point of view, by exercising the entire application stack from the UI through the backend to the database and back. It answers one key question: Can a real user complete a real scenario successfully?

• End-to-end testing with Microsoft Playwright
• Building your First Playwright Test
• Recording a Playwright Test
• Tracing Interactions, Screen Shots, Videos
• LAB: Using Playwright

Architecture Testing

.NET architecture testing is the practice of automatically verifying that your .NET application`s architectural rules and design decisions are respected—not just that the code works, but that it is structured correctly over time.

• When is Architecure Testing Useful?
• Checking Layering Rules
• Validating Dependency Direction
• Forbidden Dependencies
• Naming Conventions
• LAB: Adding Architecture Tests

Automatic Regression Testing

So your software works! Great! But how do you know if it will work next week, or next month? Did you break something while adding a new cool feature? Test everything again? Of course, but now we will automate it, making a machine do it automatically every time a team member makes a change.

• What is a regression?
• Using an automated build system
• Continuous integration
• Running integration tests
• Automatic regression tests
• Automatically running your regression tests using GitHub Actions