Testing in software development cycle

Many different types of tests can be used in software development to make sure that changes to code are working as intended and expected. However, not all tests are based on the same assumptions. The following article describes the different levels of tests used in the software development process. 

1. Module Testing

Module testing, often referred to as unit testing, is aimed at finding defects and verifying the functionality of the software (such as functions, objects, classes etc) that can be tested separately.

It can be performed in isolation from the rest of the system, depending on the context of the software development cycle and on the system itself. You can use plugs, test drivers, and simulators.

Module testing may include testing of functionality and some non-functional attributes such as resource utilization (e.g. memory leaks) or resilience, as well as structural testing. Test cases are designed from products such as module specification, software design, or data model.

Module testing is typically performed with source code access and with the support of a development environment (e.g. unit test libraries, debugging tools) and, in practice, usually also involves the developer who writes the code. All defects are fixed as soon as they are discovered without formally managing them.

In this case, it is also possible to prepare and automate test cases before coding. This approach is called “test-first” or “test-driven production”. It is a highly iterative approach and is based on a cycle of creating test cases, then building and integrating small pieces of code, executing component tests, fixing bugs, and repeating the process until the tests are passed.

2. Integration tests

Integration tests check if software components work together correctly, trying to detect errors during the interaction between systems or their parts. The interaction between a web application and a database or between two classes is a great example of this.

We can categorize integration tests as system integration tests or module integration tests which differ in scale.

When we talk about the integration of functions, methods, classes – we are dealing with module integration tests.

When we talk about connecting large elements such as programs, entire application modules, or systems, we are talking about large-scale system integration.

3. System tests

The main purpose of system tests is to check whether the solution meets the specified requirements (functional and non-functional). They take place on a fully integrated system. It is best if the environment in which tests will be performed is as close as possible to the production environment where the system will operate.

The difference between the environments comes with the risk that our tests will not detect a failure that may manifest itself in the production environment.

At this stage, you can run end-to-end testing. This includes functional testing from the user’s perspective. Ideally, system testing should be performed by people who know how the software should work. Therefore, for a tester, it is necessary to understand the tested system. There are situations when the system has incomplete or no documentation at all. As a Tester, you must be able to handle this challenge.

4. Acceptance tests

Acceptance tests are most often performed by the client or a team on the client’s side. Its purpose is not to find faults, but to verify that the software is acceptable to contract, law, and customer and user expectations. You can often find this level of testing referred to as “acceptance”. Remember that acceptance tests may not always be the last tests performed. There are three examples in the ISTQB syllabus that can be performed at multiple points in the software life cycle. Tests can be performed:  

• when installed or integrated
• during component tests
• tests of new functionality can be carried out before system tests

5. Soft skills required? 

To be an effective tester one needs to have so-called ‘soft skills’. Efficient cooperation with team members daily requires a wide skill set including the ability to discuss complex issues, translating them (in a simple way) very often to non-technical people.

Furthermore, a good tester has to be a quick learner who is open to feedback. When Agile is a chosen methodology, good organization work and independence are of great importance, manifested in the ability to carry out individual tasks with a great sense of responsibility. A good tester should also be persistent, consistent and be able to cope with stress and fatigue.

Related posts:

• Code quality sins made by startups in their software development process
• Software development metrics – how to measure the performance of your team
• Most popular Java frameworks used by Polish software houses in 2020