Luxe Quality logo
Quality Assurance

Andrii Kravchenko, Automation and Manual Quality Assurance Engineer

Dec 29, 2023 17 min read

How to Do Smoke Testing: A Step-by-Step Guide

This article will delve deep into smoke testing to explore the types, processes, and approaches software testers use. 

How to Do Smoke Testing

Smoke testing is a critical process in software development. When testing software, you run a series of tests designed to evaluate each of the software's core functions. When initiating a new software project, understanding how to do smoke testing is crucial for detecting critical issues early.

Smoke testing tools verify whether the most critical functions of the software are working. Many different approaches to smoke testing exist, and modern technologies make manual and automated smoke testing possible for most software products.  

This article will delve deep into smoke testing to explore the types, processes, and approaches software testers use. 

In a nutshell, you will learn everything you need to know about how to perform smoke testing.  

What is Smoke Testing

Smoke testing is the software testing approach to ensure compliance with essential requirements of functionality and stability. It consists of a minimal set of tests run on each build to test software functionalities.  

Smoke testing is a crucial initial stage in the quality control process, as it indicates whether the team should proceed with further testing or immediately send the product back to the developers.  

If the product fails the smoke test, it indicates that the initial build has significant defects that must be addressed before proceeding with additional testing. This phase is essential for identifying and rectifying critical issues early in development, ensuring a more robust and stable foundation for subsequent testing processes. Before diving into the details of smoke testing, it's essential to understand how to do smoke testing effectively in your software development process. Continue reading to learn more.  

When Should Smoke Testing be Performed

Considering software stability, how to perform smoke testing effectively? We perform software testing whenever we develop new features and integrate them into the existing build, as well as before deploying a new build for QA. Performing smoke testing at this stage prevents the expenditure of resources on QA testing of software with significant foundational issues.  

To perform QA smoke testing, the development team deploys a new software build to QA, selects a subset of test cases, and runs them on the build. The QA team tests the application for its critical functional capabilities. If the smoke test is successful, the QA team proceeds with regression testing; if not, the build is returned to the development team for further refinement.  

There are other instances when QA teams should smoke-test the software, such as:  

  • Before introducing new code to the repository  
  • Before a significant round of testing, including regression and acceptance testing.  
  • After the deployment of a new software build.  

So, to ensure thorough software stability, it's crucial to know how to do smoke testing in software testing and apply it rigorously during various phases of development. 

 

Suppose you don't perform smoke testing at these stages. In that case, you may discover severe defects later in the functional testing phases, potentially affecting the release date of the new build or leading to more severe disruptions in your schedule. 

Closest Similar Types of Testing and Their Differences   

Smoke Testing  

  • Smoke testing is typically performed before sanity and regression testing, even though QA teams usually conduct it.  
  • It is a quick and straightforward testing process, and today, most QA teams utilize automated smoke testing when assessing software stability. It determines whether a build is stable and whether further tests need to be conducted.  
  • Since smoke testing is the quickest and simplest test compared to regression testing, performing it before moving on to more complex tests make sense.  

Regression Testing  

  • Regression testing ensures that new code changes or feature additions do not adversely affect the software's existing functionality.  
  • Regression tests may also be performed when a functional or performance defect/issue is fixed.  

Sanity Testing  

If there is a frequently occurring bug, sanity testing would involve checking whether that specific bug has been fixed in the latest build or version. The focus is ensuring that the critical functionalities affected by the bug work correctly.  

Let's consider the key differences between these types of testing in the table below. 

Criteria

Smoke  Testing

Regression  Testing

Sanity  Testing

Acceptance Testing

Objective 

Check the performance of fundamental functionalities. Confirm application stability and ensure primary business logic, often represented by the shortest optimistic end-to-end scenario, is an operational 

