Mark Macznik
Table of Contents
Aaaah. Smoke testing. The magicians trick in the IT world. Like smoke and mirrors it gives you a glimpse of what is going on in your application without going too deep. The real magic is still hidden in the lines of code and yet you get an idea if the new build is worth putting into the next environment. Bugs behold! The Great Buggini will perform smoke testing and uncover all of you with just a few clicks!
Putting the show business aside, let's do a more serious intro.
If you want your product to succeed, it needs to be and of high quality. Software development is a complicated process. Very often a geographically spread team of developers works on a project in an iterative way. The more complex the software, the more bugs and flaws will creep their way into it. It is absolutely crucial for the test team to locate them and send back to the development team before the final build reaches your client.
Smoke testing is one of the preliminary testing methods, often performed as functional tests or unit tests during the software production process. A smoke test is a critical test type, and passing it is one of the key requirements for moving on with the testing process.
But what exactly a smoke test is and how is it performed? Is it as important as we say? We will try to answer these questions and more with this short yet informative guide on smoke testing with examples.
How does Smoke Testing work?
Smoke testing is a type of test that aims to confirm whether the basic functionalities of your software are working as intended. It might be also known as build verification testing. Smoke testing is done on one of the initial software builds when the software is at its most unstable phase. The results of smoke testing can give you a good idea of what’s working and what’s not in your app, allowing you a smooth transition into regression testing in the future.
Hiring a QA team to perform detailed tests on your software product can be expensive. If you decide to keep your own QA team on a payroll every month, you can quickly find yourself bleeding money, and the team might not have that much work to do – especially if you run a small company or a startup.
Outsourcing your QA might lower your costs, but still won’t be cheap. Smoke testing is usually a good way to have an idea which areas you will need to focus on during future testing. Keep in mind that smoke tests aren’t meant to be thoroughgoing. Make sure that your smoking test suite consists of test cases that will only target the most crucial functionalities of your software. We can check everything in more detail during the later testing stages.
Smoke Testing vs Sanity Testing
If you know your way around software testing, you might have already spotted the similarities that smoke testing has when compared to sanity testing. Both smoke and sanity tests mean to evaluate basic functionality to determine whether or not the app should move ahead to further tests, or whether it still needs more work at its most fundamental level. So what’s exactly the distinction between the two?
While some argue that the two terms can be used interchangeably, there is actually a bit of difference. Sanity testing refers to testing new functionality and fixing bugs caused by patches or updates. Smoke testing is performed to verify the key functionalities of the software.
One can also easily confuse smoke testing and acceptance testing. There are multiple differences between the two. The most crucial in this context being that smoke testing is usually done very early in the process, whereas acceptance testing is performed at the end of the development cycle.
Also there are rumours that smoke testing is a subset of regression testing. Definitely not true since the goal of regression testing is to determine whether the changes in the application do not negatively influence the current functionalities.
The advantages of Smoke Testing
While you might think smoke testing is only a rudimentary way of software testing, the benefits it gives the development team are undeniable. Apart from allowing you to save money on further QA by identifying flaws in basic functionality, smoke testing can save you tons of effort and time. If you should skip smoke testing and proceed directly to regression testing, you can easily get stuck in a testing cycle loop, moving on to thorough tests and going back a few steps each time a major error is found.
Smoke testing is fast, efficient, and effective method of system testing. It allows you to find out any flaws and defects in the earliest stages of software production, reducing the risk of releasing a faulty product. Once all of the major bugs and problems have been solved you can then move on to more detailed testing methods, but in the beginning. Smoke testing is also able to guide you to swiftly get rid of critical errors that would otherwise hinder your progress.
So what could exactly happen if you forget about ensuring a proper smoke testing stage? The most common results of skipping this preliminary test are major setbacks in the future, as major defects go on undetected and make a mess out of your functional testing stage. Having to go back to basic functions and gradually fix them one by one, instead of figuring out all of them right from the get-go, will ultimately result in a waste of time, money, and effort.
Smoke Testing examples and sample test cases for your smoke testing process
How exactly smoke testing will look depends heavily on the type of software you are developing. If you’re running a simple website that has register and login functions, an example of smoke testing would be verifying that functionality. The result you’re going to usually expect from such a test would be to simply access your website and log in without any issues. The steps would look similar to this:
- Open up your browser’s executable
- Navigate to your website
- Open the login panel
- Enter your credentials and log in/register
- Finish the process
If the results are positive – as in you actually managed to log in or register, then the test was successful. You can create similar test cases for other basic functionality of your software, like verifying whether a cart system is working properly at your online store or checking if your app doesn’t crash after you open the executable.
Summary
All in all, you can see why smoke testing is so important. Can you imagine forwarding your build to QA only to find out the app crashes on start? Avoiding smoke testing can lead to a tremendous waste of time and resources, delaying newer iterations of your software and putting you in danger of missing deadlines. Remember that smoke testing can be done in an automated way. If you select a correct testing tool, the door to automation testing will be wide open for you.
If you care about the quality of your software, smoke testing and sanity testing are the way to go. Always perform a set of smoke testing cases at the beginning of the development process and some additional sanity testing in future builds to ensure stability and minimize your team’s effort during the testing phases. Also make sure you know and understand the smoke testing vs sanity testing differences we have covered.
Happy (automated) testing!
