This course is a specialized course that will be run by experienced senior developer(s) who have been using continuous testing for a very long time.
The course is team based, meaning the participants will be divided into groups that will work together on solving objectives, guided by the trainer(s). It can be run with between 5 and 20 people. Anything above 12 people will need 2 trainers.
The course is based on creating an understanding on how unittesting, TDD and test automation works. Understanding helps you solve new problems. The exercises are not simple step-by-step guides, but actual problems you learn to solve.
The training will be be a mixture of theory, exercises and best practices, with very open minded and experienced trainer(s). We at Solidify are using automated tests, Test Driven Development and unit tests as a central element in our own software development, our developers on site will coach on the practices, and as a company we are fully committed to it. We are not only trainers, we are long time users and maintainers! The training you get comes from people who are using it actively every day!
The course is level based and split into sections, each section having a fixed objective (or a fixed set), and bringing the participants up to a new level. The levels can be seen in the agenda for the course.
If the course is run as a company in-house training, we recommend a small up front meeting to establish the current level, and the company can then choose to either 1) skip that level, 2) take it just as theory and presentation or 3) fully.
It is also possible for a company to request special sections to replace some others, to cover special issues the company have seen in their work. One optional section is a Q/A section, where the trainers and participants engage in a discussion around issues they have, and how to best resolve those.
We will base the practical exercises on C# code and the Visual Studio 2019 toolset. We include use of Visual Studio Code with command line testing using dotnet and vstest. We will use the NUnit opensource framework as a basis, even if many of the exercises can be done using MSTest or XUnit.
We will also show how you can use the same principles for testing javascript and typescript code, and some tools that can be used for that purpose.
The cost of finding defects increases exponentially the further out in a development chain you come. Thus end-to-end testing may be seen as attractive, and it will tell you if your system works or not, but when failing it doesn't tell you where the defect is in your code. You need end-to-end testing, and it should be automated, but for finding whereabouts of the defects you need to "move left". From this insight comes the "Shift Left paradigm" in automated testing, and in this course we will see how we can do that effectively.
There is an old saying "Design for testability" and this is still very true for software development. It is very hard to add automated testing to a non-testable system. You may be able to do end-to-end tests, but any attempts of moving left will be very costly. Working with legacy code, and refactoring for testing is an essential skillset to learn. For new designs, the testing should be present from the start, and using Test Driven Developement (TDD) practices ensures that your code is testable at the unit level at all times.