# test-upgrade.ps1
# Windows upgrade tests for agnt daemon
param(
[string]$AgntPath = "agnt.exe",
[string]$OldBinaryPath = "agnt-old.exe",
[string]$SocketPath = "$env:TEMP\agnt-test-upgrade.sock"
)
$ErrorActionPreference = "Stop"
# Colors for output
function Write-TestHeader($message) {
Write-Host "`n=== $message ===" -ForegroundColor Cyan
}
function Write-Success($message) {
Write-Host "[OK] $message" -ForegroundColor Green
}
function Write-Failure($message) {
Write-Host "[FAIL] $message" -ForegroundColor Red
}
function Write-Info($message) {
Write-Host "[INFO] $message" -ForegroundColor Yellow
}
# Helper: Wait for daemon to be ready
function Wait-DaemonReady {
param([int]$TimeoutSeconds = 5)
$deadline = (Get-Date).AddSeconds($TimeoutSeconds)
while ((Get-Date) -lt $deadline) {
try {
$result = & $AgntPath daemon status --socket $SocketPath 2>$null
if ($LASTEXITCODE -eq 0) {
return $true
}
} catch {}
Start-Sleep -Milliseconds 100
}
return $false
}
# Helper: Wait for daemon to stop
function Wait-DaemonStopped {
param([int]$TimeoutSeconds = 10)
$deadline = (Get-Date).AddSeconds($TimeoutSeconds)
while ((Get-Date) -lt $deadline) {
try {
& $AgntPath daemon status --socket $SocketPath 2>$null
if ($LASTEXITCODE -ne 0) {
return $true
}
} catch {
return $true
}
Start-Sleep -Milliseconds 100
}
return $false
}
# Helper: Start daemon with specific binary
function Start-TestDaemon {
param([string]$BinaryPath = $AgntPath)
Write-Info "Starting daemon: $BinaryPath"
$job = Start-Job -ScriptBlock {
param($binary, $sock)
& $binary daemon start --socket $sock 2>&1
} -ArgumentList $BinaryPath, $SocketPath
if (-not (Wait-DaemonReady -TimeoutSeconds 5)) {
Stop-Job $job -ErrorAction SilentlyContinue
Remove-Job $job -ErrorAction SilentlyContinue
throw "Daemon failed to start"
}
return $job
}
# Helper: Kill daemon process
function Kill-Daemon {
$processes = Get-Process -Name "agnt*" -ErrorAction SilentlyContinue
foreach ($proc in $processes) {
Write-Info "Killing daemon process: $($proc.Id)"
Stop-Process -Id $proc.Id -Force
}
Start-Sleep -Milliseconds 500
}
# Cleanup before tests
function Cleanup {
Write-Info "Cleaning up..."
# Try graceful stop
try {
& $AgntPath daemon stop --socket $SocketPath 2>$null
} catch {}
# Kill any remaining processes
Kill-Daemon
# Remove socket file
if (Test-Path $SocketPath) {
Remove-Item $SocketPath -Force
}
# Remove upgrade lock file
$lockFile = "$SocketPath.upgrade.lock"
if (Test-Path $lockFile) {
Remove-Item $lockFile -Force
}
Start-Sleep -Seconds 1
}
# Test 1: Basic upgrade from old to new version
function Test-BasicUpgrade {
Write-TestHeader "Test 1: Basic upgrade (current version)"
try {
# Start daemon with current binary
$daemonJob = Start-TestDaemon -BinaryPath $AgntPath
Write-Success "Daemon started"
# Get initial version
$info = & $AgntPath daemon info --socket $SocketPath 2>&1 | ConvertFrom-Json
$oldVersion = $info.version
Write-Success "Initial daemon version: $oldVersion"
# Run upgrade (should be no-op unless --force)
Write-Info "Running upgrade..."
& $AgntPath daemon upgrade --socket $SocketPath --timeout 30s --verbose 2>&1
if ($LASTEXITCODE -ne 0) {
throw "Upgrade command failed with exit code: $LASTEXITCODE"
}
# Verify daemon is running
if (-not (Wait-DaemonReady -TimeoutSeconds 5)) {
throw "Daemon not running after upgrade"
}
# Get new version
$info2 = & $AgntPath daemon info --socket $SocketPath 2>&1 | ConvertFrom-Json
$newVersion = $info2.version
Write-Success "Post-upgrade daemon version: $newVersion"
if ($newVersion -ne $oldVersion) {
throw "Version changed unexpectedly: $oldVersion -> $newVersion"
}
Write-Success "Upgrade completed successfully (version unchanged as expected)"
return $true
}
catch {
Write-Failure $_.Exception.Message
return $false
}
finally {
Cleanup
}
}
# Test 2: Force upgrade (same version)
function Test-ForceUpgrade {
Write-TestHeader "Test 2: Force upgrade (same version)"
try {
# Start daemon
$daemonJob = Start-TestDaemon -BinaryPath $AgntPath
Write-Success "Daemon started"
# Get initial info
$info = & $AgntPath daemon info --socket $SocketPath 2>&1 | ConvertFrom-Json
$oldVersion = $info.version
$oldUptime = $info.uptime
Write-Success "Initial daemon version: $oldVersion, uptime: $oldUptime"
# Force upgrade
Write-Info "Running force upgrade..."
& $AgntPath daemon upgrade --socket $SocketPath --timeout 30s --force --verbose 2>&1
if ($LASTEXITCODE -ne 0) {
throw "Force upgrade failed with exit code: $LASTEXITCODE"
}
# Verify daemon restarted
if (-not (Wait-DaemonReady -TimeoutSeconds 5)) {
throw "Daemon not running after force upgrade"
}
# Get new info
$info2 = & $AgntPath daemon info --socket $SocketPath 2>&1 | ConvertFrom-Json
$newVersion = $info2.version
$newUptime = $info2.uptime
Write-Success "Post-upgrade daemon version: $newVersion, uptime: $newUptime"
# Version should match
if ($newVersion -ne $oldVersion) {
throw "Version mismatch: expected $oldVersion, got $newVersion"
}
# Uptime should be less (daemon restarted)
Write-Success "Daemon restarted (uptime reset)"
Write-Success "Force upgrade completed successfully"
return $true
}
catch {
Write-Failure $_.Exception.Message
return $false
}
finally {
Cleanup
}
}
# Test 3: Upgrade lock prevents concurrent upgrades
function Test-ConcurrentUpgradeLock {
Write-TestHeader "Test 3: Concurrent upgrade lock"
try {
# Start daemon
$daemonJob = Start-TestDaemon -BinaryPath $AgntPath
Write-Success "Daemon started"
# Start first upgrade (long timeout to keep lock held)
Write-Info "Starting first upgrade..."
$job1 = Start-Job -ScriptBlock {
param($agnt, $sock)
& $agnt daemon upgrade --socket $sock --timeout 30s --force --verbose 2>&1
} -ArgumentList $AgntPath, $SocketPath
# Wait a bit for lock to be acquired
Start-Sleep -Seconds 2
# Try second upgrade (should fail with lock error)
Write-Info "Starting second upgrade (should fail with lock error)..."
$output = & $AgntPath daemon upgrade --socket $SocketPath --timeout 10s --force 2>&1
if ($LASTEXITCODE -eq 0) {
throw "Second upgrade should have failed but succeeded"
}
$outputStr = $output | Out-String
if ($outputStr -notmatch "lock|progress|already") {
Write-Info "Output: $outputStr"
throw "Second upgrade failed but not with expected lock error"
}
Write-Success "Second upgrade correctly blocked by lock"
# Wait for first upgrade to complete
$result1 = Receive-Job -Job $job1 -Wait
Remove-Job $job1
Write-Success "First upgrade completed"
Write-Success "Concurrent upgrade lock working correctly"
return $true
}
catch {
Write-Failure $_.Exception.Message
return $false
}
finally {
# Clean up jobs
Get-Job | Remove-Job -Force -ErrorAction SilentlyContinue
Cleanup
}
}
# Test 4: Upgrade with processes running (graceful termination)
function Test-UpgradeWithProcesses {
Write-TestHeader "Test 4: Upgrade with running processes"
try {
# Start daemon
$daemonJob = Start-TestDaemon -BinaryPath $AgntPath
Write-Success "Daemon started"
# Note: This test would need the daemon to actually support running processes
# For now, we just verify the upgrade command handles the case
Write-Info "Running upgrade (would terminate processes if any were running)..."
& $AgntPath daemon upgrade --socket $SocketPath --timeout 30s --force --verbose 2>&1
if ($LASTEXITCODE -ne 0) {
throw "Upgrade failed"
}
# Verify daemon is running
if (-not (Wait-DaemonReady -TimeoutSeconds 5)) {
throw "Daemon not running after upgrade"
}
Write-Success "Upgrade completed (processes would have been terminated)"
return $true
}
catch {
Write-Failure $_.Exception.Message
return $false
}
finally {
Cleanup
}
}
# Test 5: Upgrade timeout handling
function Test-UpgradeTimeout {
Write-TestHeader "Test 5: Upgrade timeout handling"
try {
# Start daemon
$daemonJob = Start-TestDaemon -BinaryPath $AgntPath
Write-Success "Daemon started"
# Run upgrade with very short timeout (may or may not timeout depending on speed)
Write-Info "Running upgrade with 2s timeout..."
$output = & $AgntPath daemon upgrade --socket $SocketPath --timeout 2s --force --verbose 2>&1
$exitCode = $LASTEXITCODE
Write-Info "Upgrade exit code: $exitCode"
if ($exitCode -eq 0) {
Write-Success "Upgrade completed within timeout"
# Verify daemon is running
if (-not (Wait-DaemonReady -TimeoutSeconds 3)) {
throw "Daemon not running after upgrade"
}
Write-Success "Daemon is running"
}
else {
# Timeout or other error - check if it's a reasonable error
$outputStr = $output | Out-String
Write-Info "Upgrade failed (expected with short timeout): $outputStr"
# This is acceptable - short timeout can cause failures
Write-Success "Short timeout handled appropriately"
}
return $true
}
catch {
Write-Failure $_.Exception.Message
return $false
}
finally {
Cleanup
}
}
# Test 6: Upgrade from old binary to new binary (if available)
function Test-OldToNewUpgrade {
Write-TestHeader "Test 6: Upgrade from old binary to new"
if (-not (Test-Path $OldBinaryPath)) {
Write-Info "Old binary not found at $OldBinaryPath, skipping test"
Write-Info "Run build-test-binaries.ps1 to create old binary"
return $true # Skip, not a failure
}
try {
# Start daemon with old binary
Write-Info "Starting daemon with old binary: $OldBinaryPath"
$job = Start-Job -ScriptBlock {
param($binary, $sock)
& $binary daemon start --socket $sock 2>&1
} -ArgumentList $OldBinaryPath, $SocketPath
if (-not (Wait-DaemonReady -TimeoutSeconds 5)) {
Stop-Job $job -ErrorAction SilentlyContinue
Remove-Job $job -ErrorAction SilentlyContinue
throw "Old daemon failed to start"
}
# Get old version (using old binary to query)
$infoOld = & $OldBinaryPath daemon info --socket $SocketPath 2>&1 | ConvertFrom-Json
$oldVersion = $infoOld.version
Write-Success "Old daemon version: $oldVersion"
# Run upgrade with new binary
Write-Info "Upgrading to new binary: $AgntPath"
& $AgntPath daemon upgrade --socket $SocketPath --timeout 30s --verbose 2>&1
if ($LASTEXITCODE -ne 0) {
throw "Upgrade failed"
}
# Verify new daemon is running (use new binary to query)
if (-not (Wait-DaemonReady -TimeoutSeconds 5)) {
throw "New daemon not running after upgrade"
}
# Get new version
$infoNew = & $AgntPath daemon info --socket $SocketPath 2>&1 | ConvertFrom-Json
$newVersion = $infoNew.version
Write-Success "New daemon version: $newVersion"
if ($oldVersion -eq $newVersion) {
Write-Info "Version unchanged ($oldVersion -> $newVersion)"
Write-Info "This may be expected if versions match"
}
else {
Write-Success "Upgraded: $oldVersion -> $newVersion"
}
Write-Success "Upgrade from old to new binary completed"
return $true
}
catch {
Write-Failure $_.Exception.Message
return $false
}
finally {
Get-Job | Remove-Job -Force -ErrorAction SilentlyContinue
Cleanup
}
}
# Main execution
Write-Host "`n========================================" -ForegroundColor Cyan
Write-Host " agnt Windows Upgrade Tests" -ForegroundColor Cyan
Write-Host "========================================`n" -ForegroundColor Cyan
Write-Info "Using agnt binary: $AgntPath"
Write-Info "Old binary: $OldBinaryPath"
Write-Info "Test socket path: $SocketPath"
# Verify agnt exists
if (-not (Test-Path $AgntPath)) {
Write-Failure "agnt binary not found at: $AgntPath"
Write-Info "Build it with: go build -o agnt.exe ./cmd/agnt/"
exit 1
}
# Initial cleanup
Cleanup
# Run tests
$results = @()
$results += @{ Name = "Basic upgrade"; Passed = (Test-BasicUpgrade) }
$results += @{ Name = "Force upgrade"; Passed = (Test-ForceUpgrade) }
$results += @{ Name = "Concurrent upgrade lock"; Passed = (Test-ConcurrentUpgradeLock) }
$results += @{ Name = "Upgrade with processes"; Passed = (Test-UpgradeWithProcesses) }
$results += @{ Name = "Upgrade timeout"; Passed = (Test-UpgradeTimeout) }
$results += @{ Name = "Old to new upgrade"; Passed = (Test-OldToNewUpgrade) }
# Final cleanup
Cleanup
# Summary
Write-Host "`n========================================" -ForegroundColor Cyan
Write-Host " Test Summary" -ForegroundColor Cyan
Write-Host "========================================`n" -ForegroundColor Cyan
$passCount = 0
$failCount = 0
foreach ($result in $results) {
if ($result.Passed) {
Write-Success $result.Name
$passCount++
}
else {
Write-Failure $result.Name
$failCount++
}
}
Write-Host "`nTotal: $($results.Count) tests" -ForegroundColor White
Write-Host "Passed: $passCount" -ForegroundColor Green
Write-Host "Failed: $failCount" -ForegroundColor $(if ($failCount -gt 0) { "Red" } else { "Green" })
if ($failCount -gt 0) {
exit 1
}
else {
Write-Host "`nAll tests passed!" -ForegroundColor Green
exit 0
}
