Testing is very important in software development. It can and is frequently performed at all stages of application creation. Sometimes, it is occurs even before a given feature is created, yet usually, it is done after a given functionality is deemed by the developer as finished or after the completion of the whole application. In this feature, I will provide you with some basic information regarding test levels.
Since testing is strictly connected to the development process, different kinds of tests need to be employed at every stage, depending on software’s completeness. These are called test levels. Going from the bottom to the top, they include: unit (or component) tests, integration tests, system tests and acceptance tests. In Agile methodologies, test levels frequently overlap.
Unit/component tests – testing of e.g. modules, classes or objects, performed in separation from other elements of the same kind: other modules, classes, etc. They can also be executed in separation from the rest of a given system. This level includes mainly functional tests, yet also those pertaining to structure (e.g. decision coverage) or performance (e.g. checking whether there are any memory leaks) can be performed then. Usually, it is necessary to have access to the application’s code in order to be able to create such kind of test. Unit tests are usually performed by developers, and frequently written even before the creation of the feature itself, in Test-Driven Development, which is very popular at places where continuous integration is present.
Integration tests consist in the verification of interactions between modules, parts of the system and between systems. Similarly to unit tests, they are usually automated. They can be created and performed either by developers or by testers. This level of tests focuses on functionality yet performance can be tested at this level, too. It is very important that the tester knows the architecture of the whole product, and, if possible, the order in which its next parts are to be created, as structural approach can be prove helpful in planning comprehensive and effective integration tests.
System tests are tests checking the behavior of the whole product or system, and data quality. It is vital to define their scope before their execution and to render the test environment as similar to the production one as possible. This level can be based on software models, use cases, the client’s requirements or possible risks. They include both functional and non-functional tests. Thorough planning (e.g. based on the structure of the item to be tested) and choice of suitable testing techniques is vital in this kind of tests, frequently performed by a group of independent testers.
Acceptance tests – tests based, above all, on user’s requirements and use cases, business processes and risk analysis reports. They are usually performed by the client and frequently, even by the software’s target users. Their focus is not on finding bugs but on checking whether given software is ready to be implemented and used (usability tests). Acceptance tests can be performed at various stages of software development, e.g during component tests or before system tests. Typical forms of acceptance tests include user acceptance tests, operational acceptance tests, contract and legal compliance tests, as well as alpha and beta tests. These tests are usually executed manually, but can also be automated.
Source: ISTQB Foundation Level Syllabus and Glossary