In this article, I will answer your questions that can help you get started with software testing. I’ll go over what software testing is, the most important testing concepts, and some tools to consider.
What Is Software Testing?
Quality assurance is becoming more and more popular. In fact, experts estimate that the testing jobs in the US alone will increase by 25% in the next decade. If that interests you, you may wonder where to start learning about software testing.
According to ISTQB’s glossary, software testing is:
The process consisting of all lifecycle activities, both static and dynamic, concerned with planning, preparation, and evaluation of a component or system and related work products to determine that they satisfy specified requirements, to demonstrate that they are fit for purpose and to detect defects.ISTQB’s glossary
This means that software testing plays an important role in the software development process that validates that the software application functions as intended and meets the requirements and expectations of its end users. The goal is to identify defects, errors, and inconsistencies in the software application before it is released to the public. Testing involves running the software in different conditions, configurations, and scenarios to ensure that it works correctly and efficiently.
If you're curious on how to get a start in the software testing field, then here's a list of common QA interview questions (and answers!).
Software Testing Life Cycle
The software testing life cycle (STLC) is the process followed by software testers to ensure that the application under test meets the specified quality standards and requirements. The STLC typically consists of several phases designed to ensure that the software application is thoroughly tested and meets the desired level of quality before it is released to the end users. The following are the phases of the software testing life cycle:
In this phase, the software testers analyze the requirements and specifications. They identify the functional and non-functional requirements, understand the purpose of the software application and the target audience, and develop test cases and scenarios accordingly.
In this phase, the testing team identifies the scope of the testing, the testing approach, and the resources required for testing. The test plan also identifies the risks and constraints associated with the testing process and outlines the testing timeline.
In this phase, the testing team designs the test cases and test scenarios based on the requirements and specifications. They also identify the test data required for testing and develop test scripts that automate the testing process.
the testers execute the test cases and scenarios designed in the previous phase. The test results are documented, and any defects or errors found in the software application are reported.
In this phase, the testing team prepares a report with the test results and the defects identified during testing. The report may include their recommendations for fixing the defects and improving the software application's overall quality.
It’s the last phase when the testing team evaluates the testing process and identifies areas for improvement. They also prepare a test closure report that summarizes the testing process and the testing outcomes.
The software testing life cycle is a continuous process that requires collaboration between the testing team and the development team to ensure that the software application meets the desired level of quality and functionality.
Types Of Software Testing
There are different types of software testing used by the QA teams, depending on the project's context and requirements.
We can distinguish between manual testing and automation testing, depending on how the tests are executed. Based on what is being tested, we can differentiate between functional and non-functional testing. Depending on the methods used, we have static and dynamic testing. Based on the approach, we can identify the white box and black box testing types. We also have exploratory testing, smoke and sanity testing, and regression testing. All these testing types may overlap between them, depending on how they are used.
With manual testing, the testing is done in person, without using automated tools or scripts. It may be more prone to error and usually takes longer.
Automation testing is performed by a machine that executes scripts written in advance. It requires more technical expertise, for example, knowledge of a programming language and automation tools such as Selenium. It can be more expensive than manual testing, and certain aspects of the testing process cannot be automated.
Functional testing means verifying what the application does. Functional testing checks the software application's features and capabilities and ensures that they meet the requirements and specifications.
As opposed to functional testing, non-functional tests focus on how the app behaves. There are multiple subtypes of non-functional testing, depending on what the main goal of the tests is. I will only cover a few of them in this article.
Performance Testing: is used to measure the software application's response time, throughput, and scalability under various load conditions. It checks the software application's ability to handle multiple users and transactions simultaneously and to ensure that it functions efficiently under peak load conditions.
Load Testing: simulates real-world user loads and is performed to determine a system’s behavior under normal and peak conditions. It’s used to identify whether the infrastructure used for hosting the application is sufficient or not and tells us how many simultaneous users the application can handle and the scale of the application required in terms of hardware, network capacity, etc., so that more users can access the application.
Stress Testing: involves testing beyond the normal capacity, often to a breaking point, to observe the results. The goal is to ensure that the software does not crash in conditions of insufficient computational resources (such as memory, disk space, network request, etc).
Security Testing: is used to ensure that the software application is secure and protected from unauthorized access. Security testing checks for vulnerabilities and weaknesses in the software application's security protocols and identifies any potential security threats.
Usability Testing: is used to assess whether the application is user-friendly. It checks how easy it is for users to navigate the software application and perform the intended functions efficiently.
Accessibility Testing: can be considered a subset of usability testing, accessibility testing is performed to ensure that the application being tested is usable by people with disabilities.
Localization Testing: is a software testing type in which the behavior of software is tested for a specific region, locale, or culture. Some attributes to consider during localization testing: text correctly translated, currency, measurements units, special characters allowed, and phone number formats
Compatibility Testing: tests whether the application is proficient enough to run in different browsers, databases, hardware, operating systems, mobile devices, and networks
Static Testing and Dynamic Testing
Static testing relies on the manual examination of work products (i.e., reviews) or tool-driven evaluation of the code (think code reviews) or other work products (i.e., static analysis). Can be performed on (but is not limited to): specifications, business requirements, acceptance criteria, source code, test plans, test cases, test scripts, and user guides.
Dynamic testing Is the actual execution of the software being tested. It can be manual or automated, or
White Box Testing and Black Box Testing
White box testing is a type of testing where the tester has knowledge of the internal structure of the application’s code, while black box testing is performed without any need to understand the source code. Each of these testing types applies different testing techniques, such as equivalence partitioning, boundary value analysis, and decision table, for black box testing, and statement coverage, decision coverage, for white box testing.
Exploratory testing is a type of experience-based testing. It involves minimum planning and maximum test execution.
The test design and test execution activities are performed in parallel, typically without formally documenting the test conditions, test cases, or test scripts.
It’s a useful approach when there are no or poor specifications and when time is severely limited, or works great to complement automated testing.
Smoke Testing, sometimes called “Build Verification Testing” or “Confidence Testing”, is a software testing process where the testers verify whether the deployed build is stable. Smoke testing is a validation that we can proceed with further software testing. It consists of a minimal number of tests that run on each build to test critical software functionalities.
Sanity testing is a type of software testing carried out following the delivery of a software build with minor code or feature modifications to confirm that the bugs have been resolved and no new issues have been introduced due to these changes. The objective is to confirm that the proposed feature functions roughly as expected.
Regression testing is a type of software testing where we retest existing functionalities to validate that they still work correctly after any changes or updates to the software application. Regression testing ensures that the new changes or updates have not impacted the software application's existing functionality.
Compatibility testing is used to ensure that the software application works correctly across different platforms, devices, and browsers. It checks that the software application is compatible with various hardware and software configurations
Software testing can be categorized into different levels based on the scope and objectives of the testing. The following are the common levels of software testing:
Unit testing is the first level of testing and focuses on testing individual components or units of code in isolation. Unit testing verifies that each unit of code performs as expected and meets the specified requirements.
Integration testing focuses on testing the interactions between different modules or components of the software application. Integration testing verifies that the modules or components work together as intended and meet the specified requirements.
System testing is the level of testing where the entire software application is tested as a complete system. System testing verifies that the software application meets the specified requirements and performs as expected in various scenarios.
User Acceptance Testing
Acceptance testing is the level of testing where the software application is tested from the end-user perspective. Acceptance testing verifies that the software application meets the end user's needs and requirements and performs as expected in the user environment. Common user acceptance testing types are alpha testing and beta testing.
Each level of testing is important and serves a specific purpose in the software testing process. Testing should be performed at each level to ensure that the software application meets the desired level of quality and functionality and performs as expected in various scenarios.
Software Testing Principles
There are 7 main testing principles, as defined by the ISTQB:
- Testing shows the presence of defects, not their absence: This means that you cannot guarantee the application is defect-free just because it was tested. However, after the testing is performed, confidence in the product can increase.
- Exhaustive testing is impossible: Most apps are incredibly complex, so testing every possible combination and variation is impossible, especially because the testing time and resources are also limited.
- Early testing: The sooner the bugs and defects are discovered during the software development life cycle, the easier they can be to fix. That’s where Agile gets it right, as testing activities start very early.
- Defects cluster together: This means that areas where defects were found, will most likely have even more defects. According to the Pareto principle, 80% of defects can be found in 20% of the functionalities.
- The pesticide paradox: Running the same tests repeatedly without updating them will not likely uncover any new issues.
- Testing is context-dependent: Applications will be tested differently based on their context - for example, you test an API differently than you do a user interface, and you test web applications differently than mobile or desktop apps.
- Absence-of-errors fallacy: In short, just because the defects have been found and fixed does not mean the software is useful to its users.
Software testing is a very complex domain, and there are many types of testing that can be executed. It’s important to adapt your testing strategy based on the context of the software product that is being tested.
If you enjoyed this article, why not subscribe to the QA Lead’s newsletter and be the first to know about any new blog posts about testing and quality?