Invoke-Pester -OutputFile and -OutputFormat are member of the legacy parameter set

Question

In Pester 4 the commandlet offers the possibility to explicitly specify the OutputPath.

Invoke-Pester -Script $testFile -PassThru -Verbose -OutputFile $tr `
    -OutputFormat NUnitXml -CodeCoverage "$tmp/*-*.ps1" `
    -CodeCoverageOutputFile $cc -Show All

In version 5, this option is declared as a legacy parameter set and issues a corresponding warning.

WARNING: You are using Legacy parameter set that adapts Pester 5 syntax to Pester 4 syntax. This parameter set is deprecated, and does not work 100%. The -Strict and -PesterOption parameters are ignored, and providing advanced configuration to -Path (-Script), and -CodeCoverage via a hash table does not work. Please refer to https://github.com/pester/Pester/releases/tag/5.0.1#legacy-parameter-set for more information.

Which implementation is planned for the following versions? If the parameter is no longer available, should the test results be extracted from the result object?

Answer 1

There is pretty good documentation written for the new Pester 5 which you can find here: https://github.com/pester/Pester#simple-and-advanced-interface .

That link should take you to the specific section that you're looking for.

Essentially, they moved the configuration to an assembly class [PesterConfiguration] . You can access the defaults by using [PesterConfigruation]::Default or more likely cast it to a new object that you will configure with your specific settings and output path. You could do that like this as an example:

$configuration = [PesterConfiguration]@{
    Run = @{
        Path = $testFile
    }
    Output = @{
        Verbosity = 'Detailed'
    }
    Filter = @{
        Tag = 'Acceptance'
        ExcludeTag = 'WindowsOnly'
    }
    Should = @{
        ErrorAction = 'Continue'
    }
    CodeCoverage = @{
        Enable = $true
        OutputPath = $yourPath
    }
}

You then pass that configuration object to Invoke-Pester. ie Invoke-Pester -Configuration $configuration

You can still use some of the parameters in that 'legacy' style, Pester will just yell at you so that you aren't too surprised when it gets deprecated.

As a side note- I do not see a nunit format for the test output so I don't know if they discontinued that. The only one I see is 'JaCoCo'.

Answer 2

I use Pester 5.1.1 to test Azure Resources after their deployment. In Azure DevOps Services I execute a PowerShell task within a pipeline that triggers one script (Start-Pester.ps1) which in turn invokes tests from another script (PostDeployment.Tests.ps1) while passing the necessary parameter values.

Start-Pester.ps1

