top of page

Everything about SMOKE TESTING

In Software Engineering, Smoke testing should be performed on each and every build without fail as it helps to find defects in the early stages. Smoke test activity is the final step before the software build enters the system stage. Smoke tests must be performed on each build that is turned to testing. This applies to new development and major and minor releases of the system.

Before performing smoke testing, QA team must ensure the correct build version of the application under test. It is a simple process that takes a minimum of time to test the stability of the application.

Smoke tests can minimize test effort, and can improve the quality of the application. Smoke testing can be done either manually or by automation depending on the client and the organization.

Why Software Testing is Important?

Software Testing is Important because any bugs or errors in the software can be identified early and solved before the software product is delivered. Properly tested software product ensures reliability, security, and high performance which further results in time-saving, cost-effectiveness and customer satisfaction.

Testing is important because software bugs could be expensive or even dangerous. Software bugs can potentially cause monetary and human loss, and history is full of such examples.

  • In 2015 fighter plane F-35 fell victim to a software bug, making it unable to detect targets correctly.

  • China Airlines Airbus A300 crashed due to a software bug on April 26, 1994, killing 264 innocent live

  • n 1985, Canada’s Therac-25 radiation therapy machine malfunctioned due to a software bug and delivered lethal radiation doses to patients, leaving 3 people dead and critically injuring 3 others.

  • In April of 1999, a software bug caused the failure of a $1.2 billion military satellite launch, the costliest accident in history

  • In May of 1996, a software bug caused the bank accounts of 823 customers of a major U.S. bank to be credited with 920 million US dollars.

  • example of Starbucks. In 2015, the company lost millions of dollars in sales when its point-of-sale (POS) platform shut down due to a faulty system refresh caused by a software glitch. This could have been avoided if the POS software had been tested thoroughly.

The following are important reasons why software testing techniques should be incorporated into application development:

· Identifies defects early. Developing complex applications can leave room for errors. Software testing is imperative, as it identifies any issues and defects with the written code so they can be fixed before the software product is delivered.

· Cost-Effective: It is one of the important advantages of software testing. Testing any IT project on time helps you to save your money for the long term. In case if the bugs caught in the earlier stage of software testing, it costs less to fix.

· Product quality. When it comes to customer appeal, delivering a quality product is an important metric to consider. An exceptional product can only be delivered if it's tested effectively before launch. Software testing helps the product pass quality assurance (QA) and meet the criteria and specifications defined by the users.

· Increases customer trust and satisfaction. Testing a product throughout its development lifecycle builds customer trust and satisfaction, as it provides visibility into the product's strong and weak points. By the time customers receive the product, it has been tried and tested multiple times and delivers on quality.

· Detects security vulnerabilities. Insecure application code can leave vulnerabilities that attackers can exploit. Since most applications are online today, they can be a leading vector for cyber attacks and should be tested thoroughly during various stages of application development. For example, a web application published without proper software testing can easily fall victim to a cross-site scripting attack where the attackers try to inject malicious code into the user's web browser by gaining access through the vulnerable web application. The non tested application thus becomes the vehicle for delivering the malicious code, which could have been prevented with proper software testing.

· Helps with scalability. A type of nonfunctional software testing process, scalability testing is done to gauge how well an application scales with increasing workloads, such as user traffic, data volume, and transaction counts. It can also identify the point where an application might stop functioning and the reasons behind it, which may include meeting or exceeding a certain threshold, such as the total number of concurrent app users.

· Saves money. Software development issues that go unnoticed due to a lack of software testing can haunt organizations later with a bigger price tag. After the application launches, it can be more difficult to trace and resolve the issues, as software patching is generally more expensive than testing during the development stages.

Types of software testing

There are many types of software testing, but in this blog I am going to discuss Smoke testing, Sanity testing and Regression testing.

Smoke Testing

Smoke Testing is a software testing technique performed post software build to verify that the critical functionalities of software are working fine. It is executed before any detailed functional or regression tests are executed. The main purpose of smoke testing is to reject a software application with defects so that the QA team does not waste time testing broken software applications.

