Do Testers Welcome Developers Writing Their Own Unit and Integration Tests?

Yes, testers do welcome developers writing their own unit and integration tests. This article delves into the reasons behind this acceptance and how such practices improve code quality and communication within development teams.

Understanding the Role of Unit Tests and Regression Tests

Unit tests and regression tests serve two primary purposes: ensuring that each class or function fulfills its specified contract with the code outside of it, and detecting regressions when code no longer meets the established contract. In Test-Driven Development (TDD), these tests also play a crucial role in defining the contract at the earliest possible stage.

The Importance of Code Coverage

While acceptance testing is often carried out by testers not directly involved with the main development, they still play a critical role in interpreting and ensuring the software meets its requirements. Software specifications are inherently incomplete; the only truly complete definition of the system is the software itself. This incompleteness leaves room for interpretation, especially in commercial development where specifications are often vague and incomplete.

For example, while a specification may not explicitly state that a user must see their keystrokes appear immediately with no lag, this is often assumed as an unwritten requirement. When discrepancies arise during testing, it is easier to identify whether the issue lies with a bug in the code or a flaw in the design. This is always easier when the code has good test coverage, as the tests act as a form of documentation on how the code should behave.

The Role of Testers in Software Development

Testers, particularly those who are not the main developers, focus on acceptance testing. This involves verifying that the software meets the specification. However, this becomes significantly easier when the developers include unit and integration tests. These tests not only help in ensuring the code works as intended but also serve as a reference point for interpretation and clarification.

When testers encounter discrepancies, they have two main avenues to resolve the issue:

They can consult the domain experts who designed the specification. They can examine the code and its contracts between classes or functions.

Having unit and integration tests makes it easier to pinpoint discrepancies. The tests clearly outline the expected behavior of the code, making it simpler to determine whether the issue is a bug in the implementation or a design flaw.

Facilitating Collaboration and Communication

When developers write tests, it makes it easier for testers to communicate their requirements. A simple test request like "please add a test that passes null as the third parameter and checks that the correct exception is thrown" or "the output of this method should always be positive, but it is currently negative if the second parameter is negative, please fix this and add tests to show it is fixed" provides clear and actionable instructions. This common language of tests simplifies the process of understanding the testers' needs and expectations.

Conclusion

In summary, code that includes unit and integration tests written by the developers is not only easier to test but also enhances collaboration and communication within the development team. By providing clear documentation and a reliable reference point, these tests significantly improve the quality of the software and make it easier for testers to work effectively.

Investing in high-quality, comprehensive tests is an investment in efficient and effective software development processes.