param(
        [string]$SubscriptionId,
        [string]$TenantId,
        [string]$Username,
        [string]$Password,
        [string]$ResourceGroupName,
        [string]$FunctionAppName,
        [string]$EventHubNamespaceName,
        [string]$EventHubNamespaceAuthorizationRuleName,
        [string]$EventHubName,
        [string]$EventHubAuthorizationRuleName,
        [string]$EventHubAuthorizationRuleName1,
        [string]$ModulePath,
        [switch]$Publish,
        [string]$ResultsPath
    )
    
    [string]$SubscriptionId = (Get-Item env:SubscriptionId).value
    [string]$TenantId = (Get-Item env:TenantId).value
    [string]$Username = (Get-Item env:Username).value
    [string]$Password = (Get-Item env:Password).value
    [string]$ResourceGroupName = (Get-Item env:ResourceGroupName).value
    [string]$FunctionAppName = (Get-Item env:FunctionAppName).value
    [string]$EventHubNamespaceName = (Get-Item env:EventHubNamespaceName).value
    [string]$EventHubNamespaceAuthorizationRuleName = (Get-Item env:EventHubNamespaceAuthorizationRuleName).value
    [string]$EventHubName = (Get-Item env:EventHubName).value
    [string]$EventHubAuthorizationRuleName = (Get-Item env:EventHubAuthorizationRuleName).value
    [string]$EventHubAuthorizationRuleName1 = (Get-Item env:EventHubAuthorizationRuleName1).value
    
    $WarningPreference = "SilentlyContinue" 
    Set-Item Env:\SuppressAzurePowerShellBreakingChangeWarnings "true"
    
    [array]$ModuleName = @("Az.Accounts", "Az.Resources", "Az.EventHub", "Az.Functions")
    foreach ($Module in $ModuleName) {
        Install-Module $Module -Scope CurrentUser -Force -SkipPublisherCheck -confirm:$false -AllowClobber
        Import-Module -Name $Module 
        Get-InstalledModule -Name $Module -AllVersions | Select-Object Name, Version
    }
    
    # Authentication
    $Credentials = New-Object System.Management.Automation.PSCredential ($Username, $(ConvertTo-SecureString $Password -AsPlainText -Force))
    Connect-AzAccount -Credential $Credentials -ServicePrincipal -Tenant $TenantId
    
    # Subscription
    Set-AzContext -Subscription $SubscriptionId
    
    $PesterModule = Get-Module -Name Pester -ListAvailable | Where-Object { $_.Version -like '5.*' }
    if (!$PesterModule) { 
        try {
            Install-Module -Name Pester -Scope CurrentUser -Force -SkipPublisherCheck -MinimumVersion "5.0" -Repository PSGallery
            $PesterModule = Get-Module -Name Pester -ListAvailable | Where-Object { $_.Version -like '5.*' }
        }
        catch {
            Write-Error "Failed to install the Pester module."
        }
    }
    
    Write-Host "Pester version: $($PesterModule.Version.Major).$($PesterModule.Version.Minor).$($PesterModule.Version.Build)"
    $PesterModule | Import-Module
    
    if ($Publish) {
        if (!(Test-Path -Path $ResultsPath)) {
            New-Item -Path $ResultsPath -ItemType Directory -Force | Out-Null
        }
    }
    
    $Tests = (Get-ChildItem -Path $($ModulePath) -Recurse | Where-Object { $_.Name -like "*Tests.ps1" }).FullName
    
    $Params = [ordered]@{
        Path = $Tests;
        Data = @{
            ResourceGroupName                      = $ResourceGroupName; 
            FunctionAppName                        = $FunctionAppName;
            EventHubNamespaceName                  = $EventHubNamespaceName;
            EventHubNamespaceAuthorizationRuleName = $EventHubNamespaceAuthorizationRuleName;
            EventHubName                           = $EventHubName;
            EventHubAuthorizationRuleName          = $EventHubAuthorizationRuleName;
            EventHubAuthorizationRuleName1         = $EventHubAuthorizationRuleName1;
        }
    }
    
    $Container = New-PesterContainer @Params
    
    $Configuration = [PesterConfiguration]@{
        Run          = @{
            Container = $Container
        }
        Output       = @{
            Verbosity = 'Detailed'
        }
        TestResult   = @{
            Enabled      = $true
            OutputFormat = "NUnitXml"
            OutputPath   = "$($ResultsPath)\Test-Pester.xml"
        }
        CodeCoverage = @{
            Enabled      = $true
            Path         = $Tests
            OutputFormat = "JaCoCo"
            OutputPath   = "$($ResultsPath)\Pester-Coverage.xml"
        }
    }
    
    if ($Publish) {
        Invoke-Pester -Configuration $Configuration
    }
    else {
        Invoke-Pester -Container $Container -Output Detailed
    }

PostDeployment.Tests.ps1

param(
    [string]$ResourceGroupName,
    [string]$FunctionAppName,
    [string]$EventHubNamespaceName,
    [string]$EventHubNamespaceAuthorizationRuleName,
    [string]$EventHubName,
    [string]$EventHubAuthorizationRuleName,
    [string]$EventHubAuthorizationRuleName1
)

