Artifact: Developer Test
The automated instructions that validates that individual software components perform as specified.
Domain:  Development
Work Product Kinds:  Solution
Relationships
RolesResponsible: Modified By:
TasksInput To: Output From:
Description
Main Description

This artifact has all the steps required to validate a software components the specification of a set of test inputs, execution conditions, and expected results, identified for the purpose of making an evaluation of some particular aspect of a scenario.

The tests should be self-documenting such that it is clear upon test completion whether the component has run correctly.

Tailoring
Impact of not havingNot having developer tests can inhibit iterative development as there is no assurance that modified components are still working correctly as components are modified iteration by iteration.
Reasons for not needingIf the tests can be embedded into the actual code, a separate work product might not be needed.  But some support for developer testing is always needed.
Representation Options

The following are recommendation and options for representing this work product.

Recommendation: Automated Code Unit.

The most appropriate technique for rendering these tests is code that fully tests the components that can be run regularly as updates are made.

When code is the sole form of the tests, care must be taken to ensure that the code is self-documenting including specifications of what conditions are being tested and what setup or clean-up is required for the test to run properly.

Option: Manual Instructions.

In some cases, some sort of manual instructions can suffice.  For example, when testing a user interface, a developer could walk through a script exercising the component.  In this case it can still be valuable to create a test harness that goes straight to the user interface so that the script can be followed without having to walk through a complicated set of instructions to get to some particular screen or page.

Option: Embedded Code

Certain technologies (such as Java 5 Test Annotation) will allow tests to be embedded in the implementation.  In those cases, there will be a logical work product, but physically it will be assimilated into the code being tested.  The same issues of ensuring the code is self-documenting described above should be taken into consideration.

More Information