Subscribe by Email


Showing posts with label Smoke Testing. Show all posts
Showing posts with label Smoke Testing. Show all posts

Tuesday, July 16, 2013

Critical to do a smoke testing of the regular build - saves time and effort

For teams that have setup a smoke test of their regular builds, the benefits are such that they may not even understand about why such a post needs to be done; after all, it seems to be obvious that if you put a smoke test to do a quick check of the regular build (in our case, it was a daily build), there are multiple advantages. The most prominent advantage is that as soon as the build is available, the smoke test can be triggered to be run automatically, which in turn will take the build through a series of tests and determine whether there is a problem that needs to be resolved.
Sounds great, right ? After all, there are all advantages to having such a smoke testing of the regular build, but a number of teams do not use it, and at the same time, there are some additional effort that does need to be added in the calculation. Let me lay out the case which we used to have. Because of the size of our code and the amount of synchronizations that needed to be done with the source safe, we would have a daily build that would kick off in the night around 11 PM and typically get done around 7 AM. Now, the problem we used to have was that it was not possible to get anybody to be there to check whether, even if the build did get formed, whether the build would even launch and whether there were any major components or workflows that were broken.
When somebody from the testing team would typically get in around 9 AM, they would check the build and then provide their feedback. Our earnest hope used to be that there no problems revealed in this check. However, once in a while, the morning verification would reveal some problems that needed to be fixed, and it would mean that the build for that day would be late or would even have to be canceled, which had some impact on the defect find / fix rate.
The ideal solution was to have a smoke test run on the daily build. Now, the problem was that thought it sounded like an ideal solution, there were some incremental efforts that we had to calculate:
- Somebody had to write the smoke test cases and integrate that with the build system to provide an email output to several members of the team about the success or failure of the smoke test
- As and when we made some changes to any of the major UI or the workflows, we would need to update the smoke test to incorporate these changes. Sometimes these would get missed, and then you would find that the Smoke test stopped in the middle of some feature, and then it would take effort to do the diagnostic of what the problem was.
- The smoke test did yield some false positives as well. The team would then have to spend some time looking for the break in the build, and also examine whether this was a genuine catch, or whether the smoke test malfunctioned, and the problem could be ignored.
- The tools for running the smoke test could be expensive and the expenditure may need to be approved by somebody who does not understand as to why there is a need for such a software, so some amount of negotiation and discussion would be needed.
- Suppose the smoke test would start running at 7:30 AM and run for around 45 minutes, somebody from the team would need to be in place or looking at the report from the smoke testing at the completion time of the smoke test, and hence there would be a rotating chair where team members would be assigned this role for a specific period.


Saturday, June 23, 2012

What are limitations of smoke testing?


Smoke testing though being quite a helpful software testing methodology has got some limitations which will be discussed in this article. 
Smoke testing is an important software testing methodologies when it comes to the development of very large software projects. "The formal definition of the smoke testing states that it a quick and indeed a dirty software testing methodology that is deployed mainly for testing the major features and functionalities of a piece of software system or application". 

About Smoke Testing


- It is essential to perform smoke testing whenever any changes are implemented in the software system. 
- Originally, the smoke testing for software systems was adopted from the hardware industry. 
- Smoke testing is quite time and cost effective since it lays its primary focus on the components that have been changed recently in order to ensure continued compatibility.
- In addition to all this, a smoke test provides an effective means to confirm that the changed code works as desired and does not hampers the functioning of the whole build. 
- Following this approach, the bugs entering the software system can be immediately fixed. 
Smoke testing has many advantages that outweigh the limitations but still the limitations cannot be ignored.

