Empty array contains null??

[YoraiLevi]

Describe 'Empty array contains null' {
    # ModuleType Version    PreRelease Name                                PSEdition ExportedCommands
    # ---------- -------    ---------- ----                                --------- ----------------
    # Script     5.5.0                 Pester                              Desk      {Invoke-Pester, Describe, Context, It…} 
    It 'Piped BeIn' {
        # https://github.com/pester/Pester/blob/acc66a965219a8e70981977289227a211af4c70e/src/functions/assertions/BeIn.ps1#L12
        $null | Should -Not -BeIn @() 
        
    }
    It 'Piped Contain' {
        # https://github.com/pester/Pester/blob/acc66a965219a8e70981977289227a211af4c70e/src/functions/assertions/Contain.ps1#L12
        @() | Should -Contain $null
        # Expected $null to not be found in collection $null, but it was found.
    }
    It 'No pipe Contain' {
        Should @() -Not -Contain $null
    }
    It 'Sanity?' {
        @() -contains $null | Should -BeFalse
        $null -contains @() | Should -BeFalse
        $null -contains $null | Should -BeTrue
    }
}

When @() is piped it passes $null to contains, which makes sense but unintuitive to me.
other than Should @() -Contain $null which solves the issue, is it possible to use pipes and avoid this?

[YoraiLevi]

Contain's behavior is weird and inconsistent with the other should operators.

Describe 'Contain' {
    #? Should [[-ActualValue] <Object>] [-Not] [-ExpectedValue <Object>] [-Because <Object>] [-Contain] [<CommonParameters>]
    # Asserts that collection contains a specific value. Uses PowerShell's -contains operator to confirm.
    It 'Piped syntax' {
        1 | Should -Contain 1
        @(1, 2, 3) | Should -Contain 1
        @(1, 2, 3) | Should -Contain '1'
        'hello', 'world' | Should -Contain 'hello'
        'hello', 'world' | Should -Contain 'Hello'
        
        @() | Should -Not -Contain 1
        @() | Should -Contain $null
    }
    It 'Direct syntax' {
        Should -ActualValue 1 -Contain 1
        { Should -ActualValue @(1, 2, 3) -Contain 1 } | Should -Throw -ExpectedMessage '*Expected 1 to be found in collection @(@(1, 2, 3)), but it was not found.*'
        { Should -ActualValue @(1, 2, 3) -Contain '1' } | Should -Throw -ExpectedMessage "*Expected '1' to be found in collection @(@(1, 2, 3)), but it was not found.*"
        { Should -ActualValue @('hello', 'world') -Contain 'hello' } | Should -Throw -ExpectedMessage "*Expected 'hello' to be found in collection @(@('hello', 'world')), but it was not found.*"
        { Should -ActualValue @('hello', 'world') -Contain 'Hello' } | Should -Throw -ExpectedMessage "*Expected 'Hello' to be found in collection @(@('hello', 'world')), but it was not found.*"

        Should -ActualValue @() -Not -Contain 1
        { Should -ActualValue @() -Contain $null } | Should -Throw -ExpectedMessage '*Expected $null to be found in collection @(@()), but it was not found.*'
    }
    It 'Single element arrays are evaluated as the single element' {
        @(1) | Should -Contain 1
        { Should -ActualValue @(1) -Contain 1 } | Should -Throw -ExpectedMessage '*Expected 1 to be found in collection @(1), but it was not found.*'
    }
    It 'Arrays are evaluated as a whole when piped to Contain' {
        { @(@(1, 2, 3), @(1, 2, 3)) | Should -Contain 1 } | Should -Throw -ExpectedMessage '*Expected 1 to be found in collection @(@(1, 2, 3), @(1, 2, 3)), but it was not found.*'
        { @(@(1, 2, 3), @(1, 2, 3)) | Should -Contain @(1, 2, 3) } | Should -Throw -ExpectedMessage '*Expected @(1, 2, 3) to be found in collection @(@(1, 2, 3), @(1, 2, 3)), but it was not found.*'
        $obj = @(1, 2, 3)
        @($obj, @(4, 5, 6)) | Should -Contain $obj
    }
    It 'Arrays are wrapped with another array when not piped' {
        { Should -ActualValue @(@(1, 2, 3), @(1, 2, 3)) -Contain 1 } | Should -Throw -ExpectedMessage '*Expected 1 to be found in collection @(@(@(1, 2, 3), @(1, 2, 3))), but it was not found.*'
        { Should -ActualValue @(@(1, 2, 3), @(1, 2, 3)) -Contain @(1, 2, 3) } | Should -Throw -ExpectedMessage '*Expected @(1, 2, 3) to be found in collection @(@(@(1, 2, 3), @(1, 2, 3))), but it was not found.*'
        $obj = @(1, 2, 3)
        { Should -ActualValue @($obj, @(4, 5, 6)) -Contain $obj } | Should -Throw -ExpectedMessage '*Expected @(1, 2, 3) to be found in collection @(@(@(1, 2, 3), @(4, 5, 6))), but it was not found.*'
        Should -ActualValue $obj -Contain $obj
    }
    It "Omitting '-ActualValue' inputs `$null to the Should command and defaults to '-ExpectedValue'" {
        { Should 1 -Contain 1 } | Should -Throw -ExpectedMessage '*Cannot retrieve the dynamic parameters for the cmdlet. Legacy Should syntax (without dashes) is not supported in Pester 5.*'
        { Should @(1) -Contain 1 } | Should -Throw -ExpectedMessage '*Expected 1 to be found in collection @($null), because 1, but it was not found.*'   
    }
}

