refactor(kubevirt): Extract common VM test verification logic to shared helpers

Extract common verification patterns from VM test tasks into a shared helper
library to improve code reuse, maintainability, and consistency.

Changes:
- Create shared verification helper library in tests/helpers/
  - verify-vm.sh: 8 reusable verification functions with flexible matching
  - README.md: Comprehensive documentation with usage examples

- Refactor all VM test tasks to use shared helpers:
  - create-vm-basic: 43 → 33 lines (~23% reduction)
  - create-vm-ubuntu: 43 → 33 lines (~23% reduction)
  - create-vm-with-size: 62 → 39 lines (~37% reduction)
  - create-vm-with-instancetype: 59 → 39 lines (~34% reduction)
  - create-vm-with-performance: 72 → 45 lines (~38% reduction)

Helper Functions:
- verify_vm_exists: Wait for VM creation
- verify_container_disk: Verify OS container disk (checks all volumes)
- verify_run_strategy: Check runStrategy (accepts spec or status)
- verify_instancetype: Verify instancetype with optional exact match
- verify_instancetype_contains: Check instancetype contains substring
- verify_instancetype_prefix: Check instancetype starts with prefix
- verify_no_direct_resources: Verify VM uses instancetype
- verify_has_resources_or_instancetype: Verify either instancetype or resources

Bug Fixes:
- Fix volume name verification to check all volumes instead of specific names
  (handles different VM creation approaches)
- Fix runStrategy verification to accept both spec.runStrategy and
  status.runStrategy (handles deprecated 'running' field)

Benefits:
- Eliminated ~150 lines of duplicated verification code
- Single source of truth for verification logic
- More maintainable and easier to extend
- Consistent error messages and output formatting
- Tests are more concise and readable

Assisted-By: Claude <noreply@anthropic.com>
Signed-off-by: Lee Yarwood <lyarwood@redhat.com>

Author: lyarwood

pkg/toolsets/kubevirt/vm/tests/helpers/README.md

