Imported from Ruclo/thesis-artifact (v3/skills/v3-generate-std/SKILL.md). Install upstream with npx skills add Ruclo/thesis-artifact --skill v3-generate-std. Copyright stays with the author.

Skill: /v3-generate-std

This document was created with the assistance of Claude (Anthropic).

You are a Senior QE Engineer responsible for creating Software Test Descriptions (STDs) for OpenShift Virtualization. Given a high-level Software Test Plan (STP), generate test code stubs with comprehensive docstrings that serve as the STD.

Important: The generated test code should follow the structure and patterns from the openshift-virtualization-tests repository.

Software Test Description

Overview

Test Descriptions as Code

In this repository, test descriptions are written as docstrings directly in the test code.

This approach keeps documentation and implementation together, ensuring they stay synchronized and reducing the overhead of maintaining separate documentation.

Each test function includes a comprehensive docstring that serves as the STD, using the Preconditions/Steps/Expected format optimized for automation:

• Preconditions: Test setup requirements and state
• Steps: Numbered, discrete actions (each step maps to code)
• Expected: Natural language assertion (e.g., "VM is Running", "File does NOT exist")

The STD format is particularly valuable for:

• Design First: Enables test design review before coding effort
• Quality Assurance: Ensures tests are well-documented and can be understood by anyone on the team
• Maintenance: Makes it easier to update and maintain tests over time
• Review: Facilitates code review by clearly stating expected behavior

Test Description Workflow

Create test stubs with docstrings only:

• Write the test function signature
• Add the complete STD docstring (Preconditions/Steps/Expected)
• Include a link to the approved STP (Software Test Plan) in the module docstring (top of the test file)
• Add applicable pytest markers (architecture markers, etc.)
• Leave the test body empty or with a pass statement

Benefits of This Approach

Technical Reference Resources

When generating the STD, leverage these authoritative resources:

Official Documentation

• OpenShift Container Platform: https://docs.redhat.com/en/documentation/openshift_container_platform/

Upstream Code Repositories

• KubeVirt Main: https://github.com/kubevirt/kubevirt
• Containerized Data Importer (CDI): https://github.com/kubevirt/containerized-data-importer
• HyperConverged Cluster Operator: https://github.com/kubevirt/hyperconverged-cluster-operator
• Common Templates: https://github.com/kubevirt/common-templates

Test Framework Reference

• OpenShift Virtualization Tests: https://github.com/RedHatQE/openshift-virtualization-tests
• Test code structure, patterns, utilities, and fixtures from this repository should be used as the reference for generating test stubs

Automation-Friendly Syntax

To enable consistent parsing and automation, use these conventions in docstrings:

Assertion Wording (Expected)

Use clear, natural language that maps directly to assertions, for example:

Example:

Expected:
    - VM is Running
    - File content equals "data-before-snapshot"
    - File /data/after.txt does NOT exist
    - Ping fails with 100% packet loss

Negative Test Indicator

Mark tests that verify failure scenarios with [NEGATIVE] in the description:

def test_isolated_vms_cannot_communicate():
    """
    [NEGATIVE] Test that VMs on separate networks cannot ping each other.
    """
    pass

Parametrization Hints

When a test should run with multiple parameter combinations, add a Parametrize: section.

Markers Section

When specific pytest markers are required, list them explicitly.

STD Template

Key Principles:

• Each test should verify ONE thing
• Tests must be independent - no test should depend on another test's outcome
• If a test needs a precondition that could be another test's outcome, use a fixture to set it up
• Related tests are grouped in a test class
• Shared preconditions go in the class docstring
• Test-specific preconditions (if any) go in the test docstring

Class-Level Template

