A technique for using automated unit test scenarios to design and decoupling of dependencies is called Test Driven Development. This technique is heavily used in Agile development methodologies. To use this technique with Visual Studio Team System, you have to understand the following topics:
- Creating and running automated tests inside the VSTS IDE
- Abstracting dependencies in an object-oriented world
- Re-factoring new and old features to remove duplication in the code
The main theme of TDD is “Red, Green, Refactor.”
- To work with TDD you must have a Test Project solution for creating new test cases in VSTS and it should reference the class library where you are adding new functionality.
Follow these steps to perform TDD:
- Understand the requirements of the user story and feature that you are working on.
- Red: Create a test and make it fail.
- Write the test for already existed code and change the logic of the code to make our test fail.
- Run the test case. It should fail. This means your test is calling the correct code and that the code is not working by properly. This is a meaningful failure, and you expect it to fail.
- Green: Make the test pass
- Initially hard code the expected return value to verify success after that write the correct logic of code to make the test pass.
- If you’ve written the code so that the test passes as intended, you are finished. You do not have to write more code speculatively. If new functionality is still needed, then another test is needed. Make this one test pass and continue.
- When the test passes, you might want to run all tests up to this point to build confidence that everything else is still working.
- Refactor: Change the code to remove duplication in your project and to improve the design while ensuring that all tests still pass.
- Remove duplication caused by the addition of the new functionality
- Make design changes to improve the overall solution.
- After each refactoring, rerun all the tests to ensure that they all still pass.
Advantages of Test-Driven Development
- When the unit test case passes success and logic of the code is refactored to remove duplicate code.
- The unit tests will not expire until you separate documentation and this will feedback that each component is still working.
- TDD will help Developer to understand the complete design and critical analysis of requirement to work with the logic of code and get the accurate result.
- Any software developed using TDD can be maintained easily, better designed.
- If a bug is found, the developer should create a test to reveal the bug and then modify the logic of the code until successive test run, all old bug are verified and Reduced debugging time.
- Due to extensive use of test cases all code logic is not executes success or failure properly.
- Some Security Issues for Integration testing and Compliance testing