Software Testing Practices, Test Methodologies and Test Competency Services


Welcome to the world of Software Testing & Best Test Practices.

All you wanted to know about Software Testing, Test Practices, Test Methodologies and building the Test Competency Services !!


Friday, April 26, 2013

Priority and Severity


All decent bug tracking and issue tracking tools will include a field in their bug report template for Priority and another field for Severity. These fields are used to describe the importance of a given bug by the person who is reporting it to the person who will eventually handle it.


The big question is this -what is difference between Priority and Severity? And which one should use when?

The image below should explain how to triage bugs (triage in a hospital is the process of determining the priority of patients’ treatments based on the severity of their condition).

However, for added detail, check out the bullet points below which should explain Priority and Severity even further. 


Priority:

  • Priority relates to how fast the bug or issue has to be fixed.
  • Priority is related to scheduling to resolve the problem.
  • Is largely related to business or marketing considerations in that it is indicatory of the importance of the bug especially in terms of stakeholders.
  • The priority status is also set based on the customer requirements.
  • Priority relates heavily to the technical aspect of the product and how ‘bad’ the impact of the bug is for the system.
  • Priority obviously dictates how urgently the issue should be fixed.
  • Fixes are carried out based also on the project’s priorities
  • The Priority status is set by the tester to the developer mentioning the time frame to fix a defect. If High priority is mentioned then the developer has to fix it at the earliest.

Severity:

  • Severity is related entirely to the quality standard.
  • Logically, severity enquires how severely the issue is affecting the functionality.
  • The severity type is defined by the tester based on the test cases and functionality.
  • Severity is assigned by tester according to the seriousness of the bug.

Monday, January 28, 2013

Qualified User Story


Most of Agile test teams seem to initially struggle with understanding how big (or small) a User Story is, relative to Epics, Features, and Tasks.




It doesn’t help when they first ask how big user stories are and the first response to get is “it depends“.
It’s not uncommon to find team members asking if they can call smaller stories a minor or sub-story or a larger story a major story.  

But then they get distracted by colors of index cards or some ancillary attribute.

The Distinction

Those who identify what the business wants (you may call him or her a Product Owner) take a stab at breaking down stuff to manageable chunks.  You can call those chucks an A/B-level requirement, epic, theme, feature, or spike. It doesn’t matter what you call it.  But when the team estimates that stuff, it is still sometimes (more often than not) too big to fit into a sprint or iteration or just isn’t ready to be worked.

We need to label [this] to set it apart as work that will be committed to next.  Either it will be scheduled in an upcoming sprint or it will be pulled to the next step on a Kanban story board.  To be clear, I’m not saying the team should start working on [this], merely because they think it is small enough to be completed within a predetermined cycle.  Until your team has sufficiently defined and mapped requirements, developed acceptance criteria, and removed all known blocking dependencies, it is still not a Qualified User Story.

Though I still use the term User Story as that placeholder for conversations, I believe the Qualified User Story more appropriately identifies a placeholder for conversations that meets a definition of ready and allows the team to commit to complete something within an estimated period of time.

Wednesday, December 12, 2012

Test Efforts in the Agile World

We have all heard and seen over the last few years how products are moving into an Agile mode of development. Although they may not be explicitly termed Agile, the core characteristics of the model including faster releases, an iterative development model with demonstrable software at the end of each milestone, close collaboration amongst teams De-emphasizing on product documentation and formal processes, are all becoming more visible and inevitable.

When time to market is one of the critical factors in determining the product's acceptance in the market place, effort estimation for all disciplines in very important to ensure the product can be released within the committed timelines yet not compromising on its feature set or performance. In this article, I would like to share with you all the most important points along with some best practices to keep in mind in estimating an Agile test effort.

Firstly, as you may be aware the product release typically consists of several sprints. Each sprint may be anywhere between a week to a month in duration, with specific features that need to be targeted in that interval. Daily scrum meetings are conducted to discuss the team's progress, plan of action for the next day and any blocking issues that need to be addressed.

In the traditional waterfall model, one would typically base estimates off of the requirements defined, the complexity of the requirements, potential test cases for each of the requirements, complexity of test cases and estimate test efforts depending on the complexity factor and the number of expected test cases.

In Agile, estimation is based off of user stories. The user story's priority, complexity, associated use cases, types of testing needed are the primary determinants of the testing effort estimate. You may see that there is not much difference here compared to the traditional estimation model. However what is different is the agility of your estimates. Given how short the milestones are, effort estimation tends to be an ongoing activity, where one needs to keep tabs on the numbers and raise any alarms as soon as they are sensed. On the same note, if one is able to finish tasks ahead of the original estimates, such extra bandwidth should be leveraged to take on tasks from the subsequent sprint, to give you a head start. Agile world also offers you the advantage of precedence setting where one is able to learn from the mistakes of the previous effort estimates which are often comparable, because user stories from previous milestones are relatively of the same magnitude and were implemented not too long ago. So, there is often a good baseline to refer to, to help produce more robust estimates.

