This time I'll share my experience about Test Cases. What
are the motivation factors when creating TCs and how we need to write TC in long team projects. As far as I can see
our motivation is to create TCs depend on several aspects and those are as follows:
1. If we are working in a product
based company we have to work with one product or related products within a
long period of time. Then we are mastering that domain. Hence we try to create
TCs with only the essentials and basically those are very similar to the check
lists or light test cases.
2. Process we are following in our companies is another
point. If we are following waterfall method then we have lot of time to write
lengthy TCs and execute. But in an Agile environment, the approach is bit
differ since we have limited time space within a sprint. And also QA members
are often tackle with POs, PPOs and Dev members and know all the details in and
out so the motivation behind writing lengthy TCs is very low. I think we should
follow linear way and do more exploratory testing.
3. Another vital thing would be the TC maintenance. Say if
we have several related products and you have thousands of lengthy TCs. If
there is a change in the feature etc, again all the related TCs should be
updated. But it is not an easy task as you have lengthy and thorough TCs. So
you need more main power and money (this is one of the main motivations behind
writing linear type TCs in our customer).
4. And one of the most important factors is the project
criticality. If the cost of failure in the particular project is very high (Mission
critical project) you should have rigorous test cases with all the necessary
details. And when there is a requirement change, there should be a very good
mechanism to update those test cases though it is expensive.
But whatever the motivation behind writing TCs I have
following suggestions when writing TCs for long term projects. In this approach
(filtering mechanism), we have divided our TCs to 3 categories and create separate
TCs for each. So the details is as follows:
1. According to the new user story or spec, we can create
TCs with all the adequate details. This is the initial TCs we are going to use.
So we can say we should write a test case with 100% test coverage. Using these
TCs, we can do a thorough feature test after complete the development. Furthermore,
this is utmost important when testing critical applications as I said earlier.
2. Then we can write TCs for extended smoke test (So this is
more filtered and light version than the first one). So in this case we can do an
exploratory testing as well while
executing the TCs to fulfill the major requirement of agile. Furthermore, this
category is more related to mind mapping technique (In our company, we have
created a model called 'sModel' for this).
3. And finally, we can create TCs for ready to release test
(or light smoke test). So this should be a check list kind of test cases (Very
simple). So final result will be test cases with major functionalities. As an
example, 'Add / Edit / Delete Contact', 'Document download and read' etc. By
using these, we can make sure that the application main functionalities are
working as expected within a very short period of time.
Hope this will help you to create TCs for different testing stages.