Limitations of Smoke Testing


  1. Biggest limitation of the smoke testing is that its field of application and usefulness is quite narrow.
  2. Smoke testing can only be used when the time frame is small during the introduction of a new functionality or feature in to the software system or application.
  3. Though being wide, a smoke test is very shallow.
  4. Smoke testing does not take into consideration the fine details of the software system or application.
  5. Smoke tests cannot be substituted for actual functional tests.
  6. Smoke testing is a kind of black box testing and does not consider the internals of the software system or application.
  7. In smoke testing the tester cannot access the source code.
  8. In smoke testing the tester has to interact with the system via an interface by giving a variety of inputs and then examining the obtained outputs.
  9. Another limitation is that the path coverage provided by the smoke tests is very limited since all the given inputs have to be checked.
  10. Smoke tests cannot keep a control on targeting the paths and code segments that might be more error prone than the other segments.
  11. Smoke test are a bit difficult to design since they should be designed in such a way that they touch every part of the application software.
  12. Usually the smoke testing can be applied only when some new components are incorporated in to the existing software system or application.
More about Smoke Tests...
- Smoke tests can be thought of as preliminary tests that facilitate the further testing of the software system or application. 
- Though the smoke tests reveal simple failure, these failures are good enough to be the cause of the rejection of a prospective and deserving software project. 
- At last we conclude that there exists no such absolute best software testing methodology, each being having its own weakness as well as strength. 
- You cannot expect a testing methodology to fit the test requirements of every application software and conditions. 
- This reason only is enough to conclude that no testing methodology is most important. 


Friday, June 22, 2012

What are different tools used for smoke testing?


The success of a software testing methodology depends a lot on the quality and type of tools that are being used to carry out that particular test. 
In this article we have discussed about the tools that are used for smoke testing. One can find so many tools around that are available for automating the smoke tests. 

Functions performed by these tools


Using these tools a lot of functions can be performed few of which have been mentioned below:
  1. Using these smoke testing tools one can easily and quickly write the test cases and scripts as well as automate them and guess what? These tools do not require any programming.
  2. With these smoke testing tools, the validation of all the builds can be carried out easily before any changes are introduced in to them.
  3. Nothing comes as handy as these smoke testing tools when one needs to stabilize the whole build process.
  4. The available tools make it easy the verification of a build to determine its readiness for further full scale testing.
  5. The smoke testing tools help in conducting lightening fast tests determining whether or not the major functionalities are intact and still working as expected.
  6. The tools help in reducing the drudgery of the testers as well as the developers by helping in the early detection of the problems and errors.
  7. These tools help a great deal in cutting down the overall development costs by significant margins providing the team with sufficient time period for developing the software system or application.

Tools for Smoke Testing


- So many tools are available using which you can perfect your tests like advanced web recorder, object recorder, editor and so on. 
- The tools provide so many actions to be performed for editing the tests if it is required to make any changes in the software system or application. 
- Such an approach to testing i.e., using tools allows flexibility between the test and testers and eliminates the need of creating new tests. 
- There are tools called “work flow designers” that come with an intuitive graphical representation and using which you can easily create as well as manage the work flows of high level of the entire suite of your smoke tests. 
- There are testing tools available that help you introduce check points in the application so that at any point your software application functionality can be further verified. 
- There is one tool available for testing methodologies that is perhaps the most sought after testing tool. 
- This tool lets you convert a test script in to an executable code and then run it on multiple systems without installing testing application on each and every machine. 
- This feature of this tool facilitates an automation that never existed before. 
- Any of the test scripts can be run and with any inputs operating from any data base or application software and almost in every kind of environment. 
- Some reporting and log tools have been introduced which possess advance reporting features like:
  1. Time lines
  2. Report customization tools that are quite easy to use.
  3. Report dash board
  4. Audit trail capability (this feature provides you with a complete data base of all the events that took place in the automated testing environment.)
  5. Visual logs
- With a tool having all such features a tester can easily analyze the reports with visual aids and fix them quickly.
- These tools provide the testers with a more complete view of the smoke test runs. 
- Though smoke testing can be carried out manually also it is advisable to use automated test tools which initiate tests by a similar process that generates the build itself.


