Providing high quality software from early stages in the software project is the key to a successful project. We must check the quality of our software in every single release and make sure it’s meeting our expectations. It’s much easier to code having quality requirements in mind from the very beginning than finishing a module and then fixing all the unexpected behavior afterwards.

There are many tools to improve the quality of our work. Developers have refactoring tools, memory profilers, code coverage, etc. But in a software project we also have testing resources, also known as Quality Assurance. Their job is to test the application and find as many bugs as possible: to achieve a high quality product, thorough testing is a very important step. However, this can be a very tedious and time-consuming task. Fortunately, part of this work can be performed automatically using some tools.

Automated testing tools provide:

1. Better software
   By building a library of automated tests, you are generally going to ship better software that you can guarantee will work when used in certain, predictable, preconceived ways (the uses cases that have been accounted for in the tests).
2. Continuously-run tests
   Once you have tests automated, there is very little cost to running the tests. As such, once you’ve made the investment in building automated tests scripts, there is no good reason not to run them frequently. You could schedule a process to run all tests every night, and get the results in the morning to start fixing the bugs as soon as possible.
3. Cheaper to fix bugs
   The moment in which you find the bug and how much it costs to fix are highly correlated. The more time that elapses from when the bug was created to when the bug is actually found, the more expensive the bug becomes to find and fix. If it is found in a matter of hours instead of weeks (or maybe even months) the amount of effort involved in fixing it is going to be orders of magnitude smaller.
4. Freedom to change and evolve the software
   As software systems get bigger, it becomes harder and harder to make changes without breaking things. If you’ve got a large battery of automated test scripts, it frees the programmers to touch parts of the code that they might have fear to break otherwise.  the automated testing is a “safety net”: they can refactor the code, add or change features, etc. with a lot less loss of sleep.
5. Happier clients
   Less bugs mean less problems with customers, less support costs and higher retention rates.

A growing trend in software development is the use of testing frameworks that allow the execution of unit tests to determine whether various sections of the code are acting as expected under various circumstances. Test cases describe tests that need to be run on the program to verify that the program runs as expected. These tests are written to define the functionality before the code is written. Only when all tests pass is the code considered complete.

Many test automation tools provide record and playback features that allow users to interactively record user actions and replay it back any number of times, comparing actual results to those expected. The advantage of this approach is that it requires little or no software development to perform the tests. This approach can be applied to any application that has a graphical user interface. These tools perform what is called Graphical User Interface (GUI) testing.

In the next two posts we’ll be discussing Unit and GUI testing tools. Stay tuned!

Related posts:

1. GUI Testing
2. Unit testing
3. Test-driven development
4. Load testing
5. Some open source projects for .NET you should take a look at