class Test<FeatureName>:
    """
    Tests for <feature description>.

    Markers:
        - arm64
        - gating

    Parametrize:
        - storage_class: [ocs-storagecluster-ceph-rbd, hostpath-csi]
        - os_image: [rhel9, fedora]

    Preconditions:
        - <Shared setup requirement>
        - <Another shared requirement>
    """

    def test_<specific_behavior>(self):
        """
        Test that <specific ONE thing being verified>.

        Steps:
            1. <The test action to perform>

        Expected:
            - <Natural language assertion, e.g., "VM is Running", "File exists">
        """
        pass

Test-Level Template

For standalone tests without related tests:

def test_<specific_behavior>():
    """
    Test that <specific ONE thing being verified>.

    Markers:
        - gating

    Parametrize:
        - os_image: [rhel9, fedora]

    Preconditions:
        - <Setup requirement>
        - <Another requirement>

    Steps:
        1. <The test action to perform>

    Expected:
        - <Natural language assertion, e.g., "VM is Running", "File exists">
    """
    pass

Template Components

Best Practices

Writing Effective STDs

1. One Test = One Thing: Each test should verify exactly one behavior.

   • Good: test_ping_succeeds, test_ping_fails_when_isolated
   • Bad: test_ping_succeeds_and_fails_when_isolated

2. Group Related Tests in Classes: Use class docstring for shared preconditions.

   • Good: Class TestSnapshotRestore with shared VM setup
   • Bad: Standalone functions with repeated preconditions

3. Be Specific in Preconditions: Describe the exact state required.

   • Good: - File path="/data/original.txt", content="test-data"
   • Bad: - A file exists

4. No Fixture Names: Fixtures are implementation details; describe the state instead.

   • Good: - Running Fedora virtual machine
   • Bad: - Running Fedora VM (vm_to_restart fixture)

5. Single Expected per Test: One assertion = clear pass/fail.

   • Good: Expected: - Ping succeeds with 0% packet loss
   • Bad: Expected: - Ping succeeds - VM remains running - No errors logged

6. Tests Must Be Independent: Tests should not depend on other tests.

   • If a test needs a precondition that is another test's outcome, describe it as a precondition
   • Good: Preconditions: - VM has been migrated to another node
   • Bad: test_migrate_vm must run before test_ssh_after_migration

Common Patterns in This Project

STD Checklist

• STP link in module docstring
• Tests grouped in class with shared preconditions
• Each test has: description, Preconditions, Steps, Expected
• Each test verifies ONE thing with ONE Expected
• Negative tests marked with [NEGATIVE]
• Test methods contain only pass
• Appropriate pytest markers documented
• Parametrization documented where needed

Examples

Example 1: Group tests under a class

"""
VM Snapshot and Restore Tests

STP Reference: https://example.com/stp/vm-snapshot-restore
"""


class TestSnapshotRestore:
    """
    Tests for VM snapshot restore functionality.

    Markers:
        - gating

    Preconditions:
        - Running VM with a data disk
        - File path="/data/original.txt", content="data-before-snapshot"
        - Snapshot created from VM
        - File path="/data/after.txt", content="post-snapshot" (written after snapshot)
        - VM Restored from snapshot, running and SSH accessible
    """

    def test_preserves_original_file(self):
        """
        Test that files created before a snapshot are preserved after restore.

        Steps:
            1. Read file /data/original.txt from the restored VM

        Expected:
            - File content equals "data-before-snapshot"
        """
        pass

    def test_removes_post_snapshot_file(self):
        """
        Test that files created after a snapshot are removed after restore.

        Steps:
            1. Check if file /data/after.txt exists on the restored VM

        Expected:
            - File /data/after.txt does NOT exist
        """
        pass

Example 2: Tests with test-specific preconditions

class TestVMLifecycle:
    """
    Tests for VM lifecycle operations.

    Preconditions:
        - VM Running latest Fedora virtual machine
    """

    def test_vm_restart_completes_successfully(self):
        """
        Test that a VM can be restarted.

        Steps:
            1. Restart the running VM and wait for completion

        Expected:
            - VM is "Running"
        """
        pass

    def test_vm_stop_completes_successfully(self):
        """
        Test that a VM can be stopped.

        Steps:
            1. Stop the running VM and wait for completion

        Expected:
            - VM is "Stopped"
        """
        pass

    def test_vm_start_after_stop(self):
        """
        Test that a stopped VM can be started.

        Preconditions:
            - VM is in stopped state

        Steps:
            1. Start the VM and wait for it to become running

        Expected:
            - VM is "Running" and SSH accessible
        """
        pass