Full functionality check after any changes (ensuring changes haven't adversely affected the application and all functionality is operational) 

Verification after build, before deploy in case of minimal code changes. It exercises only the particular component of the entire system  

Verification of only the new feature against all acceptance criteria and requirements 

Scope  

Perform a minimal set of positive test cases for core business logic E2E 

Depending on the application's size, practically from 1 to infinity 

Minimal set of positive test cases for core business logic, and bug fixes 

All positive and negative scenarios for the specific feature 

Utilization of negative tests 

Do not use 

Use 

Do not use 

Use 

Entry criteria  

Release of a new build 

Release of a new build

Release of a new build with minor changes 

Release of a new build and added new features 

Understanding the differences between these types of testing and their objectives is essential for building robust and reliable software products while efficiently managing the testing process. The choice of which type of testing to apply depends on project needs, time constraints, and the desired level of confidence in the software's quality. 

The Objective of Smoke Testing

Smoke testing aims to verify the end-to-end functionality of a software application, focusing on the core business logic and essential features. This testing approach ensures the system's critical functionalities work as expected after changes, updates, or deployments. The goal is to quickly identify significant issues, ensuring that the basic functionalities are intact before more in-depth testing is performed. On the other hand, E2E (End-to-End) Core Business Logic refers to testing the complete flow of business processes from start to finish. It involves validating the critical functions that drive the core business logic of a system. This type of testing ensures that all components work together seamlessly to achieve business objectives.  

Let's explore examples 

Example E2E Scenario of Smoke Testing for E-commerce Platform  

Successful smoke testing in this context would ensure that users can smoothly select products, add them to the cart, and complete a purchase without encountering critical issues.

Example E2E Scenario of Smoke Testing for Healthcare Platform 

So, how to perform a smoke test in the case of a healthcare platform. The smoke test may cover such functionalities: 

In both cases, E2E core business logic ensures that these critical operations are seamlessly integrated into the application's workflow, guaranteeing a smooth end-to-end experience for users and successful fulfillment of core business objectives.  

Application of Smoke Testing at Different Levels  

  1. Acceptance Level Smoke Testing: Smoke testing at the acceptance level is typically conducted when a software build is handed over to the QA team. This type of test verifies the basic functionality of the build and checks whether it aligns with the expected functionality.  
  2. System Level Testing: Smoke testing at the system level involves testing the most critical processes of the system. It is done after testing the system itself and before conducting a full regression test of the system. Automated smoke testing is the most common form at the system level.  
  3. Integration Level Testing: At the integration testing level, smoke tests ensure that all cross-functional aspects of the software are functioning as expected and the essential integration is operational.  

These levels of smoke testing help ensure the stability and functionality of the software at different stages of development. The acceptance level ensures that the basic functionality meets expectations, the system level verifies critical processes, and the integration level confirms the seamless interaction of integrated modules within the software build.  

Manual and Automated Smoke Testing  

When software development teams embark on smoke testing for the first time, they must decide whether to conduct manual or automated smoke testing.  

While automated smoke tests generally yield quicker and more cost-effective results, their creation and implementation can also take time. Many teams start with manual smoke tests before considering automation in the future.  

Manual Smoke Testing  

Manual smoke tests are relatively simple to develop and can typically be executed by non-technical professionals outside of QA or development teams. It means manual smoke tests are often favored in smaller companies that still need a dedicated quality control manager.  

During manual smoke testing, it is essential to test a few usage scenarios that cover enough of the software's essential functions but not so many that the smoke testing becomes too time-consuming. The ideal number of usage scenarios is usually between 20 and 50.  

Advantages of Manual Smoke Testing  

  • Non-engineers can perform manual testing: While automated smoke testing typically requires experience from engineer programmers and developers, manual smoke testing can be conducted by team members with less experience. It is advantageous in small teams where resources may already be stretched, and specialists' time is precious.  
  • Tailor tests for each task: Creating a manual smoke test for each project allows testers to adapt the test to the specific needs of the build, ensuring it precisely covers the most critical functions of any software application.  
  • Qualitative data discovery: When conducting manual smoke testing, team members can use their understanding, intuition, and judgment to evaluate whether the build passes and how and why it may fail.

Challenges of Manual Smoke Testing  

  • Time-consuming: Manual smoke tests take significantly more time than automated tests and require more attention from your team. Unlike automated tests that can run in the background, manual smoke tests need a dedicated time slot.  
  • Limited frequency: Due to the substantial time and resource requirements of manual smoke tests, they cannot be conducted as frequently as automated smoke tests. Daily smoke testing, considered a best practice, is challenging with manual testing.  
  • Error-prone: As humans conduct manual testing, errors are always possible. It makes manual smoke testing less comprehensive than automated testing, especially when detecting subtle errors or during highly repetitive testing, where testers may lose focus.

When to Use Manual Smoke Testing  

It is most commonly used in small teams needing more resources to allocate engineers for automated smoke testing. Additionally, it is employed when additional human understanding and judgment are deemed necessary.  

While manual smoke testing has advantages, it comes with challenges like time consumption and a higher likelihood of errors. Understanding when to use manual smoke testing depends on the needs and resources of the development team.  

Automated Smoke Testing  

It can be implemented by software engineers with coding skills necessary for creating and executing a series of relevant use case scenarios for each software build.  

Automated smoke testing occurs much faster than manual testing, typically taking no more than 30-60 minutes, and can be conducted in the background while all team members, including developers and QA.  

For this reason, automated smoke testing has become a common practice in the software industry as more companies strive to enhance workplace efficiency.  

Advantages of Automated Smoke Testing  

  • Speed and Efficiency: Automated smoke testing is significantly faster than manual testing, usually taking no more than 30-60 minutes. In comparison, manual testing can take hours.  
  • Daily Smoke Testing: Modern best practices advocate for daily smoke tests, especially when working with software in a constant state of flux. Manual smoke tests are too labor-intensive to be conducted daily, but automated smoke tests can be run at the beginning of each workday.  
  • Elimination of Human Errors: Automated tests are executed from scripts prepared in advance and created according to high standards, minimizing the likelihood of missing significant errors or issues.  
  • Load and Performance Testing Simulation: Automated smoke testing can simulate load and performance tests, evaluating how well an application performs simultaneously under the stress of multiple users. It is challenging to achieve with manual testing and provides additional insights into software performance under specific conditions.  

Challenges of Automated Smoke Testing  

  • Technical Requirements: Automated smoke tests require mu technical knowledge and coding skills than manual tests. Engineers must possess the time and knowledge to create automated tests before implementation, which may only be available to some teams.  
  • Lack of Human Understanding: Automated testing provides a general overview of software functionality but lacks insights into more subjective aspects, such as usability and accessibility.  

When to Use Automated Smoke Testing

Automated testing is often utilized in smoke testing since its purpose aligns with verifying basic functionality, which automated testing handles relatively well. Teams with sufficient technical skills for implementing automated smoke testing will likely have the time and resources to invest in this process. More importantly, established companies may feel tremendous pressure to adhere to the best practices of daily smoke testing.  

Automated Smoke Testing vs. Manual Smoke Testing  

There is no one-size-fits-all approach to smoke testing; what works well for one team may not be suitable for another. Before performing smoke tests, development teams should analyze their goals, resources, and long-term project plans. While manual testing can serve as a valuable learning experience for newcomers to quality control, for more experienced teams, there is rarely an advantage in choosing manual testing over automated testing.

Frameworks for Automated Smoke Testing  

How to do a smoke test using automated testing frameworks for faster and more consistent results? There are many frameworks that you can use for automated smoke testing. Here are some frameworks commonly used for automating smoke tests:   

Playwright  

Playwright is a framework for automating web application testing that supports all modern web browsers.   

Main features:  

  • Works with popular browsers like Chrome, Firefox, Safari, and Edge.  
  • Have good tools, such as Playwriter Inspector, tracer, etc., that simplify test creation.  
  • Includes scenarios such as concurrent sessions, mobile device emulation, working with files, and more.  

WebdriverIO (Wdio)  

WebdriverIO represents the next generation of testing frameworks supporting web and mobile applications.  

Main features:  

  • A large number of plugins and integrations for extending functionality.  
  • Simplifies test writing with a Node. js-style asynchronous API.  
  • An active community and a wealth of user-contributed add-ons.  

Cypress  

Cypress offers a comprehensive solution for front-end web application test automation.   

Main features:  

  • Tests run in a browser environment, ensuring accurate testing.  
  • Visual tracking of test execution in real-time.  
  • Integrates effortlessly with other tools and services like GitHub and Slack.  

Testim.io  

Testim.io is a cloud-based platform for test automation that specializes in the rapid and intuitive construction of automated test scenarios for web applications.   

Main features:  

  • Tests can be created and executed directly in the web browser, with no need for additional software installation.  
  • Uses artificial intelligence to improve test stability and reduce the need for frequent updates.  
  • Easily integrates with primary continuous integration and delivery systems.  

Appium  

Appium is a comprehensive mobile test automation tool suitable for various testing types, including regression test automation. It supports multiple programming languages, enabling the creation and execution of diverse test scripts. Appium can be used for Android, iOS, and Windows. Appium allows you to connect both remote and local mobile devices.

Main features:  

  • Support for various programming languages.  
  • Ability to connect remote and local mobile devices.  
  • Support for dynamic display of the device.  

These frameworks offer a range of features to meet different testing needs, from no-code solutions to comprehensive automation for various platforms. The framework choice depends on the testing team's specific requirements and preferences.  

The Smoke Testing Process

When initiating a new software development project, understanding how to do smoke testing is crucial for detecting critical issues early in the core functionalities. The optimal way to conduct smoke testing depends on the organization. If you are new to this, it might be worthwhile to experiment with different approaches to understand what best suits your team.  

Below is an example of how to do a smoke test to evaluate the core functions of your software.  

IMPLEMENTATION STEPS

Step 1: Choose Your Test Cases  

To carry out a smoke test, the initial step is to decide which test cases to run. While creating a smoke test, software engineers and QA engineers should contemplate which software functions are the most critical to the software and how they can be tested effectively. It is essential not to waste time testing features that are not crucial to the software's function. 

 Step 2: Automation of Test Cases  

This step is relevant for automated testing. If you are performing testing manually, you may skip this step. If the test cases are not automated, the focus at this stage is on automating them. This involves updating the test script for test execution. Automated testing streamlines the testing process, enhances repeatability, and helps to ensure efficient test coverage. The script for test execution should be revised and optimized for automation to leverage the benefits of automated testing methodologies.  

Step 3: Run smoke tests 

Once you've finished selecting test casesвyou can run them on your build to look for bugs and other significant errors. It shouldn't take more than 60 minutes to complete the test. Once finished, you can evaluate the results to determine the next steps.

Step 4: Fix any bugs  

Smoke testing in software development aims to identify any significant bugs or showstoppers before complete QA testing gets underway.  

Suppose your smoke tests detect any significant problems that impact the core functionalities of your software build. In that case, sending the software and your analysis back to the development team for bug-fixing before proceeding with QA testing is crucial.

By following these steps, you can perform smoke testing effectively to identify critical issues early in development. 

Best Practices for Smoke Testing  

To ensure the reliability of your software, knowing how to perform smoke testing correctly is crucial. Let's explore the best practices for successful smoke testing. Smoke testing is a reliable way to detect critical errors in software builds at all stages of development. Adhering to industry best practices is the most effective way to ensure your smoke test's efficiency, accuracy, and productivity.

  • Perform Smoke Tests Frequently: Perform smoke tests as frequently as possible, mainly if you perform manual rather than automated ones. Daily smoke tests are considered a best practice.  
  • Never Skip Testing Stages: While you may be tempted to skip certain testing stages to progress quickly in the development process, smoke and regression testing are necessary to keep your development on track. Always test your builds for smoke and sanity before moving to the next stage.  
  • Test Every Change: No one-size-fits-all approach to smoke testing exists. It would help if you used smoke tests to check every change you make to the software build and to test your software between different development stages. Smoke tests should precede integration testing, performance testing, and functional testing.  
  • Track Testing Results: Formal smoke test result verification is standard practice, but engineers should keep track of the results even when conducting informal smoke tests. It facilitates communication of results to developers and allows tracking of features that still need to pass the test.  
  • Run Smoke Tests Twice: Running the smoke test twice may seem redundant, but it's better to run it twice if you genuinely want to detect all errors during testing. It ensures that your smoke test can identify significant errors and issues that could cause problems if not addressed immediately.  

Advantages of Using Smoke Testing  

Let's consider the advantages of using smoke testing  

Timely Detection of Regressions  

When regression testing is conducted manually, critical issues may surface the next day or even after several days. With smoke testing, vulnerabilities in the system might be noticed once they impact vital functionalities. For instance, if regression testing is manual, identifying critical issues may take a week.  

Risk Mitigation  

Smoke testing is essential for catching regressions early in development. Without it, the chances of overlooking critical issues increase, potentially leading to severe consequences. Since regressions might not be identified for a week if only manual testing is employed, it poses a considerable risk to the project's success.

Commercial Impact  

In commercial transactions, payments are processed until Friday. However, if regressions are not identified promptly, they might persist from Monday to Friday, disrupting customers' ability to make purchases. This scenario emphasizes the urgency of addressing issues swiftly.  

Automated Regression and Smoke Testing  

The importance of automation in regression and smoke testing has become evident. Automated testing allows for the rapid verification of core functionalities after deployment, ensuring that potential issues are identified and addressed in the shortest possible time frame.   

Conclusion  

Smoke testing is not an independent form of testing. It does not replace regression or other types of testing in any way.  

If you require a professional assessment of different testing types that may be necessary for your project, contact the Luxe Quality team. We provide quality and comprehensible consulting services in this matter.  

Have a project for us?

Let's make a quality product! Tell us about your project, and we will prepare an individual solution.

Frequently Asked Questions

What is smoke testing? 

Smoke testing is a preliminary testing approach to ensure compliance with essential requirements of functionality and stability. It involves minimal tests run on each build to check core software functionalities. It acts as a crucial initial stage in quality control, indicating whether further testing should proceed or if the product needs refinement.  

How to do a smoke test?

Performing a smoke test is a crucial initial stage in the quality control process, as it indicates whether the team should proceed with further testing or immediately send the product back to the developers. If the product fails the smoke test, it indicates that the initial build has significant defects that must be addressed before proceeding with additional testing.      

How to maintain smoke tests?

Smoke test maintenance ensures that the smoke tests you create stay healthy and relevant as your software build project continues. Execute smoke tests daily and create new test cases as and when needed. You can also maximize the benefits of your smoke tests by working closely with those developers whose contributions fail to improve the quality of their code. 

What is the difference between smoke and regression testing?

Smoke testing, also called "build verification testing," is usually performed to verify that the system's primary functions are working and that the build is ready for further testing. It does not usually include negative test cases, as the goal is to test core functionality, not to test system boundaries. Unlike smoke testing, regression testing focuses on identifying errors that may have occurred due to changes in the software code. It includes re-executing both positive and negative test cases across the functionality to ensure that existing functionality has not been broken.   

Can any tests be used for regression testing?

Not all tests are equally suitable for regression testing. Tests that require significant effort to maintain or those that rarely detect errors may not be the most efficient choice. The regression suite should be optimized in scope and include tests that provide maximum coverage with minimal time consumption. 

Recommended Articles