GroTechMinds

GroTechMinds logo
writing good test cases

Introduction

Every customer, as well as organization, wants a quality software application for fulfilling daily real-life requirements as well as organizational needs respectively. So it has become necessary to develop quality software applications for fulfilling customer as well as organizational requirements. So every software application after development undergoes various phases of testing in order to check the quality before release into production. So writing good test cases is one of the most important aspects of the software testing process so as to easily detect faults in any features of software as well as to check if any feature works as per requirement and expectations.

Characteristics of a good test case
Thinking from the Customer's perspective

Testers should design their test cases keeping in mind the customer’s requirements. In other words, the testers should think from the customer’s perspective, and their daily needs while preparing test cases. Customers tend to complain to the tech support team in case of any issue arising in the software application. So testers should write test cases in a manner where customer needs are kept as top priority. Every test cases should cover the functionality of the application and how customers utilize those functionalities for their real-time tasks. Writing good test cases can also help in performing usability testing and accessibility testing of software applications.

Creation of user personas

The best way testers can understand user requirements is by creating user personas. User persona refers to the dummy profile of the end-user which is created to test the functionality of applications and websites. Suppose for example in order to test an e-commerce application user named ‘Mr. X’ will test the login functionality of the application by trying to log in with valid and invalid credentials. Then after logging in with valid credentials, he will test the search functionality by typing the valid and invalid product name. After that he will check whether the product logos and prices are properly displayed, the product is getting added to the cart, the delivery address is getting selected or not and payment methods are working properly. He will perform this testing through different browsers to check the compatibility of the e-commerce application. However, this user persona will not focus on the internal logic of the e-commerce application which is called API testing. In this way, different user personas are created for different types of applications for easy understanding of application functionalities and their usage.  So based on this user persona testers should be able to write good test cases.

Target for 100 percent test coverage

The most important feature in writing a good test case is to ensure maximum test coverage. Every test case ensures that most of the functionality and features especially the basic and critical functionality are covered thoroughly. Testers should set their aim for 100 percent coverage which ensures that the test cases each and every feature is rigorously tested. Testers should write the test cases for each and every requirement mentioned in the Software Requirement Specification(SRS) document. Testers can make use of the Traceability matrix document to make the test coverage process easier. A traceability matrix is a document or template that maps all the requirements mentioned in the software requirement specification document with the test scenarios thus helping in a thorough coverage of tests. 

Use of proper Test Case Management tool

Test case management tools ensure a proper and smoother testing process. These tools are necessary to provide a stable software release cycle. These tools provide transparency and track the workings of each member of the team involved in the software development process. Testers after writing the test cases and completing the review process should store the test cases in the Test Case Management tool which is also called as Test Repository. It is also important for testers to properly understand the usage of test case management tools in order to store their test cases. The most commonly used test case management tools are Test Rail, TestFirst, and Tuskr.

test cases
Focus on Dependent Test Cases

Test case dependency refers to the phenomenon where the execution of one test case depends on the execution of other test cases. For example, test case X will be executed only if test case V and W are executed. In such scenarios whenever any bug is detected, it becomes very difficult to replicate the same bug. So this shows the existence of one test case’s execution depending on the execution of other test cases. So testers need to manage properly the dependencies of test cases to ensure a smoother testing process. 

Since bug replication is a time-consuming process in case of test case dependency, testers need to ensure that the test cases are written in such a way that test case dependency does not happen.

Thorough review of test cases

It is necessary for testers to review their test cases before doing test case execution. Test case review includes checking if all requirements are covered in the test case document, and if for every test case the steps, the expected results, preconditions, and test case ID are properly written. The review process also includes checking for any spelling mistakes or grammatical errors. Testers can send the test cases for review to various team members like fellow testers, the team lead, the QA Manager, etc. Reviewers’ job is to ensure that the test cases have maximum coverage, negative test cases are written after positive test cases, and test scenarios and test cases are written in a simple easy to understand language.

Coordination with team members

Proper coordination between various team members like the product manager, Senior tester, team lead, and developer is very important for the development of a creative and effective test case. Testers should share their test cases for review with their team members and all stakeholders involved in the project and ask for feedback to modify test cases based on customer requirements and expectations. This process ensures the creation of more effective test cases.

Test cases should be based on Scenarios

Since test cases come from test scenarios testers should ensure that the test cases are scenario-based. For example, in the case of system scenarios, the test cases should be system scenario-based whereas for component and integration scenarios respectively the test cases should be component or integration-based. 

Test cases should be context-based

While preparing test cases, testers should keep in mind that the test cases are context-based. It means depending on the application or website testers should prepare their test cases. The test cases for e-commerce application should be different from airline applications and gaming applications.

Mistakes to avoid while creating good test cases

The testers should avoid the following mistakes  while creating good test cases:

Avoid test cases that run on only one specific condition

The aim of writing good test cases is to ensure that they cover all the conditions as well as different combinations of one condition required for the performance of the application. So every test case must be written keeping in mind the multiple scenarios to be performed by users in accessing the website or application. 

There should not be partial coverage of the functionality of an application

 Test cases should written in a comprehensive way ensuring complete coverage of functionalities of websites or applications. If the test cases have less or partial coverage of the functionalities of the application then it can result in non-performance of the functionality of the application which can even lead to a breakdown of the application. As a result, it can affect the end users as well as organizations’ real-time workflow. 

Should not be limited to specific user role :

It has been found that the test cases that are created for specific user roles have limited scope and are not effective. So a good test case should cater to multiple users’ roles thus showcasing the user experience in using the application. For example, test cases for a business application should cover the entire business processes associated with the application including the contribution of users in initiating and completing the entire business processes.

Never let the test cases without update for a long duration

Software applications always undergo changes and updates due to frequent changes in customer requirements. As a result, the programming codes keep on changing. So it becomes necessary to update the test cases as per the code changes. Not updating the test cases for a long period of time can result in non-identification of bugs which can affect the basic and critical functionality of applications. This phenomenon is also called as “Pesticide Paradox”.

Repetition of test scenarios from the requirement document

Testers should avoid repetition of the same test scenarios in their test cases but instead should prepare test cases for “corner scenarios” because those test cases can detect the defects which can make it impossible for users to perform the critical functions in the application or website.

Conclusion

Writing good test cases has proven to be one of the most crucial parts of the development of a quality software application.  Apart from writing test cases, it is also equally essential to store those test cases in test case management tools like test rail. After writing test cases, they are properly reviewed and then go through the execution process before the final software application is sent to production. All these result in customers getting a good quality of software application as well as ensuring customer satisfaction.  

Popular Courses
Share:
Upskill Yourself
Consult Us