Book Image

Hands-On Test Management with Jira

By : Afsana Atar
Book Image

Hands-On Test Management with Jira

By: Afsana Atar

Overview of this book

Hands-On Test Management with Jira begins by introducing you to the basic concepts of Jira and takes you through real-world software testing processes followed by various organizations. As you progress through the chapters, the book explores and compares the three most popular Jira plugins—Zephyr, Test Management, and synapseRT. With this book, you’ll gain a practical understanding of test management processes using Jira. You’ll learn how to create and manage projects, create Jira tickets to manage customer requirements, and track Jira tickets. You’ll also understand how to develop test plans, test cases, and test suites, and create defects and requirement traceability matrices, as well as generating reports in Jira. Toward the end, you’ll understand how Jira can help the SQA teams to use the DevOps pipeline for automating execution and managing test cases. You’ll get to grips with configuring Jira with Jenkins to execute automated test cases in Selenium. By the end of this book, you’ll have gained a clear understanding of how to model and implement test management processes using Jira.
Table of Contents (19 chapters)
Title Page
Copyright and Credits
About Packt

Software Development Life Cycle versus Software Testing Life Cycle

The Software Development Life Cycle (SDLC) is a process to develop and deliver software products or services that details the end-to-end phase, from designing, coding, and testing, to maintaining the product after release. The Software Testing Life Cycle (STLC) is a subset of the SDLC. Let's explore both the SDLC and STLC in detail.


The SDLC is a planned and organized process that divides software development tasks into various phases. These phases help the team to build a product that adheres to the factors of scope, time, cost, and quality. It also helps the project manager to monitor and control project activities at each stage and perform risk analysis effectively.

Any traditional SDLC comprises the following basic, but critical, phases:

  • Requirement analysis: A software product exists to solve a problem for the customer. Understanding customer needs is hence essential to building one. Requirement analysis is the phase where this is achieved. This is the stage where we try to answer the question, what do we want to build and why?
    • We create formal documentation (for example, a Business Requirement Document (BRD)) with customer needs, wants, and wish lists.
    • We also identify the objectives, goals, risks, resources, and the technology being used, as well as its limitations.
    • We need to specify what is within and what is out of scope for the selected iteration or version of the software that has been committed to for the customer. Usually, a team of client managers, business analysts, and project managers work together to prepare the final version of the business requirement document. Once it's ready and approved, the team moves on to the designing phase.
  • Designing: Designing is done based on the requirement documents.
    • In this phase, the team prepares high-level and low-level design documents, to further narrow down the broad requirements
    • These documents help to establish a logical relationship between different components of the application, and define its architecture in detail, including a format, look and feel, and a UI mockup
    • Once everything is ready, it moves on to the team of developers to start with actual coding
  • Coding: The end of the designing phase kicks off the start of the coding phase, where developers start to build actual applications.
    • In this phase, developers convert every component, the logical relationships between them, and build the architecture as mentioned in the high-level and low-level documents. The main goal here is to generate an actual workable software product or service, as designed in the mockup.
    • Developers make sure to meet the customer requirements mentioned in the requirement documents.
    • Developers also perform unit testing, a method for testing  functions to get the desired results by passing different input parameters.
    • Once the code looks good and it's ready for the testers to verify, the developers deploy it in the test environment and make it available for the testers to start testing.
  • Testing: This is where testers verify the application to confirm that it meets customer requirements. The main goal is to determine whether the solution works for customer needs without any issues or defects.
    • As a part of the testing process, testers verify critical paths, verify all the necessary workflows, and perform happy path testing. However, they also try to break the application by passing invalid parameters in the form of negative testing.
    • Using different testing types, they confirm whether the product or service is acceptable to the user, and think from the end user's perspective when validating every single text field, checkbox, links, and buttons—in short, every single UI component of the application.
    • Testing the application under stress to see how it reacts under extreme conditions and how it performs by adding load to it are parts of performance testing. Once the software is thoroughly tested and confirmed, with the number of known defects, which are either in closed or deferred status, it's shipped to the end users.
  • Maintenance: This is where errors get reported or suggestions and/or enhancements get added by end users after realizing the product or service are implemented, as a part of the maintenance phase. It can also be a part of releasing or upgrading the current version of the software or service.
    • A dedicated team works on this phase, where team members interact with their clients or end users to get feedback, issues, or errors
    • They also provide documents to help customers learn how to use a software product or service, efficiently