What are different types of smoke tests?


Smoke testing has merged as one of the best general software testing methodology though it is a dirty one and very shallow too! Smoke testing is one of the easiest and quickest black box software testing methodologies that we have today. 

Smoke tests are of two types namely:
1. Functional tests and
2. Unit tests

About Functional Tests


- These type of smoke tests are typically scripts or programs that have been configured to test the group of classes so as to determine whether or not they meet the external requirements.
- One example of functional tests is the screen- driving programs that are used to test the graphical user interfaces (GUIs).
- They are a certain class of black box tests that are based up on the specifications of the software components under testing. 
- The testing is carried out normally i.e., giving the input and observing the output and the internal structure of the system is neglected.
- Functional tests are implanted via the following 5 steps:
(a)  Identifying the functions that are to be performed by the software system.
(b)  Creating the input data that is based up on the specifications of the functions.
(c)   Determining the output based up on the specifications of the functions.
(d)  Executing the test case.
(e)  Comparing the actual and expected outcomes.
- The functional smoke tests form a key component of the software engineering as they help track the growth of the project.
- Using the functional tests, the system can be tested from end to end. 
- Similar to the unit tests the functional tests accelerate the development rate of the project while ensuring its quality. 
- Functional tests are specified by the customers or the customers may provide the developers with user stories based on which the developers may write the functional tests. 
Errors that are encountered during functional tests are fixed using the unit tests and then again verified by the functional tests. 
- The more the number of functional tests and the more correct they are, the more is the certainty that the software system or application is working. 
- To make this whole process efficient, you need to automate the whole testing process.

About Unit Tests


- For carrying out these types of smoke tests you need a unit test frame work that will create automated unit tests suites. 
- Another thing is that all the classes within the build should be tested. 
- The tests are created before the code is written. 
- The code repository holds the unit tests along with the code that is to be tested. 
- Automated unit tests though are difficult and take a lot of time, yet they offer huge pay back. - It takes a lot of time to produce a good unit test suite. 
- The unit tests enable the following aspects:
(a) Collective ownership: This eliminates the need for individual code ownership since all the classes are guarded by the unit tests.
(b) Re-factoring: This ensures that a change in one part has not hampered the performance of the other parts.

About Frequent Integration

- This is possible only if there is a single universal unit test suite for regression testing and validation. 
- When your unit tests are automated it becomes easy to merge the changes with the latest released version. 
- Whenever a new functionality is added it is required that the unit tests are also changed  accordingly to reflect the functionality. 


How is optimization of smoke testing done?


Smoke testing being one of the quick and dirty software testing methodologies, needs to be optimized. This article focuses on the need of optimizing the smoke tests and how to optimize them. 

Let us first see the scenario behind the need for optimization of the smoke tests that are carried out on the software system or application. 
- In most cases of the development of software systems or applications, the code can be executed either directly from the command prompt or via a sub- routine of the larger software systems or applications. This is called the command prompt approach. 
- The code is designed in such a way that it has the qualities like self awareness as well as it is autonomous. 
- By the code being self aware, we mean that if anything goes wrong during the execution, the code should explain it. 
- Commonly two types of problems are encountered during testing and have been mentioned below:
  1. The path was compiled with too much of optimization and
  2. The data directory is not pointed out properly by the path.

Steps for Optimization of Smoke tests


- In order to confirm that the code was compiled correctly one should run the test suite properly at least once. 
- The first step towards optimization of the smoke test is to run it and then examine the output. 
- There are two possibilities that either the code will pass the test or it won’t. 
- If it is the second case then there are two possibilities that where your smoke test went wrong:
  1. Compiler bugs and errors or
  2. The path has not been set properly.

Compiler Bugs and Errors


