Test Driven Development (TDD)

TDD (Test Driven Development) is a computer programming method that consists of small iterations. In this method you begin by writing the test cases covering the new functionality, then you write the production code necessary to make the test pass, and after that you refactor the code to make it more maintainable. Writing the tests before writing the code guaranties immediate feedback after changes are made.  TDD (test-driven development) is a technique for designing the software as well as testing it.

In Test Driven Development (TDD) automated unit tests are written before the code is actually written. Running these tests give you fast confirmation of whether your code behaves as it should.

TDD can be summarized as a set of the following actions:

(1). Writing a test
In TDD (Test-driven development), you begin by writing a test. In order to write the test, the programmer must fully comprehend the requirements. At first, this test will fail because it is written prior to the feature.

(2). Run all of the tests and make sure that the newest test doesn’t pass
This insures that the test suite is in order and that the new test is not passing by accident, making it irrelevant.

(3) Write the minimal code that will make the test pass
At this point you need to write code that will successfully pass the test. The code written at this stage will not be 100% final, you will improve it later stages. Do not try to write the perfect code at this stage, just write code that will pass the test.

4. Make sure that all of the previous tests still pass
If all tests now succeed, the developer can be sure that the code meets all of the test specifications and requirements and move on to the next stage.

5. Refactor your code 
In this stage you will clean up and improve your code. By running the test cases again, the programmer can be sure that the refactoring / restructuring has not damaged your code in any way.

6. Repeat the cycle with a new test
Now the cycle is repeated with another new test.

In Test-driven development you always repeat the stages mentioned above (adding tests that will not succeed, making them succeed, and refactoring of the code). Getting the wanted outcome at each step greatly increases the developer’s confidence, productivity, and shortens the time to market.

Advantages of  Test Driven Development (TDD):

• Cut development costs
• Shorten the development Time to Market
• Increase the programmer’s productivity
• An effective, organized and neat code that works
• Shorten the development feedback time
• Provide unmistakable proof that your software code works as intended
• Encourage the writing of quality code

Resources

• Test driven development tutorial – Test driven development tutorial with example
• Test Driven Development – TDD from Wikipedia

Want a specific video tutorial? Add a resource to the list? Stop by the forums, and let us know!

The advantages of unit testing are well known, giving development teams a safety net to facilitate change, ease integration and supply live documentation.

Unit testing of small logical code is quite easy and can show value quickly.

But in real life, our code will use other classes and components. If this happens, things can get quite fragile and the tests will quickly become system tests.

Examples are classes that use a database, a logging system, web service, and any other external component.

These external components may require a complex setup. For example, in order to run a test that uses a database you must have a running database with  tables and data set up correctly for the test.

Because these tests now rely on these external components, they are are very fragile and will ‘break’ fast even if the actual test scenario still works. This can happen for numerous reasons, among others because the database has been modified (perhaps by another test), the web service is not running, or a configuration file is not configured properly.

This leads to numerous failed tests that require high maintenance. As a result, developers lose their faith in unit testing and deliver their code untested.

Typemock Isolator to the Rescue

Typemock Isolator enables developers to unit test all their code by magically disconnecting and isolating  external components.

This allows the code to be unit tested, fast, locally and in a stable manner

How does Typemock Isolator Work

Typemock Isolator uses aspect-oriented technology to redirect calls from the real code. This enables developers to define the behavior of the external component required for a tested scenario. For example, you can simulate that the disk is full when writing to a database by instructing Typemock Isolator to throw an OutOfDiskSpaceException when writing to the database. This is a scenario that will be nearly impossible to test without  Typemock Isolator. The developer defines the behavior in the actual unit test and Typemock Isolator automatically isolates all required components.

All this is done without any need to change or refactor the production code, which will still call the external components API. However, these APIs will not really run any code and will return scenario-specific values, as defined in the test.

What about other Mocking frameworks?

Other mocking frameworks can only work when a special and complex pattern called Inversion of Control is used. Once you write your code using this pattern, you are able to inject fake objects into it. This is done by creating mock objects and passing them as an argument into the production code. These techniques require more development and complicated code that add complexity to development and maintenance.

If you are looking for a robust solution that will give you the freedom to design your code without using Inversion of Control patterns, you should use Typemock Isolator.

To learn more about Typemock Isolator:

• • • • Download Typemock Isolator
      • See the Developers Guide
      • Register to Obtain a FREE Typemock account
      • Unit Test Patterns for .NET development – Part I

  To download Typemock Isolator visit our

Download page

.

The advantages of unit testing are well known, giving development teams a safety net to facilitate change, ease integration and supply live documentation.