Testing is a given in most modern codebases, with unit tests contributing a large portion of that code. However, the tests are often written without long-term maintenance in mind, creating a coupling between the code and the tests. This course will address some of the most common problems facing test code maintainability. It starts with a basic introduction to testing, moving into the more common unit test patterns, and finishing with legacy code testing patterns. It will use C# standards; however, the underlying patterns will be relevant to all developers.
Core Patterns Hi. This is Justin Pihony. In this module we'll continue working on the banking project that we started in the last module. In building this project from the ground up we'll encounter many of the most common testing scenarios and learn how to best handle them such that they'll be easy to read and maintain. The module will start with the basics of unit testing. Once those basics are covered, it'll cover the patterns needed for increased maintainability of all types of tests including asynchronous ones, and, to conclude, it'll go over some test smells to keep an eye out for so that you can sidestep some common testing anti-patterns.
Legacy Patterns Hi. This is Justin Pihony. In this module we come back to the banking project after some time has passed. The project hasn't kept up good design principles, especially around the test code, so the goal of the module is to help show you some ways to introduce good testing practices into an existing project often referred to as legacy code. This module will primarily focus on two things, what is legacy code, refactoring, and maintenance, and the bulk of the module will be how to clean up this existing code so that maintenance of it can become easier and easier.