Let us take up the first possibility, i.e., the compiler bugs and errors. 
-  It is probable that the correct code might not have been produced by the compiler. 
- In some cases of the serious compiler bugs, it is possible that there might be some hardware exception and these kinds of errors are caused mainly by the compiler bugs. 
- In this case the optimization level of the code should be minimized. 
- After this the code should be recompiled and observed again. 
- Optimizing is good for code but if it is of aggressive kind then it will definitely cause problems.

If path is not set properly


- It is obvious that if the code is not able to trace its data files then it will definitely show up some error and this happens because the path has not been set properly. 
- In such cases you need to check which path was it, fix it and recompile the whole code and execute once again.

When does a system or an application crash?


Don’t think that the software system or application crashes only when there has aggressive optimization of the code! 
- Crashes also happens with those programs in which there is no optimization of the code. 
But in such cases, only compiler errors can be blamed since it happens only if the compiler has not been set up properly on your system. 
- If no program executes, it means that your compiler is broken and you need to talk about this to your system administrator.

How to optimize smoke tests?


- A lot of help comes from MPGO (managed profile guided optimization). 
- The best way to optimize any kind of testing is to maintain a balance between the automated and manual testing.
- You need to run MPGO tool along with the necessary parameters for the test and then run the test. The test now will be optimized. 
- It is actually the internal binaries that are optimized either fully or partially. 
- Partially optimized binaries are deployed only in automated smoke testing. 


Thursday, June 21, 2012

Explain Automation of Smoke Testing?


Smoke testing though being a very useful, quick  software testing methodology, if not carried out in an automated way can take up a lot of time and efforts. 

Need for Automation


There is one more thing to manually carry out smoke testing which is that if later if you come to know that the testing was being carried out in wrong direction then it will surely give you a headache to perform whole of the testing once again and again if required. 

Why automation of smoke testing useful?


- Automation of smoke testing proves to be very useful in saving time and efforts.
- Smoke testing is considered to be one of the most effective ways that are used for the validation of the changes that are made to the software system or application program code at a high level before a detailed testing is undertaken on the new build. 
- Carrying out smoke tests can help a lot to stabilize the builds and verify that there are no major problems in the software system or application.
- The reliability factor of the smoke testing determines the success of the smoke test i.e., the more you can rely up on the smoke test for finding major problems, the more you can cut down the costs and increase the quality measures of the software product or artifact.
- Smoke testing provides a reliable, scalable solution that can be quickly and easily be automated. 
- One of the best things about automating the smoke test is that it does not require any programming.
- Smoke tests can be quickly written and automated by testers of any skill level within few minutes.

What functions are provided by the tools used for automating smoke tests?


There are so many tools available for automating the smoke tests. With these tools you can perform the following functions:
  1. With these tools smoke tests can be written and automated within few minutes and without requiring any programming.
  2. Using these tools all the builds can be validated before any changes are incorporated in to them.
  3. These tools are quite helpful when it comes to stabilizing the whole build process and verifying the readiness of a build for further full scale QA testing.
  4. With these tools quick tests can be conducted ensuring that the basic functionality is still intact and is working properly.
  5. The overall quality of the product can be improved since the problems can be detected early.
  6. Costs can be reduced ensuring that the team is having sufficient time for developing the product.

How a smoke test is automated?


- Smoke testing is usually preceded by quality assurance.
- As soon as the errors are discovered, it requires less efforts and money to get fixed.
-In automated smoke test, a continuous build process is deployed that automatically performs a smoke test each time a build is finished developing. 
- With such a methodology, the developers come to know easily if the recently developed build caused the problem. 
- Depending upon the configuration of the build tool and the software system or application, the process of implementing the automated smoke tests will vary despite of the basic steps being followed the same. 
- After the successful completion of the build, some set up steps are performed before the application is tested. The steps may include:
1. Copying files to the appropriate places.
2. Setting up the data base tables.
3. Starting a server.
4. Installing licenses.
Next step is to obtain all the QA files required for the smoke test and running the smoke test. 
- The report of the smoke test is saved and final step involves clean up including the steps:
  1. Stopping a server
  2. Emptying data base tables and
  3. Deleting files.