In Smoke Testing, the test cases chose to cover the most important functionality or component of the system. The objective is not to perform exhaustive testing, but to verify that the critical functionalities of the system are working fine. For Example, a typical smoke test would be – Verify that the application launches successfully, Check that the GUI is responsive … etc.

When do we do smoke testing?

Smoke Testing is done whenever the new functionalities of the software are developed and integrated with an existing build that is deployed in QA/staging environment. It ensures that all critical functionalities are working correctly or not.

In this testing method, the development team deploys the build in QA. A subsets of test cases are taken, and then testers run test cases on the build. The QA team test the application against the critical functionalities. These series of test cases are designed to expose errors that are in build. If these tests are passed, QA team continues with Functional Testing.

Any failure indicates a need to handle the system back to the development team. Whenever there is a change in the build, we perform Smoke Testing to ensure the stability.

Example: -New registration button is added in the login window and build is deployed with the new code. We perform smoke testing on a new build.

The smoke tests qualify the build for further formal testing. The main aim of smoke testing is to detect early major issues. Smoke tests are designed to demonstrate system stability and conformance to requirements. A build includes all data files, libraries, reusable modules, engineered components that are required to implement one or more product functions.

What happens if we don’t do Smoke testing

If we don’t perform smoke testing in early stages, defects may be encountered in later stages where it can be costly. And the Defect found in later stages can be show stoppers where it may affect the release of deliverables.

Who will do the Smoke Testing

After releasing the build to QA environment, Smoke Testing is performed by QA engineers/QA lead. Whenever there is a new build, QA team determines the major functionality in the application to perform smoke testing. QA team checks for showstoppers in the application that is under testing.

Why do we do smoke testing?

Smoke testing plays an important role in software development as it ensures the correctness of the system in the initial stages. By this, we can save test effort. As a result, smoke tests bring the system to a good state. Once we complete smoke testing then only we start functional testing.

  • All the show stoppers in the build will get identified by performing smoke testing.

  • Smoke testing is done after the build is released to QA. With the help of smoke testing, most of the defects are identified at initial stages of software development.

  • With smoke testing, we simplify the detection and correction of major defects.

  • By smoke testing, QA team can find defects to the application functionality that may have surfaced by the new code.

  • Smoke testing finds the major severity defects.

Example 1: Logging window: Able to move to the next window with a valid username and password on clicking submit button.

How to do Smoke Testing?

Smoke Testing is usually done manually though there is a possibility of accomplishing the same through automation. It may vary from organization to organization.

Manual Smoke testing

In general, smoke testing is done manually. Its approaches vary from one organization to other. Smoke testing is carried to ensure the navigation of critical paths is as expected and doesn’t hamper the functionality. Once the build is released to QA, high-priority functionality test cases are to be taken and tested to find the critical defects in the system. If the test passes, we continue the functional testing. If the test fails, the build is rejected and sent back to the development team for correction.

QA again starts smoke testing with a new build version. Smoke testing is performed on new builds and will get integrated with old builds to maintain the correctness of the system. Before performing smoke testing, QA team should check for correct build versions.

Smoke testing by Automation

Automation Testing is used for Regression Testing. However, we can also use a set of automated test cases to run against Smoke Test. With the help of automation tests, developers can check the build immediately, whenever there is a new build ready for deployment.

Instead of having repeated tests manually whenever the new software build is deployed, recorded smoke test cases are executed against the build. It verifies whether the major functionalities still operate properly. If the test fails, then they can correct the build and redeploy the build immediately. By this, we can save time and ensure a quality build to the QA environment.

Using an automated tool, the test engineer records all manual steps that are performed in the software build.

Advantages of Smoke testing

Here are a few advantages listed for Smoke Testing.

  • Easy to perform testing

  • Defects will be identified in the early stages.

  • Improves the quality of the system

  • Reduces the risk

  • Progress is easier to access.

  • Saves test effort and time

  • Easy to detect critical errors and correction of errors.

  • It runs quickly

  • Minimizes integration risks

Hope you got the complete idea about Smoke Testing. Happy reading!!!

77 views0 comments


Rated 0 out of 5 stars.
No ratings yet

Add a rating
bottom of page