[nohwnd]

You are right, this is partially our fault and partially powershells fault. We have to work hard to figure out what you provided to the assertion and have to know if you did that via the pipeline or not. This is becuse the pipeline unwraps the values, and this is an edge case. I've tried the same thing in my Assert module, where I think I solved this better (because I don't have to keep the behavior backwards compatible there), and it still has the same issue.

The code is simple to follow, definitely simpler than in Should, so this is my implementation there:

function Assert-Contain {
    param (
        [Parameter(Position=1, ValueFromPipeline=$true)]
        $Actual, 
        [Parameter(Position=0)]
        $Expected,
        [String]$CustomMessage
    )

    $Actual = Collect-Input -ParameterInput $Actual -PipelineInput $local:Input
    if ($Actual -notcontains $Expected) 
    { 
        $type = [string]$Expected
        $Message = Get-AssertionMessage -Expected $Expected -Actual $Actual -CustomMessage $CustomMessage -DefaultMessage "Expected <expectedType> '<expected>' to be present in collection '<actual>', but it was not there."
        throw [Assertions.AssertionException]$Message
    }

    $Actual
}

function Collect-Input ($ParameterInput, $PipelineInput) 
{
    #source: http://www.powertheshell.com/input_psv3/
    $collectedInput = @($PipelineInput)

    $isInPipeline = $collectedInput.Count -gt 0
    if ($isInPipeline) {
        $collectedInput
    }
    else 
    {
        $ParameterInput
    }
}

The $local:input is an automatic variable that contains array of all the incoming values in the pipeline. Problem is that when you do @() | Assert-Contains we will see the input array has length 0 and take the value from $Actual, which is $null because there is no value bound to it. This is wrong.

I think there is a solution though, $MyInvocation.ExpectingInput seems to be true when we are in pipeline, and false when we run as Assert-Contains -Actual @(), so hopefully we can use that to distinguish between those two cases.

I am planning to bring assert assertions into Pester in the next version, so hopefully this will be fixed this early next year.

[YoraiLevi]

I haven't checked how Pester works in much detail but I was struggling with distinguishing between pipeline inputs and not in the past and my solution was to use parameter sets. this allowed me to know for sure what state i am in and how to digest the input.
sample code:

function Import-Reg {
    [CmdletBinding(DefaultParameterSetName = 'LiteralPath')]
    param(
        [Parameter(Mandatory = $true, ParameterSetName = 'Path')]
        [string[]]$Path,
        [Parameter(Mandatory = $true, ParameterSetName = 'LiteralPath', Position = 0)]
        [string[]]$LiteralPath,
        [Parameter(Mandatory = $true, ValueFromPipeline = $true, ParameterSetName = 'Pipeline')]
        [psobject[]]$InputObject
    )
    begin {}
    process {
        switch ($PsCmdlet.ParameterSetName) {
            'Path' {
                $Path | ForEach-Object { Get-Content -Path $_ | ConvertFrom-Reg }
            }
            'LiteralPath' {
                $LiteralPath | ForEach-Object { Get-Content -LiteralPath $_ | ConvertFrom-Reg }
            }
            'Pipeline' {
                $InputObject | Get-Content | ConvertFrom-Reg
            }

        }
    }
    end {}
}