Update tests for Pester 5.x

Author: Jaykul

Build.build.ps1

@@ -19,6 +19,15 @@ param(
     # Collect code coverage when tests are run
     [switch]$CollectCoverage,
 
+    # The PesterFilter from New-PesterConfiguration.
+    # Supports specifying any of:
+    #   Tag: Tags of Describe, Context or It to be run.
+    #   ExcludeTag: Tags of Describe, Context or It to be excluded from the run.
+    #   Line: Filter by file and scriptblock start line, useful to run parsed tests programmatically to avoid problems with expanded names. Example: 'C:\tests\file1.Tests.ps1:37'
+    #   ExcludeLine: Exclude by file and scriptblock start line, takes precedence over Line.
+    #   FullName: Full name of test with -like wildcards, joined by dot. Example: '*.describe Get-Item.test1'
+    [hashtable]$PesterFilter,
+
     # Which projects to build
     [Alias("Projects")]
     $dotnetProjects = @(),
@@ -39,6 +48,7 @@ $ErrorView = 'DetailedView'
 
 # The name of the module to publish
 $script:PSModuleName = "TerminalBlocks"
+$script:RequiredCodeCoverage = 0.85
 # Use Env because Earthly can override it
 $Env:OUTPUT_ROOT ??= Join-Path $BuildRoot Modules
 

RequiredModules.psd1

@@ -2,7 +2,7 @@
 @{
     Configuration    = "[1.5.0, 2.0)"
     Metadata         = "[1.5.1, 2.0)"
-    Pester           = "[4.10.1,5.0)"
+    Pester           = "[5.6.1, 6.0)"
     ModuleBuilder    = "[3.0.0, 4.0)"
     PSScriptAnalyzer = "[1.21.0,2.0)"
     PowerShellGet    = "2.0.4"

Source/Private/CompressToBase64.ps1

@@ -0,0 +1,57 @@
+function CompressToBase64 {
+    <#
+        .SYNOPSIS
+            Compresses and encodes a module file for embedding into a script
+        .DESCRIPTION
+            Reads the raw bytes and then compress (gzip) them, before base64 encoding the result
+        .EXAMPLE
+            Get-ChildItem *.dll, *.psm1 | CompressToBase64 -ExpandScript ImportBase64Module > Script.ps1
+
+            Script.ps1 will contain the base64 encoded (and compressed) contents of the files, piped to the ImportBase64Module function
+        .LINK
+            ImportBase64Module
+    #>
+    [CmdletBinding(DefaultParameterSetName = "Base64")]
+    [OutputType([string])]
+    param(
+        # The path to the dll or script file to compress
+        [Parameter(Mandatory, Position = 0, ValueFromPipeline, ValueFromPipelineByPropertyName)]
+        [Alias("PSPath")]
+        [string[]]$Path,
+
+        # If set, wraps the Base64 encoded content in the specified command
+        [Parameter(Mandatory, Position = 1, ParameterSetName = "ExpandScriptName")]
+        [string]$ExpandScriptName,
+
+        # If set, wraps the Base64 encoded content in the specified command
+        [Parameter(Mandatory, Position = 1, ParameterSetName = "ExpandScript")]
+        [ScriptBlock]$ExpandScript
+    )
+    begin {
+        $Result = @()
+        if ($ExpandScriptName -and !$ExpandScript) {
+            $ExpandScript = (Get-Command $ExpandScriptName).ScriptBlock
+        }
+    }
+    process {
+        foreach ($File in $Path | Convert-Path) {
+            $Source = [System.IO.MemoryStream][System.IO.File]::ReadAllBytes($File)
+            $OutputStream = [System.IO.Compression.DeflateStream]::new(
+                [System.IO.MemoryStream]::new(),
+                [System.IO.Compression.CompressionMode]::Compress)
+            $Source.CopyTo($OutputStream)
+            $OutputStream.Flush()
+            $ByteArray = $OutputStream.BaseStream.ToArray()
+            if (!$ExpandScript) {
+                [Convert]::ToBase64String($ByteArray)
+            } else {
+                $Result += [Convert]::ToBase64String($ByteArray)
+            }
+        }
+    }
+    end {
+        if ($ExpandScript) {
+            [ScriptBlock]::Create("@(`n'$($Result -join "'`n'")'`n)|.{`n${ExpandScript}`n}").ToString()
+        }
+    }
+}

Source/Private/CopyReadMe.ps1

@@ -1,4 +1,8 @@
 function CopyReadMe {
+    <#
+        .SYNOPSIS
+            Copy the readme file as an about_ help file
+    #>
     [CmdletBinding()]
     param(
         # The path to the ReadMe document to copy
@@ -22,19 +26,18 @@ function CopyReadMe {
         [Switch]$Force
     )
     process {
-        # Copy the readme file as an about_ help file
-        Write-Verbose "Test for ReadMe: $Pwd/$($ReadMe)"
+        Write-Verbose "Test for ReadMe: $ReadMe"
         if ($ReadMe -and (Test-Path $ReadMe -PathType Leaf)) {
             # Make sure there's a language path
             $LanguagePath = Join-Path $OutputDirectory $Culture
             if (!(Test-Path $LanguagePath -PathType Container)) {
+                Write-Verbose "Create language path: $LanguagePath"
                 $null = New-Item $LanguagePath -Type Directory -Force
             }
-            Write-Verbose "Copy ReadMe to: $LanguagePath"
 
             $about_module = Join-Path $LanguagePath "about_$($ModuleName).help.txt"
             if (!(Test-Path $about_module)) {
-                Write-Verbose "Turn readme into about_module"
+                Write-Verbose "Copy $ReadMe to: $about_module"
                 Copy-Item -LiteralPath $ReadMe -Destination $about_module -Force:$Force
             }
         }

Source/Private/ImportBase64Module.ps1

@@ -0,0 +1,43 @@
+# The comment-based help for this function is outside the function to avoid packing it
+# Normally, I put it inside, but I do not want this in packed scripts
+
+<#
+    .SYNOPSIS
+        Expands Base64+GZip strings and loads the result as an assembly or module
+    .DESCRIPTION
+        Converts Base64 encoded string to bytes and decompresses (gzip) it.
+        If the result is a valid assembly, it is loaded.
+        Otherwise, it is imported as a module.
+    .PARAMETER Base64Content
+        A Base64 encoded and deflated assembly or script
+    .LINK
+        CompressToBase64
+#>
+function ImportBase64Module {
+    [CmdletBinding(DefaultParameterSetName = "ByteArray")]
+    param(
+        [Parameter(Mandatory, ValueFromPipeline)]
+        [string]$Base64Content
+    )
+    process {
+        $Out = [System.IO.MemoryStream]::new()
+        $In = [System.IO.MemoryStream][System.Convert]::FromBase64String($Base64Content)
+        $zip = [System.IO.Compression.DeflateStream]::new($In, [System.IO.Compression.CompressionMode]::Decompress)
+        $zip.CopyTo($Out)
+        trap [System.IO.InvalidDataException] {
+            Write-Debug "Base64Content not Compressed. Skipping Deflate."
+            $In.CopyTo($Out)
+            continue
+        }
+        $null = $Out.Seek(0, "Begin")
+        $null = [System.Reflection.Assembly]::Load($Out.ToArray())
+        trap [BadImageFormatException] {
+            Write-Debug "Base64Content not an Assembly. Trying New-Module and ScriptBlock.Create."
+            $null = $Out.Seek(0, "Begin")
+            # Use StreamReader to handle possible BOM
+            $Source = [System.IO.StreamReader]::new($Out, $true).ReadToEnd()
+            $null = New-Module ([ScriptBlock]::Create($Source)) -Verbose:$false | Import-Module -Scope Global -Verbose:$false
+            continue
+        }
+    }
+}

Source/Private/MoveUsingStatements.ps1

@@ -0,0 +1,65 @@
+using namespace System.Management.Automation.Language
+
+function Move-UsingStatement {
+    <#
+        .SYNOPSIS
+            A Script Generator that commetnts out using statements and copies them to the top of the file
+        .DESCRIPTION
+            Move-UsingStatement supports having using statements repeated in multiple files that are merged by ModuleBuilder.
+            When all the files are merged together, the using statements from individual files
+            don't necessarily end up at the beginning of the PSM1, which creates Parsing Errors.
+
+            This function uses the AST to generate TextReplacements to:
+            1. Comment out the original using statements (to preserve line numbering)
+            2. Insert the using statements (conserving order, but removing duplicates) at the top of the script
+    #>
+    [CmdletBinding()]
+    [OutputType([TextReplacement])]
+    param(
+        # The AST of the original script module to refactor
+        [Parameter(Mandatory, ValueFromPipelineByPropertyName)]
+        [Alias("Ast")]
+        [Ast]$InputObject,
+
+        # Parser Errors from parsing the original script module
+        [Parameter(ValueFromPipelineByPropertyName)]
+        [AllowNull()]
+        [ParseError[]]$ParseErrors
+    )
+    process {
+        # Avoid modifying the file if there's no Parsing Error caused by Using Statements or other errors
+        if (!$ParseErrors.Where{ $_.ErrorId -eq 'UsingMustBeAtStartOfScript' }) {
+            Write-Debug "No using statement errors found."
+            return
+        } else {
+            # as decided https://github.com/PoshCode/ModuleBuilder/issues/96
+            Write-Debug "Parsing errors found. We'll still attempt to Move using statements."
+        }
+
+        # Find all Using statements including those non erroring (to conserve their order)
+        $UsingStatementExtents = $InputObject.FindAll(
+            { $Args[0] -is [System.Management.Automation.Language.UsingStatementAst] },
+            $false
+        ).Extent
+
+        # Edit the Script content by commenting out existing statements (conserving line numbering)
+        $StatementsToCopy = [System.Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
+
+        foreach ($UsingSatement in $UsingStatementExtents) {
+            [TextReplacement]@{
+                StartOffset = $UsingSatement.StartOffset
+                EndOffset   = $UsingSatement.EndOffset
+                Text        = '# ' + $UsingSatement.Text
+            }
+            # Keep track of unique statements we'll need to insert at the top
+            $null = $StatementsToCopy.Add($UsingSatement.Text)
+        }
+        if ($StatementsToCopy.Count -gt 0) {
+            [TextReplacement]@{
+                StartOffset = 0
+                EndOffset   = 0
+                Text        = ($StatementsToCopy -join "`r`n")+ "`r`n"
+            }
+        }
+    }
+}

Source/Public/Move-UsingStatement.ps1

@@ -1,29 +1,31 @@
-#requires -Module ModuleBuilder
 . $PSScriptRoot\..\Convert-FolderSeparator.ps1
 
 Describe "Parameters.Set in build manifest" -Tag Integration {
     BeforeAll {
+        # This file should not be deleted by the build, because VersionedOutput defaults true now
+        # So the actual Build output will be ../Result3/Parameters/3.0.0
         New-Item $PSScriptRoot\Result3\Parameters\ReadMe.md -ItemType File -Force
+
         $Output = Build-Module $PSScriptRoot\Parameters\build.psd1
         if ($Output) {
             $Module = [IO.Path]::ChangeExtension($Output.Path, "psm1")
             $Metadata = Import-Metadata $Output.Path
         }
     }
 
-    It "Passthru works" {
+    It "Passthru can be set from build.psd1" {
         $Output | Should -Not -BeNullOrEmpty
     }
 
-    It "The Target is Build" {
-        "$PSScriptRoot\Result3\Parameters\ReadMe.md" | Should -Exist
+    It "The version can be set from build.psd1" {
+        $Metadata.ModuleVersion | Should -Be "3.0.0"
     }
 
-    It "The version is set" {
-        $Metadata.ModuleVersion | Should -Be "3.0.0"
+    It "Files outside the Output should not be cleaned up or overwritten" {
+        "$PSScriptRoot\Result3\Parameters\ReadMe.md" | Should -Exist
     }
 
-    It "The PreRelease is set" {
+    It "The PreRelease is set properly even when set from build.psd1" {
         $Metadata.PrivateData.PSData.Prerelease | Should -Be 'alpha001'
     }
 }