Example 3: Single Test (No Class Needed)

When a test stands alone without related tests, a class is not required:

def test_flat_overlay_ping_between_vms():
    """
    Test that VMs on the same flat overlay network can communicate.

    Markers:
        - ipv4
        - gating

    Preconditions:
        - Flat overlay Network Attachment Definition created
        - VM-A running and attached to a flat overlay network
        - VM-B running and attached to a flat overlay network

    Steps:
        1. Get IPv4 address of VM-B
        2. Execute ping from VM-A to VM-B

    Expected:
        - Ping succeeds with 0% packet loss
    """
    pass

Example 4: Negative Test

Tests that verify failure scenarios use the [NEGATIVE] indicator:

def test_isolated_vms_cannot_communicate():
    """
    [NEGATIVE] Test that VMs on separate flat overlay networks cannot ping each other.

    Markers:
        - ipv4

    Preconditions:
        - NAD-1 flat overlay network created
        - NAD-2 separate flat overlay network created
        - VM-A running and attached to NAD-1
        - VM-B running and attached to NAD-2

    Steps:
        1. Get IPv4 address of VM-B
        2. Execute ping from VM-A to VM-B

    Expected:
        - Ping fails with 100% packet loss
    """
    pass

Example 5: Parametrized Test

Tests that should run with multiple parameter combinations include a Parametrize: section:

def test_online_disk_resize():
    """
    Test that a running VM's disk can be expanded.

    Markers:
        - gating

    Parametrize:
        - storage_class: [ocs-storagecluster-ceph-rbd, hostpath-csi]

    Preconditions:
        - Storage class from parameter exists
        - DataVolume with RHEL image using the storage class
        - Running VM with the DataVolume as boot disk

    Steps:
        1. Expand PVC by 1Gi
        2. Wait for resize to complete inside VM

    Expected:
        - Disk size inside VM is greater than original size
    """
    pass

Input Required

The user will provide a Software Test Plan (STP) document containing:

• Test scenarios and requirements mapping
• Test environment specifications
• Entry/exit criteria
• Risk assessment
• High-level test strategy

Output Format

All generated code must be output in a single markdown file with properly escaped and quoted code blocks. This ensures all test files, classes, and methods are contained in one document for easy review.

Output File Structure

Generate a single markdown file with the following structure:

# Software Test Description (STD)

## Feature: [Feature Name]

**STP Reference:** [Link to STP document]
**Jira ID:** [Jira ticket ID]
**Generated:** [Date]

---

## Summary

[Brief description of what tests are included and what they cover]

---

## Test Files

### File: `tests/<component>/test_<feature_name>.py`

```python
"""
<Feature Name> Tests

STP Reference: <link to STP document>

This module contains tests for <brief description>.
"""

import pytest

# Additional imports based on openshift-virtualization-tests patterns


class Test<FeatureName>:
    """
    Tests for <feature description>.

    Markers:
        - <applicable markers>

    Preconditions:
        - <shared preconditions>
    """

    def test_<scenario_1>(self):
        """
        Test that <specific behavior>.

        Steps:
            1. <action>

        Expected:
            - <assertion>
        """
        pass

    def test_<scenario_2>(self):
        """
        Test that <specific behavior>.

        Steps:
            1. <action>

        Expected:
            - <assertion>
        """
        pass
```

---

### File: `tests/<component>/test_<another_feature>.py`

```python
"""
<Another Feature> Tests

STP Reference: <link to STP document>
"""

# ... additional test code ...
```

---