Describe "Structure Tests" {

    BeforeAll {

        if ($ResourceGroupName.Length -gt 0) {
    
            $ResourceGroupData = Get-AzResourceGroup -Name $ResourceGroupName
        }

        if ($EventHubNamespaceName.Length -gt 0) {

            $EventHubNamespaceData = Get-AzEventHubNamespace -ResourceGroupName $ResourceGroupName -Name $EventHubNamespaceName
            $EventHubNamespaceAuthorizationRuleData = Get-AzEventHubAuthorizationRule -ResourceGroupName $ResourceGroupName -NamespaceName $EventHubNamespaceName -Name $EventHubNamespaceAuthorizationRuleName
        }

        if ($EventHubName.Length -gt 0) {

            $EventHubData = Get-AzEventHub -ResourceGroupName $ResourceGroupName -NamespaceName $EventHubNamespaceName -EventHubName $EventHubName
            $EventHubAuthorizationRuleData = Get-AzEventHubAuthorizationRule -ResourceGroupName $ResourceGroupName -NamespaceName $EventHubNamespaceName -EventHubName $EventHubName -Name $EventHubAuthorizationRuleName
            $EventHubAuthorizationRuleData1 = Get-AzEventHubAuthorizationRule -ResourceGroupName $ResourceGroupName -NamespaceName $EventHubNamespaceName -EventHubName $EventHubName -Name $EventHubAuthorizationRuleName1
        }

        if ($FunctionAppName.Length -gt 0) {

            $FunctionAppData = Get-AzFunctionApp -Name $FunctionAppName -ResourceGroupName $ResourceGroupName
        }
    }

    # Resource Group

    Context -Name "Resource Group" {

        It -Name "Passed Resource Group existence check" -Test {
            $ResourceGroupData | Should -Not -Be $null
        }        
    }

    # Event Hub Namespace

    Context -Name "Event Hub Namespace" {

        It -Name "Passed Event Hub Namespace existence check" -Test {
            $EventHubNamespaceData | Should -Not -Be $null
        }
        
        It -Name "Passed Event Hub Namespace tier check" -Test {
            $EventHubNamespaceData.Sku.Tier | Should -Be "Standard"
        }
        
        It -Name "Passed Event Hub Namespace TU check" -Test {
            $EventHubNamespaceData.Sku.Capacity | Should -Be 1
        }
        
        It -Name "Passed Event Hub Namespace auto-inflate check" -Test {
            $EventHubNamespaceData.IsAutoInflateEnabled | Should -Be $true
        }
        
        It -Name "Passed Event Hub Namespace maximum TU check" -Test {
            $EventHubNamespaceData.MaximumThroughputUnits | Should -Be 2
        }

        It -Name "Passed Event Hub Namespace shared access policies check" -Test {
            $EventHubNamespaceAuthorizationRuleData.Rights.Count | Should -Be 3
        }
    }

    # Event Hub

    Context -Name "Event Hub" {
    
        It -Name "Passed Event Hub existence check" -Test {
            $EventHubData | Should -Not -Be $null
        }
    
        It -Name "Passed Event Hub 'Listen' shared access policies check" -Test {
            $EventHubAuthorizationRuleData.Rights | Should -Be "Listen"
        }
    
        It -Name "Passed Event Hub 'Send' shared access policies check" -Test {
            $EventHubAuthorizationRuleData1.Rights | Should -Be "Send"
        }
    }

    # Function App

    Context -Name "Function App" {
    
        It -Name "Passed Function App existence check" -Test {
            $FunctionAppData | Should -Not -Be $null
        }        
        It -Name "Passed Function App AppSettings configuration existence check" -Test {
            $FunctionAppData.ApplicationSettings | Should -Not -Be $null
        }
        It -Name "Passed Function App APPINSIGHTS_INSTRUMENTATIONKEY existence check" -Test {
            $FunctionAppData.ApplicationSettings.APPINSIGHTS_INSTRUMENTATIONKEY | Should -Not -Be $null
        }  
        It -Name "Passed Function App FUNCTIONS_WORKER_RUNTIME value check" -Test {
            $FunctionAppData.ApplicationSettings.FUNCTIONS_WORKER_RUNTIME | Should -Be "dotnet"
        }
    }
}

As you can see I am overwriting [PesterConfigruation]::Default with my configuration. And yes, TestResult block with NUnitXml works as well. Just add Publish Test Results task at the end of the pipeline. It will pick up the test results and publish them. Hope this will help someone in the future.

Answer 3

They moved many settings to a new Configuration object. Described here: https://pester-docs.netlify.app/docs/commands/New-PesterConfiguration

Old:

Invoke-Pester -Script $testFile -PassThru -Verbose -OutputFile $tr `
    -OutputFormat NUnitXml -CodeCoverage "$tmp/*-*.ps1" `
    -CodeCoverageOutputFile $cc -Show All

New:

$configuration = [PesterConfiguration]@{
      PassThru = $true
      Run = @{
         Path = $testFile
      }
      Output = @{
         Verbosity = 'Detailed'
      }
      TestResult = @{
         Enabled = $true
         OutputFormat = "NUnitXml"
         OutputPath   = $tr
         }
      CodeCoverage = @{
         Enabled = $true
         Path = "$tmp/*-*.ps1"
         OutputPath = $cc
         }
      }       

  Invoke-Pester -Configuration $configuration