Also, some of the more time consuming test activities such as test maintenance are typically separated out of the core agile test cycle. In some projects I've seen the team set aside a milestone for quality every quarter or so, where about a week is reserved for various disciplines to focus on maintenance efforts. The test team can use such times for activities such as test case updates, add tests for ad hoc bugs, develop test automation frameworks etc. not including these as part of the core test effort estimation.

Similarly identify tasks that are Sprint contained and ones that span across Sprints. Typically, functional, UI, compatibility tests are specific to Sprints and associated with features that are developed in each Sprint. However, tasks such as Performance, Security testing may run across Sprints. Specific to your product determine what makes the most sense, depending on whether a V1 product is developed or the effort is sustenance in nature.

A lot of unit testing is typically undertaken in Agile model, where the tester tends to focus on the number of units to be tested, the kind of asserts to verify for each feature. This is an area, where collaborative estimation along with the development team becomes important. If the team is taking on Test Driven Development, where automated tests are designed upfront, which become the basis for development coding, test estimation actually becomes more straightforward as the tester has most visibility into the product scenarios compared to the rest of the product team.

Agile by nature is a self-correcting model which promotes a lot of collaboration and frequent communication. So, it is inherently designed to ease the estimation process and promote accuracy of estimates by keeping everyone in sync on updates, changes. The Sprint planning meeting that happens at the start of every Sprint, forces every team member to come prepared with their effort estimates. This allows for everyone to know what the overall product team's estimates are and what ratios they would like to maintain as a team. In most cases, I have seen a 1:1.25 development: test effort estimate. Keeping such high level ratios in mind, such team meetings help review everyone's estimates specific to the Sprint at hand. This is an excellent opportunity for everyone to collaborate, brainstorm, question and review each other's estimates to ensure they are not unreasonable unlike in the traditional waterfall model, where efforts are estimated in isolation, without a complete view into the product dynamics. So in some sense, estimation becomes a group activity bringing in all the checks and balances needed to make it more accurate.

That said, every team has to play its part in making the process a success. If one is not responsive to change, ready to learn from past experience, collaborate with the team, they are setting not just themselves for failure, but are pulling the entire team down. So, it is in the best interest of the entire team, to align oneself with the product dynamics, and help provide robust and near-to-accurate estimates in building and shipping products of exceptional quality.
Along similar lines of test effort estimation in agile, is an interesting topic on test metrics to gauge product and test effort's quality in the agile world. I will touch upon this in my subsequent post, exclusively for the Silicon India audience.

Thursday, November 22, 2012

Test Estimation Techniques



Estimation is done often because it is expected to help in predicting how much will the project cost and when will the project get completed. Proper analysis and effort estimation is necessary for successfully planning for a testing project. Any flaw in critical estimation phase, results in missing the project deadlines, reduces ROI and loses of customer’s faith. Remember - Bad estimation can lead to poor distribution of work. 

There are different standard and non standard methods for test estimation. In many product based companies, people utilize non standardized but conventional estimation methods to make things work. These methods might have developed over a continuous period accommodating hidden factors like nature of application under test, environment, and risk factors for that specific product/market. But these methods can’t be adopted as a generalized organization standard for a mature operation model.

Fact: Managers/Leads are not comfortable with software estimation work. But it is a required activity, so based on their past experience on one particular Product, Test Leads/Test Managers estimate the entire testing project (but for that Product only). Because they spent 1-2 or 2-3 or even more years on that particular product. But if they are asked to change company or shift to new product of entire different domain, then it is very hard for them to do estimation.
In this topic, we will discuss following methods for test estimation:
1. FIA (finger in the air) or best guess
2. Ad-hoc method
3. Experience Based - Analogies and experts
4. WBS
5. Delphi technique
6. Three-point estimation (successive calculation)
7. Function points / Test point Analysis
8. Percentage of development effort method
9. Percentage distribution
10. Use case point estimation method
 
Lets discuss one by one:
1. Best Guess – This technique is purely guesswork and based on the some sort of experience.
The method is very common, but since it is based on your gut feeling, its uncertainty contingency is probably around 200% or even higher.

2. Ad-hoc method - The test efforts are based on tentative timeframe. The timeline set by managerial or marketing personnel or by client without any guess/experience. Alternatively, it is done until the budgeted finances run out.
This is very common practise in extremely immature organizations and has error margins of over 100% at times.

3. Experience Based - Analogies and experts:
  • Metrics collected from previous tests.
  • You already tested similar application in previous project.
  • Inputs are taken from Subject Matter experts who know the application (as well as testing) very well.
4. Work Breakdown Structure - It is created by breaking down the test project into small pieces. Modules are divided into sub-modules. Sub modules are further divided into functionalities and functionalities are divided in sub-functionalities.
Review all the requirements from Requirement Document to make sure they are added in WBS. Now you figure out the number of tasks your team needs to complete. Estimate the duration of each task.

