Concepts
The Agile approach, which combines iterative and dynamic development strategies, has been integral in advocating for the implementation of unit-testing. This article explores five practices and principles of unit-testing essential to developers targeting the Advanced Certified Scrum Developer (A-CSD) certification.
1. Test First Development (TFD)
In Test First Development, unit tests are written before the actual code. This ensures the software code aligns with desired requirements as tests are defined based on the feature descriptions. Coding only begins after the unit tests have been written.
The following table shows a simplistic example:
| Requirement | Test Case |
|---|---|
| “The application should confirm user authentication before granting access.” | Test if the system prompts for login credentials. |
Once each requirement has a corresponding test case, developers can begin coding. This decreases the chances of developing functionalities that derail from the original requirement, reducing refactoring time.
2. Red, Green, Refactor
Often associated with Test-Driven Development (TDD), Red, Green, Refactor constitutes an integral part of unit-testing principles. Right after coding for a particular feature, the developer runs the defined unit tests.
- ‘Red’ signifies a failing test, indicating code discrepancies.
- ‘Green’ entails passing all tests, meaning code aligns perfectly with requirements.
- ‘Refactor’ denotes making improvements on the code to enhance its efficiency, readability, or structure. Testing is done after each refactoring to ensure that the code still passes all tests.
3. Test Isolation
In unit-testing, it is necessary to isolate tests so that one doesn’t affect the other. To ensure proper isolation, Mocking techniques are widely used. Mocking imitates behaviours and responses of real objects in controlled ways. By asserting that methods get invoked as expected, Mocks can assist in eliminating dependencies while testing.
| Without Mocking | With Mocking |
|---|---|
| The software’s functionality can concatenate multiple strings. | Mock objects substitute real objects. Their behaviour is easily manipulated. |
4. Testing Hierarchies and Dependencies
A good practice in unit testing is evaluating object hierarchies and resolving dependencies. An object may depend on another object’s behaviour or an external factor, which can introduce issues if it isn’t functioning correctly.
By employing the principle of testing hierarchies and dependencies, we validate the overall functionality of the entire system. On identifying an issue, we can easily locate its origin.
5. Continuous Testing
Continuous testing (CT) integrates testing efforts with software delivery workflow and helps in detecting errors at early stages. This approach enables teams to assess the business risks associated with the software release candidate. With services allowing real time risk assessments, CT efficiently implements shift-left testing that promotes system reliability.
Through the application of these unit testing principles, Agile teams can wrap their software development efforts around delivering a product that meets defined requirements. Preparing for the Advanced Certified Scrum Developer (A-CSD) exam equally requires developers to fully understand and effectively utilize these strategies.
Answer the Questions in Comment Section
True or False: Unit testing should test the entire software system as a whole.
- True
- False
Answer: False
Explanation: Unit testing focuses on testing individual components or units of a software system, not the whole system.
Which of the following is a principle of unit testing?
- a) Test individual components
- b) Test early and often
- c) Code and test are inseparable
- d) All of the above
Answer: d) All of the above
Explanation: All these principles are integral to effective unit testing.
Multiple Select: What are the best practices of unit testing?
- a) Avoid testing trivial code
- b) Write tests for every function or method
- c) Test one piece of functionality per test
- d) Test only at the end of development
Answer: a) Avoid testing trivial code, b) Write tests for every function or method, c) Test one piece of functionality per test
Explanation: Testing should be a continuous process and should not be done only at the end of development.
True or False: It is not necessary to run all unit tests after a small change in code.
- True
- False
Answer: False
Explanation: Even a small change can affect other parts of the system, so running all unit tests after each change is a key principle of unit testing.
Single Select: What’s the primary goal of unit testing?
- a) To find bugs before users do
- b) To ensure all code paths are executed
- c) To verify the correctness of individual units of source code
- d) All of the above
Answer: c) To verify the correctness of individual units of source code
Explanation: While unit tests can help find bugs and ensure all code paths are executed, their primary goal is to verify the correctness of individual units of source code.
True or False: Unit tests should depend on other unit tests.
- True
- False
Answer: False
Explanation: Each unit test should be independent and able to run standalone.
Multiple Select: Which of the following are principles of unit testing?
- a) Tests should be fast
- b) Tests should have predictable results
- c) Tests should rely on external systems
- d) Tests should be written after the entire system is built
Answer: a) Tests should be fast, b) Tests should have predictable results
Explanation: Tests should not rely on external systems and should be written just after a function or method is developed, not after the entire system is built.
True or False: In unit testing, code coverage is more important than test quality.
- True
- False
Answer: False
Explanation: While code coverage is important, quality of tests matters even more. Tests should be meaningful and well-designed.
Single Select: What distinguishes a good unit test?
- a) Complex code
- b) Test of multiple functions
- c) High running time
- d) Simplicity and clarity
Answer: d) Simplicity and clarity
Explanation: A good unit test should be simple, clear, and easy to understand.
True or False: Refactoring code doesn’t require running all unit tests again.
- True
- False
Answer: False
Explanation: After refactoring, all unit tests should be run again to ensure the code changes haven’t broken existing functionality.
Multiple Select: The testing principle “Test Early and Often” supports which practice in unit testing?
- a) Running tests after every small modification
- b) Using a Continuous Integration server
- c) Writing tests before writing the code (Test-Driven Development)
- d) Only testing at the end of the development cycle
Answer: a) Running tests after every small modification, b) Using a Continuous Integration server, c) Writing tests before writing the code (Test-Driven Development)
Explanation: “Test Early and Often” principle supports practices like running tests continuously, incorporating continuous integration and following TDD. It’s opposite to the practice of testing only at the end of the development cycle.
I found that applying the SOLID principles to unit testing really helps in building maintainable and scalable tests. Anyone else tried this?
Thanks for sharing, the blog post was very helpful!
I’m new to unit testing. Can someone explain how to use dependency injection (DI) in unit tests?
Commenting just to say, this is a fantastic blog post!
Does anyone use TDD (Test Driven Development) while preparing for the A-CSD exam?
I think automated testing frameworks are overhyped.
Are there any specific mocking frameworks recommended for A-CSD preparation?
This post is a lifesaver. I was struggling with unit testing concepts. Thanks!