We are BDQ, a Zephyr Expert Partner and an Atlassian Solution Partner based in London. Our core focus is on the Atlassian technology stack and the Zephyr agile test management products, and how these can deliver value to our customers through digital transformation. Among our services, we provide consultancy, training and workshops on implementing Zephyr for Jira, empowering teams to effectively test in agile scrum.
The Agile Methodology has become the cornerstone of any digital transformation within software-oriented organizations. While Agile has a clear set of principles, the implementation varies depending on which phase of the software lifecycle you are focusing on. Zephyr for Jira is the most trusted test management Jira add-on that provides a clear way to introduce any Agile practices into your testing processes. In this article, we introduce using Agile methodology in your testing with Zephyr for Jira.
Defining Agile and Scrum
Firstly, we will just recap what Agile and Scrum are. This is going to be a very brief summary, as these subjects are worthy of their own articles.
"Agile" is a term that comes from the Agile Manifesto - a famous document that outlined principles for improving the process of software development, which had mainly been done using waterfall principles. Some of the principles are:
- Individuals and interactions over processes and tools
- Working software over comprehensive docs
- Customer collaboration over contract negotiation
- Responding to change over following a plan
Anyone who has worked on a waterfall project, following requirements that had been developed months or years previously, which seem to make less sense as time moves on, will appreciate the benefits of these principles. We prefer to use these concepts ourselves when delivering projects with our customers, because projects become more collaborative and responsive to change.
Agile and Scrum Processes
"Scrum" is really a framework which suggests roles and processes to implement the principles from the Agile manifesto, with concepts such as Scrum Master, Sprints, Daily Stand-ups - terms you may be familiar with. Some key concepts which we will refer to later are:
- User Stories - requirements to be implemented. This is generally a description of a software feature from an end-user perspective.
- Backlog - a prioritised list of stories and other work. This list may change during the lifecycle of the project.
- Sprints - generally two-week periods, during which the team will work on, and hopefully finish, a selection of Stories from the backlog.
In other words, teams work in focused periods on small sets of prioritised requirements, with the objective of finishing these during each sprint, and demonstrating the result at the end. This is the implementation of the Agile concept of "working software over comprehensive documents".
Adopting Agile Test Management
However - where does testing fit in? We have seen more than one situation where a company has moved from Waterfall to Agile and jettisoned the concept of structured testing along the way, with the assumption that QA will somehow happen during implementation.
At a minimum, the advantage of having explicit test cases associated with requirements means that some thought has to go into the edge cases of the implementation of the user stories, and if the test team is separate from the developers, it can bring clarity to what exactly is being developed and tested.
Zephyr for Jira is a fully integrated plugin for Jira and is designed to work in a way that is compatible with Jira. So, if you have bought into Jira, Zephyr will fit in just fine. With that in mind, we will just touch on the features that Jira Software has to support Scrum development.
How Zephyr for Jira Enables Testing in Agile Scrum
For a given project, you will usually have a Project within Jira, which will contain all the work and tasks required. Jira Software has Scrum boards which have Backlog views, and Sprint views. Jira also contains the concept of Releases (also known as Fix Versions), which are used in Zephyr. So - we have:
- A Project full of work items in various states
- A prioritised list of all the features we might implement - the Backlog
- A board which shows the work in progress right now - the Sprint.
- Releases - this indicates that a set of stories are all related to a particular Release, which is a logical grouping.
As the project continues, more sprints are executed, each one taking stories from the backlog and turning them into software. This software is then released from time to time (how and when depends on the organisation).
When to start testing in Agile scrum sprints:
- At the end of a Sprint. "Does the software built in this Sprint function as expected?"
- Before software is Released. "Does this release function as expected?"
- Other candidate areas for testing which depend on the organisation and context: UAT testing, smoke testing, and regression testing, as required.
There are features within Zephyr which can help us with these tasks. we'll cover these now:
- Tests: the description of a Test Case, with steps, outcomes etc. A Test is a Jira Issue Types, and can be organised accordingly, e.g. by component, version, label etc. Typically, we keep the Tests for a project within the same Jira Project as the stories that they relate to.
- Test Cycles: this lists a set of Test Cases that will be executed. For example, a smoke test may refer to a couple of Test Cases, whereas a pre-release test may refer to many Test Cases. A Test Case can be used in many different Test Cycles. If you are used to using spreadsheets for testing, a good analogy is that your Test Cases will be in your master list of tests, and the Test Cycles are copies of these spreadsheets that are made and given to testers to fill out when actually executing the tests.
Zephyr for Jira is deeply integrated. Some key points are:
- Releases: Zephyr for Jira is aware of Jira Releases, and using these can really give your reporting a lift. Test Cycles can relate to particular Releases - so it is possible to identify what has been tested for a particular software release, and what the results were.
- Traceability: Using issue links to connect Stories and Tests together enables the use of Zephyr's traceability report. It is possible to see what Stories have Tests associated with them, and the results of any test executions.
- Sprint Board integration: We can link a Cycle of Tests into a Sprint Board, so it is easy to see all the tests that we expect to be executed for a given Sprint.
We've now covered potential places where software can be tested in an Agile lifecycle, some key integration points between Jira Software and Zephyr for Jira, and some important features of Zephyr which make test management possible, so let's cover a couple of scenarios of how you can use Zephyr to manage testing in an Agile context. For other scenarios, create Test Cycles and add in the tests that you need.
Testing at the end of sprints
Each Sprint should produce working software based on the Stories that have been worked on - this is a good time to test the software, to check that it really has been "finished". To achieve this:
- For each Story, create some relevant Test(s). Link them together, so we can use the Traceability reports.
- Create a Test Cycle for this Sprint. Add your Tests that should be executed - typically these are for the stories being completed.
- Link the Test Cycle into your Sprint Board, so that the tests are available at a glance.
- Ideally, use Releases with your Stories and Test Cycles - in your reporting you can then slice and dice test results more easily.
- Execute the Tests at the end of the Sprint, or after Stories have been completed, depending on your confidence level regarding regressions.
If software has been produced and demonstrated, but doesn't pass testing, then maybe this story must return the backlog and be worked on for the next sprint, and its associated tests moved in the next sprint test cycle!
Testing before Release
When we are ready to release, it is a good idea to run a set of tests to ensure that the release is ready to go out of the door. The scope of this will depend very much on context, and the confidence level around the introduction of regressions. A very clean and well understood codebase vs a fragile, legacy codebase with a lot of dependencies will have different testing requirements.
- Create a Release Test Cycle - link it to the Release in Jira, so we can clearly understand what tests have been executed against this release.
- Choose a set of tests that make sense for this Release and add them to this Test Cycle. Whether this needs to be a full regression test vs all tests executed since the previous release vs a set of smoke tests depends on your situation, and is a balance between efficiency, confidence and system criticality.
- Execute the tests before release. If it all goes well, you will have a Release Test Cycle, which will be a record of all Test executions for this release! If there any problems, raise bugs if necessary, clone the Cycle (or a subset) and retest. Continue until everything is passed!
We hope that this gives you some ideas, and an overview of how you can use Zephyr for Jira to test software during Agile development in Jira Software.
If you have any questions or are interested in learning more about our services, please get in contact at firstname.lastname@example.org