A quick guide to smoke testing


21 August 2018 • 11 min read

    It’s safe to say that quality is one of the most essential attributes of every application released to market today. After all, not many users will give an app a second chance if it’s not responsive enough, has bad UX or is simply buggy.

    One of the things we can do to ensure the high quality of their deliverables is software testing. In fact, testing has become a mature area boasting many of test types, various test levels, best practices, and tools to support the testing process. All of that means that we conduct hundreds or even thousands of tests every day – all with the hope that the software we develop is bug-free.

    But sometimes when we’re busy testing the functionalities we’re working on, we forget about testing the basic functions of our application. That sort of omission can become catastrophic if we release a version with such errors to production.

    Smoke tests are an excellent method for quick verification of critical software functionalities. Dedicating relatively little time to smoke testing, you’ll make sure that what is absolutely crucial in your application works smoothly.

    In this article, I wanted to take a closer look at smoke testing to share with you some of the best practices I’ve learned in my experience as a team leader.

    Start early

    It’s best to start as early as possible. That’s true not only for smoke testing but testing in general. You can do that already at the level of requirements by defining the critical points in the application you will want always to verify. When your application is being developed, you can gradually expand your smoke tests set with new test cases. By doing that, you’ll be verifying the most critical functionalities at every stage of development.

    Adjust the scope

    When planning the scope of test cases dedicated for smoke tests, it’s important to note that they need to concern only the most critical functionalities in your application. That type of testing is there to help us answer the question whether it makes sense to test a given version or build further. For example, if you’re developing an e-commerce application and you can’t log in as a client or add a product to cart, these make cases for smoke tests.

    Quick execution

    This issue is somewhat related to the previous point because the scope of testing should be adjusted in a way that allows executing the entire smoke test set as quickly as possible. Naturally, there are no standard time frames here. However, you can simply assume that executing these tests should never take you more than an hour. After all, we do that to check whether it’s worth to continue testing and not testing the entire version at this point.

    Manual or automated?​

    At some point in the building software, you’ll arrive at a constant smoke tests set. Naturally, this is the moment when you should consider automation. That type of approach will be slightly more time-consuming at the beginning. However, once you write down the tests, you’ll save a lot of time in the future. When automating smoke tests, consider the question of maintaining these tests as well. Given their relatively limited scope, most of the time it’s not a big problem. If you don’t get the opportunity for automating tests, you can always execute them manually – all the while remembering that they’re supposed to be quick and based on small scope of use cases.

    Test repository

    Smoke tests are used cyclically as a specific constant subset of all tests for a given application. That’s why it’s a good idea to create a test repository or a special place in that repository dedicated to smoke tests. After all, you don’t want to create all tests from scratch every time but use an already existing set. In case of changes in your software, you can also review your smoke test cases and update them if that’s necessary.

    Use tools

    Just like other types of testing, smoke tests are most efficient if you support them with the right tools. There are a lot of tools on the market, regardless of whether we decide to automate our tests or conduct them manually. A well-chosen tool will ensure efficient management of smoke tests and their execution. If your organization uses Jira Software to manage projects, consider using that tool for test management as well. All it takes is installing one of the specialized apps that support test management. An example of such an app is TestFLO which allows creating a test repository and quick preparation of smoke tests thanks to reusable test cases.

    Continue testing

    Smoke tests are one of the initial phases of testing a new version or build. That’s why you should remember that smoke tests only serve to answer the question of whether you should be testing your app further or not. They act as a type of security for critical functionalities – however, without other tests, they don’t bring you real value. After completing smoke tests with a positive result, you should continue testing and move to more detailed functional and nonfunctional tests that focus on new features and changes.

    Key takeaway

    Testing software is a complex process made up of many different elements. It’s smart to include a set of smoke tests that secure you against bugs in the most critical functionalities in our app.

    The amount of work required for designing such tests and their cyclical execution is relatively small in comparison to the benefits you’re getting in return. If each version or build that goes to testing is also ran through your smoke tests, you can be sure that further testing makes sense and that the eventual release for to the production environment will be bug-free in the essential areas of the application.

    Have you got any questions about smoke testing? Reach out to me at marcin.zurawiecki@deviniti.com or leave a comment below; I’m always happy to share my knowledge about best practices in testing.

    [contact-form-7 404 "Not Found"]