Eu tenho tentado escrever um código seguro que ofereça suporte ao método ShouldProcess para que meus usuários tenham uma idéia do que um cmdlet deve fazer antes de executá-lo de verdad

No entanto, me deparei com um problema. Se eu chamar um script com -whatif como argumento, $ pscmdlet.ShouldProcess retornará false. Tudo bem e bem. Se eu chamar um cmdlet definido no mesmo arquivo (que possui SupportsShouldProcess = $ true), ele retornará false também.

No entanto, se eu estiver chamando um cmdlet definido em outro módulo que eu carreguei usando o Import-Module, ele retornará true. O contexto -que não parece ser passado para chamadas no outro módulo.

Eu não quero passar manualmente um sinalizador para cada cmdlet. Alguém tem uma solução melhor?

Este problema parece relacionado a estequestã. No entanto, eles não estão falando sobre o problema entre módulo

Exemplo de script:

#whatiftest.ps1
[CmdletBinding(SupportsShouldProcess=$true)]
param()

Import-Module  -name .\whatiftest_module  -Force

function Outer
{
    [CmdletBinding(SupportsShouldProcess=$true)]
    param()
    if( $pscmdlet.ShouldProcess("Outer"))
    {
        Write-Host "Outer ShouldProcess"
    }
    else
    {
        Write-Host "Outer Should not Process"
    }

    Write-Host "Calling Inner"
    Inner
    Write-Host "Calling InnerModule"
    InnerModule
}

function Inner
{
    [CmdletBinding(SupportsShouldProcess=$true)]
    param()

    if( $pscmdlet.ShouldProcess("Inner"))
    {
        Write-Host "Inner ShouldProcess"
    }
    else
    {
        Write-Host "Inner Should not Process"
    }
}

    Write-Host "--Normal--"
    Outer

    Write-Host "--WhatIf--"
    Outer -WhatIf

O Módulo:

#whatiftest_module.psm1
 function InnerModule
 {
    [CmdletBinding(SupportsShouldProcess=$true)]
    param()    

    if( $pscmdlet.ShouldProcess("InnerModule"))
    {
        Write-Host "InnerModule ShouldProcess"
    }
    else
    {
        Write-Host "InnerModule Should not Process"
    }
 }

Resultado

F:\temp> .\whatiftest.ps1
--Normal--
Outer ShouldProcess
Calling Inner
Inner ShouldProcess
Calling InnerModule
InnerModule ShouldProcess
--WhatIf--
What if: Performing operation "Outer" on Target "Outer".
Outer Should not Process
Calling Inner
What if: Performing operation "Inner" on Target "Inner".
Inner Should not Process
Calling InnerModule
InnerModule ShouldProcess