@@ -0,0 +1,173 @@
+# Test Verification Helpers
+
+This directory contains shared helper functions for VirtualMachine test verification.
+
+## Usage
+
+Source the helper script in your test verification section:
+
+```bash
+#!/usr/bin/env bash
+source "$(dirname "${BASH_SOURCE[0]}")/../../helpers/verify-vm.sh"
+
+# Use helper functions
+verify_vm_exists "test-vm" "vm-test" || exit 1
+verify_container_disk "test-vm" "vm-test" "fedora" || exit 1
+verify_run_strategy "test-vm" "vm-test" || exit 1
+```
+
+## Available Functions
+
+### verify_vm_exists
+Waits for a VirtualMachine to be created.
+
+**Usage:** `verify_vm_exists <vm-name> <namespace> [timeout]`
+
+**Example:**
+```bash
+verify_vm_exists "my-vm" "vm-test" "30s" || exit 1
+```
+
+**Default timeout:** 30s
+
+---
+
+### verify_container_disk
+Verifies that a VM uses a specific container disk OS (checks all volumes).
+
+**Usage:** `verify_container_disk <vm-name> <namespace> <os-name>`
+
+**Example:**
+```bash
+verify_container_disk "my-vm" "vm-test" "fedora" || exit 1
+verify_container_disk "ubuntu-vm" "vm-test" "ubuntu" || exit 1
+```
+
+---
+
+### verify_run_strategy
+Verifies that runStrategy is set (checks both spec and status).
+
+**Usage:** `verify_run_strategy <vm-name> <namespace>`
+
+**Example:**
+```bash
+verify_run_strategy "my-vm" "vm-test" || exit 1
+```
+
+**Note:** This function accepts runStrategy in either `spec.runStrategy` or `status.runStrategy` to accommodate VMs created with the deprecated `running` field.
+
+---
+
+### verify_instancetype
+Verifies that a VM has an instancetype reference with optional exact match.
+
+**Usage:** `verify_instancetype <vm-name> <namespace> [expected-instancetype] [expected-kind]`
+
+**Examples:**
+```bash
+# Just verify instancetype exists
+verify_instancetype "my-vm" "vm-test" || exit 1
+
+# Verify specific instancetype
+verify_instancetype "my-vm" "vm-test" "u1.medium" || exit 1
+
+# Verify instancetype and kind
+verify_instancetype "my-vm" "vm-test" "u1.medium" "VirtualMachineClusterInstancetype" || exit 1
+```
+
+**Default kind:** VirtualMachineClusterInstancetype
+
+---
+
+### verify_instancetype_contains
+Verifies that instancetype name contains a substring (e.g., size like "large").
+
+**Usage:** `verify_instancetype_contains <vm-name> <namespace> <substring> [description]`
+
+**Example:**
+```bash
+verify_instancetype_contains "my-vm" "vm-test" "large" "requested size 'large'"
+verify_instancetype_contains "my-vm" "vm-test" "medium"
+```
+
+**Note:** Returns success even if substring not found (prints warning only).
+
+---
+
+### verify_instancetype_prefix
+Verifies that instancetype starts with a specific prefix (e.g., performance family like "c1").
+
+**Usage:** `verify_instancetype_prefix <vm-name> <namespace> <prefix> [description]`
+
+**Example:**
+```bash
+verify_instancetype_prefix "my-vm" "vm-test" "c1" "compute-optimized"
+verify_instancetype_prefix "my-vm" "vm-test" "u1" "general-purpose"
+```
+
+**Note:** Returns success even if prefix doesn't match (prints warning only).
+
+---
+
+### verify_no_direct_resources
+Verifies that VM uses instancetype for resources (no direct memory specification).
+
+**Usage:** `verify_no_direct_resources <vm-name> <namespace>`
+
+**Example:**
+```bash
+verify_no_direct_resources "my-vm" "vm-test"
+```
+
+**Note:** Returns success even if direct resources found (prints warning only).
+
+---
+
+### verify_has_resources_or_instancetype
+Verifies that VM has either an instancetype or direct resource specification.
+
+**Usage:** `verify_has_resources_or_instancetype <vm-name> <namespace>`
+
+**Example:**
+```bash
+verify_has_resources_or_instancetype "my-vm" "vm-test" || exit 1
+```
+
+**Note:** Fails only if neither instancetype nor direct resources are present.
+
+## Design Principles
+
+1. **Flexible matching**: Functions use pattern matching instead of exact volume names to handle different VM creation approaches.
+
+2. **Clear output**: Each function prints clear success (✓) or failure (✗) messages.
+
+3. **Warning vs Error**: Some functions print warnings (⚠) for non-critical mismatches but still return success.
+
+4. **Return codes**: Functions return 0 for success, 1 for failure. Always check return codes with `|| exit 1` for critical validations.
+
+## Example Test Verification
+
+```bash
+#!/usr/bin/env bash
+source "$(dirname "${BASH_SOURCE[0]}")/../../helpers/verify-vm.sh"
+
+# Wait for VM to exist
+verify_vm_exists "test-vm" "vm-test" || exit 1
+
+# Verify container disk
+verify_container_disk "test-vm" "vm-test" "fedora" || exit 1
+
+# Verify runStrategy
+verify_run_strategy "test-vm" "vm-test" || exit 1
+
+# Verify instancetype with size
+verify_instancetype "test-vm" "vm-test" || exit 1
+verify_instancetype_contains "test-vm" "vm-test" "large"
+
+# Verify no direct resources
+verify_no_direct_resources "test-vm" "vm-test"
+
+echo "All validations passed"
+exit 0
+```

pkg/toolsets/kubevirt/vm/tests/helpers/verify-vm.sh