Wednesday, June 20, 2012

What are the advantages of smoke testing?


Smoke testing is one of the quick and dirty tests that we have in the software testing fields because of which the major functions of the software system or applications can be worked out without bothering about the finer details of the code and implementation. 

When and how smoke testing is performed?


- Smoke testing is basically performed when the software system or application is thought to be absolutely new.
- After the build is received, it is run and here the smoke testing comes in to play and involves checking whether the build is stable or not.
- A smoke test is not a singular test but rather a series of tests that are carried out on the software system or application before the actual full scale testing of the application is commenced.
- It would not be wrong if you say that the smoke testing is type of non- exhaustive test. 
Furthermore, in some cases the smoke testing also plays the part of the acceptance test that is run prior to the introduction of a new build to the main structure of the software system or application and before the regression or integration process.

In this article we will be discussing about the advantages of the smoke test but before this let us see what all are its characteristics:
  1. Smoke test is scripted either as an automated test or a manually written test.
  2. It is designed to focus on all the parts of the application like a cursor can do.
  3. It is shallow.
  4. It is wide.
  5. Ensures the working of the most crucial functions of a program.
  6. Ensures that the build is not broken.
  7. Verifies readiness of a build to be tested.
  8. It is not a substitute for actual functional test.

Advantages of Smoke Testing


Now let us chalk out the advantages of the smoke testing:

  1. Carrying out smoke testing at various stages reduces the problem of integration. The risk of integration is minimised. Most of the teams fear facing this risk that a project in which they have to integrate or combine code up on which they have been working individually and it may not work well. At this stage only the incompatibility of the software system is discovered. If the integration takes place earlier than smoke testing then the debugging process will take a lot of time and may require re- implementation and re- designing of the whole system. In most of the cases, projects have been cancelled due to errors during the integration. With the daily smoke tests, the integration errors can be reduced and runaway integration problems can be prevented.
  2. If the smoke test has been designed properly, it can detect errors and problems at an early stage.
  3. Since the smoke test detects the majority of the problems at an early stage, much time and efforts are saved.
  4. With smoke testing, the risk of low quality is reduced.
  5. With the daily smoke tests, the quality problems can be prevented from taking the control of the project.
  6. The smoke test can uncover major problems and defects as a consequence of wrong configuration.
Basically what happens in smoke testing is that the whole system is exercised from end to end and those errors and problems are stressed that cause the functioning of the whole system to stop. The smoke test is not so exhaustive but it does expose out major problems of the software system or application under test. The smoke testing at all stages ensures the working of the major functionality and keeps a check on the stability of the build. 


What are different characteristics of smoke testing?


Smoke testing is considered to be one of the preliminary software testing techniques to further testing that are intended to reveal simple failures that are simple enough to be a cause of a software project to be rejected. 
In the term “smoke testing”, smoke is used as a metaphor. All the test cases that are known to provide coverage to most important functionality of a component of the software system or application are selected and grouped under a set and later are run. This is basically done to ascertain that the most crucial functions and features of the software system and application are working as desired or not! 
One can understand smoke testing better by having a look at the below mentioned questions:
  1. Does the program run?
  2. Does clicking the start button do anything?
  3. Does the program run?

Goals of Smoke Testing


- The primary goal of the smoke testing is to determine if the problem or fault in the software system or application is so worse that any further testing on that software system or application will be a waste. 
- To put it simply, the smoke testing can be considered to be a cheap and less time consuming way to broadly cover the features and functionalities of the software product in a limited period of time. 
- By carrying out smoke testing, you can easily find out if any of your software system’s or application’s key feature or functionality is broken at some point and so your development team would not spend further time on it fixing or recreating it. 

People often confuse between the two similar terms i.e., smoke testing and build verification test. No doubt both are one and same the only thing when the smoke testing is performed on a build it called build verification test.


