Skip to main content

Test Execution

This section of the user guide explains how to manage and execute tests within the platform, including creating and configuring test runs, running and recording test results, and managing defects discovered during testing. The features described here help teams organize their testing process, track progress, and ensure issues are properly logged and followed up, including integration with external systems like Jira.

Test Runs​

Test runs are collections of test cases that are grouped together to be executed in a coordinated session. You can create and configure test runs from scratch or base them on a predefined test plan.

Creating a Test Run​

  • To create a new test run, navigate to the relevant project and open the "Test Runs" section.
  • Click the button to create a new test run. You will be prompted to enter details such as the run's name, description, status (e.g., draft, active), type, associated milestone, and due date.
  • You can also create a test run directly from a test plan. This allows you to quickly set up a run with all the test cases defined in that plan.
  • After creating the test run, you can add or remove test cases as needed. The platform allows you to select from available test cases and include them in the run.
  • You can edit the test run's details at any time by opening the run and switching to edit mode.

Configuring a Test Run​

  • You can update the run's metadata (name, description, status, type, milestone, due date) at any time.
  • Test cases can be added or removed from the run before or during execution. Use the "Add Cases" dialog to select additional cases, or remove cases as needed.
  • The order of test cases in the run can be adjusted to match your preferred execution sequence.

Executing Tests​

Executing tests involves running each test case in the run and recording the outcome. The platform provides a dedicated dashboard for each test run, showing progress and allowing you to manage the flow of execution.

Running Tests​

  • To start executing a test run, open the run's details page.
  • Click the "Start Run" button. This will begin the session and typically navigate you to the first test case to be executed.
  • For each test case, you can view its details, steps, and expected results.
  • Mark the outcome of the test case by selecting the appropriate status: Passed, Failed, Blocked, Skipped, or Partial.
  • If needed, you can provide additional comments or attach evidence (such as screenshots or logs) to the test execution result.
  • After marking a test case, the system will guide you to the next one in the run.
  • The dashboard provides an overview of the run's progress, including the number of tests passed, failed, pending, and the overall pass rate.

Recording Results​

  • When marking a test case, you can add notes or comments to provide context for the result.
  • If a test fails, is blocked, or is only partially successful, you can immediately log a defect (see below).
  • All test execution results are saved and can be reviewed later for reporting and analysis.

Managing the Execution Flow​

  • You can sort and filter the list of test cases in a run by various criteria, such as status, priority, or name.
  • Failed or blocked tests can be retried as needed. The platform allows you to re-execute selected cases and update their results.
  • You can stop the test run at any time, which will finalize the session and lock in the results for reporting.

Managing Defects​

Comprehensive defect management with support for external issue tracking systems and complete lifecycle tracking.

Defect Integration Options​

Testworthy integrates directly with external issue tracking systems for seamless defect management:

  • Jira Integration: Connect to Jira Cloud via API token authentication. Create issues directly from failed tests, fetch live issue status by key, and link test cases to Jira issues. Supports project-level default configuration with optional per-user credential overrides.
  • GitHub Issues: Link defects to GitHub repository issues by external issue ID
  • Bugzilla: Link defects to Bugzilla issues by external issue ID
  • Internal Tracking: Use Testworthy's built-in defect management for simple workflows

Defect records store the external system type (Jira, GitHub, or Bugzilla), the external issue ID (e.g., "PROJ-123"), status, comments, and assignee information.

Logging Defects​

When test execution reveals issues, you can quickly log defects with full traceability and external system integration.

Tracking and Viewing Defects​

  • Each test case has a "Defects" tab or section where you can view all defects associated with it.
  • You can see the status of each defect, comments, and any updates made during the defect's lifecycle.
  • The platform provides filtering and search capabilities to help you find and review defects efficiently.

Linking to External Systems​

  • When logging a defect, select the external system type (Jira, GitHub, or Bugzilla) and enter the corresponding issue ID
  • For Jira: if the project has a Jira configuration, you can create a new Jira issue directly or link to an existing one by key
  • The platform fetches live issue details (status, assignee, summary) from Jira when viewing linked defects
  • You can view all Jira-linked defects across a project with their current statuses in a single overview
  • Defects can be linked to code changes, providing comprehensive traceability from test execution to development

Updating and Resolving Defects​

  • Defects can be updated as their status changes (e.g., from Open to In Progress to Resolved).
  • Comments and attachments can be added to document investigation steps, fixes, or additional findings.
  • Once a defect is resolved, you can update its status and, if appropriate, re-execute the associated test case to verify the fix.

Summary​

The platform provides a comprehensive workflow for managing test execution, from organizing test runs and executing test cases to recording results and managing defects. The system is designed to be flexible, supporting both manual and automated workflows, and integrates with external tools to streamline defect tracking and resolution. By following these processes, teams can ensure thorough test coverage, accurate reporting, and effective issue management throughout the software development lifecycle.