UAT Test Case Generator

Overview

The UAT Test Case Generator skill provides specialized capabilities for generating User Acceptance Testing test cases from requirements and acceptance criteria. This skill enables systematic test case development, test data specification, traceability maintenance, and export to test management tools.

Capabilities

Acceptance Criteria to Test Case Conversion

• Convert acceptance criteria to test cases
• Parse Given-When-Then format into test steps
• Handle complex acceptance criteria with multiple scenarios
• Generate positive and negative test cases

Test Scenario Generation

• Generate test scenarios with expected results
• Create end-to-end user journey tests
• Develop boundary condition tests
• Build error handling scenarios

Test Data Requirements

• Create test data requirements specifications
• Define data setup and teardown procedures
• Identify data dependencies between tests
• Generate sample test data sets

Requirements Traceability

• Map test cases to requirements
• Maintain bidirectional traceability
• Calculate requirements coverage by test
• Identify untested requirements

Defect Logging Templates

• Generate defect logging templates
• Define severity and priority classifications
• Create reproduction steps formats
• Establish expected vs actual result documentation

Test Coverage Metrics

• Calculate test coverage metrics
• Measure requirements coverage percentage
• Track test execution coverage
• Report coverage gaps

Test Management Tool Export

• Export to Excel/CSV formats
• Generate Jira Xray import format
• Create Azure Test Plans format
• Support TestRail import

Usage

Generate Test Cases

Generate UAT test cases from these acceptance criteria:
[Acceptance criteria in Given-When-Then format]

Include positive and negative scenarios.

Create Test Scenarios

Create end-to-end test scenarios for:
[User story or feature description]

Generate complete user journey tests.

Define Test Data

Define test data requirements for these test cases:
[Test case list]

Include data setup, dependencies, and sample values.

Calculate Coverage

Calculate test coverage for:
Requirements: [Requirements list]
Test Cases: [Test case list]

Identify coverage gaps and missing tests.

Process Integration

This skill integrates with the following business analysis processes:

• uat-planning.js - Core UAT planning activities
• user-story-development.js - Story to test conversion
• requirements-traceability.js - Test traceability

Dependencies

• Test templates and formats
• Traceability data structures
• Test management export formats
• Coverage calculation algorithms

UAT Test Case Reference

Test Case Template

Test Case ID: TC-XXX
Title: [Descriptive test title]
Requirement ID: REQ-XXX
Priority: High/Medium/Low

Preconditions:
- [Precondition 1]
- [Precondition 2]

Test Steps:
| Step | Action | Expected Result |
|------|--------|-----------------|
| 1    | [Action] | [Expected] |
| 2    | [Action] | [Expected] |

Test Data:
- [Data item 1]: [Value]
- [Data item 2]: [Value]

Postconditions:
- [State after test]

Given-When-Then to Test Case Mapping

Test Case Types for UAT

Defect Report Template

Defect ID: DEF-XXX
Title: [Brief description]
Test Case: TC-XXX
Requirement: REQ-XXX

Severity: Critical/High/Medium/Low
Priority: P1/P2/P3/P4

Environment:
- Browser/Device: [Details]
- Environment: UAT/QA/Staging

Steps to Reproduce:
1. [Step 1]
2. [Step 2]
3. [Step 3]

Expected Result:
[What should happen]

Actual Result:
[What actually happened]

Attachments:
- [Screenshots, logs, etc.]

Coverage Metrics

Test Prioritization Criteria