Jira and Zephyr Scale - Notes By ShariqSP

Agile Testing Process Overview

Agile testing follows iterative development cycles, known as sprints, where testers work closely with developers and stakeholders to validate each feature as it’s developed. Agile prioritizes continuous feedback, collaborative development, and incremental delivery, ensuring that the product is ready to deploy at any point.

Roles and Responsibilities in Agile

  • Product Owner (PO): Creates and manages the backlog, prioritizing items based on business needs and customer feedback.
  • Scrum Master: Facilitates the process, removes roadblocks, and ensures the team follows Agile practices.
  • Development Team: Builds the product, working in small increments based on user stories in each sprint.
  • Test Engineers: Responsible for writing, executing, and automating test cases, and reporting bugs in JIRA.

Agile Testing Workflow in JIRA and Zephyr Scale

  1. Backlog Creation: The Product Owner gathers requirements and creates user stories or tasks. Test Engineers review and clarify acceptance criteria to ensure testable requirements.
  2. Sprint Planning: The team meets to discuss the scope of the sprint, breaking down each user story and estimating the effort required.
  3. Development and Testing: Developers start building features while Test Engineers create and execute test cases in parallel. Zephyr Scale is used for managing test cases, linking them to user stories in JIRA.
  4. Bug Reporting: When tests fail, Test Engineers log bugs in JIRA with details like steps to reproduce, expected vs. actual results, and severity. The bug is assigned to a developer, and upon resolution, Test Engineers retest it.
  5. Daily Standups: The team meets daily to discuss progress, blockers, and next steps. The Scrum Master ensures the team stays on track.
  6. Sprint Review and Retrospective: After each sprint, the team reviews completed work with stakeholders and discusses areas for improvement.

Writing Test Plans, Test Cases, and Executing Tests

  • Test Plan: A document that outlines the scope, approach, resources, and schedule for testing activities. It covers objectives, test criteria, risk assessments, and deliverables.
  • Test Cases: Detailed steps to validate a particular feature, including inputs, actions, and expected outcomes. Test cases are written in Zephyr Scale and linked to user stories in JIRA.
  • Test Execution: Test Engineers execute test cases during each sprint, marking them as "Pass" or "Fail." If a test fails, they raise a bug in JIRA and assign it to a developer.

Raising and Managing Bugs in JIRA

  1. Open the user story or task in JIRA.
  2. Click on “Create” and select "Bug" as the issue type.
  3. Describe the bug, providing steps to reproduce, expected and actual results, severity, and priority.
  4. Assign the bug to the developer responsible, and set the status as "Open." The developer will resolve the bug and move it to “Ready for Retest.”
  5. Test Engineers retest the bug and close it if fixed, or reopen if it still fails.

End-to-End Agile Project Workflow

This includes an example workflow from project initiation to release:

  • Project Creation: Product Owner defines objectives, Scrum Master organizes Agile structure, and the team reviews requirements.
  • Backlog Creation: The Product Owner adds high-priority Epics and Stories, and team members add requirements as needed.
  • Sprint Planning and Development: The team plans sprints, divides tasks, and begins development and testing. Developers work on tasks while Test Engineers write and execute test cases in Zephyr Scale.
  • Bug Fixing and Retesting: Developers fix bugs raised by Test Engineers, who then retest and close the bugs if resolved.
  • Sprint Review and Retrospective: Stakeholders review completed features, and the team discusses improvements in the retrospective.
  • Release Planning: The code is merged into production with a final smoke test by Test Engineers, and stakeholders approve the release.
  • Post-Release Support: Any issues in production are logged, prioritized, and fixed in subsequent sprints.

Adding User Stories to an Epic in JIRA

  1. Create an Epic: In JIRA, create an Epic with a name, summary, and detailed description. This Epic represents a larger feature or goal.
  2. Create a User Story and Link It to the Epic: Add a new User Story, filling out its details, and link it to the Epic in the "Epic Link" field.
  3. Alternative Method (Directly from the Epic View): Go to the Epic and select "Create Child Issue" to add new User Stories directly.
  4. Organize User Stories: View all User Stories under the Epic in the backlog, where they’ll appear as child items for easy tracking.

Detailed Guide: Creating a Sprint, Epic, User Stories, and Test Cases for HRM Software

Scenario Overview: HRM Software Project

In this project, the objective is to develop an HRM software that includes features like Employee Onboarding, Leave Management, and Payroll Processing. Each feature is treated as an Epic, and specific tasks (user stories) within these features will define what needs to be developed and tested.

