Gain insights into unit testing principles, and delve into configuring and using NUnit. Discover how to write effective tests, maximize coverage, and elevate your testing projects.

Dockerfile.tar.gz

Iteration1

Iteration2

AssertTrueExample

AssertTrueExercise

AssertNullExample

AssertNullExercise

GeneralJob

WebAppWithoutTest

MSTest

XUnit

ConsoleWithoutTest

GeneralJobFIX

WebAppWithoutTestFIX

WebAppWithoutTestNIAZ

NiazSolution

Industry, employers, startups, and amateur developers are increasingly looking towards unit testing their software. Unit testing is one of the most reliable ways to find and keep software bugs at bay, thus reducing costs and development pains. Developers working with the .NET framework are overwhelmingly turning to NUnit to meet their unit testing needs.

In this course, you’ll learn the principles of unit testing, and in the process, learn to configure and use the NUnit testing framework. Given that the course places an emphasis on principles, these skills are transferable to other unit testing frameworks. Alongside these, you’ll also get hands-on experience with projects and exercises that provide ample opportunities to learn how to design effective tests in the NUnit framework.

At the end of the course, you’ll be able to quickly write unit tests that maximize logical coverage, test complex applications, and better organize your testing projects—setting you up as a natural leader in your organization.

Mastering Unit Testing Principles with NUnit

# Introduction

Software is split into the following two parts:
- The application code implements the software features.
- The test code includes the tests that test the behavior of the application code.


There are two high-level test process approaches. One emphasizes writing test code after the application code, and the other emphasizes writing test code before the application code. This lesson focuses on the first approach.

# Test after development approach

The **test after development (TAD)** approach is when the test code is written after the application code. It emphasizes designing the software by first delving into the implementation of the application code. This concept is illustrated below:

# Disadvantages of TAD

There are a few disadvantages of the TAD approach:

- **Bias:** Focus may inadvertently shift to testing implementation rather than the actual requirements.
- **Overcomplication:** The application code may include sections that are redundant or not required at all.
- **Slow development time:** The application code may have testability challenges that only surface when attempts are made to write the test code.
- **Poor design:** Focusing too much on the implementation details may lead to poor design because the focus is placed on implementation.
- **Incomplete testing:** On feature completion, there is an inclination to move to the next feature addition and skip testing altogether.

# TAD exercise

Suppose you decide to follow a TAD approach and are required to write a `Triangle` class. A similar example was presented in an earlier lesson to demonstrate the importance of edge cases. The class has a constructor that takes the lengths of all three sides. The class has a single public method, `GetTriangleType`. This method returns the triangle type depending on the lengths with which it was constructed. The following are the three main triangle types.

- **Equilateral:** All sides are equal in length.
- **Isosceles:** Two of the three sides are equal in length.
- **Scalene:** No two sides are equal in length.

Write the test code that tests the public `GetTriangleType` method:

Learn the test after development approach.

Fundamentals of Unit Testing

Testing Conditions With Classic And Fluent Assertions

Making Unit Testing More Effective

Unit Testing Code with External Dependencies

Conclusion

Appendix - Unit Test Project Organization and Console Setup

Test After Development

Introduction

Test after development approach

Disadvantages of TAD