diff --git a/tests/Add-DbaDbMirrorMonitor.Tests.ps1 b/tests/Add-DbaDbMirrorMonitor.Tests.ps1 index 3f3ef63d76..26f1f1c3b5 100644 --- a/tests/Add-DbaDbMirrorMonitor.Tests.ps1 +++ b/tests/Add-DbaDbMirrorMonitor.Tests.ps1 @@ -1,19 +1,32 @@ -$commandname = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandpath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tags "UnitTests" { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Add-DbaDbMirrorMonitor" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Add-DbaDbMirrorMonitor + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$commandname Integration Tests" -Tag "IntegrationTests" { +Describe "Add-DbaDbMirrorMonitor" -Tag "IntegrationTests" { BeforeAll { $null = Remove-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2 -WarningAction SilentlyContinue } @@ -21,8 +34,13 @@ Describe "$commandname Integration Tests" -Tag "IntegrationTests" { $null = Remove-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2 -WarningAction SilentlyContinue } - It "adds the mirror monitor" { - $results = Add-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2 -WarningAction SilentlyContinue - $results.MonitorStatus | Should -Be 'Added' + Context "When adding mirror monitor" { + BeforeAll { + $results = Add-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2 -WarningAction SilentlyContinue + } + + It "Adds the mirror monitor" { + $results.MonitorStatus | Should -Be 'Added' + } } } diff --git a/tests/Add-DbaDbRoleMember.Tests.ps1 b/tests/Add-DbaDbRoleMember.Tests.ps1 index 956e9226b0..30b9e77bc8 100644 --- a/tests/Add-DbaDbRoleMember.Tests.ps1 +++ b/tests/Add-DbaDbRoleMember.Tests.ps1 @@ -1,19 +1,36 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandpath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tags "UnitTests" { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'Database', 'Role', 'Member', 'InputObject', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Add-DbaDbRoleMember" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Add-DbaDbRoleMember + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "Database", + "Role", + "Member", + "InputObject", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$CommandName Integration Tests" -Tags "IntegrationTests" { +Describe "Add-DbaDbRoleMember" -Tag "IntegrationTests" { BeforeAll { $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2 $user1 = "dbatoolssci_user1_$(Get-Random)" @@ -29,58 +46,75 @@ Describe "$CommandName Integration Tests" -Tags "IntegrationTests" { $null = New-DbaDbUser -SqlInstance $TestConfig.instance2 -Database msdb -Login $user2 -Username $user2 -IncludeSystem $null = $server.Query("CREATE ROLE $role", $dbname) } + AfterAll { $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2 $null = $server.Query("DROP USER $user1", 'msdb') $null = $server.Query("DROP USER $user2", 'msdb') - $null = Remove-DbaDatabase -SqlInstance $TestConfig.instance2 -Database $dbname -confirm:$false - $null = Remove-DbaLogin -SqlInstance $TestConfig.instance2 -Login $user1, $user2 -confirm:$false + $null = Remove-DbaDatabase -SqlInstance $TestConfig.instance2 -Database $dbname -Confirm:$false + $null = Remove-DbaLogin -SqlInstance $TestConfig.instance2 -Login $user1, $user2 -Confirm:$false } - Context "Functionality" { - It 'Adds User to Role' { - Add-DbaDbRoleMember -SqlInstance $TestConfig.instance2 -Role $role -Member $user1 -Database $dbname -confirm:$false + Context "When adding a user to a role" { + BeforeAll { + $result = Add-DbaDbRoleMember -SqlInstance $TestConfig.instance2 -Role $role -Member $user1 -Database $dbname -Confirm:$false $roleDBAfter = Get-DbaDbRoleMember -SqlInstance $server -Database $dbname -Role $role + } - $roleDBAfter.Role | Should Be $role - $roleDBAfter.Login | Should Be $user1 - $roleDBAfter.UserName | Should Be $user1 + It "Adds the user to the role" { + $roleDBAfter.Role | Should -Be $role + $roleDBAfter.Login | Should -Be $user1 + $roleDBAfter.UserName | Should -Be $user1 } + } - It 'Adds User to Multiple Roles' { + Context "When adding a user to multiple roles" { + BeforeAll { $roleDB = Get-DbaDbRoleMember -SqlInstance $server -Database msdb -Role db_datareader, SQLAgentReaderRole - Add-DbaDbRoleMember -SqlInstance $TestConfig.instance2 -Role db_datareader, SQLAgentReaderRole -Member $user1 -Database msdb -confirm:$false - + $result = Add-DbaDbRoleMember -SqlInstance $TestConfig.instance2 -Role db_datareader, SQLAgentReaderRole -Member $user1 -Database msdb -Confirm:$false $roleDBAfter = Get-DbaDbRoleMember -SqlInstance $server -Database msdb -Role db_datareader, SQLAgentReaderRole - $roleDBAfter.Count | Should BeGreaterThan $roleDB.Count - $roleDB.UserName -contains $user1 | Should Be $false - $roleDBAfter.UserName -contains $user1 | Should Be $true + } + It "Adds the user to multiple roles" { + $roleDBAfter.Count | Should -BeGreaterThan $roleDB.Count + $roleDB.UserName | Should -Not -Contain $user1 + $roleDBAfter.UserName | Should -Contain $user1 } + } - It 'Adds User to Roles via piped input from Get-DbaDbRole' { + Context "When adding a user to roles via piped input from Get-DbaDbRole" { + BeforeAll { $roleInput = Get-DbaDbRole -SqlInstance $server -Database msdb -Role db_datareader, SQLAgentReaderRole $roleDB = Get-DbaDbRoleMember -SqlInstance $server -Database msdb -Role db_datareader, SQLAgentReaderRole - $roleInput | Add-DbaDbRoleMember -User $user2 -confirm:$false - + $result = $roleInput | Add-DbaDbRoleMember -User $user2 -Confirm:$false $roleDBAfter = Get-DbaDbRoleMember -SqlInstance $server -Database msdb -Role db_datareader, SQLAgentReaderRole - $roleDB.UserName -contains $user2 | Should Be $false - $roleDBAfter.UserName -contains $user2 | Should Be $true } - It 'Skip adding user to role if already a member' { - $messages = Add-DbaDbRoleMember -SqlInstance $TestConfig.instance2 -Role $role -Member $user1 -Database $dbname -confirm:$false -Verbose 4>&1 - $messageCount = ($messages -match 'Adding user').Count + It "Adds the user to roles via piped input" { + $roleDB.UserName | Should -Not -Contain $user2 + $roleDBAfter.UserName | Should -Contain $user2 + } + } + + Context "When adding a user to a role they are already a member of" { + BeforeAll { + $messages = Add-DbaDbRoleMember -SqlInstance $TestConfig.instance2 -Role $role -Member $user1 -Database $dbname -Confirm:$false -Verbose 4>&1 + } - $messageCount | Should Be 0 + It "Skips adding the user and outputs appropriate message" { + $messageCount = ($messages -match 'Adding user').Count + $messageCount | Should -Be 0 } + } - It 'Adds Role to Role' { - Add-DbaDbRoleMember -SqlInstance $TestConfig.instance2 -Role db_datawriter -Member $role -Database $dbname -confirm:$false + Context "When adding a role to another role" { + BeforeAll { + $result = Add-DbaDbRoleMember -SqlInstance $TestConfig.instance2 -Role db_datawriter -Member $role -Database $dbname -Confirm:$false $roleDBAfter = Get-DbaDbRoleMember -SqlInstance $server -Database $dbname -Role db_datawriter + } - $roleDBAfter.MemberRole | Should Contain $role + It "Adds the role to another role" { + $roleDBAfter.MemberRole | Should -Contain $role } } } - diff --git a/tests/Add-DbaExtendedProperty.Tests.ps1 b/tests/Add-DbaExtendedProperty.Tests.ps1 index ba4339484b..6dddcfbbd2 100644 --- a/tests/Add-DbaExtendedProperty.Tests.ps1 +++ b/tests/Add-DbaExtendedProperty.Tests.ps1 @@ -1,19 +1,36 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [array]$params = ([Management.Automation.CommandMetaData]$ExecutionContext.SessionState.InvokeCommand.GetCommand($CommandName, 'Function')).Parameters.Keys - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'Database', 'Name', 'InputObject', 'EnableException', 'Value' - It "Should only contain our specific parameters" { - Compare-Object -ReferenceObject $knownParameters -DifferenceObject $params | Should -BeNullOrEmpty +Describe "Add-DbaExtendedProperty" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Add-DbaExtendedProperty + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "Database", + "Name", + "Value", + "InputObject", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$CommandName Integration Tests" -Tag "IntegrationTests" { - +Describe "Add-DbaExtendedProperty" -Tag "IntegrationTests" { BeforeAll { $random = Get-Random $server2 = Connect-DbaInstance -SqlInstance $TestConfig.instance2 @@ -26,9 +43,13 @@ Describe "$CommandName Integration Tests" -Tag "IntegrationTests" { $null = $db | Remove-DbaDatabase -Confirm:$false } - Context "commands work as expected" { - It "works" { - $ep = $db | Add-DbaExtendedProperty -Name "Test_Database_Name" -Value "Sup" + Context "When adding extended properties" { + It "Adds an extended property to the database" { + $splatExtendedProperty = @{ + Name = "Test_Database_Name" + Value = "Sup" + } + $ep = $db | Add-DbaExtendedProperty @splatExtendedProperty $ep.Name | Should -Be "Test_Database_Name" $ep.ParentName | Should -Be $db.Name $ep.Value | Should -Be "Sup" diff --git a/tests/Add-DbaPfDataCollectorCounter.Tests.ps1 b/tests/Add-DbaPfDataCollectorCounter.Tests.ps1 index 3d7b0a2213..e9a1eeab4d 100644 --- a/tests/Add-DbaPfDataCollectorCounter.Tests.ps1 +++ b/tests/Add-DbaPfDataCollectorCounter.Tests.ps1 @@ -1,31 +1,62 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'ComputerName', 'Credential', 'CollectorSet', 'Collector', 'Counter', 'InputObject', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Add-DbaPfDataCollectorCounter" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Add-DbaPfDataCollectorCounter + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "ComputerName", + "Credential", + "CollectorSet", + "Collector", + "Counter", + "InputObject", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$CommandName Integration Tests" -Tags "IntegrationTests" { - BeforeEach { +Describe "Add-DbaPfDataCollectorCounter" -Tag "IntegrationTests" { + BeforeAll { $null = Get-DbaPfDataCollectorSetTemplate -Template 'Long Running Queries' | Import-DbaPfDataCollectorSetTemplate | Get-DbaPfDataCollector | Get-DbaPfDataCollectorCounter -Counter '\LogicalDisk(*)\Avg. Disk Queue Length' | Remove-DbaPfDataCollectorCounter -Confirm:$false } + AfterAll { $null = Get-DbaPfDataCollectorSet -CollectorSet 'Long Running Queries' | Remove-DbaPfDataCollectorSet -Confirm:$false } - Context "Verifying command returns all the required results" { - It "returns the correct values" { - $results = Get-DbaPfDataCollectorSet -CollectorSet 'Long Running Queries' | Get-DbaPfDataCollector | Add-DbaPfDataCollectorCounter -Counter '\LogicalDisk(*)\Avg. Disk Queue Length' - $results.DataCollectorSet | Should Be 'Long Running Queries' - $results.Name | Should Be '\LogicalDisk(*)\Avg. Disk Queue Length' + + Context "When adding a counter to a data collector" { + BeforeAll { + $splatAddCounter = @{ + CollectorSet = 'Long Running Queries' + Counter = '\LogicalDisk(*)\Avg. Disk Queue Length' + } + $results = Get-DbaPfDataCollectorSet @splatAddCounter | + Get-DbaPfDataCollector | + Add-DbaPfDataCollectorCounter @splatAddCounter + } + + It "Returns the correct DataCollectorSet" { + $results.DataCollectorSet | Should -Be 'Long Running Queries' + } + + It "Returns the correct counter name" { + $results.Name | Should -Be '\LogicalDisk(*)\Avg. Disk Queue Length' } } -} \ No newline at end of file +} diff --git a/tests/Add-DbaRegServer.Tests.ps1 b/tests/Add-DbaRegServer.Tests.ps1 index 76bacdcd5b..0b292b3340 100644 --- a/tests/Add-DbaRegServer.Tests.ps1 +++ b/tests/Add-DbaRegServer.Tests.ps1 @@ -1,44 +1,100 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandpath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tags "UnitTests" { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'ServerName', 'Name', 'Description', 'Group', 'ActiveDirectoryTenant', 'ActiveDirectoryUserId', 'ConnectionString', 'OtherParams', 'InputObject', 'ServerObject', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Add-DbaRegServer" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Add-DbaRegServer + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "ServerName", + "Name", + "Description", + "Group", + "ActiveDirectoryTenant", + "ActiveDirectoryUserId", + "ConnectionString", + "OtherParams", + "InputObject", + "ServerObject", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$CommandName Integration Tests" -Tag "IntegrationTests" { - Context "Setup" { +Describe "Add-DbaRegServer" -Tag "IntegrationTests" { + BeforeAll { + $srvName = "dbatoolsci-server1" + $group = "dbatoolsci-group1" + $regSrvName = "dbatoolsci-server12" + $regSrvDesc = "dbatoolsci-server123" + $groupobject = Add-DbaRegServerGroup -SqlInstance $TestConfig.instance1 -Name $group + } + + AfterAll { + Get-DbaRegServer -SqlInstance $TestConfig.instance1, $TestConfig.instance2 | Where-Object Name -match dbatoolsci | Remove-DbaRegServer -Confirm:$false + Get-DbaRegServerGroup -SqlInstance $TestConfig.instance1, $TestConfig.instance2 | Where-Object Name -match dbatoolsci | Remove-DbaRegServerGroup -Confirm:$false + } + + Context "When adding a registered server" { BeforeAll { - $srvName = "dbatoolsci-server1" - $group = "dbatoolsci-group1" - $regSrvName = "dbatoolsci-server12" - $regSrvDesc = "dbatoolsci-server123" - $groupobject = Add-DbaRegServerGroup -SqlInstance $TestConfig.instance1 -Name $group - } - AfterAll { - Get-DbaRegServer -SqlInstance $TestConfig.instance1, $TestConfig.instance2 | Where-Object Name -match dbatoolsci | Remove-DbaRegServer -Confirm:$false - Get-DbaRegServerGroup -SqlInstance $TestConfig.instance1, $TestConfig.instance2 | Where-Object Name -match dbatoolsci | Remove-DbaRegServerGroup -Confirm:$false + $results1 = Add-DbaRegServer -SqlInstance $TestConfig.instance1 -ServerName $srvName } - It "adds a registered server" { - $results1 = Add-DbaRegServer -SqlInstance $TestConfig.instance1 -ServerName $srvName + It "Adds a registered server with correct name" { $results1.Name | Should -Be $srvName + } + + It "Adds a registered server with correct server name" { $results1.ServerName | Should -Be $srvName - $results1.SqlInstance | Should -Not -Be $null } - It "adds a registered server with extended properties" { - $results2 = Add-DbaRegServer -SqlInstance $TestConfig.instance1 -ServerName $RegsrvName -Name $srvName -Group $groupobject -Description $regSrvDesc + + It "Adds a registered server with non-null SqlInstance" { + $results1.SqlInstance | Should -Not -BeNullOrEmpty + } + } + + Context "When adding a registered server with extended properties" { + BeforeAll { + $splat = @{ + SqlInstance = $TestConfig.instance1 + ServerName = $regSrvName + Name = $srvName + Group = $groupobject + Description = $regSrvDesc + } + + $results2 = Add-DbaRegServer @splat + } + + It "Adds a registered server with correct server name" { $results2.ServerName | Should -Be $regSrvName + } + + It "Adds a registered server with correct description" { $results2.Description | Should -Be $regSrvDesc + } + + It "Adds a registered server with correct name" { $results2.Name | Should -Be $srvName - $results2.SqlInstance | Should -Not -Be $null + } + + It "Adds a registered server with non-null SqlInstance" { + $results2.SqlInstance | Should -Not -BeNullOrEmpty } } } diff --git a/tests/Add-DbaRegServerGroup.Tests.ps1 b/tests/Add-DbaRegServerGroup.Tests.ps1 index 14df3ef2b0..4987cd28c2 100644 --- a/tests/Add-DbaRegServerGroup.Tests.ps1 +++ b/tests/Add-DbaRegServerGroup.Tests.ps1 @@ -1,55 +1,84 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandpath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tags "UnitTests" { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'Name', 'Description', 'Group', 'InputObject', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Add-DbaRegServerGroup" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Add-DbaRegServerGroup + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "Name", + "Description", + "Group", + "InputObject", + "EnableException" + ) } - } -} -Describe "$CommandName Integration Tests" -Tag "IntegrationTests" { - Context "Setup" { - BeforeAll { - $group = "dbatoolsci-group1" - $group2 = "dbatoolsci-group2" - $description = "group description" - $descriptionUpdated = "group description updated" + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem } - AfterAll { - Get-DbaRegServerGroup -SqlInstance $TestConfig.instance1 | Where-Object Name -match dbatoolsci | Remove-DbaRegServerGroup -Confirm:$false + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } + } +} +Describe "Add-DbaRegServerGroup" -Tag "IntegrationTests" { + BeforeAll { + $group = "dbatoolsci-group1" + $group2 = "dbatoolsci-group2" + $description = "group description" + $descriptionUpdated = "group description updated" + } + AfterAll { + Get-DbaRegServerGroup -SqlInstance $TestConfig.instance1 | Where-Object Name -match dbatoolsci | Remove-DbaRegServerGroup -Confirm:$false + } + + Context "When adding a registered server group" { It "adds a registered server group" { $results = Add-DbaRegServerGroup -SqlInstance $TestConfig.instance1 -Name $group $results.Name | Should -Be $group - $results.SqlInstance | Should -Not -Be $null + $results.SqlInstance | Should -Not -BeNullOrEmpty } + It "adds a registered server group with extended properties" { $results = Add-DbaRegServerGroup -SqlInstance $TestConfig.instance1 -Name $group2 -Description $description $results.Name | Should -Be $group2 $results.Description | Should -Be $description - $results.SqlInstance | Should -Not -Be $null + $results.SqlInstance | Should -Not -BeNullOrEmpty } - It "supports hella pipe" { - $results = Get-DbaRegServerGroup -SqlInstance $TestConfig.instance1 -Id 1 | Add-DbaRegServerGroup -Name dbatoolsci-first | Add-DbaRegServerGroup -Name dbatoolsci-second | Add-DbaRegServerGroup -Name dbatoolsci-third | Add-DbaRegServer -ServerName dbatoolsci-test -Description ridiculous + } + + Context "When using pipeline input" { + It "supports pipeline input" { + $results = Get-DbaRegServerGroup -SqlInstance $TestConfig.instance1 -Id 1 | + Add-DbaRegServerGroup -Name dbatoolsci-first | + Add-DbaRegServerGroup -Name dbatoolsci-second | + Add-DbaRegServerGroup -Name dbatoolsci-third | + Add-DbaRegServer -ServerName dbatoolsci-test -Description ridiculous $results.Group | Should -Be 'dbatoolsci-first\dbatoolsci-second\dbatoolsci-third' } + } + + Context "When adding nested groups" { It "adds a registered server group and sub-group when not exists" { $results = Add-DbaRegServerGroup -SqlInstance $TestConfig.instance1 -Name "$group\$group2" -Description $description $results.Name | Should -Be $group2 - $results.SqlInstance | Should -Not -Be $null + $results.SqlInstance | Should -Not -BeNullOrEmpty } + It "updates description of sub-group when it already exists" { $results = Add-DbaRegServerGroup -SqlInstance $TestConfig.instance1 -Name "$group\$group2" -Description $descriptionUpdated $results.Name | Should -Be $group2 $results.Description | Should -Be $descriptionUpdated - $results.SqlInstance | Should -Not -Be $null + $results.SqlInstance | Should -Not -BeNullOrEmpty } } } diff --git a/tests/Add-DbaReplArticle.Tests.ps1 b/tests/Add-DbaReplArticle.Tests.ps1 index aed3185e0f..8088f9e516 100644 --- a/tests/Add-DbaReplArticle.Tests.ps1 +++ b/tests/Add-DbaReplArticle.Tests.ps1 @@ -1,17 +1,39 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'Database', 'Publication', 'Schema', 'Name', 'Filter', 'CreationScriptOptions', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Add-DbaReplArticle" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Add-DbaReplArticle + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "Database", + "Publication", + "Schema", + "Name", + "Filter", + "CreationScriptOptions", + "EnableException", + "WhatIf", + "Confirm" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } + <# Integration tests for replication are in GitHub Actions and run from \tests\gh-actions-repl-*.ps1.ps1 -#> \ No newline at end of file +#> diff --git a/tests/Add-DbaServerRoleMember.Tests.ps1 b/tests/Add-DbaServerRoleMember.Tests.ps1 index aac1596439..ad095cb7a8 100644 --- a/tests/Add-DbaServerRoleMember.Tests.ps1 +++ b/tests/Add-DbaServerRoleMember.Tests.ps1 @@ -1,59 +1,104 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tags "UnitTests" { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('WhatIf', 'Confirm')} - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'ServerRole', 'Login', 'Role', 'InputObject', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should -Be 0 +Describe "Add-DbaServerRoleMember" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Add-DbaServerRoleMember + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "ServerRole", + "Login", + "Role", + "InputObject", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$CommandName Integration Tests" -Tags "IntegrationTests" { +Describe "Add-DbaServerRoleMember" -Tag "IntegrationTests" { BeforeAll { $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2 $login1 = "dbatoolsci_login1_$(Get-Random)" $login2 = "dbatoolsci_login2_$(Get-Random)" $customServerRole = "dbatoolsci_customrole_$(Get-Random)" - $fixedServerRoles = 'dbcreator','processadmin' - $null = New-DbaLogin -SqlInstance $TestConfig.instance2 -Login $login1 -Password ('Password1234!' | ConvertTo-SecureString -asPlainText -Force) - $null = New-DbaLogin -SqlInstance $TestConfig.instance2 -Login $login2 -Password ('Password1234!' | ConvertTo-SecureString -asPlainText -Force) + $fixedServerRoles = @( + "dbcreator", + "processadmin" + ) + $splatNewLogin = @{ + SqlInstance = $TestConfig.instance2 + Password = ('Password1234!' | ConvertTo-SecureString -asPlainText -Force) + } + $null = New-DbaLogin @splatNewLogin -Login $login1 + $null = New-DbaLogin @splatNewLogin -Login $login2 $null = New-DbaServerRole -SqlInstance $TestConfig.instance2 -ServerRole $customServerRole -Owner sa } AfterAll { - $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2 - $null = Remove-DbaLogin -SqlInstance $TestConfig.instance2 -Login $login1, $login2 -Confirm:$false + $splatRemoveLogin = @{ + SqlInstance = $TestConfig.instance2 + Login = $login1, $login2 + Confirm = $false + } + $null = Remove-DbaLogin @splatRemoveLogin } Context "Functionality" { It 'Adds Login to Role' { - Add-DbaServerRoleMember -SqlInstance $TestConfig.instance2 -ServerRole $fixedServerRoles[0] -Login $login1 -Confirm:$false + $splatAddRole = @{ + SqlInstance = $TestConfig.instance2 + ServerRole = $fixedServerRoles[0] + Login = $login1 + Confirm = $false + } + Add-DbaServerRoleMember @splatAddRole $roleAfter = Get-DbaServerRole -SqlInstance $server -ServerRole $fixedServerRoles[0] $roleAfter.Role | Should -Be $fixedServerRoles[0] - $roleAfter.EnumMemberNames().Contains($login1) | Should -Be $true + $roleAfter.EnumMemberNames() | Should -Contain $login1 } It 'Adds Login to Multiple Roles' { $serverRoles = Get-DbaServerRole -SqlInstance $server -ServerRole $fixedServerRoles - Add-DbaServerRoleMember -SqlInstance $TestConfig.instance2 -ServerRole $serverRoles -Login $login1 -Confirm:$false + $splatAddRoles = @{ + SqlInstance = $TestConfig.instance2 + ServerRole = $serverRoles + Login = $login1 + Confirm = $false + } + Add-DbaServerRoleMember @splatAddRoles $roleDBAfter = Get-DbaServerRole -SqlInstance $server -ServerRole $fixedServerRoles $roleDBAfter.Count | Should -Be $serverRoles.Count - $roleDBAfter.Login -contains $login1 | Should -Be $true - + $roleDBAfter.Login | Should -Contain $login1 } It 'Adds Customer Server-Level Role Membership' { - Add-DbaServerRoleMember -SqlInstance $TestConfig.instance2 -ServerRole $customServerRole -Role $fixedServerRoles[-1] -Confirm:$false + $splatAddCustomRole = @{ + SqlInstance = $TestConfig.instance2 + ServerRole = $customServerRole + Role = $fixedServerRoles[-1] + Confirm = $false + } + Add-DbaServerRoleMember @splatAddCustomRole $roleAfter = Get-DbaServerRole -SqlInstance $server -ServerRole $fixedServerRoles[-1] $roleAfter.Role | Should -Be $fixedServerRoles[-1] - $roleAfter.EnumMemberNames().Contains($customServerRole) | Should -Be $true + $roleAfter.EnumMemberNames() | Should -Contain $customServerRole } It 'Adds Login to Roles via piped input from Get-DbaServerRole' { @@ -61,7 +106,7 @@ Describe "$CommandName Integration Tests" -Tags "IntegrationTests" { $serverRole | Add-DbaServerRoleMember -Login $login2 -Confirm:$false $roleAfter = Get-DbaServerRole -SqlInstance $server -ServerRole $fixedServerRoles[0] - $roleAfter.EnumMemberNames().Contains($login2) | Should -Be $true + $roleAfter.EnumMemberNames() | Should -Contain $login2 } } } diff --git a/tests/Backup-DbaComputerCertificate.Tests.ps1 b/tests/Backup-DbaComputerCertificate.Tests.ps1 index a1064dccfe..b810b7643a 100644 --- a/tests/Backup-DbaComputerCertificate.Tests.ps1 +++ b/tests/Backup-DbaComputerCertificate.Tests.ps1 @@ -1,25 +1,49 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object { $_ -notin ('whatif', 'confirm') } - [object[]]$knownParameters = 'SecurePassword', 'InputObject', 'Path', 'FilePath', 'Type', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object { $_ }) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Backup-DbaComputerCertificate" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Backup-DbaComputerCertificate + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SecurePassword", + "InputObject", + "Path", + "FilePath", + "Type", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$commandname Integration Tests" -Tags "IntegrationTests" { - Context "Certificate is added properly" { - $null = Add-DbaComputerCertificate -Path "$($TestConfig.appveyorlabrepo)\certificates\localhost.crt" -Confirm:$false - It "returns the proper results" { - $result = Get-DbaComputerCertificate -Thumbprint 29C469578D6C6211076A09CEE5C5797EEA0C2713 | Backup-DbaComputerCertificate -Path C:\temp - $result.Name -match '29C469578D6C6211076A09CEE5C5797EEA0C2713.cer' +Describe "Backup-DbaComputerCertificate" -Tag "IntegrationTests" { + Context "Certificate is added and backed up properly" { + BeforeAll { + $null = Add-DbaComputerCertificate -Path "$($TestConfig.appveyorlabrepo)\certificates\localhost.crt" -Confirm:$false + $certThumbprint = "29C469578D6C6211076A09CEE5C5797EEA0C2713" + $backupPath = "C:\temp" + } + + It "Returns the proper results" { + $result = Get-DbaComputerCertificate -Thumbprint $certThumbprint | Backup-DbaComputerCertificate -Path $backupPath + $result.Name | Should -Match "$certThumbprint.cer" + } + + AfterAll { + $null = Remove-DbaComputerCertificate -Thumbprint $certThumbprint -Confirm:$false } - $null = Remove-DbaComputerCertificate -Thumbprint 29C469578D6C6211076A09CEE5C5797EEA0C2713 -Confirm:$false } } diff --git a/tests/Backup-DbaDbCertificate.Tests.ps1 b/tests/Backup-DbaDbCertificate.Tests.ps1 index d6d04b86db..f185d3fae3 100644 --- a/tests/Backup-DbaDbCertificate.Tests.ps1 +++ b/tests/Backup-DbaDbCertificate.Tests.ps1 @@ -1,19 +1,40 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object { $_ -notin ('whatif', 'confirm') } - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'Certificate', 'Database', 'ExcludeDatabase', 'EncryptionPassword', 'DecryptionPassword', 'Path', 'Suffix', 'InputObject', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object { $_ }) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Backup-DbaDbCertificate" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Backup-DbaDbCertificate + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "Certificate", + "Database", + "ExcludeDatabase", + "EncryptionPassword", + "DecryptionPassword", + "Path", + "Suffix", + "InputObject", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$commandname Integration Tests" -Tag "IntegrationTests" { +Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" { BeforeAll { $random = Get-Random $db1Name = "dbatoolscli_$random" @@ -31,12 +52,11 @@ Describe "$commandname Integration Tests" -Tag "IntegrationTests" { } Context "Can create and backup a database certificate" { - It "backs up the db cert" { $results = Backup-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Certificate $cert.Name -Database $db1Name -EncryptionPassword $pw -DecryptionPassword $pw $null = Get-ChildItem -Path $results.Path -ErrorAction Ignore | Remove-Item -Confirm:$false -ErrorAction Ignore $results.Certificate | Should -Be $cert.Name - $results.Status -match "Success" + $results.Status | Should -Match "Success" $results.DatabaseID | Should -Be (Get-DbaDatabase -SqlInstance $TestConfig.instance1 -Database $db1Name).ID } @@ -45,23 +65,19 @@ Describe "$commandname Integration Tests" -Tag "IntegrationTests" { $invalidDBCertName2 = "dbatoolscli_invalidCertName2" $results = Backup-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Certificate $invalidDBCertName, $invalidDBCertName2, $cert2.Name -Database $db1Name -EncryptionPassword $pw -DecryptionPassword $pw -WarningVariable warnVariable 3> $null $null = Get-ChildItem -Path $results.Path -ErrorAction Ignore | Remove-Item -Confirm:$false -ErrorAction Ignore - #$results.Certificate | Should -Be $cert2.Name $warnVariable | Should -BeLike "*Database certificate(s) * not found*" } - # works locally, gah - It -Skip "backs up all db certs for a database" { + It "backs up all db certs for a database" -Skip { $results = Backup-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Database $db1Name -EncryptionPassword $pw -DecryptionPassword $pw $null = Get-ChildItem -Path $results.Path -ErrorAction Ignore | Remove-Item -Confirm:$false -ErrorAction Ignore $results.length | Should -Be 2 $results.Certificate | Should -Be $cert.Name, $cert2.Name } - # Skip this test as there's a mix of certs, some require a password and some don't and i'll fix later - It -Skip "backs up all db certs for an instance" { + It "backs up all db certs for an instance" -Skip { $results = Backup-DbaDbCertificate -SqlInstance $TestConfig.instance1 -EncryptionPassword $pw $null = Get-ChildItem -Path $results.Path -ErrorAction Ignore | Remove-Item -Confirm:$false -ErrorAction Ignore - # $results.length | Should -BeGreaterOrEqual 2 } } } diff --git a/tests/Backup-DbaDbMasterKey.Tests.ps1 b/tests/Backup-DbaDbMasterKey.Tests.ps1 index 5c1a0366b6..726ea4abba 100644 --- a/tests/Backup-DbaDbMasterKey.Tests.ps1 +++ b/tests/Backup-DbaDbMasterKey.Tests.ps1 @@ -1,39 +1,70 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object { $_ -notin ('whatif', 'confirm') } - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'Credential', 'Database', 'ExcludeDatabase', 'SecurePassword', 'Path', 'InputObject', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object { $_ }) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Backup-DbaDbMasterKey" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Backup-DbaDbMasterKey + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "Credential", + "Database", + "ExcludeDatabase", + "SecurePassword", + "Path", + "InputObject", + "EnableException", + "WhatIf", + "Confirm" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$commandname Integration Tests" -Tags "IntegrationTests" { - Context "Can create a database certificate" { +Describe "Backup-DbaDbMasterKey" -Tag "IntegrationTests" { + Context "Can backup a database master key" { BeforeAll { - if (-not (Get-DbaDbMasterKey -SqlInstance $TestConfig.instance1 -Database tempdb)) { - $masterkey = New-DbaDbMasterKey -SqlInstance $TestConfig.instance1 -Database tempdb -Password $(ConvertTo-SecureString -String "GoodPass1234!" -AsPlainText -Force) -Confirm:$false + $instance = $TestConfig.instance1 + $database = "tempdb" + $password = ConvertTo-SecureString -String "GoodPass1234!" -AsPlainText -Force + + if (-not (Get-DbaDbMasterKey -SqlInstance $instance -Database $database)) { + $null = New-DbaDbMasterKey -SqlInstance $instance -Database $database -Password $password -Confirm:$false + } + + $splatBackup = @{ + SqlInstance = $instance + Database = $database + SecurePassword = $password + Confirm = $false } } + AfterAll { - (Get-DbaDbMasterKey -SqlInstance $TestConfig.instance1 -Database tempdb) | Remove-DbaDbMasterKey -Confirm:$false + Get-DbaDbMasterKey -SqlInstance $instance -Database $database | Remove-DbaDbMasterKey -Confirm:$false } - $results = Backup-DbaDbMasterKey -SqlInstance $TestConfig.instance1 -Confirm:$false -Database tempdb -Password $(ConvertTo-SecureString -String "GoodPass1234!" -AsPlainText -Force) - $null = Remove-Item -Path $results.Path -ErrorAction SilentlyContinue -Confirm:$false - - It "backs up the db cert" { - $results.Database -eq 'tempdb' - $results.Status -eq "Success" - } + It "Backs up the database master key" { + $results = Backup-DbaDbMasterKey @splatBackup + $results | Should -Not -BeNullOrEmpty + $results.Database | Should -Be $database + $results.Status | Should -Be "Success" + $results.DatabaseID | Should -Be (Get-DbaDatabase -SqlInstance $instance -Database $database).ID - It "Database ID should be returned" { - $results.DatabaseID | Should -Be (Get-DbaDatabase -SqlInstance $TestConfig.instance1 -Database tempdb).ID + $null = Remove-Item -Path $results.Path -ErrorAction SilentlyContinue -Confirm:$false } } } diff --git a/tests/Backup-DbaServiceMasterKey.Tests.ps1 b/tests/Backup-DbaServiceMasterKey.Tests.ps1 index c04b886400..1d36c8b026 100644 --- a/tests/Backup-DbaServiceMasterKey.Tests.ps1 +++ b/tests/Backup-DbaServiceMasterKey.Tests.ps1 @@ -1,25 +1,47 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object { $_ -notin ('whatif', 'confirm') } - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'KeyCredential', 'SecurePassword', 'Path', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object { $_ }) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Backup-DbaServiceMasterKey" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Backup-DbaServiceMasterKey + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "KeyCredential", + "SecurePassword", + "Path", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$commandname Integration Tests" -Tags "IntegrationTests" { +Describe "Backup-DbaServiceMasterKey" -Tag "IntegrationTests" { Context "Can backup a service master key" { - $results = Backup-DbaServiceMasterKey -SqlInstance $TestConfig.instance1 -Confirm:$false -Password $(ConvertTo-SecureString -String "GoodPass1234!" -AsPlainText -Force) - $null = Remove-Item -Path $results.Path -ErrorAction SilentlyContinue -Confirm:$false + BeforeAll { + $securePassword = ConvertTo-SecureString -String "GoodPass1234!" -AsPlainText -Force + $results = Backup-DbaServiceMasterKey -SqlInstance $TestConfig.instance1 -SecurePassword $securePassword -Confirm:$false + } + + AfterAll { + $null = Remove-Item -Path $results.Path -ErrorAction SilentlyContinue -Confirm:$false + } It "backs up the SMK" { - $results.Status -eq "Success" + $results.Status | Should -Be "Success" } } } diff --git a/tests/Clear-DbaConnectionPool.Tests.ps1 b/tests/Clear-DbaConnectionPool.Tests.ps1 index 53bb663354..7d734fe919 100644 --- a/tests/Clear-DbaConnectionPool.Tests.ps1 +++ b/tests/Clear-DbaConnectionPool.Tests.ps1 @@ -1,20 +1,35 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'ComputerName', 'Credential', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Clear-DbaConnectionPool" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Clear-DbaConnectionPool + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "ComputerName", + "Credential", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$commandname Integration Tests" -Tags "IntegrationTests" { - It "doesn't throw" { - { Clear-DbaConnectionPool } | Should Not Throw +Describe "Clear-DbaConnectionPool" -Tag "IntegrationTests" { + Context "When clearing connection pool" { + It "Doesn't throw" { + { Clear-DbaConnectionPool } | Should -Not -Throw + } } -} \ No newline at end of file +} diff --git a/tests/Clear-DbaLatchStatistics.Tests.ps1 b/tests/Clear-DbaLatchStatistics.Tests.ps1 index 634451dfff..2acb9cf86f 100644 --- a/tests/Clear-DbaLatchStatistics.Tests.ps1 +++ b/tests/Clear-DbaLatchStatistics.Tests.ps1 @@ -1,24 +1,43 @@ -$commandname = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandpath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tags "UnitTests" { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Clear-DbaLatchStatistics" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Clear-DbaLatchStatistics + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$commandname Integration Tests" -Tags "IntegrationTests" { +Describe "Clear-DbaLatchStatistics" -Tag "IntegrationTests" { Context "Command executes properly and returns proper info" { - $results = Clear-DbaLatchStatistics -SqlInstance $TestConfig.instance1 -Confirm:$false + BeforeAll { + $splatClearLatch = @{ + SqlInstance = $TestConfig.instance1 + Confirm = $false + } + $results = Clear-DbaLatchStatistics @splatClearLatch + } - It "returns success" { - $results.Status -eq 'Success' | Should Be $true + It "Returns success" { + $results.Status | Should -Be 'Success' } } } diff --git a/tests/Clear-DbaPlanCache.Tests.ps1 b/tests/Clear-DbaPlanCache.Tests.ps1 index c33d5476d3..fbdd3030c9 100644 --- a/tests/Clear-DbaPlanCache.Tests.ps1 +++ b/tests/Clear-DbaPlanCache.Tests.ps1 @@ -1,31 +1,50 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'Threshold', 'InputObject', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Clear-DbaPlanCache" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Clear-DbaPlanCache + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "Threshold", + "InputObject", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$commandname Integration Tests" -Tag "IntegrationTests" { - Context "doesn't clear plan cache" { - It "returns correct datatypes" { +Describe "Clear-DbaPlanCache" -Tag "IntegrationTests" { + Context "When not clearing plan cache" { + BeforeAll { # Make plan cache way higher than likely for a test rig - $results = Clear-DbaPlanCache -SqlInstance $TestConfig.instance1 -Threshold 10240 - $results.Size -is [dbasize] | Should -Be $true - $results.Status -match 'below' | Should -Be $true + $threshold = 10240 } - It "supports piping" { - # Make plan cache way higher than likely for a test rig - $results = Get-DbaPlanCache -SqlInstance $TestConfig.instance1 | Clear-DbaPlanCache -Threshold 10240 - $results.Size -is [dbasize] | Should -Be $true - $results.Status -match 'below' | Should -Be $true + + It "Returns correct datatypes" { + $results = Clear-DbaPlanCache -SqlInstance $TestConfig.instance1 -Threshold $threshold + $results.Size | Should -BeOfType [dbasize] + $results.Status | Should -Match 'below' + } + + It "Supports piping" { + $results = Get-DbaPlanCache -SqlInstance $TestConfig.instance1 | Clear-DbaPlanCache -Threshold $threshold + $results.Size | Should -BeOfType [dbasize] + $results.Status | Should -Match 'below' } } } diff --git a/tests/Clear-DbaWaitStatistics.Tests.ps1 b/tests/Clear-DbaWaitStatistics.Tests.ps1 index 120ce455e6..405751bcc1 100644 --- a/tests/Clear-DbaWaitStatistics.Tests.ps1 +++ b/tests/Clear-DbaWaitStatistics.Tests.ps1 @@ -1,24 +1,39 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Clear-DbaWaitStatistics" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Clear-DbaWaitStatistics + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "SqlInstance", + "SqlCredential", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$commandname Integration Tests" -Tags "IntegrationTests" { +Describe "Clear-DbaWaitStatistics" -Tag "IntegrationTests" { Context "Command executes properly and returns proper info" { - $results = Clear-DbaWaitStatistics -SqlInstance $TestConfig.instance1 -Confirm:$false + BeforeAll { + $results = Clear-DbaWaitStatistics -SqlInstance $TestConfig.instance1 -Confirm:$false + } - It "returns success" { - $results.Status -eq 'Success' | Should Be $true + It "Returns success" { + $results.Status | Should -Be 'Success' } } } diff --git a/tests/Convert-DbaLsn.Tests.ps1 b/tests/Convert-DbaLsn.Tests.ps1 index 226c2bfc87..87369bfef1 100644 --- a/tests/Convert-DbaLsn.Tests.ps1 +++ b/tests/Convert-DbaLsn.Tests.ps1 @@ -1,46 +1,65 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - $paramCount = 2 - $defaultParamCount = 11 - [object[]]$params = (Get-ChildItem function:\Convert-DbaLSN).Parameters.Keys - $knownParameters = 'LSN', 'EnableException' - It "Should contain our specific parameters" { - ( (Compare-Object -ReferenceObject $knownParameters -DifferenceObject $params -IncludeEqual | Where-Object SideIndicator -eq "==").Count ) | Should Be $paramCount +Describe "Convert-DbaLSN" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Convert-DbaLSN + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "LSN", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem } - It "Should only contain $paramCount parameters" { - $params.Count - $defaultParamCount | Should Be $paramCount + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } Context "Converts Numeric LSN to Hex" { - $LSN = '00000000020000000024300001' + BeforeAll { + $LSN = '00000000020000000024300001' + $result = Convert-DbaLSN -Lsn $LSN + } + It "Should convert to 00000014:000000f3:0001" { - (Convert-DbaLSN -Lsn $Lsn).Hexadecimal | Should -Be '00000014:000000f3:0001' + $result.Hexadecimal | Should -Be '00000014:000000f3:0001' } } Context "Converts Numeric LSN to Hex without leading 0s" { - $LSN = '20000000024300001' + BeforeAll { + $LSN = '20000000024300001' + $result = Convert-DbaLSN -Lsn $LSN + } + It "Should convert to 00000014:000000f3:0001" { - (Convert-DbaLSN -Lsn $Lsn).Hexadecimal | Should -Be '00000014:000000f3:0001' + $result.Hexadecimal | Should -Be '00000014:000000f3:0001' } } Context "Converts Hex LSN to Numeric" { - $LSN = '00000014:000000f3:0001' + BeforeAll { + $LSN = '00000014:000000f3:0001' + $result = Convert-DbaLSN -Lsn $LSN + } + It "Should convert to 20000000024300001" { - (Convert-DbaLSN -Lsn $Lsn).Numeric | Should -Be 20000000024300001 + $result.Numeric | Should -Be 20000000024300001 } } - - } + <# Integration test should appear below and are custom to the command you are writing. Read https://github.com/dataplat/dbatools/blob/development/contributing.md#tests - for more guidence. -#> \ No newline at end of file + for more guidance. +#> diff --git a/tests/Convert-DbaMaskingValue.Tests.ps1 b/tests/Convert-DbaMaskingValue.Tests.ps1 index bed662ab4a..12d5fb9c17 100644 --- a/tests/Convert-DbaMaskingValue.Tests.ps1 +++ b/tests/Convert-DbaMaskingValue.Tests.ps1 @@ -1,21 +1,33 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object { $_ -notin ('whatif', 'confirm') } - [object[]]$knownParameters = 'Value', 'DataType', 'Nullable', 'EnableException' +Describe "Convert-DbaMaskingValue" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Convert-DbaMaskingValue + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "Value", + "DataType", + "Nullable", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object { $_ }) -DifferenceObject $params).Count ) | Should Be 0 + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$CommandName Integration Tests" -Tag "IntegrationTests" { - +Describe "Convert-DbaMaskingValue" -Tag "IntegrationTests" { Context "Null values" { It "Should return a single 'NULL' value" { $value = $null @@ -25,38 +37,38 @@ Describe "$CommandName Integration Tests" -Tag "IntegrationTests" { It "Should return multiple 'NULL' values" { $value = @($null, $null) - [array]$convertedValues = Convert-DbaMaskingValue -Value $value -Nullable:$true + $convertedValues = Convert-DbaMaskingValue -Value $value -Nullable:$true $convertedValues[0].NewValue | Should -Be 'NULL' $convertedValues[1].NewValue | Should -Be 'NULL' } } Context "Text data types" { - It "Should return a text value" { + It "Should return a text value for char data type" { $value = "this is just text" $convertedValue = Convert-DbaMaskingValue -Value $value -DataType char $convertedValue.NewValue | Should -Be "'this is just text'" } - It "Should return a text value" { + It "Should return a text value for nchar data type" { $value = "this is just text" $convertedValue = Convert-DbaMaskingValue -Value $value -DataType nchar $convertedValue.NewValue | Should -Be "'this is just text'" } - It "Should return a text value" { + It "Should return a text value for nvarchar data type" { $value = "this is just text" $convertedValue = Convert-DbaMaskingValue -Value $value -DataType nvarchar $convertedValue.NewValue | Should -Be "'this is just text'" } - It "Should return a text value" { + It "Should return a text value for varchar data type" { $value = "this is just text" $convertedValue = Convert-DbaMaskingValue -Value $value -DataType varchar $convertedValue.NewValue | Should -Be "'this is just text'" } - It "Should return a text value" { + It "Should return a text value for numeric string" { $value = "2.13" $convertedValue = Convert-DbaMaskingValue -Value $value -DataType varchar $convertedValue.NewValue | Should -Be "'2.13'" @@ -70,41 +82,41 @@ Describe "$CommandName Integration Tests" -Tag "IntegrationTests" { } Context "Date and time data types" { - It "Should return a text value" { + It "Should return a date value" { $value = "2020-10-05 10:10:10.1234567" $convertedValue = Convert-DbaMaskingValue -Value $value -DataType date $convertedValue.NewValue | Should -Be "'2020-10-05'" } - It "Should return a text value" { + It "Should return a time value" { $value = "2020-10-05 10:10:10.1234567" $convertedValue = Convert-DbaMaskingValue -Value $value -DataType time $convertedValue.NewValue | Should -Be "'10:10:10.1234567'" } - It "Should return a text value" { + It "Should return a datetime value" { $value = "2020-10-05 10:10:10.1234567" $convertedValue = Convert-DbaMaskingValue -Value $value -DataType datetime $convertedValue.NewValue | Should -Be "'2020-10-05 10:10:10.123'" - } #> + } } Context "Handling multiple values" { - It "It should return a NULL value and text value" { + It "Should return a NULL value and text value" { $value = @($null, "this is just text") - [array]$convertedValues = Convert-DbaMaskingValue -Value $value -Nullable:$true + $convertedValues = Convert-DbaMaskingValue -Value $value -Nullable:$true $convertedValues[0].NewValue | Should -Be 'NULL' $convertedValues[1].NewValue | Should -Be "'this is just text'" } } Context "Error handling" { - It "It should return the value missing error" { + It "Should throw an error when value is missing" { { Convert-DbaMaskingValue -Value $null -DataType datetime -EnableException } | Should -Throw "Please enter a value" } - It "It should return the data type missing error" { + + It "Should throw an error when data type is missing" { { Convert-DbaMaskingValue -Value "whatever" -EnableException } | Should -Throw "Please enter a data type" } } - -} \ No newline at end of file +} diff --git a/tests/ConvertTo-DbaTimeline.Tests.ps1 b/tests/ConvertTo-DbaTimeline.Tests.ps1 index cf7f8d4f87..e3f7a1872a 100644 --- a/tests/ConvertTo-DbaTimeline.Tests.ps1 +++ b/tests/ConvertTo-DbaTimeline.Tests.ps1 @@ -1,19 +1,33 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'InputObject', 'ExcludeRowLabel', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "ConvertTo-DbaTimeline" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command ConvertTo-DbaTimeline + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "InputObject", + "ExcludeRowLabel", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } + <# Integration test should appear below and are custom to the command you are writing. Read https://github.com/dataplat/dbatools/blob/development/contributing.md#tests - for more guidence. -#> \ No newline at end of file + for more guidance. +#> diff --git a/tests/ConvertTo-DbaXESession.Tests.ps1 b/tests/ConvertTo-DbaXESession.Tests.ps1 index c675a40aa0..d70d6f3743 100644 --- a/tests/ConvertTo-DbaXESession.Tests.ps1 +++ b/tests/ConvertTo-DbaXESession.Tests.ps1 @@ -1,112 +1,135 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'InputObject', 'Name', 'OutputScriptOnly', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "ConvertTo-DbaXESession" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command ConvertTo-DbaXESession + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "InputObject", + "Name", + "OutputScriptOnly", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$commandname Integration Tests" -Tags "IntegrationTests" { +Describe "ConvertTo-DbaXESession" -Tag "IntegrationTests" { BeforeAll { - $sql = "-- Create a Queue - declare @rc int - declare @TraceID int - declare @maxfilesize bigint - set @maxfilesize = 5 - exec @rc = sp_trace_create @TraceID output, 0, N'C:\windows\temp\temptrace', @maxfilesize, NULL + $sql = @" +-- Create a Queue +declare @rc int +declare @TraceID int +declare @maxfilesize bigint +set @maxfilesize = 5 +exec @rc = sp_trace_create @TraceID output, 0, N'C:\windows\temp\temptrace', @maxfilesize, NULL - -- Set the events - declare @on bit - set @on = 1 - exec sp_trace_setevent @TraceID, 14, 1, @on - exec sp_trace_setevent @TraceID, 14, 9, @on - exec sp_trace_setevent @TraceID, 14, 10, @on - exec sp_trace_setevent @TraceID, 14, 11, @on - exec sp_trace_setevent @TraceID, 14, 6, @on - exec sp_trace_setevent @TraceID, 14, 12, @on - exec sp_trace_setevent @TraceID, 14, 14, @on - exec sp_trace_setevent @TraceID, 15, 11, @on - exec sp_trace_setevent @TraceID, 15, 6, @on - exec sp_trace_setevent @TraceID, 15, 9, @on - exec sp_trace_setevent @TraceID, 15, 10, @on - exec sp_trace_setevent @TraceID, 15, 12, @on - exec sp_trace_setevent @TraceID, 15, 13, @on - exec sp_trace_setevent @TraceID, 15, 14, @on - exec sp_trace_setevent @TraceID, 15, 15, @on - exec sp_trace_setevent @TraceID, 15, 16, @on - exec sp_trace_setevent @TraceID, 15, 17, @on - exec sp_trace_setevent @TraceID, 15, 18, @on - exec sp_trace_setevent @TraceID, 17, 1, @on - exec sp_trace_setevent @TraceID, 17, 9, @on - exec sp_trace_setevent @TraceID, 17, 10, @on - exec sp_trace_setevent @TraceID, 17, 11, @on - exec sp_trace_setevent @TraceID, 17, 6, @on - exec sp_trace_setevent @TraceID, 17, 12, @on - exec sp_trace_setevent @TraceID, 17, 14, @on - exec sp_trace_setevent @TraceID, 10, 9, @on - exec sp_trace_setevent @TraceID, 10, 2, @on - exec sp_trace_setevent @TraceID, 10, 10, @on - exec sp_trace_setevent @TraceID, 10, 6, @on - exec sp_trace_setevent @TraceID, 10, 11, @on - exec sp_trace_setevent @TraceID, 10, 12, @on - exec sp_trace_setevent @TraceID, 10, 13, @on - exec sp_trace_setevent @TraceID, 10, 14, @on - exec sp_trace_setevent @TraceID, 10, 15, @on - exec sp_trace_setevent @TraceID, 10, 16, @on - exec sp_trace_setevent @TraceID, 10, 17, @on - exec sp_trace_setevent @TraceID, 10, 18, @on - exec sp_trace_setevent @TraceID, 12, 1, @on - exec sp_trace_setevent @TraceID, 12, 9, @on - exec sp_trace_setevent @TraceID, 12, 11, @on - exec sp_trace_setevent @TraceID, 12, 6, @on - exec sp_trace_setevent @TraceID, 12, 10, @on - exec sp_trace_setevent @TraceID, 12, 12, @on - exec sp_trace_setevent @TraceID, 12, 13, @on - exec sp_trace_setevent @TraceID, 12, 14, @on - exec sp_trace_setevent @TraceID, 12, 15, @on - exec sp_trace_setevent @TraceID, 12, 16, @on - exec sp_trace_setevent @TraceID, 12, 17, @on - exec sp_trace_setevent @TraceID, 12, 18, @on - exec sp_trace_setevent @TraceID, 13, 1, @on - exec sp_trace_setevent @TraceID, 13, 9, @on - exec sp_trace_setevent @TraceID, 13, 11, @on - exec sp_trace_setevent @TraceID, 13, 6, @on - exec sp_trace_setevent @TraceID, 13, 10, @on - exec sp_trace_setevent @TraceID, 13, 12, @on - exec sp_trace_setevent @TraceID, 13, 14, @on +-- Set the events +declare @on bit +set @on = 1 +exec sp_trace_setevent @TraceID, 14, 1, @on +exec sp_trace_setevent @TraceID, 14, 9, @on +exec sp_trace_setevent @TraceID, 14, 10, @on +exec sp_trace_setevent @TraceID, 14, 11, @on +exec sp_trace_setevent @TraceID, 14, 6, @on +exec sp_trace_setevent @TraceID, 14, 12, @on +exec sp_trace_setevent @TraceID, 14, 14, @on +exec sp_trace_setevent @TraceID, 15, 11, @on +exec sp_trace_setevent @TraceID, 15, 6, @on +exec sp_trace_setevent @TraceID, 15, 9, @on +exec sp_trace_setevent @TraceID, 15, 10, @on +exec sp_trace_setevent @TraceID, 15, 12, @on +exec sp_trace_setevent @TraceID, 15, 13, @on +exec sp_trace_setevent @TraceID, 15, 14, @on +exec sp_trace_setevent @TraceID, 15, 15, @on +exec sp_trace_setevent @TraceID, 15, 16, @on +exec sp_trace_setevent @TraceID, 15, 17, @on +exec sp_trace_setevent @TraceID, 15, 18, @on +exec sp_trace_setevent @TraceID, 17, 1, @on +exec sp_trace_setevent @TraceID, 17, 9, @on +exec sp_trace_setevent @TraceID, 17, 10, @on +exec sp_trace_setevent @TraceID, 17, 11, @on +exec sp_trace_setevent @TraceID, 17, 6, @on +exec sp_trace_setevent @TraceID, 17, 12, @on +exec sp_trace_setevent @TraceID, 17, 14, @on +exec sp_trace_setevent @TraceID, 10, 9, @on +exec sp_trace_setevent @TraceID, 10, 2, @on +exec sp_trace_setevent @TraceID, 10, 10, @on +exec sp_trace_setevent @TraceID, 10, 6, @on +exec sp_trace_setevent @TraceID, 10, 11, @on +exec sp_trace_setevent @TraceID, 10, 12, @on +exec sp_trace_setevent @TraceID, 10, 13, @on +exec sp_trace_setevent @TraceID, 10, 14, @on +exec sp_trace_setevent @TraceID, 10, 15, @on +exec sp_trace_setevent @TraceID, 10, 16, @on +exec sp_trace_setevent @TraceID, 10, 17, @on +exec sp_trace_setevent @TraceID, 10, 18, @on +exec sp_trace_setevent @TraceID, 12, 1, @on +exec sp_trace_setevent @TraceID, 12, 9, @on +exec sp_trace_setevent @TraceID, 12, 11, @on +exec sp_trace_setevent @TraceID, 12, 6, @on +exec sp_trace_setevent @TraceID, 12, 10, @on +exec sp_trace_setevent @TraceID, 12, 12, @on +exec sp_trace_setevent @TraceID, 12, 13, @on +exec sp_trace_setevent @TraceID, 12, 14, @on +exec sp_trace_setevent @TraceID, 12, 15, @on +exec sp_trace_setevent @TraceID, 12, 16, @on +exec sp_trace_setevent @TraceID, 12, 17, @on +exec sp_trace_setevent @TraceID, 12, 18, @on +exec sp_trace_setevent @TraceID, 13, 1, @on +exec sp_trace_setevent @TraceID, 13, 9, @on +exec sp_trace_setevent @TraceID, 13, 11, @on +exec sp_trace_setevent @TraceID, 13, 6, @on +exec sp_trace_setevent @TraceID, 13, 10, @on +exec sp_trace_setevent @TraceID, 13, 12, @on +exec sp_trace_setevent @TraceID, 13, 14, @on - -- Set the Filters - declare @intfilter int - declare @bigintfilter bigint +-- Set the Filters +declare @intfilter int +declare @bigintfilter bigint - exec sp_trace_setfilter @TraceID, 10, 0, 7, N'SQL Server Profiler - 934a8575-0dc1-4937-bde1-edac1cb9691f' - -- Set the trace status to start - exec sp_trace_setstatus @TraceID, 1 +exec sp_trace_setfilter @TraceID, 10, 0, 7, N'SQL Server Profiler - 934a8575-0dc1-4937-bde1-edac1cb9691f' +-- Set the trace status to start +exec sp_trace_setstatus @TraceID, 1 - -- display trace id for future references - select TraceID=@TraceID" +-- display trace id for future references +select TraceID=@TraceID +"@ $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2 $traceid = ($server.Query($sql)).TraceID $TestConfig.name = "dbatoolsci-session" } + AfterAll { $null = Remove-DbaXESession -SqlInstance $TestConfig.instance2 -Session $TestConfig.name $null = Remove-DbaTrace -SqlInstance $TestConfig.instance2 -Id $traceid Remove-Item C:\windows\temp\temptrace.trc -ErrorAction SilentlyContinue } + Context "Test Trace Conversion" { - $results = Get-DbaTrace -SqlInstance $TestConfig.instance2 -Id $traceid | ConvertTo-DbaXESession -Name $TestConfig.name | Start-DbaXESession - It "returns the right results" { - $results.Name | Should Be $TestConfig.name - $results.Status | Should Be "Running" - $results.Targets.Name | Should Be "package0.event_file" + BeforeAll { + $results = Get-DbaTrace -SqlInstance $TestConfig.instance2 -Id $traceid | + ConvertTo-DbaXESession -Name $TestConfig.name | + Start-DbaXESession + } + + It "Returns the right results" { + $results.Name | Should -Be $TestConfig.name + $results.Status | Should -Be "Running" + $results.Targets.Name | Should -Be "package0.event_file" } } } diff --git a/tests/Copy-DbaAgentAlert.Tests.ps1 b/tests/Copy-DbaAgentAlert.Tests.ps1 index e40e27fe13..68ae79f484 100644 --- a/tests/Copy-DbaAgentAlert.Tests.ps1 +++ b/tests/Copy-DbaAgentAlert.Tests.ps1 @@ -1,19 +1,38 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'Source', 'SourceSqlCredential', 'Destination', 'DestinationSqlCredential', 'Alert', 'ExcludeAlert', 'IncludeDefaults', 'Force', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Copy-DbaAgentAlert" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Copy-DbaAgentAlert + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "Source", + "SourceSqlCredential", + "Destination", + "DestinationSqlCredential", + "Alert", + "ExcludeAlert", + "IncludeDefaults", + "Force", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$commandname Integration Tests" -Tag "IntegrationTests" { +Describe "Copy-DbaAgentAlert" -Tag "IntegrationTests" { BeforeAll { $alert1 = 'dbatoolsci test alert' $alert2 = 'dbatoolsci test alert 2' @@ -46,6 +65,7 @@ Describe "$commandname Integration Tests" -Tag "IntegrationTests" { @operator_name = N'$operatorName', @notification_method = 1 ;") } + AfterAll { $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2 -Database master $server.Query("EXEC msdb.dbo.sp_delete_alert @name=N'$($alert1)'") @@ -56,25 +76,27 @@ Describe "$commandname Integration Tests" -Tag "IntegrationTests" { $server.Query("EXEC msdb.dbo.sp_delete_alert @name=N'$($alert1)'") } - It "Copies the sample alert" { - $results = Copy-DbaAgentAlert -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Alert $alert1 - $results.Name -eq 'dbatoolsci test alert', 'dbatoolsci test alert' - $results.Status -eq 'Successful', 'Successful' - } + Context "When copying alerts" { + It "Copies the sample alert" { + $results = Copy-DbaAgentAlert -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Alert $alert1 + $results.Name | Should -Be @('dbatoolsci test alert', 'dbatoolsci test alert') + $results.Status | Should -Be @('Successful', 'Successful') + } - It "Skips alerts where destination is missing the operator" { - $results = Copy-DbaAgentAlert -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Alert $alert2 -WarningAction SilentlyContinue - $results.Status -eq 'Skipped', 'Skipped' - } + It "Skips alerts where destination is missing the operator" { + $results = Copy-DbaAgentAlert -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Alert $alert2 -WarningAction SilentlyContinue + $results.Status | Should -Be @('Skipped', 'Skipped') + } - It "Doesn't overwrite existing alerts" { - $results = Copy-DbaAgentAlert -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Alert $alert1 - $results.Name -eq 'dbatoolsci test alert' - $results.Status -eq 'Skipped' - } + It "Doesn't overwrite existing alerts" { + $results = Copy-DbaAgentAlert -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Alert $alert1 + $results.Name | Should -Be 'dbatoolsci test alert' + $results.Status | Should -Be 'Skipped' + } - It "The newly copied alert exists" { - $results = Get-DbaAgentAlert -SqlInstance $TestConfig.instance2 - $results.Name -contains 'dbatoolsci test alert' + It "The newly copied alert exists" { + $results = Get-DbaAgentAlert -SqlInstance $TestConfig.instance2 + $results.Name | Should -Contain 'dbatoolsci test alert' + } } } diff --git a/tests/Copy-DbaAgentJob.Tests.ps1 b/tests/Copy-DbaAgentJob.Tests.ps1 index 81151184f7..62a43bbcab 100644 --- a/tests/Copy-DbaAgentJob.Tests.ps1 +++ b/tests/Copy-DbaAgentJob.Tests.ps1 @@ -1,19 +1,8 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'Source', 'SourceSqlCredential', 'Destination', 'DestinationSqlCredential', 'Job', 'ExcludeJob', 'DisableOnSource', 'DisableOnDestination', 'Force', 'EnableException', 'InputObject' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 - } - } -} - -Describe "$commandname Integration Tests" -Tag "IntegrationTests" { +Describe "Copy-DbaAgentJob" -Tag "IntegrationTests" { BeforeAll { $null = New-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job dbatoolsci_copyjob $null = New-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job dbatoolsci_copyjob_disabled @@ -25,8 +14,40 @@ Describe "$commandname Integration Tests" -Tag "IntegrationTests" { $null = Remove-DbaAgentJob -SqlInstance $TestConfig.instance3 -Job dbatoolsci_copyjob, dbatoolsci_copyjob_disabled -Confirm:$false } + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Copy-DbaAgentJob + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "Source", + "SourceSqlCredential", + "Destination", + "DestinationSqlCredential", + "Job", + "ExcludeJob", + "DisableOnSource", + "DisableOnDestination", + "Force", + "InputObject", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty + } + } + Context "Command copies jobs properly" { - $results = Copy-DbaAgentJob -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Job dbatoolsci_copyjob + BeforeAll { + $results = Copy-DbaAgentJob -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Job dbatoolsci_copyjob + } It "returns one success" { $results.Name | Should -Be "dbatoolsci_copyjob" @@ -34,16 +55,24 @@ Describe "$commandname Integration Tests" -Tag "IntegrationTests" { } It "did not copy dbatoolsci_copyjob_disabled" { - Get-DbaAgentJob -SqlInstance $TestConfig.instance3 -Job dbatoolsci_copyjob_disabled | Should -Be $null + Get-DbaAgentJob -SqlInstance $TestConfig.instance3 -Job dbatoolsci_copyjob_disabled | Should -BeNullOrEmpty } It "disables jobs when requested" { - (Get-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job dbatoolsci_copyjob_disabled).Enabled - $results = Copy-DbaAgentJob -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Job dbatoolsci_copyjob_disabled -DisableOnSource -DisableOnDestination -Force + $splatCopyJob = @{ + Source = $TestConfig.instance2 + Destination = $TestConfig.instance3 + Job = "dbatoolsci_copyjob_disabled" + DisableOnSource = $true + DisableOnDestination = $true + Force = $true + } + $results = Copy-DbaAgentJob @splatCopyJob + $results.Name | Should -Be "dbatoolsci_copyjob_disabled" $results.Status | Should -Be "Successful" - (Get-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job dbatoolsci_copyjob_disabled).Enabled | Should -Be $false - (Get-DbaAgentJob -SqlInstance $TestConfig.instance3 -Job dbatoolsci_copyjob_disabled).Enabled | Should -Be $false + (Get-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job dbatoolsci_copyjob_disabled).Enabled | Should -BeFalse + (Get-DbaAgentJob -SqlInstance $TestConfig.instance3 -Job dbatoolsci_copyjob_disabled).Enabled | Should -BeFalse } } } diff --git a/tests/Copy-DbaAgentJobCategory.Tests.ps1 b/tests/Copy-DbaAgentJobCategory.Tests.ps1 index 943c31d943..61a135d93b 100644 --- a/tests/Copy-DbaAgentJobCategory.Tests.ps1 +++ b/tests/Copy-DbaAgentJobCategory.Tests.ps1 @@ -1,19 +1,8 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'Source', 'SourceSqlCredential', 'Destination', 'DestinationSqlCredential', 'CategoryType', 'JobCategory', 'AgentCategory', 'OperatorCategory', 'Force', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 - } - } -} - -Describe "$commandname Integration Tests" -Tag "IntegrationTests" { +Describe "Copy-DbaAgentJobCategory" -Tag "IntegrationTests" { BeforeAll { $null = New-DbaAgentJobCategory -SqlInstance $TestConfig.instance2 -Category 'dbatoolsci test category' } @@ -21,17 +10,58 @@ Describe "$commandname Integration Tests" -Tag "IntegrationTests" { $null = Remove-DbaAgentJobCategory -SqlInstance $TestConfig.instance2 -Category 'dbatoolsci test category' -Confirm:$false } - Context "Command copies jobs properly" { - It "returns one success" { - $results = Copy-DbaAgentJobCategory -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -JobCategory 'dbatoolsci test category' - $results.Name -eq "dbatoolsci test category" - $results.Status -eq "Successful" + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Copy-DbaAgentJobCategory + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "Source", + "SourceSqlCredential", + "Destination", + "DestinationSqlCredential", + "CategoryType", + "JobCategory", + "AgentCategory", + "OperatorCategory", + "Force", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty + } + } + + Context "When copying job categories" { + It "Returns successful results" { + $splat = @{ + Source = $TestConfig.instance2 + Destination = $TestConfig.instance3 + JobCategory = "dbatoolsci test category" + } + + $results = Copy-DbaAgentJobCategory @splat + $results.Name | Should -Be "dbatoolsci test category" + $results.Status | Should -Be "Successful" } - It "does not overwrite" { - $results = Copy-DbaAgentJobCategory -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -JobCategory 'dbatoolsci test category' - $results.Name -eq "dbatoolsci test category" - $results.Status -eq "Skipped" + It "Does not overwrite existing categories" { + $splatSecondCopy = @{ + Source = $TestConfig.instance2 + Destination = $TestConfig.instance3 + JobCategory = "dbatoolsci test category" + } + + $secondCopyResults = Copy-DbaAgentJobCategory @splatSecondCopy + $secondCopyResults.Name | Should -Be "dbatoolsci test category" + $secondCopyResults.Status | Should -Be "Skipped" } } } diff --git a/tests/Copy-DbaAgentOperator.Tests.ps1 b/tests/Copy-DbaAgentOperator.Tests.ps1 index 361ebf9a1d..9cf6327ee3 100644 --- a/tests/Copy-DbaAgentOperator.Tests.ps1 +++ b/tests/Copy-DbaAgentOperator.Tests.ps1 @@ -1,19 +1,37 @@ -$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "") -Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan +#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"} +param($ModuleName = "dbatools") $global:TestConfig = Get-TestConfig -Describe "$CommandName Unit Tests" -Tag 'UnitTests' { - Context "Validate parameters" { - [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')} - [object[]]$knownParameters = 'Source', 'SourceSqlCredential', 'Destination', 'DestinationSqlCredential', 'Operator', 'ExcludeOperator', 'Force', 'EnableException' - $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters - It "Should only contain our specific parameters" { - (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0 +Describe "Copy-DbaAgentOperator" -Tag "UnitTests" { + Context "Parameter validation" { + BeforeAll { + $command = Get-Command Copy-DbaAgentOperator + $expectedParameters = $TestConfig.CommonParameters + + $expectedParameters += @( + "Source", + "SourceSqlCredential", + "Destination", + "DestinationSqlCredential", + "Operator", + "ExcludeOperator", + "Force", + "EnableException" + ) + } + + It "Has parameter: <_>" -ForEach $expectedParameters { + $command | Should -HaveParameter $PSItem + } + + It "Should have exactly the number of expected parameters" { + $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" } + Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty } } } -Describe "$commandname Integration Tests" -Tag "IntegrationTests" { +Describe "Copy-DbaAgentOperator" -Tag "IntegrationTests" { BeforeAll { $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2 $sql = "EXEC msdb.dbo.sp_add_operator @name=N'dbatoolsci_operator', @enabled=1, @pager_days=0" @@ -21,6 +39,7 @@ Describe "$commandname Integration Tests" -Tag "IntegrationTests" { $sql = "EXEC msdb.dbo.sp_add_operator @name=N'dbatoolsci_operator2', @enabled=1, @pager_days=0" $server.Query($sql) } + AfterAll { $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2 $sql = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator'" @@ -35,17 +54,19 @@ Describe "$commandname Integration Tests" -Tag "IntegrationTests" { $server.Query($sql) } - Context "Copies operators" { - $results = Copy-DbaAgentOperator -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Operator dbatoolsci_operator, dbatoolsci_operator2 + Context "When copying operators" { + BeforeAll { + $results = Copy-DbaAgentOperator -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Operator dbatoolsci_operator, dbatoolsci_operator2 + } - It "returns two results" { - $results.Count -eq 2 - $results.Status -eq "Successful", "Successful" + It "Returns two results" { + $results.Count | Should -Be 2 + $results.Status | Should -Be @("Successful", "Successful") } - It "return one result that's skipped" { - $results = Copy-DbaAgentOperator -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Operator dbatoolsci_operator - $results.Status -eq "Skipped" + It "Returns one result that's skipped when copying an existing operator" { + $skippedResults = Copy-DbaAgentOperator -Source $TestConfig.instance2 -Destination $TestConfig.instance3 -Operator dbatoolsci_operator + $skippedResults.Status | Should -Be "Skipped" } } }