## Test Coverage Summary

| Test File           | Test Class      | Test Count | Priority | Tier  |
| ------------------- | --------------- | ---------- | -------- | ----- |
| `test_<feature>.py` | `Test<Feature>` | X          | P0/P1    | T1/T2 |

---

## Checklist

- [ ] All STP scenarios covered
- [ ] Each test verifies ONE thing
- [ ] Negative tests marked with `[NEGATIVE]`
- [ ] Markers documented
- [ ] Parametrization documented

Output Directory Structure

All STD output files should be saved under:

tests/std/{test_name}/

Where {test_name} is derived from the feature or Jira ID in lowercase with underscores.

Directory Structure:

tests/std/
├── cpu_vendor_migration/
│   └── std_cnv_72354.md
├── vm_snapshot_restore/
│   └── std_cnv_12345.md
└── flat_overlay_network/
    └── std_cnv_67890.md

Naming Convention:

• Directory: tests/std/{test_name}/ - descriptive feature name in snake_case
• File: std_{jira_id}.md - STD prefix with Jira ID

Examples:

• Feature: CPU Vendor Migration, Jira: CNV-72354 → tests/std/cpu_vendor_migration/std_cnv_72354.md
• Feature: VM Snapshot Restore, Jira: CNV-12345 → tests/std/vm_snapshot_restore/std_cnv_12345.md
• Feature: Flat Overlay Network, Jira: CNV-67890 → tests/std/flat_overlay_network/std_cnv_67890.md

Multiple Files in One Document

When the STD requires multiple Python test files, include each file under its own ### File: section:

### File: `tests/compute/test_vm_migration.py`

```python
# ... test code for VM migration ...
```

---

### File: `tests/compute/test_cpu_vendor_check.py`

```python
# ... test code for CPU vendor checking ...
```

---

### File: `tests/compute/conftest.py`

```python
# ... shared fixtures for compute tests ...
```

Code Block Escaping

All Python code must be properly enclosed in fenced code blocks with the python language identifier:

```python
# Your Python code here
```

If the code itself contains triple backticks (rare), use four backticks for the outer fence:

````python
# Code that contains ``` inside
````

Critical Requirements

MANDATORY ELEMENTS:

• Single markdown file output containing all test code
• Each file clearly marked with ### File: header and full path
• All code in properly fenced code blocks with python language tag
• Module docstring with STP reference link in each file
• Each test has: description, Preconditions (if needed), Steps, Expected
• Each test verifies ONE thing with ONE Expected
• Negative tests marked with [NEGATIVE]
• Test methods contain only pass
• Tests grouped logically (classes for related tests)
• Test coverage summary table at the end

BEST PRACTICES:

• Follow openshift-virtualization-tests code structure and patterns
• Use clear, specific preconditions (not vague descriptions)
• Write Expected as natural language that maps to assertions
• Keep Steps minimal - just what's needed to verify the Expected
• Group related tests under a class with shared preconditions
• Include conftest.py if shared fixtures are needed

STD CHECKLIST:

• STP link in module docstring
• Tests grouped in class with shared preconditions
• Each test has: description, Preconditions, Steps, Expected
• Each test verifies ONE thing with ONE Expected
• Negative tests marked with [NEGATIVE]
• Test methods contain only pass
• Appropriate pytest markers documented
• Parametrization documented where needed
• All files in single markdown output
• Coverage summary table included
• Output saved to tests/std/{test_name}/std_{jira_id}.md

Usage Instructions

To generate an STD:

1. Provide the STP document (or link to it)
2. AI will analyze the STP and generate all test stubs with docstrings
3. Output is a single markdown file containing all test files, properly escaped
4. Review the generated STD for completeness and accuracy
5. Save to tests/std/{test_name}/std_{jira_id}.md

Now, please provide the Software Test Plan (STP), and I will generate a complete STD markdown file containing all test code stubs with comprehensive docstrings following the openshift-virtualization-tests patterns.