Files
PowerShell-PowerShell/test/powershell/Language/Scripting/CommonParameters.Tests.ps1
T
xtqqczze 743983390e Update pester syntax to v4 (#11544)
* Capitalize 'Should' command and fix whitespace

```powershell
$_ -ireplace '\s?\|\s?should\b',' | Should'
```

* Capitalise and apply hyphen to 'Not' parameter

```powershell
$_ -ireplace '(\| Should) not\b','$1 -Not'
```

* Capitalise and apply hyphen to 'Be' parameter

```powershell
$_ -ireplace '(\| Should(?: -Not)?) -?be\b','$1 -Be'
```

* Capitalise and apply hyphen to 'BeExactly' parameter

$_ -ireplace '(\| Should(?: -Not)?) -?beexactly\b','$1 -BeExactly'

* Capitalise and apply hyphen to 'BeGreaterThan' parameter

```powershell
$_ -ireplace '(\| Should(?: -Not)?) -?begreaterthan\b','$1 -BeGreaterThan'
```

* Use 'BeTrue' parameter

```powershell
$_ -ireplace '(\| Should(?: -Not)?) -Be\s\$?true\b','$1 -BeTrue'
```

* Use 'BeFalse' parameter

```powershell
$_ -ireplace '(\| Should(?: -Not)?) -Be\s\$?false\b','$1 -BeFalse'
```

* Capitalise and apply hyphen to 'Match' parameter

```powershell
$_ -ireplace '(\| Should(?: -Not)?)\s-?match\b','$1 -Match'
```

* Capitalise and apply hyphen to 'Throw' parameter

```powershell
$_ -ireplace '(\| Should(?: -Not)?)\s-?throw\b','$1 -Throw'
```

* Capitalise and apply hyphen to 'BeNullOrEmpty' parameter

```powershell
$_ -ireplace '(\| Should(?: -Not)?)\s-?benullorempty\b','$1 -BeNullOrEmpty'
```

* Capitalise 'Because' parameter

```powershell
$_ -ireplace '\s-because\b',' -Because'
```

* Fix 'BeNullOrEmpty'
2020-01-11 20:41:59 +05:00

368 lines
11 KiB
PowerShell

# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
Describe "Common parameters support for script cmdlets" -Tags "CI" {
BeforeEach {
$rs = [system.management.automation.runspaces.runspacefactory]::CreateRunspace()
$rs.open()
$ps = [System.Management.Automation.PowerShell]::Create()
$ps.Runspace = $rs
}
AfterEach {
$ps.Dispose()
$rs.Dispose()
}
Context "Debug" {
BeforeAll {
$script = "
function get-foo
{
[CmdletBinding()]
param()
write-output 'output foo'
write-debug 'debug foo'
}"
}
It "Debug get-foo" {
$command = 'get-foo'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$output[0] | Should -BeExactly "output foo"
$ps.Streams.Debug.Count | Should -Be 0
}
It 'get-foo -debug' {
$command = 'get-foo -debug'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$output[0] | Should -BeExactly "output foo"
$ps.Streams.Debug[0].Message | Should -BeExactly "debug foo"
$ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
}
}
Context "verbose" {
BeforeAll {
$script = "
function get-foo
{
[CmdletBinding()]
param()
write-output 'output foo'
write-verbose 'verbose foo'
}"
}
It 'get-foo' {
$command = 'get-foo'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$output[0] | Should -BeExactly "output foo"
$ps.streams.verbose.Count | Should -Be 0
}
It 'get-foo -verbose' {
$command = 'get-foo -verbose'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$output[0] | Should -BeExactly "output foo"
$ps.Streams.verbose[0].Message | Should -BeExactly "verbose foo"
$ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
}
}
Context "erroraction" {
BeforeAll {
$script = "
function get-foo
{
[CmdletBinding()]
param()
write-error 'error foo'
write-output 'output foo'
}"
}
It 'erroraction' {
$command = 'get-foo'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$output[0] | Should -BeExactly "output foo"
$ps.Streams.error[0].ToString() | Should -Match "error foo"
}
It 'erroraction continue' {
$command = 'get-foo -erroraction Continue'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$output[0] | Should -BeExactly "output foo"
$ps.Streams.error[0].ToString() | Should -Match "error foo"
}
It 'erroraction SilentlyContinue' {
$command = 'get-foo -erroraction SilentlyContinue'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$output[0] | Should -BeExactly "output foo"
$ps.streams.error.count | Should -Be 0
}
It 'erroraction Stop' {
$command = 'get-foo -erroraction Stop'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
{ $ps.EndInvoke($asyncResult) } | Should -Throw -ErrorId "ActionPreferenceStopException"
# Exception: "Command execution stopped because the preference variable "ErrorActionPreference" or common parameter is set to Stop: error foo"
# BUG in runspace api.
#$ps.error.count | Should -Be 1
$ps.InvocationStateInfo.State | Should -BeExactly 'Failed'
}
}
Context "SupportShouldprocess" {
$script = '
function get-foo
{
[CmdletBinding(SupportsShouldProcess=$true)]
param()
if($pscmdlet.shouldprocess("foo", "foo action"))
{
write-output "foo action"
}
}'
It 'SupportShouldprocess' {
$command = 'get-foo'
$ps = [system.management.automation.powershell]::Create()
[void] $ps.AddScript($script + $command)
$ps.RunspacePool = $rp
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$output[0] | Should -BeExactly 'foo action'
}
It 'shouldprocess support -whatif' {
$command = 'get-foo -whatif'
$ps = [system.management.automation.powershell]::Create()
[void] $ps.AddScript($script + $command)
$ps.RunspacePool = $rp
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
}
It 'shouldprocess support -confirm under the non-interactive host' {
$command = 'get-foo -confirm'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$ps.EndInvoke($asyncResult)
$ps.Streams.Error.Count | Should -Be 1 # the host does not implement it.
$ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
}
}
Context 'confirmimpact support: none' {
BeforeAll {
$script = '
function get-foo
{
[CmdletBinding(supportsshouldprocess=$true, ConfirmImpact="none")]
param()
if($pscmdlet.shouldprocess("foo", "foo action"))
{
write-output "foo action"
}
}'
}
It 'get-foo' {
$command = 'get-foo'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$output[0] | Should -BeExactly 'foo action'
}
It 'get-foo -confirm' {
$command = 'get-foo -confirm'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$output[0] | Should -BeExactly 'foo action'
}
}
Context 'confirmimpact support: low under the non-interactive host' {
BeforeAll {
$script = '
function get-foo
{
[CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact="low")]
param()
if($pscmdlet.shouldprocess("foo", "foo action"))
{
write-output "foo action"
}
}'
}
It 'get-foo' {
$command = 'get-foo'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$output[0] | Should -BeExactly 'foo action'
}
It 'get-foo -confirm' {
$command = 'get-foo -confirm'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$ps.EndInvoke($asyncResult)
$ps.Streams.Error.Count | Should -Be 1 # the host does not implement it.
$ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
}
}
Context 'confirmimpact support: Medium under the non-interactive host' {
BeforeAll {
$script = '
function get-foo
{
[CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact="medium")]
param()
if($pscmdlet.shouldprocess("foo", "foo action"))
{
write-output "foo action"
}
}'
}
It 'get-foo' {
$command = 'get-foo'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$output = $ps.EndInvoke($asyncResult)
$output[0] | Should -BeExactly 'foo action'
}
It 'get-foo -confirm' {
$command = 'get-foo -confirm'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$ps.EndInvoke($asyncResult)
$ps.Streams.Error.Count | Should -Be 1 # the host does not implement it.
$ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
}
}
Context 'confirmimpact support: High under the non-interactive host' {
BeforeAll {
$script = '
function get-foo
{
[CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact="high")]
param()
if($pscmdlet.shouldprocess("foo", "foo action"))
{
write-output "foo action"
}
}'
}
It 'get-foo' {
$command = 'get-foo'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$ps.EndInvoke($asyncResult)
$ps.Streams.Error.Count | Should -Be 1 # the host does not implement it.
$ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
}
It 'get-foo -confirm' {
$command = 'get-foo -confirm'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$ps.EndInvoke($asyncResult)
$ps.Streams.Error.Count | Should -Be 1 # the host does not implement it.
$ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
}
}
Context 'ShouldContinue Support under the non-interactive host' {
BeforeAll {
$script = '
function get-foo
{
[CmdletBinding()]
param()
if($pscmdlet.shouldcontinue("foo", "foo action"))
{
write-output "foo action"
}
}'
}
It 'get-foo' {
$command = 'get-foo'
[void] $ps.AddScript($script + $command)
$asyncResult = $ps.BeginInvoke()
$ps.EndInvoke($asyncResult)
$ps.Streams.Error.Count | Should -Be 1 # the host does not implement it.
$ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
}
}
}