Over the past decades, software development and software testing have greatly changed. Modern software systems have become very complex and at the same time software release cycles have kept shortening. Additional aspects like cyber security, distributed and connected systems, artificial intelligence or cloud-based software will add another level of complexity.
As a result of this development, software testing needs to be creative, cover a lot of functionality and go beyond what may be described in requirements documents, use cases or user stories. Of course, a good software testing engineer masters a lot of test design techniques like requirement-based testing, decision tables, boundary-value analysis or fuzz testing. But these techniques must be used with respect to the software to test. A good test design is a result of an efficient combination of testing techniques with respect to the actual software system.
Unfortunately, the conditions in many companies do not support an efficient test workflow. Very often test designs are created by one person or team, working from documents or user stories. So, the software test designers often work in isolation.
When test design is created in isolation, it is easy to miss important perspectives and conditions that should be tested. Therefore, it is important to change this workflow and establish a collaborative approach. This will strongly increase the quality of the test process. A collaborative approach has many benefits:
- Increased knowledge of the application to be tested
- Shared knowledge and experience in test design
- Shared problem-solving ability
- Increased creativity in ways to create tests
- Better planning and prioritizing of tests
- Better communication about the project, the tests and the problems to be solved
Working in isolation is a no go in modern software development. The complexity of software systems in combination with short release cycles can only be managed through an efficient test procedure. The basis for an efficient test procedure is collaboration. Test engineers need to work together among their team and with other departments like developers, users and managers.
Collaboration is necessary in all areas of the software testing workflow:
- Test case creation
- Test execution
- Test evaluation and documentation
Especially the test case creation part is very critical. This task is the most difficult one of the whole software testing process. It is very complex and requires a high level of knowledge in software testing principles and a strong understanding of the software to test. Therefore, working in isolation is impossible, as the needed knowledge is distributed over different departments and people. This fact is often underestimated in daily practice. In my opinion, the test case creation process has the highest improvement potential of all the software testing tasks.
Testing process during software implementation
Software developers will normally test their implementations during the development process. These unit tests can be executed before the new feature is even integrated into the product. Even if these unit tests may have a technical focus, each software unit is created with respect to the final use cases of the system. Therefore, unit tests should not be created and managed in isolation by the development team, they must be a part of the overall test process.
As consequence, collaboration should be the basis of the whole test process, independent whether it is a unit test, integration test or system test. There are several established development processes that see collaboration as a central element, for example agile development methods like scrum. Within this article I will not explain a single development process, but you should keep in mind that testing during development should get the same attention as any other test phase. The software implementation phase and the test process are strongly coupled and belong to one overall process. Even unit tests should be developed with respect to a collaborative test process.
Unfortunately, there are a lot of projects where people work isolated. The developers create their unit tests and the test engineers create their integration tests and system tests. Sometimes they work together within their groups or even totally independent of each other. As we already know, this inefficient process will often result in bad test quality.
Luckily, there is an easy solution for this issue: just talk with each other! It isn’t always necessary to introduce a new workflow within your company or define new development rules. It will be sufficient to spend a little time and bring all project members together, for example within brainstorming meetings. For example, you can start each software iteration with such a brainstorming and talk about the features for the next iteration and the ways to test these features.
With this kind of collaboration all project members can benefit of each other’s knowledge and together it will be possible to define an efficient test procedure. Testing engineers and software developers will benefit a lot from each other if they work in close collaboration. Testing engineers bring in expertise in understanding and analyzing requirements from a system perspective. Software developers have the application knowledge which is needed to write effective test cases.
Of course, after such an initial brainstorming, the project members should not continue to work in isolation. But now everyone can do his work with respect to the whole testing workflow and with the benefit of the common knowledge of the whole team. The collaboration must continue during this software iteration, for example by working groups and synchronization meetings. Again, this can be done without changing the development process at all. You can do such meetings independent of your actual development process.
Brainstorming with product owner
Especially for critical or complex functionalities, it may be advantageous to expand the brainstorming and consult additional project roles, like managers, product owners or users. Everyone has its own view of the expected functionality and its own quality criteria. But you should keep in mind that a brainstorming may become inefficient if there are too many participants. In this case you can split up the group into smaller working groups or use other communication techniques.
There are numerous tools useable for test case development, execution and documentation, as well as tools for the execution and documentation of meetings and for the collaboration within teams. Since cooperation is important in many areas and not in testing only, there is a wide selection of tools that cover general or test-specific requirements. So, from a tool perspective, you are well covered. And you should use this fact to your advantage. You should establish a development and testing process which fulfils your needs. Due to the huge number of software tools you will find the tools that matches with your process. Unfortunately, some companies or teams will start with the selection of the tool and create their process around that tool. This will normally result in an inefficient process. So, the tool should be according to the process and not the other way around.
Collaboration during test execution
So far, we have seen the benefits of collaboration for the test design and test development process. But what’s with test execution?
Manual tests or partially automated tests are never executed twice in the same way. No matter whether you have a very detailed test specification or not, the execution always depends on the tester. Each tester will have its own interpretation of the test description and each tester will execute the test a little bit different. Even if two testers will repeat the exact same steps, there may be a difference in terms of time, for example the timespan between two user interactions.
Now, you may think it is a disadvantage, having such unprecise test cases. But it is a chance to find more issues. If your test case is executed by different persons, it is executed in little bit different variations. And one of these variations may show a bug which may never have been found if the test would always be executed by the same person.
In many companies, the tests or tests groups are always executed by the same persons. So, each tester has its own tests and after a while the tester does no longer need to think during execution and even the attention wears off. Break this dreary and inefficient daily routine! Work together with the other team members and other teams and distribute the tests. A collaborative test execution will increase the test quality and makes the daily work more varied.
Testing is one of the most important steps in software development. It is part of the whole process, from requirement analysis to delivery of the final product. Modern software systems have become very complex and at the same time software release cycles have kept shortening. Even experienced software testing engineers are not able to handle this complexity if they work isolated. Collaboration is a basis for modern software tests. This collaboration of different teams should therefore a primary part of the overall software development process.