When should smoke testing be performed?


- One of the best practices of software testing is that the smoke testing should be performed everyday without fail. 
- Furthermore, the smoke testing can also be performed by the testers before accepting a module or build for further testing.
- Some testing has been listed as the most cost effective method for the identification and fixation of the defects in a software system or application after the code reviews by the software giant Microsoft Corporation. 
- The smoke testing is deployed as a process for the validation of the changes that have to be in the code before they are passed on to the source control in the Microsoft Corporation. 
- The smoke testing has to be carried out either automatically or manually that is purely the choice of the tester.
- When the smoke testing is carried out manually, the process goes on normally but when the automated tools are used, the tests that have to be carried out are initiated during the same process through which the build is generated. 

Smoke tests have 2 types as mentioned below:
  1. Unit tests: Smoke tests under this category are known to exercise the sub routines, object methods and individual functions and so on.
  2. Functional tests: These types of smoke tests are known to exercise the complete program along with various inputs.
Both the above mentioned type of smoke testing tools together make up a third party product that falls out of the compiler suite. 
A scripted series of program inputs form a function test and some may also have an automated mechanism. On the other hand the unit tests may be formed out of the separate functions that lie within the code. They can even be a driver layer that might be linked to the code. The smoke testing in software can be compared to the smoke testing in hard wares. 


Tuesday, June 19, 2012

What are different characteristics of build verification test?


Build verification test is often abbreviated as BVT and can be defined as a set of tests that are carried out on all the builds that are newly built in order to verify if those builds are testable or not before they are transferred to the testing team for their further testing. 
Generally, the test cases used in build verification test are considered to be the core functionality test cases which are used to keep the stability of the software systems or applications in check and regulate their testing thoroughly. 
The whole process of build verification test takes a whole lot of efforts and time if carried out manually and therefore the whole process is usually automated. If a build fails the build verification, then the same build is again returned to the developer to fix the faults. 

There are other names also by which the build verification test is known as mentioned below:
  1. Smoke testing
  2. Build acceptance testing or BAT
In a typical build verification test, there are two aspects that are exclusively tested and are mentioned below:
  1. Build acceptance
  2. Build validation

Few basics of Build Verification Tests


  1. Build verification tests are a sub set of tests that are used for the verification of the main functionalities.
  2. Some build verification tests are created on a daily basis and some builds are daily tested and if those builds fail the build verification test, they are rejected and returned back to their developer for making the fixes and when the fixes have been done, a new build is released and is gain subjected to the build verification test.
  3. The build verification test has an advantage that it saves the precious efforts of the testing team that are required for setting up a test and testing a build whenever there is a break in the major functionality of the build.
  4. The test cases of the build verification test should be designed very carefully so that they provide the maximum possible coverage to the basic functionality of the build.
  5.  A typical build verification test is run for 30 minutes maximum and not then this limit.
  6. The build verification testing can also be considered as a type of regression testing that is done on each and every build that is new.

Aim of Build Verification Test


- The primary aim of the build verification test is to keep a check on the integrity of the whole software system or application in terms of its build or we can say modules.
- When several development teams are working together on the same project, it is important that the modules that they are developing individually have got good ability for integrating with each other since this is very important. 
Till now so many cases have been recorded in which the whole project failed miserably due to a lack of integration among the modules. There are some worst cases also in which the whole project gets scraped just because of the failure in the module integration. 
- The build release has got a main task i.e., file check in i.e., including all the modified as well as new project files associated with the corresponding builds. 
- Earlier checking the health of the building initially was considered to be the main task of the build verification test. 
- This is called as “initial build health check” and it includes:

  1. Whether or not all the files have been included in the release or not?
  2. Whether all the files are in their proper format or not?
  3. Whether all the file versions and languages have been included or not?
  4. Whether the appropriate flags have been associated with the file or not?


Facebook activity