Table of content

• Smoke Testing
• When Smoke testing is required?
• Example of a smoke test case
• Sanity, Smoke & Regression Testing
• Summary

Smoke Testing is a kind of prototype testing or a pre-test, where the test is carried out only to ensure, that the system or the software is stable enough for further testing to be carried out on it.

Smoke testing is the way to apply all possible test cases, just after the completion of the software build, so that it could be seen whether any damage or major fault will appear after the entire testing is carried out.

It is definitely, not the way to correct major flaws in the software before it is tested fully, but a very necessary step for measuring the stability of the system. This is sometimes, also called "Confidence Testing", as positive results in this testing, boosts the confidence of the tester and of the entire team.



Smoke testing can also be considered as a regression testing in the sense, that, it can also be applied anytime, in the phases of the software development, to carry out mini-tests.

It may be noted that this testing is carried out after the sanity testing and before the functional testing. Smoke test cases are carried out in the way the formal testing is carried out. The main difference is that the test cases are designed in a way, which will just check the software flaws.

It is important to understand, that, a build is a complete set-up requirement such as the data-files, software libraries, the components or the modules which are necessary to carry out even a smaller kind of tests.

Below there is a representative diagram of carrying out of a smoke test:

As shown in the diagram above, different builds are fed into smoke testing phase and sanity test respectively. Therefore, only when both the phases are complete, then only the builds are again ready for the integration test.

Frontend Testing

Smoke testing is carried out when there these major criteria is fulfilled:

• New Functionality is added.
• A new feature is added.
• The team senses that testing the system directly, may create the software to hang or corrupt.
• The formal test cannot predict the performance of the system, therefore, a pre-test is required.
• The name is called smoke testing because any fire starts with a cloud of smoke, that is why, this test by its smoke decides, whether there are chances of fire or not, following the further tests.

Advantages of Smoke Testing:

• Save time and effort, as the damage or any related issues, can be detected earlier.
• Easier to deploy, as small test cases are required.
• Quality of the software is significantly improved, as the team gets the chances of solving the bugs or the process much earlier of its occurrence.
• The risk of the software getting corrupt or the entire system collapse is reduced.
• It is a quick process.
• Since it runs a small test case, therefore, the set-up cost is much lesser compared to the process of running the whole test.

Penetration Testing

A simple example of a test case can be performed for login into a session and then adding an item into a cart. Below are the steps which can be tested:

Suppose, the user has to login into his account, by putting his/her credentials and then has to add an item in the cart and then may proceed to pay and then make the payment and then may log out from the session.

• Logging into the session : Here only the credentials are checked. Whether the username or the password is checked. It is expected that, when the user input valid credentials, it should create a session for the user and login himself/herself. If positive happens, the test is successful or else it has failed.
• The functionality of adding to cart: Here, we shall see how the functionality of adding cart works. As mentioned, so this test case will just add one single item, to the card and see whether the price is added to the final list and then proceed to pay button has appeared.
• Payment: Here, we see whether the payment is redirecting to the page for payment or the banking website, securely. If, positive happens, then as expected, the test will be considered as positive. But to maintain the property of the smoke test, we shall not make the payment, if this is done in regression.
• The functionality of Signing-out: In this step, we just see how the functionality, of signing out of the session. This is done by hitting the sign-out button. After signing off, it is expected that the session is destroyed and the user should not be redirected to the login page again without the credentials.

In the software testing industry, many get confused about these three different kinds of testing. One is regression testing, smoke testing, and sanity. It should be made clear, these three are totally different testing, and should not be misunderstood.

Since they are solely interrelated topics, therefore their ideas may get overlapped sometimes. Here is some clarifications about the three different kinds of tests.

• Sanity test is done just after the regression test, to ensure that, the changes made just before the regression to ensure the stability of the system, are holding good. That is, no functionality has been changed due to the addition or updating of the software. Smoke testing is done just after that.
• Sometimes, the smoke test and sanity test may run parallelly. Meaning, there can be software builds which can be different. Some builds may require to go through smoke testing and some may require to go through sanity testing, which has undergone regression testing a lot of times.
• Smoke test may be sometime iterated with regression testing, as with changes different features may be modified which may require sanity test in recursion.

Below diagram shows how these three testings is inter-linked.



Therefore, to conclude, about the relation of smoke, sanity and regression testing, this can be said that, all are inter-related and one should not get confused with their scope of work.

One test can be carried out earlier and another may be carried out later, based on the scenario, but that does not mean, that they are fully overlapped or not related at all.

Active Testing

Smoke Testing is a software testing type in which a small pre-test is carried out to check whether the software will able to stand with further tests and there will be no problem in carrying out the test.

Smoke testing can help reduce, cost, time and effort, as in the smoke testing, all the test attribute of the software is checked and therefore bigger problems are less likely to arise while carrying out the main testings.

This is a quick process, which ensures the improvement of the quality of the software product with a lesser chance of corrupting the software white testing.