Step 1: Creating a Sprint in JIRA

  1. Navigate to the Backlog section in JIRA.
  2. Click on Create Sprint. This will set up a new sprint in the project’s backlog.
  3. Assign a name to the sprint (e.g., "Sprint 1: Employee Onboarding").
  4. Set a Start Date and End Date for the sprint, typically lasting 2-4 weeks depending on the team’s schedule.
  5. Add the tasks, user stories, and bugs planned for this sprint.
  6. Click on Start Sprint to begin the sprint when the team is ready.

Step 2: Creating an Epic in JIRA

  1. Go to Backlog and find the Epics panel (usually on the left sidebar).
  2. Click on Create Epic.
  3. Enter details:
    • Epic Name: Employee Onboarding
    • Summary: Development of the Employee Onboarding module for HRM software.
    • Description: This Epic includes user stories for adding new employees, assigning roles, and setting up initial HR information.
  4. Click on Create to add the Epic.

Step 3: Creating and Writing User Stories

User stories describe individual pieces of functionality. For instance, in the Employee Onboarding Epic, you might have the following user stories:

  • As an HR manager, I want to add a new employee to the system so that they can be tracked in the HRM system.
  • As an HR manager, I want to assign a department to each employee for proper team organization.

Steps to Create a User Story in JIRA

  1. Click Create to add a new issue.
  2. Select Story as the issue type.
  3. Fill in the following details:
    • Summary: Add a new employee to the system.
    • Description: The HR manager can enter employee details like name, role, and department.
    • Acceptance Criteria: HR can save and view employee details in the system.
  4. In the Epic Link field, select Employee Onboarding to associate the story with the Epic.
  5. Click Create to add the user story.

Step 4: Writing a Test Plan

The Test Plan defines the testing scope, objectives, schedule, criteria, and resources for testing the HRM software. For this scenario:

  • Objective: Validate that the Employee Onboarding module functions as expected.
  • Scope: All user stories in the Employee Onboarding Epic.
  • Resources: Test Engineer, Automation Engineer.
  • Test Environment: Staging environment with employee data set.
  • Schedule: Aligned with Sprint 1 timeline.

Step 5: Identifying and Writing Test Scenarios

For each user story, we identify high-level test scenarios. For example, for the "Add New Employee" user story:

  • Test Scenario 1: Verify that the HR manager can add a new employee with valid details.
  • Test Scenario 2: Verify that an error is shown if mandatory fields are left blank.
  • Test Scenario 3: Verify that the system saves employee details correctly and displays them in the employee list.

Step 6: Writing Test Cases in Zephyr Scale

Test cases provide step-by-step instructions to validate each scenario. In Zephyr Scale, test cases are managed within the JIRA environment. For each scenario, create a test case with these steps:

  1. Open Zephyr Scale in JIRA and navigate to the Test Cases section.
  2. Click Create Test Case.
  3. Enter the following details:
    • Test Case Name: Add New Employee with Valid Details
    • Description: Verify that an HR manager can add an employee with valid details.
    • Steps: List each action and the expected result for each step.
      • Step 1: Log in as HR manager – HR dashboard loads.
      • Step 2: Click "Add Employee" – Add Employee form opens.
      • Step 3: Fill in details and save – New employee appears in the employee list.
    • Expected Result: Employee details are saved, and the employee appears in the system.
  4. Link the test case to the user story by adding the Linked Issues or Story Link field.
  5. Save the test case.

Step 7: Executing Test Cases in Zephyr Scale

  1. In Zephyr Scale, go to the Test Execution section.
  2. Create a Test Cycle for this sprint (e.g., "Sprint 1: Employee Onboarding Tests").
  3. Add the test cases created in the previous step to this Test Cycle.
  4. Start executing each test case:
    • Mark each step as Pass or Fail.
    • If a step fails, log a defect in JIRA and link it to the test case.
    • Add comments for any issues or observations during testing.

Step 8: Raising and Managing Bugs in JIRA

  1. If a test case fails, open the user story or task in JIRA.
  2. Click on Create and select Bug as the issue type.
  3. Enter the bug details:
    • Summary: "Error saving employee details if phone number is missing."
    • Description: Steps to reproduce, expected vs. actual results.
    • Severity: Choose based on impact (e.g., Major or Critical).
  4. Assign the bug to a developer, and set the status as Open.
  5. Once resolved, retest the issue and mark it as Closed if fixed, or Reopen if still failing.

Step 9: Reviewing Test Results and Closing the Sprint

At the end of the sprint, the team reviews test results and progress on the sprint goals. Ensure that all user stories are completed, and all bugs are either resolved or documented for the next sprint.

End of Guide: By following these steps, teams can manage sprints, organize test cases, execute tests, and handle defects effectively, ensuring a successful Agile project outcome.

☰