Simon Elms's questions

Tenho um script do PowerShell para configurar um site no IIS. Ele inclui as seguintes funções:

function Set-IisWebsiteBinding (
    [Parameter(Mandatory = $true)]
    [string]$SiteName, 
    
    [Parameter(Mandatory = $true)]
    [Microsoft.Web.Administration.Site]$Website,
    
    [Parameter(Mandatory = $true)]
    [array]$WebsiteBindingSettings
)
{
    # Set up website bindings ...
}

Estou tentando escrever testes para a função no Pester. Gostaria de criar um objeto fictício $Website para passar para a função em teste. O problema é que o Microsoft.Web.Administration.Sitetipo não tem construtor. Como posso criar um objeto do tipo Microsoft.Web.Administration.Siteno PowerShell se ele não tem construtor?

Eu poderia criar um via , IISServerManager.Sites.CreateElement()mas gostaria de evitar ter que depender do uso de um IISServerManager. Alternativamente, eu poderia me livrar da coerção de tipo para o parâmetro de função $Website, para permitir que o código de teste passasse uma tabela de hash em vez de um objeto Microsoft.Web.Administration.Site. No entanto, prefiro manter a coerção de tipo para que fique óbvio para os futuros mantenedores do script qual $Websiteé o tipo do objeto.

Existe alguma maneira de contornar essa falta de um construtor sem usar um real IISServerManagerou remover a coerção de tipo?

No SQL Server Management Studio (SSMS), ao filtrar eventos no XEvent Profiler, qual é a diferença entre o operador Contains e o operador Like? Não consegui encontrar nenhuma documentação sobre isso.

Aqui está a caixa de diálogo Filtros para o XEvent Profiler, mostrando a lista de possíveis operadores de comparação, incluindo Containse Like:

No PowerShell eu tenho uma lista de hashtables. Usei um Where()método para selecionar uma das tabelas hash da lista porque li que Where()é mais rápido que Where-Object. No entanto, quando tento operar na tabela hash selecionada, descubro que ela foi convertida em uma coleção pelo Where()método. Não consigo convertê-lo em uma tabela hash.

Existe alguma maneira de fazer com que o Where()método retorne uma tabela hash em vez de uma coleção?

Se for necessário, posso usar Where-Objecto que retorna uma tabela hash. No entanto, prefiro continuar Where()se houver uma solução alternativa simples.

Algum código de demonstração:

Clear-Host

[System.Object[]]$SqlServers = @(
                                    @{
                                        key="L"; 
                                        connectionString="Server=(localdb)\\mssqllocaldb;Database=Test;Trusted_Connection=yes;";
                                    },
                                    @{
                                        key="D"; 
                                        connectionString="Server=DEV.DEV.LOCAL;Database=Test;Trusted_Connection=yes;";
                                    }
                                )
$UserSelection = 'L'

$selectedServerDetails = $SqlServers.Where({$_.key -eq $UserSelection})
$selectedServerDetails2 = $SqlServers | Where-Object{$_.key -eq $UserSelection}

$selectedServerDetails3 = ($selectedServerDetails -as [hashtable])

$selectedServerDetails.GetType().FullName
$selectedServerDetails2.GetType().FullName
if ($selectedServerDetails3 -eq $null) { '$selectedServerDetails3 is null' } else { $selectedServerDetails3.GetType().FullName }

O que resulta em:

System.Collections.ObjectModel.Collection`1[[System.Management.Automation.PSObject, System.Management.Automation, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35]]
System.Collections.Hashtable
$selectedServerDetails3 is null

A propósito, tentei alterar o tipo de dados $SqlServerspara [hashtable[]]$SqlServers. Não fez diferença.

Estou atualizando alguns testes muito antigos para funcionar com o Pester 5. Antigamente Should -Thrownão havia suporte para especificar o tipo de exceção que deveria ser lançado, então rolei minha própria afirmação. Agora quero substituir minhas afirmações caseiras por Should -Throw -ExceptionType. No entanto , posso encontrar muito pouco on-line sobre como especificar o tipo de exceção a ser usado Should -Throw -ExceptionType.

A página de referência de afirmações de Pester não menciona -ExceptionTypenada. A única referência que encontrei é uma postagem antiga no blog, https://jakubjares.com/2017/12/19/using-should-throw/ , que inclui o código:

Should -Throw -ExceptionType ([ArgumentException])

Alguém poderia explicar o formato? O que ([...])fazer? E como posso especificar um tipo de exceção não padrão? Quero verificar se há um ParameterBindingValidationException. eu tentei

Should -Throw -ExceptionType ([System.Management.Automation.ParameterBindingValidationException]) 

e

Should -Throw -ExceptionType ([System.Management.Automation.ParameterBindingValidationException, System.Management.Automation]) 

e

Should -Throw -ExceptionType ([System.Management.Automation.ParameterBindingValidationException, System.Management.Automation, Version=7.3.7.500, Culture=neutral, PublicKeyToken=31bf3856ad364e35]) 

mas recebo um erro semelhante ao seguinte quando executo o teste:

RuntimeException: Não foi possível encontrar o tipo [System.Management.Automation.ParameterBindingValidationException]

Se eu substituir o tipo de exceção por

Should -Throw -ExceptionType ([System.ArgumentException]) 

Pester então parece reconhecer o tipo de exceção que especifiquei. Recebo a seguinte mensagem:

Esperava-se que uma exceção com o tipo [System.ArgumentException] fosse lançada, mas o tipo de exceção era [System.Management.Automation.ParameterBindingValidationException, System.Management.Automation, Version=7.3.7.500, Culture=neutral, PublicKeyToken=31bf3856ad364e35].

Portanto, estou confuso sobre como devo especificar a exceção que deve ser lançada.

Tenho alguns testes antigos do Pester v4 que falham quando tento executá-los no Pester v5.

Com o Pester v4, li que, uma vez Mockchamado, ele continuará a ser aplicado ao restante do Describebloco, mesmo que tenha sido chamado dentro de um Itbloco. Então eu chamaria isso do Describebloco, fora de um Itbloco, para deixar óbvio que não se aplica apenas a um único Itbloco.

Esse comportamento que funcionou no Pester v4 parece não funcionar no Pester v5.

Este é o script no qual estou escrevendo testes, MyScriptToTest.ps1:

function Get-FirstText ()
{
    return 'Some text'
}

function Get-SecondText ()
{
    return 'Other text'
}

function Get-Text ()
{
    $a = Get-FirstText
    $b = Get-SecondText

    return "$a; $b"
}

E aqui estão os testes, em MyScriptToTest.Tests.ps1:

BeforeAll {
    . (Join-Path $PSScriptRoot 'MyScriptToTest.ps1')
}

Describe 'Get-FirstText' {
    It 'returns text "Some text"' {
        $result = Get-FirstText
            $result | Should -Be 'Some text'
        } 
}

Describe 'Get-Text' {
    It 'returns text "Some text; Other text"' {
        Get-Text | Should -Be 'Some text; Other text'
        } 

    Mock Get-FirstText { return 'Mock text' }
    
    It 'returns text "Mock text; Other text" after mocking Get-FirstText' {
        Get-Text | Should -Be 'Mock text; Other text'
        } 
}

A saída do teste Pester v5 é a seguinte:

Describing Get-FirstText
  [+] returns text "Some text" when called indirectly 13ms (8ms|5ms)

Describing Get-Text
  [+] returns text "Some text; Other text" 66ms (54ms|13ms)
  [-] returns text "Mock text; Other text" after mocking Get-FirstText 42ms (41ms|1ms)
   Expected strings to be the same, but they were different.
   String lengths are both 21.
   Strings differ at index 0.
   Expected: 'Mock text; Other text'
   But was:  'Some text; Other text'
              ^
   at Get-Text | Should -Be 'Mock text; Other text', C:\...\MyScriptToTest.Tests.ps1:20
   at <ScriptBlock>, C:\...\MyScriptToTest.Tests.ps1:20
Tests completed in 565ms
Tests Passed: 2, Failed: 1, Skipped: 0 NotRun: 0

No entanto, se eu mover o Mockcomando para o Itbloco, ele funcionará:

BeforeAll {
    . (Join-Path $PSScriptRoot 'MyScriptToTest.ps1')
}

Describe 'Get-FirstText' {
    It 'returns text "Some text"' {
        $result = Get-FirstText
            $result | Should -Be 'Some text'
        } 
}

Describe 'Get-Text' {
    It 'returns text "Some text; Other text"' {
        Get-Text | Should -Be 'Some text; Other text'
        }   
   
    It 'returns text "Mock text; Other text" after mocking Get-FirstText' {
        Mock Get-FirstText { return 'Mock text' }
        Get-Text | Should -Be 'Mock text; Other text'
        } 
}

Não descobri as novas restrições ao chamar o Mockcomando no Pester v5. O Mockcomando ainda pode ser chamado dentro de um bloco Describeou Context, fora de um Itbloco? Ou agora sempre precisa ser chamado dentro de um Itbloco?