The STLC is part of the SDLC. It's a systematic approach that ensures the quality of a software product or services. Like the SDLC, the STLC also consists of different phases, listed as follows:

  • Requirement analysis: Once the project gets initiated, the team actively starts working on gathering customer requirements. In this phase, testers, business analysts, and developers take a closer look at each specification requested by users. For requirement analysis in STLC, testers can do the following things:
    • Testers need to break drown broader and more complex requirements into smaller pieces to understand the testable requirements, the scope of the testing, and verification key points, and to identify the gaps in the requirements
    • They can clarify their doubts regarding technology or software requirements, limitations and dependencies, and so on with the developers and business analysts, and improve suggestions or highlight missing information that needs to be added into the requirements
    • Testers can also highlight risks and develop risk-mitigation strategies before proceeding to the test-planning phase
  • Test planning: This is where testers (usually lead testers or managers) plan testing activities and milestones based on various factors, such as time, scope, and resources that help them to track the progress of the project. Let's check out some activities that the tester performs during test planning:
    • In this phase, testers plan test activities and strategies that can be used effectively during the subsequent testing phases
    • Also, the scope of testing needs to be identified and parts out of scope should be marked as well
    • They also need to decide on the testing techniques and types that will be implemented during the test-execution phase based on the current product requirements
    • Along with that, an understanding of the tool's requirements and the number of resources required with their skill level can help them plan tasks better

Considering these factors and the timelines for the selected project, a tester can prepare an effective test plan that will fit into the project budget and help the team to create a quality product. 

  • Test designing: This is where the test team starts to break down each requirement and converts them into test scenarios. These test scenarios cover happy path, positive testing, the critical path that needs to be verified, and functions that need to be verified with a different set of parameters. It also consists of negatives scenarios, acceptance tests, and scenarios based on user-interaction workflows and data flows.
    • Based on the type of application and the types of testing listed in the requirement analysis, phase testers can work on creating automated test scripts, adding scenarios for stress and load testing, and performance testing can help testers to test the application better and find more defects.
    • Once the scenarios are ready and reviewed, testers move on to preparing the test cases or test scripts (in the case of automation testing) in order to list the detailed steps.
    • One scenario can have one or more test cases, whereas a requirement can be linked to one or more scenarios. This mapping is helpful when creating a Requirement Traceability Matrix (RTM).
  • Environment setup: Establishing a separate test environment is always good practice. Keeping testing code distinct from development code can help both testers and developers debug the code in the specific version and get to the root cause more quickly. Also, it gives developers a chance to make bug fixes in the code and in their copy of the code, and to verify it in their environment to confirm that the fix is working before sending it to the testers. It saves the time and effort needed to log defects and collect artifacts.
    • When setting up the environment, testers need to ensure that they have configured the required version of the tool, the software, the hardware, and the test data.
    • They also need to make sure that they have authorization to access the environment with the required roles to test the application, databases, and other tools required. The testing environment should mimic the end user's environment. This results in documenting the known behavior of the product and helps to manage expectations after delivery.
  • Test execution: Once the code is ready and unit tested by the developers, it's deployed in the test environment so that testers can initiate the test-execution phase.
    • The first test that testers perform is a smoke test to validate whether the software product or service caters to the basic requirements
    • After the software passes the smoke test, testers can continue with the validation process, following the types of testing as planned during the test-planning phase
    • During the execution phase, testers log an undesirable result as a defect. Once the defects have been fixed, testers need to retest the parts that have been changed and the part of the application that has not been changed, as part of regression testing
  • Test reporting: It is very important for testers, leads, and managers to track and monitor the progress of the project consistently so that it becomes easy to identify obstacles or risks early. It also helps being agile to provide the solution and resolve the problem.
    • Reporting the test helps the stakeholders to know the status of the test execution after each iteration or test cycle.
    • It also helps defect managers to identify the blocked test case that is dependent on the defect.
    • Accordingly, its priority or severity can be changed so that it can help to progress test execution.
    • At the end of all iterations, a final report is prepared with the number of defects found during the test execution phase, the number of defects closed or marked as deferred, and the number of test cases passed or marked N/A. Along with this report, all the artifacts are validated and made sure that it's been added whenever it's needed. 
  • Closure: During the closure phase, test managers or test leads make sure that all the tests completed successfully, as per the schedule.
    • Team leads or managers make sure that all the required deliverables and closure documents are approved and accepted as per the evaluation criteria, and signed off as part of the closure phase

We will be learning more about each phase in the STLC, along with its practical implementation in Jira and using its plugin, in the following chapters.