video-v1/vav1/test.ps1

#!/usr/bin/env pwsh

<#
.SYNOPSIS
    Test runner script for VAV1 Player
.DESCRIPTION
    This script runs tests with various options and generates test reports.
.PARAMETER Configuration
    Build configuration (Debug or Release). Default is Debug.
.PARAMETER Filter
    Test filter expression.
.PARAMETER Coverage
    Generate code coverage report.
.PARAMETER Watch
    Run tests in watch mode.
.PARAMETER Verbose
    Enable verbose test output.
.EXAMPLE
    .\test.ps1
    .\test.ps1 -Configuration Release -Coverage
    .\test.ps1 -Filter "Decoder" -Verbose
    .\test.ps1 -Watch
#>

param(
    [string]$Configuration = "Debug",
    [string]$Filter = "",
    [switch]$Coverage,
    [switch]$Watch,
    [switch]$Verbose
)

$ErrorActionPreference = "Stop"
$scriptRoot = Split-Path -Parent $MyInvocation.MyCommand.Definition
$testProjectFile = Join-Path $scriptRoot "Vav1Player.Tests\Vav1Player.Tests.csproj"

function Write-Success { param($Message) Write-Host $Message -ForegroundColor Green }
function Write-Info { param($Message) Write-Host $Message -ForegroundColor Cyan }
function Write-Error { param($Message) Write-Host $Message -ForegroundColor Red }

function Test-Prerequisites {
    if (-not (Test-Path $testProjectFile)) {
        Write-Error "Test project not found at: $testProjectFile"
        exit 1
    }

    try {
        dotnet --version | Out-Null
    } catch {
        Write-Error ".NET SDK not found. Please install .NET 9.0 SDK or later."
        exit 1
    }
}

function Invoke-TestRun {
    Write-Info "Running VAV1 Player tests..."

    $testArgs = @(
        "test"
        $testProjectFile
        "--configuration", $Configuration
        "--no-build"
        "--no-restore"
    )

    if ($Verbose) {
        $testArgs += "--verbosity", "detailed"
        $testArgs += "--logger", "console;verbosity=detailed"
    } else {
        $testArgs += "--verbosity", "normal"
        $testArgs += "--logger", "console;verbosity=normal"
    }

    if ($Filter) {
        $testArgs += "--filter", $Filter
    }

    if ($Coverage) {
        $testArgs += "--collect", "XPlat Code Coverage"
        $testArgs += "--settings", "coverlet.runsettings"
    }

    if ($Watch) {
        $testArgs += "--watch"
    }

    & dotnet $testArgs

    if ($LASTEXITCODE -ne 0) {
        Write-Error "Tests failed with exit code $LASTEXITCODE"
        exit $LASTEXITCODE
    }

    Write-Success "All tests completed successfully."
}

function New-CoverageReport {
    if (-not $Coverage) {
        return
    }

    Write-Info "Generating coverage report..."

    # Find the most recent coverage file
    $coverageFiles = Get-ChildItem -Path $scriptRoot -Recurse -Filter "coverage.cobertura.xml" | Sort-Object LastWriteTime -Descending

    if ($coverageFiles.Count -eq 0) {
        Write-Error "No coverage files found."
        return
    }

    $latestCoverage = $coverageFiles[0].FullName
    $reportDir = Join-Path $scriptRoot "TestResults\CoverageReport"

    # Check if reportgenerator is installed
    $reportGenerator = dotnet tool list --global | Select-String "reportgenerator"

    if (-not $reportGenerator) {
        Write-Info "Installing ReportGenerator tool..."
        dotnet tool install --global dotnet-reportgenerator-globaltool
    }

    # Generate HTML report
    dotnet reportgenerator -reports:$latestCoverage -targetdir:$reportDir -reporttypes:Html

    if ($LASTEXITCODE -eq 0) {
        $reportFile = Join-Path $reportDir "index.html"
        Write-Success "Coverage report generated: $reportFile"

        # Try to open the report
        if (Get-Command "start" -ErrorAction SilentlyContinue) {
            start $reportFile
        }
    }
}

function New-CoverletSettings {
    if (-not $Coverage) {
        return
    }

    $settingsFile = Join-Path $scriptRoot "coverlet.runsettings"

    if (-not (Test-Path $settingsFile)) {
        $settingsContent = @"
<?xml version="1.0" encoding="utf-8" ?>
<RunSettings>
  <DataCollectionRunSettings>
    <DataCollectors>
      <DataCollector friendlyName="XPlat code coverage">
        <Configuration>
          <Format>cobertura</Format>
          <Exclude>[*.Tests]*</Exclude>
          <ExcludeByAttribute>Obsolete,GeneratedCodeAttribute,CompilerGeneratedAttribute</ExcludeByAttribute>
        </Configuration>
      </DataCollector>
    </DataCollectors>
  </DataCollectionRunSettings>
</RunSettings>
"@

        $settingsContent | Out-File -FilePath $settingsFile -Encoding utf8
        Write-Info "Created coverlet settings file: $settingsFile"
    }
}

function Show-TestInfo {
    Write-Info "VAV1 Player Test Runner"
    Write-Info "======================="
    Write-Info "Configuration: $Configuration"
    Write-Info "Filter: $(if ($Filter) { $Filter } else { 'None' })"
    Write-Info "Coverage: $Coverage"
    Write-Info "Watch: $Watch"
    Write-Info "Verbose: $Verbose"
    Write-Info ""
}

# Main execution
function Main {
    Show-TestInfo
    Test-Prerequisites
    New-CoverletSettings
    Invoke-TestRun
    New-CoverageReport

    Write-Success "Test run completed!"
}

Main