@@ -0,0 +1,200 @@
+#!/usr/bin/env bash
+# Shared verification helper functions for VirtualMachine tests
+
+# verify_vm_exists: Waits for a VirtualMachine to be created
+# Usage: verify_vm_exists <vm-name> <namespace> [timeout]
+verify_vm_exists() {
+    local vm_name="$1"
+    local namespace="$2"
+    local timeout="${3:-30s}"
+
+    if ! kubectl wait --for=jsonpath='{.metadata.name}'="$vm_name" virtualmachine/"$vm_name" -n "$namespace" --timeout="$timeout" 2>/dev/null; then
+        echo "VirtualMachine $vm_name not found in namespace $namespace"
+        kubectl get virtualmachines -n "$namespace"
+        return 1
+    fi
+    echo "VirtualMachine $vm_name created successfully"
+    return 0
+}
+
+# verify_container_disk: Verifies that a VM uses a specific container disk OS
+# Usage: verify_container_disk <vm-name> <namespace> <os-name>
+# Example: verify_container_disk test-vm vm-test fedora
+verify_container_disk() {
+    local vm_name="$1"
+    local namespace="$2"
+    local os_name="$3"
+
+    # Get all container disk images from all volumes
+    local container_disks
+    container_disks=$(kubectl get virtualmachine "$vm_name" -n "$namespace" -o jsonpath='{.spec.template.spec.volumes[*].containerDisk.image}')
+
+    if [[ "$container_disks" =~ $os_name ]]; then
+        echo "✓ VirtualMachine uses $os_name container disk"
+        return 0
+    else
+        echo "✗ Expected $os_name container disk, found volumes with images: $container_disks"
+        kubectl get virtualmachine "$vm_name" -n "$namespace" -o yaml
+        return 1
+    fi
+}
+
+# verify_run_strategy: Verifies that runStrategy is set (in spec or status)
+# Usage: verify_run_strategy <vm-name> <namespace>
+verify_run_strategy() {
+    local vm_name="$1"
+    local namespace="$2"
+
+    local spec_run_strategy
+    local status_run_strategy
+    spec_run_strategy=$(kubectl get virtualmachine "$vm_name" -n "$namespace" -o jsonpath='{.spec.runStrategy}')
+    status_run_strategy=$(kubectl get virtualmachine "$vm_name" -n "$namespace" -o jsonpath='{.status.runStrategy}')
+
+    if [[ -n "$spec_run_strategy" ]]; then
+        echo "✓ VirtualMachine uses runStrategy in spec: $spec_run_strategy"
+        return 0
+    elif [[ -n "$status_run_strategy" ]]; then
+        echo "✓ VirtualMachine has runStrategy in status: $status_run_strategy"
+        echo "  Note: VM may have been created with deprecated 'running' field, but runStrategy is set in status"
+        return 0
+    else
+        echo "✗ VirtualMachine missing runStrategy field in both spec and status"
+        return 1
+    fi
+}
+
+# verify_instancetype: Verifies that a VM has an instancetype reference
+# Usage: verify_instancetype <vm-name> <namespace> [expected-instancetype] [expected-kind]
+verify_instancetype() {
+    local vm_name="$1"
+    local namespace="$2"
+    local expected_instancetype="$3"
+    local expected_kind="${4:-VirtualMachineClusterInstancetype}"
+
+    local instancetype
+    instancetype=$(kubectl get virtualmachine "$vm_name" -n "$namespace" -o jsonpath='{.spec.instancetype.name}')
+
+    if [[ -z "$instancetype" ]]; then
+        echo "✗ VirtualMachine has no instancetype reference"
+        return 1
+    fi
+
+    echo "✓ VirtualMachine has instancetype reference: $instancetype"
+
+    # Check expected instancetype if provided
+    if [[ -n "$expected_instancetype" ]]; then
+        if [[ "$instancetype" == "$expected_instancetype" ]]; then
+            echo "✓ Instancetype matches expected value: $expected_instancetype"
+        else
+            echo "✗ Expected instancetype '$expected_instancetype', found: $instancetype"
+            return 1
+        fi
+    fi
+
+    # Verify instancetype kind
+    local instancetype_kind
+    instancetype_kind=$(kubectl get virtualmachine "$vm_name" -n "$namespace" -o jsonpath='{.spec.instancetype.kind}')
+    if [[ "$instancetype_kind" == "$expected_kind" ]]; then
+        echo "✓ Instancetype kind is $expected_kind"
+    else
+        echo "⚠ Instancetype kind is: $instancetype_kind (expected: $expected_kind)"
+    fi
+
+    return 0
+}
+
+# verify_instancetype_contains: Verifies that instancetype name contains a string
+# Usage: verify_instancetype_contains <vm-name> <namespace> <substring> [description]
+verify_instancetype_contains() {
+    local vm_name="$1"
+    local namespace="$2"
+    local substring="$3"
+    local description="${4:-$substring}"
+
+    local instancetype
+    instancetype=$(kubectl get virtualmachine "$vm_name" -n "$namespace" -o jsonpath='{.spec.instancetype.name}')
+
+    if [[ -z "$instancetype" ]]; then
+        echo "✗ VirtualMachine has no instancetype reference"
+        return 1
+    fi
+
+    if [[ "$instancetype" =~ $substring ]]; then
+        echo "✓ Instancetype matches $description: $instancetype"
+        return 0
+    else
+        echo "⚠ Instancetype '$instancetype' doesn't match $description"
+        return 0  # Return success for warnings
+    fi
+}
+
+# verify_instancetype_prefix: Verifies that instancetype starts with a prefix
+# Usage: verify_instancetype_prefix <vm-name> <namespace> <prefix> [description]
+verify_instancetype_prefix() {
+    local vm_name="$1"
+    local namespace="$2"
+    local prefix="$3"
+    local description="${4:-$prefix}"
+
+    local instancetype
+    instancetype=$(kubectl get virtualmachine "$vm_name" -n "$namespace" -o jsonpath='{.spec.instancetype.name}')
+
+    if [[ -z "$instancetype" ]]; then
+        echo "✗ VirtualMachine has no instancetype reference"
+        return 1
+    fi
+
+    if [[ "$instancetype" =~ ^${prefix}\. ]]; then
+        echo "✓ Instancetype matches $description family: $instancetype"
+        return 0
+    else
+        echo "⚠ Instancetype '$instancetype' doesn't start with '$prefix'"
+        return 0  # Return success for warnings
+    fi
+}
+
+# verify_no_direct_resources: Verifies VM uses instancetype (no direct memory spec)
+# Usage: verify_no_direct_resources <vm-name> <namespace>
+verify_no_direct_resources() {
+    local vm_name="$1"
+    local namespace="$2"
+
+    local guest_memory
+    guest_memory=$(kubectl get virtualmachine "$vm_name" -n "$namespace" -o jsonpath='{.spec.template.spec.domain.memory.guest}')
+
+    if [[ -z "$guest_memory" ]]; then
+        echo "✓ VirtualMachine uses instancetype for resources (no direct memory spec)"
+        return 0
+    else
+        echo "⚠ VirtualMachine has direct memory specification: $guest_memory"
+        return 0  # Return success for warnings
+    fi
+}
+
+# verify_has_resources_or_instancetype: Verifies VM has either instancetype or direct resources
+# Usage: verify_has_resources_or_instancetype <vm-name> <namespace>
+verify_has_resources_or_instancetype() {
+    local vm_name="$1"
+    local namespace="$2"
+
+    local instancetype
+    instancetype=$(kubectl get virtualmachine "$vm_name" -n "$namespace" -o jsonpath='{.spec.instancetype.name}')
+
+    if [[ -n "$instancetype" ]]; then
+        echo "✓ VirtualMachine has instancetype reference: $instancetype"
+        return 0
+    fi
+
+    # Check for direct resource specification
+    local guest_memory
+    guest_memory=$(kubectl get virtualmachine "$vm_name" -n "$namespace" -o jsonpath='{.spec.template.spec.domain.memory.guest}')
+
+    if [[ -n "$guest_memory" ]]; then
+        echo "⚠ No instancetype set, but VM has direct memory specification: $guest_memory"
+        return 0
+    else
+        echo "✗ VirtualMachine has no instancetype and no direct resource specification"
+        kubectl get virtualmachine "$vm_name" -n "$namespace" -o yaml
+        return 1
+    fi
+}