5. Delphi technique – Same as above WBS. Here functionalities and each task is allocated to each team member. Then team member gives estimate that they will take this much hours to complete the task.
Averagely, this technique gives good confidence in the estimation. This technique can be combined with other techniques.

6. Three-point estimation – This technique is based on statistical methods In this technique, task is broken down into subtasks (similar to WBS) and then three types on estimation are done on each chunk –
  • Optimistic Estimate (Best case scenario in which nothing goes wrong and all conditions are optimal.) = a
  • Most Likely Estimate (most likely duration and there may be some problem but most of the things will go right.) = m
  • Pessimistic Estimate (worst case scenario which everything goes wrong.) = b
Formula to find Value for Estimate (E) = a + (4*m) + b / 6
Standard Deviation (SD) = = (b - a)/6

7. Function Point/Testing Point Analysis: The FP technique is a direct indicator of the functionality of software application from the user's perspective. This is the most accepted technique used to estimate the size of a software project.
This technique is a part of TMap. Base of this technique is function point technique. Here we convert function points into test points. In Test Point analysis, we usually carry out the following:
  • Dynamic Test Points
  • Static Test Points
  • Environmental Factor
  • Productivity Factor
  • Primary Test Hours
  • Control Factor
  • Total Test Hours

In Testing, This estimation is based on requirement specification document, or a previously created prototype of the application. To calculate FP for a project, some major components are required.
The major components are:
Unadjusted Data Function Points: i. Internal Files, ii. External Interfaces
Unadjusted Transaction Function Points: User Inputs, ii. User Outputs & iii. User Inquiries
Capers Jones basic formula:
Number of Test cases = [Number of Function Points] x 1.2
Total Actual Effort, TAE = (Number of Test cases) * (Percentage of development effort /100)
This method is done in a case when a detailed low level design document or requirement document is available (i.e measure of function point is available) & Previous data for development and testing is available. But now days, when we are using agile and iterative methodologies to deliver projects, so most of the times all this documentation is not available.

8. Percentage of development effort method
Here the assumption is that a more complex business application may require more testing effort. The test effort required is a direct proportionate or percentage of the development effort.


Note: The development effort can be estimated using line of code (LOC) or function point (FP) which is not in the our scope.
Example:
If a previous project with 500 FPs required 50 man hours for testing, the percentage of testing effort is calculated as:
P = (50 / 500) * 100 =10%
For the current project with a development effort, say 1500 FPs, the testing effort is:
Total Actual Effort, TAE = 1500 * (P/100) = 1500 * (10/100) = 150 man hours.

9. Percentage distribution – Here all the phases of SDLC are divided in parts and assigned effort in %. Like –
Project management 7%
Requirements 9%
Design 16%
Coding 26%
Test (all test phases) 27%
Documentation 9%
Installation and training 6%
Now testing % is further distributed into all testing phases:
https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEixEYJ8vbrQpeHysS3-yz0mvaET-SITPy3-DRk4meQ6cgKQTa6SjsNnWt-IX5RURPtYteXlROwYmwQCWYuCOUUyuqbF1a-tiueA2DkSsNVeU9RPu_tXxeDTgcfCNVKEPdpzeCkDB6Xo5LWn/s400/Distribution+of+test+efforts.JPG


OR
All phases
%
Component testing
16
Independent testing
84
Total
100


Independent testing
%
Integration testing
24
System testing
52
Acceptance testing
24
Total
100


System testing
%
Functional system testing
65
Non-functional system testing
35
Total
100


Test Planning and Design Architecture
50%
Review phase
50%

10. Use case point estimation method: Use case point (UCP) method is gaining popularity because now-a-days application development is modelled around use case specification. The test case development is normally kicked off after baseline use case. So the various factors in use case give a direct proportion to the testing effort. 
Use case is a document which well specifies different users, systems or other stakeholders interacting with the concerned application. They are named as ‘Actors’. The interactions accomplish some defined goals protecting the interest of all stakeholders through different behaviour or flow termed as scenarios.

UCP Estimation Method in brief
1. Obtain unadjusted actor weight (UAW)
2. Determine unadjusted use case weight (UUCW)  
3. Calculate unadjusted use case points (UUCP) UUCP = UAW + UUCW
4. Determine the technical/environmental factor (TEF)
5. Compute the adjusted use case point (AUCP) AUCP = UUCP * [ 0.65 + (0.01 * TEF)]  
6. Arrive at final effort using a conversion factor Total Actual Effort = AUCP * CF

Conclusion
There can’t be a sole hard and fast rule for estimating the testing effort for a project. There may be different other methods also which can be effectively used for the purpose. It is recommended to add on to the possible knowledge base of test estimation methods and estimation templates constantly revised based upon new findings.