Updated March 25, 2021
Although testing involves many different stages, it’s mostly based on preparing and executing successive test cases. Tests have a strong influence on the quality of the final product. This is why it’s so important to pay attention whilst planning the process, and how it’s integrated into the rest of the development lifecycle. To ensure tight integration, we strongly recommend using Jira Software for this purpose. It’s generally known that the Atlassian suite supports managing the workflow even in the case of more complex projects which involve many people’s cooperation. In software development, all the phases are related to each other. It’s a smart idea to catch up with all the connections between the project goals, features, and test cases in order to build a consistent process, understandable for each stakeholder.
Why shouldn’t we separate our test cases?
In favor of keeping your software development process consistent, it’s always better to have all its elements inside one place. When we have to deal with more complex or scattered projects, searching for particular elements takes a lot of time and can be really frustrating. Being able to see all the relations between the objects at a glance can do miracles for the project. You’ll spot the possible defects sooner and will be able to fix them, as well as immediately tell which part of the code or incorrect requirement caused their occurrence. This kind of workflow leads to the earlier release of the final, bug-free product.
What’s more, if testers have their test cases stored in a separate testing tool, a document, or some Excel sheet, the rest of the team usually have problems with accessing it. This makes it difficult to see the context of each test case, as well as complicates the communication inside and across the teams. The consultations and meetings waste time, which could be spent otherwise. When our test cases are managed in the same place as requirements, plans, executions, and defects, the process is logical for each stakeholder every step on the way.
Benefits of using Jira for the whole software project
Test case management in Jira – challenges and advantages
There are numerous available testing tools to choose from. Before deciding which one would work best for us, first we have to find out which method we will follow in testing. Since we’re already using Jira, we can take one of these three paths:
- Standalone testing solution – we purchase specific software dedicated for test management. This path will require user training and might become a bit time-consuming, but it should also offer greater flexibility when it comes to choosing from available tools.
- Jira out of the box – don’t adapt any new tools to our instance, but instead focus on customizing Jira to make it into a test management tool, on our own or with the help of the Jira administrator. The users won’t require extra training, because Jira is a familiar environment. We can transform Jira into a testing platform, but be aware that it will always have its limitations.
- Jira paired with a test management app – we can extend your Jira functionality with a dedicated app from the Atlassian Marketplace. That way, our instance will be better adjusted to testing activities.
Each method listed above can become a smashing success or total failure. In the end, it all depends on the project, organization specifics, and many other factors. Even the spreadsheets we mentioned before can become a suitable solution for very basic implementation of the testing process, but it’s definitely a good idea to find something a bit more advanced for a growing project in order to aim higher and always be prepared for constant development. So let’s take a closer look at each of these solutions to help us see which one works best for the specific needs.
Despite Jira isn’t a dedicated testing tool, many teams still use it for this purpose. When a company manages projects in the Atlassian suite and storing everything inside one place significantly improves the process. Jira Software simplifies communication between and across teams. When someone modifies a task or issue, all people involved can see it. It’s a dream come true not only for managers who need to control the workflow all the time, but also for various team members who not necessarily like to run from desk to desk every time they have a question.
Nevertheless, when it comes to testing, Jira Software has its limitations. Although it has a few issue types to choose from, like Bugs or Epics, it doesn’t have anything intended strictly for tests. Custom issue types can be created, but it’s always an additional activity, which takes extra time. In this case, an admin has to set up and prepare each issue type by adding custom fields, putting them into screens, and practically built the whole workflow from scratch. Secondly, test cases in Jira once marked Done can’t be used again, which is practically inevitable in software testing. It’s highly probable that a test case will have to be re-executed, for example, whilst verifying if the functionality works in another environment, or in the case of regression testing.
Standalone Jira Software shows direct relations between the issues on the issue screen, but it’s still very easy to get lost in the successive stages, as there isn’t any consolidated view of indirect connections. Checking the requirement-test case-test plan coverage isn’t clear, and presenting your progress or results to the other stakeholders requires meetings and preparing reports, inside or outside the software, so everyone could really understand what’s going on. It seems like Jira constitutes a great foundation for testing, but there’s quite a lot of functionalities missing to execute the complete process.
The most common option is investing in software designed particularly for test management with highly specialized functionalities to enable efficient testing. Integration with different issue trackers like Jira is a must-have feature, which allows to incorporate the testing process into our team’s current workflow. If we choose this option, we can expect the tool to be well-suited for different testing tasks. That’s the most valuable advantage of a standalone software solution. The testing process we establish should be fairly easy to achieve, if we pick the right solution.
There are many standalone test management tools on the market, so picking the right one can be difficult. Looking for the most suitable one and browsing through demos, POCs and documentation lectures can be time-consuming. And once we finally make a decision, we’ll have another tool in our set and need to offer the end users a lot of training to learn how to use the solution efficiently. Also, it may take even more time to reach full efficiency while the team is geting accustomed to the tool. In the end, there’s the matter of integration with our current setup as well. Using many different tools might affect global monitoring of our work progress and make keeping the data actual very challenging.
Jira with a testing extension
Testing extensions for Jira are the solution to all the challenges of software development teams. On the Atlassian Marketplace, there are over 160 test management apps to choose from. First of all, we can decide on a separate tool, which integrates with Jira or on an add-on. Both give Jira the functionalities, which make test case management more efficient than in the case of standalone Jira. The right tool will provide its users with the possibility of advanced customization and with features created especially to answer testers’ needs. Moreover, it’s much more convenient for an admin to install the app than to go through the procedure related to adapting plain Jira for tests.
By advanced customization, we understand a couple of things. First of all, apps for test management have built-in issue types for testing objects, such as test cases, test plans, test executions, and defects. Secondly, the relations between the objects are traceable, as the process is consistently executed inside one place. There are tools that include requirements management as well, and this enables performing the whole software project management in Jira from the very beginning. Connecting possible defects to the elements of the initial part of the process may lead to very useful conclusions for the project, such as which of the planned features of our product to-be generate most of the bugs. Designers of testing apps took care of the reporting, too: each app has the reports displaying the current progress and statuses ready to be presented to the stakeholders anytime we want. The great thing about the reports is that they are real-time and update automatically, which means they immediately show all the modifications made by the team.
Test Case screen in Requirements and Test Management for Jira (RTM)
Why choose Jira apps for test management
Reason 1: Most teams know Jira environment
The overall user experience is one of the most important characteristics of almost any software. The interface quality impacts the time users require to learn the tool and use it with maximum efficiency. Choosing a Jira app for your test management solution ensures that our team continues to work in a familiar environment. If Jira and other Atlassian tools are currently utilized on a daily basis for completing different tasks in our team, an extension of the issue tracker will keep the users comfortable and ready to go. Surely some kind of training will be needed, but it should be fairly simple. The team needs to be aware of the core functionalities the app brings and the test process itself, but that is still just a small part of what needs to be done when we’re introducing an entirely new tool.
Reason 2: Test management can be incorporated into the development process
The main objective of managers who choose a test management solution is verifying its capability to model the test process they are planning to work with. Testing activities demand specific features from the solution. What was a major disadvantage when using pure Jira for test management is now brought to the table by the dedicated apps. The Atlassian Marketplace is the right place to look for apps, and we can be sure to find at least a few great ones that were designed for test management. Of course each solution is different, and we need to decide which one will suit us best, but we can be sure to find basic testing functionalities in every app. We’ll be able to create effective test cases, plan testing cycles, report on progress, perform transparent defect tracking, and more.
Reason 3: The whole team benefit from using built-in Jira features
One of the most important pros for using Jira apps is that they integrate with Jira environment itself and all its features. Most of the time, we can use the rich set of modification options to enhance your testing experience. Jira is an advanced issue tracking solution that offers users a wide range of options for customizing the way it operates. If the app is heavily based on Jira issue types, bear in mind that we can create your own custom fields to store additional data or configure the workflow including all its mechanisms (conditions, post functions, etc.). Other apps add their own modules or views to the project. If that’s the case for your choice, it’s worth a while to verify if it is well integrated with Jira interface. By making sure it’s possible to track relations between testing objects and Jira issues, we succesfully bring the whole project into one tool and build a continuous process clear for all the stakeholders. Later on, to improve our test results reporting, we can configure a dashboard with gadgets of our choice and set up permission and notification schemes for better control of our project. This is just a tiny part of Jira feature set that can be used for enhancing test management.
Reason 4: Seamless integration clarifies relations between objects
In the end, there is always the matter of integration between various tools our team uses for performing different tasks. The more tools are there in our setup, the more complicated the work becomes. Dealing with different interfaces, various sources of data, separate maintenance processes, and methods of carrying out the integration can become quite problematic. Extending Jira with an app guarantees the best integration. We have one point of management for both project tracking and testing activities. This is a great advantage, since we keep all the data in one place and there is no need to switch tools for performing different tasks, be it daily work or technical, maintenance tasks.
Customizing Jira for tests
The most common way of setting up Jira for tests is by using Stories and Sub-tasks. It’s good for the start or smaller projects because even the beginners will understand how it works without an additional explanation. When we add a test case, in its description list your test steps and indicate what results are expected from every action. Then, it’s time to create sub-tasks for each test run and adequately label them with the outcomes, the versions, and the assignee responsible. This way would require adding a dedicated testing project to our instance by the admin. Otherwise, User Stories generated for tests will affect the developers’ sprint scopes, burndown charts, and other ways to measure their work effectiveness. This is a big flaw in this solution.
If so, we may ask our Jira admin to create a specific issue type for test cases. This might work even inside the development project, where we can exclude it from the sprint scope and reports. However, creating an issue type from scratch implies designing a workflow, adding some custom fields and configuring screens, which isn’t too good for the instance from the admin’s perspective. Using pure Jira means working on a single issue type, too. We won’t tell test cases from test plans and executions at a glance.
Creating a new Jira issue type for testing. Source: TestLodge
If we already use certain apps for Jira, we can try out our Issue Templates or Dynamic Forms apps as a workaround to optimize test case management. Even without custom issue types, Issue Templates for Jira can enable creating reusable test suites. After generating a test plan template and saving it as a User Story with test cases listed as Sub-tasks, we’ll be able to execute them in every other project in Jira. On the other hand, Dynamic Forms for Jira’s feature called Bundled Fields lets us create a transparent table for test steps, which makes the test case view clear and easy to understand.
The fourth option is installing a dedicated testing app from the Atlassian Marketplace. As we know, there are quite a lot of them available on the market, and each one has its pros and cons. The Requirements and Test Management for Jira (RTM) by Deviniti stands out yet at the beginning, as it enables plug-and-play configuration. Not without the cause, it’s known as the most intuitive test management tool. Its friendly UI provides users with a well-known environment to work in, and most importantly, supports bringing the whole software project into one place so that requirements, features, test cases, and defects could be transparently managed altogether.
Atlassian’s Jira is a great tool for software project management (and more!). The modification capabilities of this solution are outstanding and allow implementing different processes. Still, Jira is not an all-in-one tool. Using Jira for testing is a smart move, because it will require much less time for the users to get accustomed to it, as we’re not introducing a new piece of software. The user interface and core functionalities are familiar to users, so there’s no need for extra training for the tool. Just configure the project, explain the process to the team, and we’re good to go.
Even though this is a quick and simple way of setting test management in place, in most cases it’s not going to be enough. Jira doesn’t include dedicated functionalities for creating effective test cases, tracking their execution, or generating dedicated reports. Many test management features need to be implemented as a workaround and that can be quite inconvenient when we’re using Jira for testing on daily basis.
Here’s how QA teams can benefit from using Jira features for managing tests but not all of them are ready to use out of the box
Good practices in test case documentation
1. Track requirements-test cases-test plans relations
Avoid executing each stage of our process in a separate tool. Many teams make a mistake of excluding their requirements from the rest of the software development. It’s a risky move, as it can cause chaos and makes it practically impossible to fully track the relations between the objects. Only this way we can always make sure if all of the initial expectations are executed, though. If we keep this in mind, we can be sure that not only our customers, business analysts, and testers will appreciate it. The developers’ work will also become much easier, as the total number of omissions and ‘human errors’ will significantly decrease. This means less coding and going back and forth all the time.
It’s just another reason why we recommend using testing apps for Jira so much. They fully support verifying relations, not only these between the requirements and test cases, but also between the test cases and test plans, executions, and defects. RTM for Jira offers two dedicated reports: the Requirement Coverage report and the Traceability Matrix, which help us make sure that all our requirements are covered with related test cases, test cases included in test plans as well as executions, and quickly check which defects result from which actions.
2. Prepare a functional structure
Most people are visualizers. They understand and remember well-illustrated things much better. Structuring tasks also helps organize the workflow and aids an order in successive steps. This is why in RTM for Jira we created a transparent tree structure for all testing objects, including test cases. Thanks to this feature, we can group our test cases per category, assignee, feature, environment, and practically by any parameter that comes to our head. This will make every part of the process clear and easy to divide among the team members.
Another tool that perfectly supports test management is TestFLO – Test Management for Jira. Integrated with Jira, it allows us to create comprehensive test plans. In addition, thanks to TestFLO, we can generate extensive reports on the entire test process.
3. Describe test cases attentively
When describing test cases and test steps, it’s crucial to always have in mind that the better we explain them at the beginning, the more time we save. The time economization usually means also savings in the budget, so this case is really important for the whole company. Attentively explained actions reduce the number of questions, appointments, and e-mails from the others involved in the process. There are some useful tips we should take into consideration if we want to write good test cases for our team:
- always identify the purpose of the feature-to-be,
- define all activities which need to be executed in each test step,
- make our test cases short, and to-the-point,
- indicate the frameworks of our test cases,
- become familiar with the internal software modules.
4. Stay up to date with the progress
Always remember to check the overall progress of your testing and verify the statuses of test case executions every once in a while. This way we will know the probable time left to complete testing and we’re able to observe which test cases take more time than others, or which assignees are the most efficient in their jobs. The conclusions will help us improve our workflow organization later on, and be more conscious in the meetings whilst planning the process. When it comes to meetings, RTM for Jira supports easy on the eye reporting, which is understandable for all the stakeholders, so we don’t have to worry about the uncomfortable questions anymore. Thanks to the real-time reports, we can be prepared any minute.
As we said earlier, every software development project requires a well-developed test management process, and every test management process requires the right tools. Sure, we can start with simple and informal spreadsheets as our testing command center. But as our software grows, we will need a more mature process as well as more advanced tools to build it. There are so many great solutions designed for test management that decisions on which one to acquire for our process can become challenging. Even if it may look a bit complicated in the beginning, testing in Jira is definitely a good idea, so it’s worth considering this solution.
If we have our test cases included in the rest of the software development process, it speeds up our testing and increases the chances of releasing a complete, bug-free product. Not only the whole team can work together with one tool, but also, we get maximum traceability of relations between the initial requirements, test cases, and test plans. A great solution is bringing our software development along with tests to the place where we manage our project, divide tasks, and describe issues: Jira Software. Nevertheless, the standalone Jira is usually not enough. This is why we recommend extending it with a dedicated app for test case management, which will open the world of new testing possibilities. If additionally, we’ll keep in mind some universal rules which concern creating good test cases as such, we’ll benefit from all the advantages of a really high-level testing approach.
Modern test management is a critical process for developing software products, and keeping all testing activities organized requires a well-suited and robust tool. When choosing a testing solution, be prepared that there is a wide range of tools on the market. If we are using Jira for project tracking, we should definitely consider extending it with a test management app from the Atlassian Marketplace. It is a great way to get the testing process running while keeping all essential information in one place.
Our apps, TestFLO or Requirements and Test Management for Jira, support executing the whole testing process right inside Atlassian suite. Choose the one compatible with your hosting option and take a free 30-day trial from the Atlassian Marketplace. You can also book a live demo via Calendly to see the app in action.
We also invite you to read more on bringing the test management process inside Jira on Deviniti blog: