PowerShell 技能连载 - Pester 测试技巧

在 PowerShell 中使用 Pester 进行测试是一项重要任务，本文将介绍一些实用的 Pester 测试技巧。

首先，让我们看看基本的 Pester 测试操作：

# 创建 Pester 测试函数
function New-PesterTest {
    param(
        [string]$TestName,
        [string]$TestPath,
        [string]$ModuleName,
        [string[]]$Functions
    )
    
    try {
        # 创建测试文件
        $testContent = @"
Describe '$ModuleName' {
    BeforeAll {
        Import-Module $ModuleName
    }
    
    Context '基本功能测试' {
        BeforeEach {
            # 测试前的准备工作
        }
        
        AfterEach {
            # 测试后的清理工作
        }
        
        It '应该成功导入模块' {
            Get-Module -Name $ModuleName | Should -Not -BeNullOrEmpty
        }
        
        It '应该包含所有必需的函数' {
            $module = Get-Module -Name $ModuleName
            foreach ($function in $Functions) {
                $module.ExportedFunctions.Keys | Should -Contain $function
            }
        }
    }
}
"@
        
        $testContent | Out-File -FilePath $TestPath -Encoding UTF8
        Write-Host "测试文件 $TestPath 创建成功"
    }
    catch {
        Write-Host "创建测试文件失败：$_"
    }
}

Pester 模拟测试：

# 创建 Pester 模拟测试函数
function New-PesterMockTest {
    param(
        [string]$TestName,
        [string]$TestPath,
        [string]$FunctionName,
        [hashtable]$MockData
    )
    
    try {
        $testContent = @"
Describe '$FunctionName 模拟测试' {
    BeforeAll {
        Import-Module $ModuleName
    }
    
    Context '模拟外部依赖' {
        BeforeEach {
            Mock Get-Process {
                return @(
                    @{
                        Name = 'Process1'
                        Id = 1001
                        CPU = 10
                    },
                    @{
                        Name = 'Process2'
                        Id = 1002
                        CPU = 20
                    }
                )
            }
            
            Mock Get-Service {
                return @(
                    @{
                        Name = 'Service1'
                        Status = 'Running'
                    },
                    @{
                        Name = 'Service2'
                        Status = 'Stopped'
                    }
                )
            }
        }
        
        It '应该正确模拟进程数据' {
            $result = Get-Process
            $result.Count | Should -Be 2
            $result[0].Name | Should -Be 'Process1'
            $result[1].Name | Should -Be 'Process2'
        }
        
        It '应该正确模拟服务数据' {
            $result = Get-Service
            $result.Count | Should -Be 2
            $result[0].Status | Should -Be 'Running'
            $result[1].Status | Should -Be 'Stopped'
        }
    }
}
"@
        
        $testContent | Out-File -FilePath $TestPath -Encoding UTF8
        Write-Host "模拟测试文件 $TestPath 创建成功"
    }
    catch {
        Write-Host "创建模拟测试文件失败：$_"
    }
}

Pester 参数测试：

# 创建 Pester 参数测试函数
function New-PesterParameterTest {
    param(
        [string]$TestName,
        [string]$TestPath,
        [string]$FunctionName,
        [hashtable]$Parameters
    )
    
    try {
        $testContent = @"
Describe '$FunctionName 参数测试' {
    BeforeAll {
        Import-Module $ModuleName
    }
    
    Context '参数验证' {
        It '应该验证必需参数' {
            { & $FunctionName } | Should -Throw
        }
        
        It '应该验证参数类型' {
            { & $FunctionName -Name 123 } | Should -Throw
        }
        
        It '应该验证参数范围' {
            { & $FunctionName -Count -1 } | Should -Throw
        }
        
        It '应该验证参数格式' {
            { & $FunctionName -Email 'invalid-email' } | Should -Throw
        }
    }
    
    Context '参数组合' {
        It '应该处理有效的参数组合' {
            $result = & $FunctionName -Name 'Test' -Count 5
            $result | Should -Not -BeNullOrEmpty
        }
        
        It '应该处理边界条件' {
            $result = & $FunctionName -Name 'Test' -Count 0
            $result | Should -BeNullOrEmpty
        }
    }
}
"@
        
        $testContent | Out-File -FilePath $TestPath -Encoding UTF8
        Write-Host "参数测试文件 $TestPath 创建成功"
    }
    catch {
        Write-Host "创建参数测试文件失败：$_"
    }
}

Pester 性能测试：

# 创建 Pester 性能测试函数
function New-PesterPerformanceTest {
    param(
        [string]$TestName,
        [string]$TestPath,
        [string]$FunctionName,
        [int]$Iterations = 1000,
        [int]$Timeout = 30
    )
    
    try {
        $testContent = @"
Describe '$FunctionName 性能测试' {
    BeforeAll {
        Import-Module $ModuleName
    }
    
    Context '执行时间测试' {
        It '应该在指定时间内完成' {
            $measurement = Measure-Command {
                for ($i = 0; $i -lt $Iterations; $i++) {
                    & $FunctionName
                }
            }
            
            $measurement.TotalSeconds | Should -BeLessThan $Timeout
        }
        
        It '应该保持稳定的执行时间' {
            $times = @()
            for ($i = 0; $i -lt 10; $i++) {
                $measurement = Measure-Command {
                    & $FunctionName
                }
                $times += $measurement.TotalMilliseconds
            }
            
            $average = ($times | Measure-Object -Average).Average
            $standardDeviation = [math]::Sqrt(($times | ForEach-Object { [math]::Pow($_ - $average, 2) } | Measure-Object -Average).Average)
            
            $standardDeviation | Should -BeLessThan ($average * 0.1)
        }
    }
    
    Context '资源使用测试' {
        It '应该控制内存使用' {
            $before = (Get-Process -Id $PID).WorkingSet64
            for ($i = 0; $i -lt $Iterations; $i++) {
                & $FunctionName
            }
            $after = (Get-Process -Id $PID).WorkingSet64
            
            ($after - $before) / 1MB | Should -BeLessThan 100
        }
    }
}
"@
        
        $testContent | Out-File -FilePath $TestPath -Encoding UTF8
        Write-Host "性能测试文件 $TestPath 创建成功"
    }
    catch {
        Write-Host "创建性能测试文件失败：$_"
    }
}

Pester 测试报告：

# 创建 Pester 测试报告函数
function New-PesterTestReport {
    param(
        [string]$TestPath,
        [string]$ReportPath,
        [string]$Format = 'HTML'
    )
    
    try {
        $testResults = Invoke-Pester -Path $TestPath -PassThru
        
        switch ($Format) {
            'HTML' {
                $testResults | ConvertTo-Html -Title "Pester 测试报告" | Out-File -FilePath $ReportPath -Encoding UTF8
            }
            'XML' {
                $testResults | ConvertTo-Xml | Out-File -FilePath $ReportPath -Encoding UTF8
            }
            'JSON' {
                $testResults | ConvertTo-Json -Depth 10 | Out-File -FilePath $ReportPath -Encoding UTF8
            }
        }
        
        return [PSCustomObject]@{
            TotalTests = $testResults.TotalCount
            PassedTests = $testResults.PassedCount
            FailedTests = $testResults.FailedCount
            SkippedTests = $testResults.SkippedCount
            ReportPath = $ReportPath
        }
    }
    catch {
        Write-Host "生成测试报告失败：$_"
    }
}

这些技巧将帮助您更有效地使用 Pester 进行测试。记住，在编写测试时，始终要注意测试覆盖率和可维护性。同时，建议使用适当的测试数据和模拟来确保测试的可靠性。