In this article, we’ll cover the basics of Confirmation Testing: what it is, when & how to run confirmation tests, what to do after you’ve run these tests, and it’s salient features.
We’ll also cover challenges, advantages and disadvantages of confirmation testing. Our intent is that the reader, after absorbing all the information here, can make completely informed and unbiased decisions about whether to run tests and in what capacities to do so.
Let’s dive in.
Table Of Contents
What is Confirmation Testing?
Confirmation testing is a type of software testing technique in which the software-under-test is run through a set of previously run tests, just to make sure that the results are consistent & accurate. The intent is to ferret out any remaining bugs and check that all previously found bugs have been truly eliminated from the software components.
Basically, all tests run earlier are run once again, after the bugs found in the first tests have been fixed by devs. Confirmation testing is also called re-testing because it is literally running the same test twice – one before finding bugs and one after.
Generally, when testers find a bug they report it to the dev team that actually created the code. After looking through the issue, the devs fix the issue and push another version the feature. Once QAs receive this scrubbed version of the software, they run tests to check that the new code is, indeed, bug-free.
Note: While running confirmation tests, QAs need to follow the defect report they have created earlier to inform developers of the bugs they found in the software at that stage. QAs must run the same tests, and check if any of the previous (or even new) functional anomalies show up.
When to do Confirmation Testing?
- Right after a bug fix: Once a bug has been reported and fixed, confirmation tests should be run to check that the bug has actually been resolved.
- Right before regression tests: Regression tests verify that code changes have not affected existing software functionalities. So, for regression to go smoothly, confirmation tests should be run beforehand. That way, the regression tests won’t be disrupted by existing bugs.
- Right after bugs have been rejected: If a bug has been reported, and is then rejected by the dev team, these tests must be run to reproduce the bug….and report it again in greater detail.
How to run Confirmation Testing
Unlike most other software tests, confirmation testing doesn’t have any specific techniques. You literally just run the same tests twice. As soon as a bug has been resolved, put the software module through the same tests that led to the discovery of the bug in the first place.
If the same bug (or new ones) do not emerge and all confirmation tests pass, you’re done. If not, testers must re-examine emerging bugs, reproduce them, and provide deeper, more detailed reports to devs. Reappearing bugs can indicate deeper flaws in the underlying system.
Note: If you need to execute these tests multiple times in the future then they become a good candidate for test automation.
What to do after Confirmation Testing?
Once confirmation tests have confirmed that no live bugs exist in the application, the software can be moved further along the development pipeline. You simply push it to the next stage of testing/deployment.
The whole point of confirmation testing is to ensure the accuracy of bug elimination, thus making the software more reliable and worthy of customers’ positive attention.
However, often, confirmation tests are immediately followed by regression tests. Since one or more bug fixes have been implemented on the software, the regression tests check that these changes haven’t negatively impacted any of the software functions that were working perfectly well before debugging took place.
- It requires planning and effort from the development and the testing team.
- It is not necessary to create new test cases, as the same ones that led to finding bugs will be run again after debugging.
- It is often performed before regression testing, so as to check that any existing modules have not been affected when fixing the bug.
- Aims to increase software success rate by ensuring that an assuredly bug-free piece of software goes through the funnel.
- Confirm if the bug(s) still exist in any shape or form after the debugging exercise.
- Confirmation tests ensure that an application works at the highest possible performance levels. These tests literally double-check if any existing bugs remain or if new bugs have shown up after debugging. With the right confirmation tests in place, bugs will not get through to deployment.
- These tests ensure that the software is bug-free and that its functionality is never disrupted in the hands of users.
- Confirmation tests are easy to execute because you literally run it twice. There is no need to create specific test cases or scripts.
- These tests are often executed right before regression tests. This is done to ensure that specific modules are bug-free before the regression test checks for any disruptions to the larger system.
- It also helps with the earlier detection of major or minor bugs.
- Confirmation tests must be run manually since they cannot usually be automated due to uncertainties with defect resolution. Manual testing inevitably stretches timelines and can delays product releases.
- Generally, it is a best practice to run regression tests after confirmation tests to check the application’s overall viability. But running regression tests takes a fair amount of time, often overnight.
Challenges in Confirmation Testing
- These tests are change-oriented. For every confirmation test, testers have to run regression tests, which is a real sink of time. As mentioned above, this can lengthen time-to-market, which is never a good thing.
- Confirmation tests usually check if pre-existing bugs are still plaguing the software. They hardly ever find new bugs. Identifying new bugs requires a separate set of tests, which pushes more workload onto tests, and the devs to has to fix those new bugs. This is quite a gap in the scope of testing.
- Once again, as mentioned above, confirmation tests can usually only be manually executed. Every time a bug is fixed, these tests have to verify that they really are gone. Given that most modern software is fairly complex and layered, multiple bugs will show up at any given time. Imagine running confirmation tests for all those bugs, and you’ll see the problem.
Confirmation tests are a necessary (if somewhat inconvenient) fail-safe that testing cycles need to push out truly bug-free products. The challenge lies in designing and scheduling these tests without stretching the timelines to unacceptable levels. However, the efficacy of these tests is beyond question, and they absolutely deserve a place of pride in your test suites.