From 969c2d0c3f1ed6d8922575040fca02f9debe7cf2 Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Fri, 8 Aug 2025 21:53:48 +0200
Subject: [PATCH 01/15] Refactor and improve test scripts for consistency

Standardized parameter quoting, variable naming, and splatting across test scripts. Improved error handling and cleanup in integration tests, replaced deprecated syntax, and enhanced readability and maintainability. No functional changes to the tested modules.
---
 tests/Add-DbaAgDatabase.Tests.ps1             |  30 ++-
 tests/Add-DbaAgListener.Tests.ps1             |  23 +-
 tests/Add-DbaAgReplica.Tests.ps1              |  40 ++--
 tests/Add-DbaComputerCertificate.Tests.ps1    |  20 +-
 tests/Add-DbaDbMirrorMonitor.Tests.ps1        |  22 +-
 tests/Add-DbaDbRoleMember.Tests.ps1           | 157 +++++++++---
 tests/Add-DbaExtendedProperty.Tests.ps1       |   8 +-
 tests/Add-DbaPfDataCollectorCounter.Tests.ps1 |  34 +--
 tests/Add-DbaRegServer.Tests.ps1              |  14 +-
 tests/Add-DbaRegServerGroup.Tests.ps1         |  39 ++-
 tests/Add-DbaReplArticle.Tests.ps1            |   6 +-
 tests/Add-DbaServerRoleMember.Tests.ps1       |  44 ++--
 tests/Backup-DbaComputerCertificate.Tests.ps1 |  25 +-
 tests/Backup-DbaDatabase.Tests.ps1            |  10 +-
 tests/Backup-DbaDbCertificate.Tests.ps1       |  46 +++-
 tests/Backup-DbaDbMasterKey.Tests.ps1         |  44 ++--
 tests/Backup-DbaServiceMasterKey.Tests.ps1    |  46 ++--
 tests/Clear-DbaConnectionPool.Tests.ps1       |  26 +-
 tests/Clear-DbaLatchStatistics.Tests.ps1      |  40 ++--
 tests/Clear-DbaPlanCache.Tests.ps1            |  32 +--
 tests/Clear-DbaWaitStatistics.Tests.ps1       |  44 ++--
 tests/Connect-DbaInstance.Tests.ps1           |   8 +-
 tests/Convert-DbaLsn.Tests.ps1                |  40 ++--
 tests/Convert-DbaMaskingValue.Tests.ps1       |  30 +--
 tests/ConvertTo-DbaDataTable.Tests.ps1        | 224 ++++++++++--------
 tests/ConvertTo-DbaTimeline.Tests.ps1         |  22 +-
 tests/ConvertTo-DbaXESession.Tests.ps1        |  51 ++--
 tests/Copy-DbaAgentAlert.Tests.ps1            |  70 +++---
 tests/Copy-DbaAgentJob.Tests.ps1              |  37 ++-
 tests/Copy-DbaAgentJobCategory.Tests.ps1      |  37 ++-
 tests/Copy-DbaAgentOperator.Tests.ps1         |  74 +++---
 31 files changed, 757 insertions(+), 586 deletions(-)

diff --git a/tests/Add-DbaAgDatabase.Tests.ps1 b/tests/Add-DbaAgDatabase.Tests.ps1
index 516fff4283c0..76c9ab07cd4a 100644
--- a/tests/Add-DbaAgDatabase.Tests.ps1
+++ b/tests/Add-DbaAgDatabase.Tests.ps1
@@ -10,10 +10,10 @@ param(
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe $CommandName -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
                 "SqlInstance",
@@ -37,10 +37,10 @@ Describe $CommandName -Tag "UnitTests" {
     }
 }
 
-Describe $CommandName -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
         # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
-        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
         # For all the backups that we want to clean up after the test, we create a directory that we can delete at the end.
         # Other files can be written there as well, maybe we change the name of that variable later. But for now we focus on backups.
@@ -58,14 +58,15 @@ Describe $CommandName -Tag "IntegrationTests" {
         $nonexistingDb = "dbdoesnotexist"
 
         # Create the objects.
-        $splat = @{
+        $splatAg = @{
             Primary      = $TestConfig.instance3
             Name         = $agName
             ClusterType  = "None"
             FailoverMode = "Manual"
             Certificate  = "dbatoolsci_AGCert"
+            Confirm      = $false
         }
-        $null = New-DbaAvailabilityGroup @splat
+        $null = New-DbaAvailabilityGroup @splatAg
 
         $null = New-DbaDatabase -SqlInstance $TestConfig.instance3 -Name $existingDbWithBackup
         $null = Backup-DbaDatabase -SqlInstance $TestConfig.instance3 -Database $existingDbWithBackup -Path $backupPath
@@ -73,12 +74,12 @@ Describe $CommandName -Tag "IntegrationTests" {
         $null = New-DbaDatabase -SqlInstance $TestConfig.instance3 -Name $existingDbWithoutBackup
 
         # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
-        $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
 
     AfterAll {
         # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
-        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
         # Cleanup all created object.
         $null = Remove-DbaAvailabilityGroup -SqlInstance $TestConfig.instance3 -AvailabilityGroup $agName
@@ -86,7 +87,7 @@ Describe $CommandName -Tag "IntegrationTests" {
         $null = Remove-DbaDatabase -SqlInstance $TestConfig.instance3 -Database $existingDbWithBackup, $existingDbWithoutBackup
 
         # Remove the backup directory.
-        Remove-Item -Path $backupPath -Recurse
+        Remove-Item -Path $backupPath -Recurse -ErrorAction SilentlyContinue
 
         # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
@@ -95,12 +96,13 @@ Describe $CommandName -Tag "IntegrationTests" {
         # We use the BeforeAll to run the test itself.
         # Results are saved in $results.
         BeforeAll {
-            $splat = @{
+            $splatAddAgDatabase = @{
                 SqlInstance       = $TestConfig.instance3
                 AvailabilityGroup = $agName
                 Database          = $existingDbWithBackup
+                Confirm           = $false
             }
-            $results = Add-DbaAgDatabase @splat
+            $results = Add-DbaAgDatabase @splatAddAgDatabase
         }
 
         # Always include this test to be sure that the command runs without warnings.
@@ -123,7 +125,8 @@ Describe $CommandName -Tag "IntegrationTests" {
                 Database          = $existingDbWithoutBackup
                 # As we don't want an output, we suppress the warning.
                 # But we can still test the warning because WarningVariable is set globally to WarnVar.
-                WarningAction     = 'SilentlyContinue'
+                WarningAction     = "SilentlyContinue"
+                Confirm           = $false
             }
             $results = Add-DbaAgDatabase @splatAddAgDb
         }
@@ -143,7 +146,8 @@ Describe $CommandName -Tag "IntegrationTests" {
                 SqlInstance       = $TestConfig.instance3
                 AvailabilityGroup = $agName
                 Database          = $nonexistingDb
-                WarningAction     = 'SilentlyContinue'
+                WarningAction     = "SilentlyContinue"
+                Confirm           = $false
             }
             $results = Add-DbaAgDatabase @splatAddAgDb
         }
diff --git a/tests/Add-DbaAgListener.Tests.ps1 b/tests/Add-DbaAgListener.Tests.ps1
index 761431c368de..054e1acc4b5e 100644
--- a/tests/Add-DbaAgListener.Tests.ps1
+++ b/tests/Add-DbaAgListener.Tests.ps1
@@ -8,7 +8,7 @@ param(
 Describe $CommandName -Tag "UnitTests" {
     Context "Parameter validation" {
         BeforeAll {
-            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
                 "SqlInstance",
@@ -34,7 +34,7 @@ Describe $CommandName -Tag "UnitTests" {
 
 Describe $CommandName -Tag "IntegrationTests" {
     BeforeAll {
-        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
         $backupPath = "$($TestConfig.Temp)\$CommandName-$(Get-Random)"
         $null = New-Item -Path $backupPath -ItemType Directory
@@ -47,35 +47,34 @@ Describe $CommandName -Tag "IntegrationTests" {
         $listenerIp = "127.0.20.1"
         $listenerPort = 14330
 
-        $splat = @{
+        $splatAg = @{
             Primary      = $TestConfig.instance3
             Name         = $agName
             ClusterType  = "None"
             FailoverMode = "Manual"
             Certificate  = "dbatoolsci_AGCert"
+            Confirm      = $false
         }
-        $ag = New-DbaAvailabilityGroup @splat
-
-        $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
+        $ag = New-DbaAvailabilityGroup @splatAg
     }
 
     AfterAll {
-        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
 
-        $null = Remove-DbaAvailabilityGroup -SqlInstance $TestConfig.instance3 -AvailabilityGroup $agName
-        $null = Get-DbaEndpoint -SqlInstance $TestConfig.instance3 -Type DatabaseMirroring | Remove-DbaEndpoint
+        $null = Remove-DbaAvailabilityGroup -SqlInstance $TestConfig.instance3 -AvailabilityGroup $agName -Confirm:$false
+        $null = Get-DbaEndpoint -SqlInstance $TestConfig.instance3 -Type DatabaseMirroring | Remove-DbaEndpoint -Confirm:$false
 
-        Remove-Item -Path $backupPath -Recurse
+        Remove-Item -Path $backupPath -Recurse -ErrorAction SilentlyContinue
     }
 
     Context "When creating a listener" {
         BeforeAll {
-            $splat = @{
+            $splatListener = @{
                 Name      = $listenerName
                 IPAddress = $listenerIp
                 Port      = $listenerPort
             }
-            $results = $ag | Add-DbaAgListener @splat
+            $results = $ag | Add-DbaAgListener @splatListener
         }
 
         It "Does not warn" {
diff --git a/tests/Add-DbaAgReplica.Tests.ps1 b/tests/Add-DbaAgReplica.Tests.ps1
index a8170d773420..7e6b65c99dd2 100644
--- a/tests/Add-DbaAgReplica.Tests.ps1
+++ b/tests/Add-DbaAgReplica.Tests.ps1
@@ -1,14 +1,14 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName               = "dbatools",
-    $CommandName              = [System.IO.Path]::GetFileName($PSCommandPath.Replace('.Tests.ps1', '')),
+    $ModuleName  = "dbatools",
+    $CommandName = "Add-DbaAgReplica",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe $CommandName -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
                 "SqlInstance",
@@ -40,29 +40,27 @@ Describe $CommandName -Tag "UnitTests" {
     }
 }
 
-Describe $CommandName -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
-        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
         $primaryAgName = "dbatoolsci_agroup"
-        $splat = @{
+        $splatPrimary = @{
             Primary      = $TestConfig.instance3
             Name         = $primaryAgName
             ClusterType  = "None"
             FailoverMode = "Manual"
             Certificate  = "dbatoolsci_AGCert"
+            Confirm      = $false
         }
-        $primaryAg = New-DbaAvailabilityGroup @splat
+        $primaryAg = New-DbaAvailabilityGroup @splatPrimary
         $replicaName = $primaryAg.PrimaryReplica
-
-        $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
     }
 
     AfterAll {
-        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
-
-        $null = Remove-DbaAvailabilityGroup -SqlInstance $TestConfig.instance3 -AvailabilityGroup $primaryAgName
-        $null = Get-DbaEndpoint -SqlInstance $TestConfig.instance3 -Type DatabaseMirroring | Remove-DbaEndpoint
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+        $null = Remove-DbaAvailabilityGroup -SqlInstance $TestConfig.instance3 -AvailabilityGroup $primaryAgName -Confirm:$false -ErrorAction SilentlyContinue
+        $null = Get-DbaEndpoint -SqlInstance $TestConfig.instance3 -Type DatabaseMirroring | Remove-DbaEndpoint -Confirm:$false -ErrorAction SilentlyContinue
     }
 
     Context "When adding AG replicas" {
@@ -79,23 +77,23 @@ Describe $CommandName -Tag "IntegrationTests" {
         }
 
         AfterAll {
-            $null = Remove-DbaAvailabilityGroup -SqlInstance $TestConfig.instance3 -AvailabilityGroup $replicaAgName
+            $null = Remove-DbaAvailabilityGroup -SqlInstance $TestConfig.instance3 -AvailabilityGroup $replicaAgName -Confirm:$false -ErrorAction SilentlyContinue
         }
 
         It "Returns results with proper data" {
             $results = Get-DbaAgReplica -SqlInstance $TestConfig.instance3
             $results.AvailabilityGroup | Should -Contain $replicaAgName
-            $results.Role | Should -Contain 'Primary'
-            $results.AvailabilityMode | Should -Contain 'SynchronousCommit'
-            $results.FailoverMode | Should -Contain 'Manual'
+            $results.Role | Should -Contain "Primary"
+            $results.AvailabilityMode | Should -Contain "SynchronousCommit"
+            $results.FailoverMode | Should -Contain "Manual"
         }
 
         It "Returns just one result for a specific replica" {
             $results = Get-DbaAgReplica -SqlInstance $TestConfig.instance3 -Replica $replicaName -AvailabilityGroup $replicaAgName
             $results.AvailabilityGroup | Should -Be $replicaAgName
-            $results.Role | Should -Be 'Primary'
-            $results.AvailabilityMode | Should -Be 'SynchronousCommit'
-            $results.FailoverMode | Should -Be 'Manual'
+            $results.Role | Should -Be "Primary"
+            $results.AvailabilityMode | Should -Be "SynchronousCommit"
+            $results.FailoverMode | Should -Be "Manual"
         }
     }
 } #$TestConfig.instance2 for appveyor
diff --git a/tests/Add-DbaComputerCertificate.Tests.ps1 b/tests/Add-DbaComputerCertificate.Tests.ps1
index 74774c53743d..8cccfc9198ae 100644
--- a/tests/Add-DbaComputerCertificate.Tests.ps1
+++ b/tests/Add-DbaComputerCertificate.Tests.ps1
@@ -1,14 +1,14 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
     $ModuleName               = "dbatools",
-    $CommandName              = [System.IO.Path]::GetFileName($PSCommandPath.Replace('.Tests.ps1', '')),
+    $CommandName              = "Add-DbaComputerCertificate",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe $CommandName -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
                 "ComputerName",
@@ -29,16 +29,24 @@ Describe $CommandName -Tag "UnitTests" {
     }
 }
 
-Describe $CommandName -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
+    BeforeAll {
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+    }
+
+    AfterAll {
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+    }
+
     Context "Certificate is added properly" {
         BeforeAll {
-            $certPath = "$($TestConfig.appveyorlabrepo)\certificates\localhost.crt"
+            $certPath = "$($TestConfig.AppveyorLabRepo)\certificates\localhost.crt"
             $certThumbprint = "29C469578D6C6211076A09CEE5C5797EEA0C2713"
             $results = Add-DbaComputerCertificate -Path $certPath
         }
 
         AfterAll {
-            Remove-DbaComputerCertificate -Thumbprint $certThumbprint
+            Remove-DbaComputerCertificate -Thumbprint $certThumbprint -ErrorAction SilentlyContinue
         }
 
         It "Should show the proper thumbprint has been added" {
diff --git a/tests/Add-DbaDbMirrorMonitor.Tests.ps1 b/tests/Add-DbaDbMirrorMonitor.Tests.ps1
index 5da763090f4b..03ddfa21bdc3 100644
--- a/tests/Add-DbaDbMirrorMonitor.Tests.ps1
+++ b/tests/Add-DbaDbMirrorMonitor.Tests.ps1
@@ -1,14 +1,14 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName               = "dbatools",
-    $CommandName              = [System.IO.Path]::GetFileName($PSCommandPath.Replace('.Tests.ps1', '')),
+    $ModuleName  = "dbatools",
+    $CommandName = "Add-DbaDbMirrorMonitor",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe $CommandName -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
                 "SqlInstance",
@@ -23,18 +23,26 @@ Describe $CommandName -Tag "UnitTests" {
     }
 }
 
-Describe $CommandName -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
+    BeforeAll {
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+    }
+
+    AfterAll {
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+    }
+
     Context "When adding mirror monitor" {
         BeforeAll {
             $results = Add-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2
         }
 
         AfterAll {
-            $null = Remove-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2
+            $null = Remove-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2 -ErrorAction SilentlyContinue
         }
 
         It "Adds the mirror monitor" {
-            $results.MonitorStatus | Should -Be 'Added'
+            $results.MonitorStatus | Should -Be "Added"
         }
     }
 }
diff --git a/tests/Add-DbaDbRoleMember.Tests.ps1 b/tests/Add-DbaDbRoleMember.Tests.ps1
index 842be2844a5d..fe1bd5ea526e 100644
--- a/tests/Add-DbaDbRoleMember.Tests.ps1
+++ b/tests/Add-DbaDbRoleMember.Tests.ps1
@@ -1,14 +1,14 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName               = "dbatools",
-    $CommandName              = [System.IO.Path]::GetFileName($PSCommandPath.Replace('.Tests.ps1', '')),
+    $ModuleName  = "dbatools",
+    $CommandName = "Add-DbaDbRoleMember",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe "Add-DbaDbRoleMember" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
                 "SqlInstance",
@@ -27,41 +27,88 @@ Describe "Add-DbaDbRoleMember" -Tag "UnitTests" {
     }
 }
 
-Describe "Add-DbaDbRoleMember" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
-        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
         $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2
         $user1 = "dbatoolssci_user1_$(Get-Random)"
         $user2 = "dbatoolssci_user2_$(Get-Random)"
         $role = "dbatoolssci_role_$(Get-Random)"
-        $null = New-DbaLogin -SqlInstance $TestConfig.instance2 -Login $user1 -Password ('Password1234!' | ConvertTo-SecureString -asPlainText -Force)
-        $null = New-DbaLogin -SqlInstance $TestConfig.instance2 -Login $user2 -Password ('Password1234!' | ConvertTo-SecureString -asPlainText -Force)
+        $splatLoginUser1 = @{
+            SqlInstance = $TestConfig.instance2
+            Login       = $user1
+            Password    = ("Password1234!" | ConvertTo-SecureString -asPlainText -Force)
+        }
+        $null = New-DbaLogin @splatLoginUser1
+        $splatLoginUser2 = @{
+            SqlInstance = $TestConfig.instance2
+            Login       = $user2
+            Password    = ("Password1234!" | ConvertTo-SecureString -asPlainText -Force)
+        }
+        $null = New-DbaLogin @splatLoginUser2
         $dbname = "dbatoolsci_$(Get-Random)"
         $null = New-DbaDatabase -SqlInstance $TestConfig.instance2 -Name $dbname -Owner sa
-        $null = New-DbaDbUser -SqlInstance $TestConfig.instance2 -Database $dbname -Login $user1 -Username $user1
-        $null = New-DbaDbUser -SqlInstance $TestConfig.instance2 -Database $dbname -Login $user2 -Username $user2
-        $null = New-DbaDbUser -SqlInstance $TestConfig.instance2 -Database msdb -Login $user1 -Username $user1 -IncludeSystem
-        $null = New-DbaDbUser -SqlInstance $TestConfig.instance2 -Database msdb -Login $user2 -Username $user2 -IncludeSystem
+        $splatDbUser1 = @{
+            SqlInstance = $TestConfig.instance2
+            Database    = $dbname
+            Login       = $user1
+            Username    = $user1
+        }
+        $null = New-DbaDbUser @splatDbUser1
+        $splatDbUser2 = @{
+            SqlInstance = $TestConfig.instance2
+            Database    = $dbname
+            Login       = $user2
+            Username    = $user2
+        }
+        $null = New-DbaDbUser @splatDbUser2
+        $splatDbUser1Msdb = @{
+            SqlInstance   = $TestConfig.instance2
+            Database      = "msdb"
+            Login         = $user1
+            Username      = $user1
+            IncludeSystem = $true
+        }
+        $null = New-DbaDbUser @splatDbUser1Msdb
+        $splatDbUser2Msdb = @{
+            SqlInstance   = $TestConfig.instance2
+            Database      = "msdb"
+            Login         = $user2
+            Username      = $user2
+            IncludeSystem = $true
+        }
+        $null = New-DbaDbUser @splatDbUser2Msdb
         $null = $server.Query("CREATE ROLE $role", $dbname)
-
-        $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
     }
 
     AfterAll {
-        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
         $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
-        $null = Remove-DbaLogin -SqlInstance $TestConfig.instance2 -Login $user1, $user2
+        $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
+
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
 
     Context "When adding a user to a role" {
         BeforeAll {
-            $result = Add-DbaDbRoleMember -SqlInstance $TestConfig.instance2 -Role $role -Member $user1 -Database $dbname
-            $roleDBAfter = Get-DbaDbRoleMember -SqlInstance $server -Database $dbname -Role $role
+            $splatAddRoleMember = @{
+                SqlInstance = $TestConfig.instance2
+                Role        = $role
+                Member      = $user1
+                Database    = $dbname
+            }
+            $result = Add-DbaDbRoleMember @splatAddRoleMember
+            $splatGetRoleMember = @{
+                SqlInstance = $server
+                Database    = $dbname
+                Role        = $role
+            }
+            $roleDBAfter = Get-DbaDbRoleMember @splatGetRoleMember
         }
 
         It "Adds the user to the role" {
@@ -73,9 +120,25 @@ Describe "Add-DbaDbRoleMember" -Tag "IntegrationTests" {
 
     Context "When adding a user to multiple roles" {
         BeforeAll {
-            $roleDB = Get-DbaDbRoleMember -SqlInstance $server -Database msdb -Role db_datareader, SQLAgentReaderRole
-            $result = Add-DbaDbRoleMember -SqlInstance $TestConfig.instance2 -Role db_datareader, SQLAgentReaderRole -Member $user1 -Database msdb
-            $roleDBAfter = Get-DbaDbRoleMember -SqlInstance $server -Database msdb -Role db_datareader, SQLAgentReaderRole
+            $splatGetRoleMemberBefore = @{
+                SqlInstance = $server
+                Database    = "msdb"
+                Role        = @("db_datareader", "SQLAgentReaderRole")
+            }
+            $roleDB = Get-DbaDbRoleMember @splatGetRoleMemberBefore
+            $splatAddMultipleRoles = @{
+                SqlInstance = $TestConfig.instance2
+                Role        = @("db_datareader", "SQLAgentReaderRole")
+                Member      = $user1
+                Database    = "msdb"
+            }
+            $result = Add-DbaDbRoleMember @splatAddMultipleRoles
+            $splatGetRoleMemberAfter = @{
+                SqlInstance = $server
+                Database    = "msdb"
+                Role        = @("db_datareader", "SQLAgentReaderRole")
+            }
+            $roleDBAfter = Get-DbaDbRoleMember @splatGetRoleMemberAfter
         }
 
         It "Adds the user to multiple roles" {
@@ -87,10 +150,25 @@ Describe "Add-DbaDbRoleMember" -Tag "IntegrationTests" {
 
     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
+            $splatGetDbRole = @{
+                SqlInstance = $server
+                Database    = "msdb"
+                Role        = @("db_datareader", "SQLAgentReaderRole")
+            }
+            $roleInput = Get-DbaDbRole @splatGetDbRole
+            $splatGetRoleMemberPipe = @{
+                SqlInstance = $server
+                Database    = "msdb"
+                Role        = @("db_datareader", "SQLAgentReaderRole")
+            }
+            $roleDB = Get-DbaDbRoleMember @splatGetRoleMemberPipe
             $result = $roleInput | Add-DbaDbRoleMember -User $user2
-            $roleDBAfter = Get-DbaDbRoleMember -SqlInstance $server -Database msdb -Role db_datareader, SQLAgentReaderRole
+            $splatGetRoleMemberPipeAfter = @{
+                SqlInstance = $server
+                Database    = "msdb"
+                Role        = @("db_datareader", "SQLAgentReaderRole")
+            }
+            $roleDBAfter = Get-DbaDbRoleMember @splatGetRoleMemberPipeAfter
         }
 
         It "Adds the user to roles via piped input" {
@@ -101,19 +179,36 @@ Describe "Add-DbaDbRoleMember" -Tag "IntegrationTests" {
 
     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
+            $splatAddExistingMember = @{
+                SqlInstance = $TestConfig.instance2
+                Role        = $role
+                Member      = $user1
+                Database    = $dbname
+            }
+            $messages = Add-DbaDbRoleMember @splatAddExistingMember
         }
 
         It "Skips adding the user and outputs appropriate message" {
-            $messageCount = ($messages -match 'Adding user').Count
+            $messageCount = ($messages -match "Adding user").Count
             $messageCount | Should -Be 0
         }
     }
 
     Context "When adding a role to another role" {
         BeforeAll {
-            $result = Add-DbaDbRoleMember -SqlInstance $TestConfig.instance2 -Role db_datawriter -Member $role -Database $dbname
-            $roleDBAfter = Get-DbaDbRoleMember -SqlInstance $server -Database $dbname -Role db_datawriter
+            $splatAddRoleToRole = @{
+                SqlInstance = $TestConfig.instance2
+                Role        = "db_datawriter"
+                Member      = $role
+                Database    = $dbname
+            }
+            $result = Add-DbaDbRoleMember @splatAddRoleToRole
+            $splatGetRoleToRole = @{
+                SqlInstance = $server
+                Database    = $dbname
+                Role        = "db_datawriter"
+            }
+            $roleDBAfter = Get-DbaDbRoleMember @splatGetRoleToRole
         }
 
         It "Adds the role to another role" {
diff --git a/tests/Add-DbaExtendedProperty.Tests.ps1 b/tests/Add-DbaExtendedProperty.Tests.ps1
index e665b36172b3..38d9663ef813 100644
--- a/tests/Add-DbaExtendedProperty.Tests.ps1
+++ b/tests/Add-DbaExtendedProperty.Tests.ps1
@@ -1,14 +1,14 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
     $ModuleName               = "dbatools",
-    $CommandName              = [System.IO.Path]::GetFileName($PSCommandPath.Replace('.Tests.ps1', '')),
+    $CommandName              = "Add-DbaExtendedProperty",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe "Add-DbaExtendedProperty" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
                 "SqlInstance",
@@ -27,7 +27,7 @@ Describe "Add-DbaExtendedProperty" -Tag "UnitTests" {
     }
 }
 
-Describe "Add-DbaExtendedProperty" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
         $random = Get-Random
         $server2 = Connect-DbaInstance -SqlInstance $TestConfig.instance2
diff --git a/tests/Add-DbaPfDataCollectorCounter.Tests.ps1 b/tests/Add-DbaPfDataCollectorCounter.Tests.ps1
index 6b8d922a511f..d36e1ed4b43c 100644
--- a/tests/Add-DbaPfDataCollectorCounter.Tests.ps1
+++ b/tests/Add-DbaPfDataCollectorCounter.Tests.ps1
@@ -1,14 +1,14 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName               = "dbatools",
-    $CommandName              = [System.IO.Path]::GetFileName($PSCommandPath.Replace('.Tests.ps1', '')),
+    $ModuleName  = "dbatools",
+    $CommandName = "Add-DbaPfDataCollectorCounter",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe "Add-DbaPfDataCollectorCounter" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
                 "ComputerName",
@@ -27,34 +27,38 @@ Describe "Add-DbaPfDataCollectorCounter" -Tag "UnitTests" {
     }
 }
 
-Describe "Add-DbaPfDataCollectorCounter" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
-        $PSDefaultParameterValues['*:Confirm'] = $false
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+    }
+
+    AfterAll {
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
 
     BeforeEach {
-        $null = Get-DbaPfDataCollectorSetTemplate -Template 'Long Running Queries' |
+        $null = Get-DbaPfDataCollectorSetTemplate -Template "Long Running Queries" |
             Import-DbaPfDataCollectorSetTemplate |
             Get-DbaPfDataCollector |
-            Get-DbaPfDataCollectorCounter -Counter '\LogicalDisk(*)\Avg. Disk Queue Length' |
+            Get-DbaPfDataCollectorCounter -Counter "\LogicalDisk(*)\Avg. Disk Queue Length" |
             Remove-DbaPfDataCollectorCounter
 
-        $results = Get-DbaPfDataCollectorSet -CollectorSet 'Long Running Queries' | Get-DbaPfDataCollector |
-            Add-DbaPfDataCollectorCounter -Counter '\LogicalDisk(*)\Avg. Disk Queue Length'
+        $results = Get-DbaPfDataCollectorSet -CollectorSet "Long Running Queries" | Get-DbaPfDataCollector |
+                Add-DbaPfDataCollectorCounter -Counter "\LogicalDisk(*)\Avg. Disk Queue Length"
     }
 
     AfterAll {
-        $null = Get-DbaPfDataCollectorSet -CollectorSet 'Long Running Queries' |
-            Remove-DbaPfDataCollectorSet
+        $null = Get-DbaPfDataCollectorSet -CollectorSet "Long Running Queries" |
+                Remove-DbaPfDataCollectorSet -ErrorAction SilentlyContinue
     }
 
     Context "When adding a counter to a data collector" {
         It "Returns the correct DataCollectorSet" {
-            $results.DataCollectorSet | Should -Be 'Long Running Queries'
+            $results.DataCollectorSet | Should -Be "Long Running Queries"
         }
 
         It "Returns the correct counter name" {
-            $results.Name | Should -Be '\LogicalDisk(*)\Avg. Disk Queue Length'
+            $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 7a24bf9d9bc7..2dda062d7563 100644
--- a/tests/Add-DbaRegServer.Tests.ps1
+++ b/tests/Add-DbaRegServer.Tests.ps1
@@ -1,14 +1,14 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName               = "dbatools",
-    $CommandName              = [System.IO.Path]::GetFileName($PSCommandPath.Replace('.Tests.ps1', '')),
+    $ModuleName  = "dbatools",
+    $CommandName = "Add-DbaRegServer",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe "Add-DbaRegServer" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
                 "SqlInstance",
@@ -33,7 +33,7 @@ Describe "Add-DbaRegServer" -Tag "UnitTests" {
     }
 }
 
-Describe "Add-DbaRegServer" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
         $srvName = "dbatoolsci-server1"
         $group = "dbatoolsci-group1"
@@ -67,7 +67,7 @@ Describe "Add-DbaRegServer" -Tag "IntegrationTests" {
 
     Context "When adding a registered server with extended properties" {
         BeforeAll {
-            $splat = @{
+            $splatRegServer = @{
                 SqlInstance = $TestConfig.instance1
                 ServerName  = $regSrvName
                 Name        = $srvName
@@ -75,7 +75,7 @@ Describe "Add-DbaRegServer" -Tag "IntegrationTests" {
                 Description = $regSrvDesc
             }
 
-            $results2 = Add-DbaRegServer @splat
+            $results2 = Add-DbaRegServer @splatRegServer
         }
 
         It "Adds a registered server with correct server name" {
diff --git a/tests/Add-DbaRegServerGroup.Tests.ps1 b/tests/Add-DbaRegServerGroup.Tests.ps1
index 0d1402a24b71..0645b055e588 100644
--- a/tests/Add-DbaRegServerGroup.Tests.ps1
+++ b/tests/Add-DbaRegServerGroup.Tests.ps1
@@ -1,14 +1,14 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName               = "dbatools",
-    $CommandName              = [System.IO.Path]::GetFileName($PSCommandPath.Replace('.Tests.ps1', '')),
+    $ModuleName  = "dbatools",
+    $CommandName = "Add-DbaRegServerGroup",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe "Add-DbaRegServerGroup" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
                 "SqlInstance",
@@ -27,7 +27,7 @@ Describe "Add-DbaRegServerGroup" -Tag "UnitTests" {
     }
 }
 
-Describe "Add-DbaRegServerGroup" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
         $group = "dbatoolsci-group1"
         $group2 = "dbatoolsci-group2"
@@ -40,13 +40,22 @@ Describe "Add-DbaRegServerGroup" -Tag "IntegrationTests" {
 
     Context "When adding a registered server group" {
         It "adds a registered server group" {
-            $results = Add-DbaRegServerGroup -SqlInstance $TestConfig.instance1 -Name $group
+            $splatAddGroup = @{
+                SqlInstance = $TestConfig.instance1
+                Name        = $group
+            }
+            $results = Add-DbaRegServerGroup @splatAddGroup
             $results.Name | Should -Be $group
             $results.SqlInstance | Should -Not -BeNullOrEmpty
         }
 
         It "adds a registered server group with extended properties" {
-            $results = Add-DbaRegServerGroup -SqlInstance $TestConfig.instance1 -Name $group2 -Description $description
+            $splatAddGroupExtended = @{
+                SqlInstance = $TestConfig.instance1
+                Name        = $group2
+                Description = $description
+            }
+            $results = Add-DbaRegServerGroup @splatAddGroupExtended
             $results.Name | Should -Be $group2
             $results.Description | Should -Be $description
             $results.SqlInstance | Should -Not -BeNullOrEmpty
@@ -60,19 +69,29 @@ Describe "Add-DbaRegServerGroup" -Tag "IntegrationTests" {
                 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'
+            $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
+            $splatAddNested = @{
+                SqlInstance = $TestConfig.instance1
+                Name        = "$group\$group2"
+                Description = $description
+            }
+            $results = Add-DbaRegServerGroup @splatAddNested
             $results.Name | Should -Be $group2
             $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
+            $splatUpdateNested = @{
+                SqlInstance = $TestConfig.instance1
+                Name        = "$group\$group2"
+                Description = $descriptionUpdated
+            }
+            $results = Add-DbaRegServerGroup @splatUpdateNested
             $results.Name | Should -Be $group2
             $results.Description | Should -Be $descriptionUpdated
             $results.SqlInstance | Should -Not -BeNullOrEmpty
diff --git a/tests/Add-DbaReplArticle.Tests.ps1 b/tests/Add-DbaReplArticle.Tests.ps1
index f8bd9825563f..4d2b4b8864bc 100644
--- a/tests/Add-DbaReplArticle.Tests.ps1
+++ b/tests/Add-DbaReplArticle.Tests.ps1
@@ -1,14 +1,14 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
     $ModuleName               = "dbatools",
-    $CommandName              = [System.IO.Path]::GetFileName($PSCommandPath.Replace('.Tests.ps1', '')),
+    $CommandName              = "Add-DbaReplArticle",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe "Add-DbaReplArticle" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
                 "SqlInstance",
diff --git a/tests/Add-DbaServerRoleMember.Tests.ps1 b/tests/Add-DbaServerRoleMember.Tests.ps1
index be498fcc980a..b26d05eac853 100644
--- a/tests/Add-DbaServerRoleMember.Tests.ps1
+++ b/tests/Add-DbaServerRoleMember.Tests.ps1
@@ -1,14 +1,14 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName               = "dbatools",
-    $CommandName              = [System.IO.Path]::GetFileName($PSCommandPath.Replace('.Tests.ps1', '')),
+    $ModuleName  = "dbatools",
+    $CommandName = "Add-DbaServerRoleMember",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe "Add-DbaServerRoleMember" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
                 "SqlInstance",
@@ -27,7 +27,7 @@ Describe "Add-DbaServerRoleMember" -Tag "UnitTests" {
     }
 }
 
-Describe "Add-DbaServerRoleMember" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
         $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2
         $login1 = "dbatoolsci_login1_$(Get-Random)"
@@ -39,7 +39,7 @@ Describe "Add-DbaServerRoleMember" -Tag "IntegrationTests" {
         )
         $splatNewLogin = @{
             SqlInstance = $TestConfig.instance2
-            Password = ('Password1234!' | ConvertTo-SecureString -asPlainText -Force)
+            Password    = ("Password1234!" | ConvertTo-SecureString -asPlainText -Force)
         }
         $null = New-DbaLogin @splatNewLogin -Login $login1
         $null = New-DbaLogin @splatNewLogin -Login $login2
@@ -48,19 +48,19 @@ Describe "Add-DbaServerRoleMember" -Tag "IntegrationTests" {
     AfterAll {
         $splatRemoveLogin = @{
             SqlInstance = $TestConfig.instance2
-            Login = $login1, $login2
-            Confirm = $false
+            Login       = $login1, $login2
+            Confirm     = $false
         }
         $null = Remove-DbaLogin @splatRemoveLogin
     }
 
     Context "Functionality" {
-        It 'Adds Login to Role' {
+        It "Adds Login to Role" {
             $splatAddRole = @{
                 SqlInstance = $TestConfig.instance2
-                ServerRole = $fixedServerRoles[0]
-                Login = $login1
-                Confirm = $false
+                ServerRole  = $fixedServerRoles[0]
+                Login       = $login1
+                Confirm     = $false
             }
             Add-DbaServerRoleMember @splatAddRole
             $roleAfter = Get-DbaServerRole -SqlInstance $server -ServerRole $fixedServerRoles[0]
@@ -69,13 +69,13 @@ Describe "Add-DbaServerRoleMember" -Tag "IntegrationTests" {
             $roleAfter.EnumMemberNames() | Should -Contain $login1
         }
 
-        It 'Adds Login to Multiple Roles' {
+        It "Adds Login to Multiple Roles" {
             $serverRoles = Get-DbaServerRole -SqlInstance $server -ServerRole $fixedServerRoles
             $splatAddRoles = @{
                 SqlInstance = $TestConfig.instance2
-                ServerRole = $serverRoles
-                Login = $login1
-                Confirm = $false
+                ServerRole  = $serverRoles
+                Login       = $login1
+                Confirm     = $false
             }
             Add-DbaServerRoleMember @splatAddRoles
 
@@ -84,12 +84,12 @@ Describe "Add-DbaServerRoleMember" -Tag "IntegrationTests" {
             $roleDBAfter.Login | Should -Contain $login1
         }
 
-        It 'Adds Customer Server-Level Role Membership' {
+        It "Adds Customer Server-Level Role Membership" {
             $splatAddCustomRole = @{
                 SqlInstance = $TestConfig.instance2
-                ServerRole = $customServerRole
-                Role = $fixedServerRoles[-1]
-                Confirm = $false
+                ServerRole  = $customServerRole
+                Role        = $fixedServerRoles[-1]
+                Confirm     = $false
             }
             Add-DbaServerRoleMember @splatAddCustomRole
             $roleAfter = Get-DbaServerRole -SqlInstance $server -ServerRole $fixedServerRoles[-1]
@@ -98,7 +98,7 @@ Describe "Add-DbaServerRoleMember" -Tag "IntegrationTests" {
             $roleAfter.EnumMemberNames() | Should -Contain $customServerRole
         }
 
-        It 'Adds Login to Roles via piped input from Get-DbaServerRole' {
+        It "Adds Login to Roles via piped input from Get-DbaServerRole" {
             $serverRole = Get-DbaServerRole -SqlInstance $server -ServerRole $fixedServerRoles[0]
             $serverRole | Add-DbaServerRoleMember -Login $login2 -Confirm:$false
 
@@ -106,4 +106,4 @@ Describe "Add-DbaServerRoleMember" -Tag "IntegrationTests" {
             $roleAfter.EnumMemberNames() | Should -Contain $login2
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Backup-DbaComputerCertificate.Tests.ps1 b/tests/Backup-DbaComputerCertificate.Tests.ps1
index 3cd68f1caf06..85d4fb54ed66 100644
--- a/tests/Backup-DbaComputerCertificate.Tests.ps1
+++ b/tests/Backup-DbaComputerCertificate.Tests.ps1
@@ -1,13 +1,14 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
 param(
-    $ModuleName = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "Backup-DbaComputerCertificate",
     $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
 )
 
-Describe "Backup-DbaComputerCertificate" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Backup-DbaComputerCertificate
+            $command = Get-Command $CommandName
             $expected = $TestConfig.CommonParameters
             $expected += @(
                 "SecurePassword",
@@ -19,8 +20,10 @@ Describe "Backup-DbaComputerCertificate" -Tag "UnitTests" {
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
+        foreach ($param in $expected) {
+            It "Has parameter: $param" {
+                $command | Should -HaveParameter $param
+            }
         }
 
         It "Should have exactly the number of expected parameters ($($expected.Count))" {
@@ -30,9 +33,9 @@ Describe "Backup-DbaComputerCertificate" -Tag "UnitTests" {
     }
 }
 
-Describe "Backup-DbaComputerCertificate" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
-        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
         $certThumbprint = "29C469578D6C6211076A09CEE5C5797EEA0C2713"
         $certPath = "$($TestConfig.appveyorlabrepo)\certificates\localhost.crt"
@@ -40,13 +43,13 @@ Describe "Backup-DbaComputerCertificate" -Tag "IntegrationTests" {
 
         $null = Add-DbaComputerCertificate -Path $certPath
 
-        $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
 
     AfterAll {
-        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
-        $null = Remove-DbaComputerCertificate -Thumbprint $certThumbprint
+        $null = Remove-DbaComputerCertificate -Thumbprint $certThumbprint -ErrorAction SilentlyContinue
     }
 
     Context "Certificate is backed up properly" {
@@ -55,7 +58,7 @@ Describe "Backup-DbaComputerCertificate" -Tag "IntegrationTests" {
         }
 
         AfterAll {
-            Get-ChildItem -Path $result.FullName | Remove-Item
+            Get-ChildItem -Path $result.FullName -ErrorAction SilentlyContinue | Remove-Item -ErrorAction SilentlyContinue
         }
 
         It "Returns the proper results" {
diff --git a/tests/Backup-DbaDatabase.Tests.ps1 b/tests/Backup-DbaDatabase.Tests.ps1
index 71e2e5d4527b..96f81a732bb8 100644
--- a/tests/Backup-DbaDatabase.Tests.ps1
+++ b/tests/Backup-DbaDatabase.Tests.ps1
@@ -150,7 +150,7 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
         }
 
         It "Should report it has backed up to the path with the correct name" {
-            $results.Fullname | Should -BeLike "$DestBackupDir*PesterTest.bak"
+            $results.FullName | Should -BeLike "$DestBackupDir*PesterTest.bak"
         }
 
         It "Should have backed up to the path with the correct name" {
@@ -164,7 +164,7 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
         }
 
         It "Should report it has backed up to the path with the correct name" {
-            $results.Fullname | Should -BeLike "$DestBackupDir*PesterTest.bak"
+            $results.FullName | Should -BeLike "$DestBackupDir*PesterTest.bak"
         }
 
         It "Should have backed up to the path with the correct name" {
@@ -329,12 +329,12 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
         }
 
         AfterAll {
-            Get-ChildItem -Path $results.Fullname | Remove-Item
+            Get-ChildItem -Path $results.FullName | Remove-Item -ErrorAction SilentlyContinue
             $PSDefaultParameterValues['Backup-DbaDatabase:BackupDirectory'] = $DestBackupDir
         }
 
         It "Should report it has backed up to the path with the corrrect name" {
-            $results.Fullname | Should -BeLike "$defaultBackupPath*PesterTest.bak"
+            $results.FullName | Should -BeLike "$defaultBackupPath*PesterTest.bak"
         }
 
         It "Should have backed up to the path with the corrrect name" {
@@ -501,7 +501,7 @@ go
 
     Context "Test Backup templating when db object piped in issue 8100" {
         BeforeAll {
-            $results = Get-DbaDatabase -SqlInstance $TestConfig.instance1 -Database master,msdb | Backup-DbaDatabase -BackupDirectory $DestBackupDir\db2\dbname\instancename\backuptype\  -BackupFileName dbname-backuptype.bak -ReplaceInName -BuildPath
+            $results = Get-DbaDatabase -SqlInstance $TestConfig.instance1 -Database master, msdb | Backup-DbaDatabase -BackupDirectory $DestBackupDir\db2\dbname\instancename\backuptype\  -BackupFileName dbname-backuptype.bak -ReplaceInName -BuildPath
             $instanceName = ([DbaInstanceParameter]$TestConfig.instance1).InstanceName
         }
 
diff --git a/tests/Backup-DbaDbCertificate.Tests.ps1 b/tests/Backup-DbaDbCertificate.Tests.ps1
index 4896e5565ba6..d1efb8d1ab98 100644
--- a/tests/Backup-DbaDbCertificate.Tests.ps1
+++ b/tests/Backup-DbaDbCertificate.Tests.ps1
@@ -67,7 +67,14 @@ Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" {
 
     Context "Can backup a database certificate" {
         BeforeAll {
-            $results = Backup-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Database $db1Name -Certificate $cert1.Name -EncryptionPassword $pw -DecryptionPassword $pw
+            $splatBackupCert = @{
+                SqlInstance        = $TestConfig.instance1
+                Database           = $db1Name
+                Certificate        = $cert1.Name
+                EncryptionPassword = $pw
+                DecryptionPassword = $pw
+            }
+            $results = Backup-DbaDbCertificate @splatBackupCert
         }
 
         AfterAll {
@@ -84,7 +91,15 @@ Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" {
 
     Context "Can backup a database certificate with a filename (see #9485)" {
         BeforeAll {
-            $results = Backup-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Database $db1Name -Certificate $cert1.Name -EncryptionPassword $pw -DecryptionPassword $pw -FileBaseName "dbatoolscli_cert1_$random"
+            $splatBackupCertWithName = @{
+                SqlInstance        = $TestConfig.instance1
+                Database           = $db1Name
+                Certificate        = $cert1.Name
+                EncryptionPassword = $pw
+                DecryptionPassword = $pw
+                FileBaseName       = "dbatoolscli_cert1_$random"
+            }
+            $results = Backup-DbaDbCertificate @splatBackupCertWithName
         }
 
         AfterAll {
@@ -102,9 +117,17 @@ Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" {
 
     Context "Warns the caller if the cert cannot be found" {
         BeforeAll {
-            $invalidDBCertName = "dbatoolscli_invalidCertName"
+            $invalidDBCertName  = "dbatoolscli_invalidCertName"
             $invalidDBCertName2 = "dbatoolscli_invalidCertName2"
-            $results = Backup-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Database $db1Name -Certificate $invalidDBCertName, $invalidDBCertName2, $cert2.Name -EncryptionPassword $pw -DecryptionPassword $pw -WarningAction SilentlyContinue
+            $splatBackupInvalidCert = @{
+                SqlInstance        = $TestConfig.instance1
+                Database           = $db1Name
+                Certificate        = @($invalidDBCertName, $invalidDBCertName2, $cert2.Name)
+                EncryptionPassword = $pw
+                DecryptionPassword = $pw
+                WarningAction      = "SilentlyContinue"
+            }
+            $results = Backup-DbaDbCertificate @splatBackupInvalidCert
         }
 
         AfterAll {
@@ -119,7 +142,13 @@ Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" {
 
     Context "Backs up all db certs for a database" {
         BeforeAll {
-            $results = Backup-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Database $db1Name -EncryptionPassword $pw -DecryptionPassword $pw
+            $splatBackupDbCerts = @{
+                SqlInstance        = $TestConfig.instance1
+                Database           = $db1Name
+                EncryptionPassword = $pw
+                DecryptionPassword = $pw
+            }
+            $results = Backup-DbaDbCertificate @splatBackupDbCerts
         }
 
         AfterAll {
@@ -135,7 +164,12 @@ Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" {
 
     Context "Backs up all db certs for an instance" {
         BeforeAll {
-            $results = Backup-DbaDbCertificate -SqlInstance $TestConfig.instance1 -EncryptionPassword $pw -DecryptionPassword $pw
+            $splatBackupAllCerts = @{
+                SqlInstance        = $TestConfig.instance1
+                EncryptionPassword = $pw
+                DecryptionPassword = $pw
+            }
+            $results = Backup-DbaDbCertificate @splatBackupAllCerts
         }
 
         AfterAll {
diff --git a/tests/Backup-DbaDbMasterKey.Tests.ps1 b/tests/Backup-DbaDbMasterKey.Tests.ps1
index 83de988e6d95..5ec18ea91d01 100644
--- a/tests/Backup-DbaDbMasterKey.Tests.ps1
+++ b/tests/Backup-DbaDbMasterKey.Tests.ps1
@@ -1,15 +1,16 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName = "dbatools",
-    $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
+    $ModuleName  = "dbatools",
+    $CommandName = "Backup-DbaDbMasterKey",
+    $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe "Backup-DbaDbMasterKey" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Backup-DbaDbMasterKey
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "SqlInstance",
                 "SqlCredential",
                 "Credential",
@@ -19,24 +20,17 @@ Describe "Backup-DbaDbMasterKey" -Tag "UnitTests" {
                 "Path",
                 "FileBaseName",
                 "InputObject",
-                "EnableException",
-                "WhatIf",
-                "Confirm"
+                "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
-Describe "Backup-DbaDbMasterKey" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     Context "Can backup a database master key" {
         BeforeAll {
             $instance = $TestConfig.instance1
@@ -54,10 +48,10 @@ Describe "Backup-DbaDbMasterKey" -Tag "IntegrationTests" {
 
         It "Backs up the database master key" {
             $splatBackup = @{
-                SqlInstance = $instance
-                Database = $database
+                SqlInstance    = $instance
+                Database       = $database
                 SecurePassword = $password
-                Confirm = $false
+                Confirm        = $false
             }
             $results = Backup-DbaDbMasterKey @splatBackup
             $results | Should -Not -BeNullOrEmpty
@@ -71,11 +65,11 @@ Describe "Backup-DbaDbMasterKey" -Tag "IntegrationTests" {
         It "Backs up the database master key with a specific filename (see #9484)" {
             $random = Get-Random
             $splatBackup = @{
-                SqlInstance = $instance
-                Database = $database
+                SqlInstance    = $instance
+                Database       = $database
                 SecurePassword = $password
-                FileBaseName = "dbatoolscli_dbmasterkey_$random"
-                Confirm = $false
+                FileBaseName   = "dbatoolscli_dbmasterkey_$random"
+                Confirm        = $false
             }
             $results = Backup-DbaDbMasterKey @splatBackup
             $results | Should -Not -BeNullOrEmpty
diff --git a/tests/Backup-DbaServiceMasterKey.Tests.ps1 b/tests/Backup-DbaServiceMasterKey.Tests.ps1
index 1145578f5f31..a7b2fced4d2d 100644
--- a/tests/Backup-DbaServiceMasterKey.Tests.ps1
+++ b/tests/Backup-DbaServiceMasterKey.Tests.ps1
@@ -1,56 +1,50 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName = "dbatools",
-    $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
+    $ModuleName  = "dbatools",
+    $CommandName = "Backup-DbaServiceMasterKey",
+    $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe "Backup-DbaServiceMasterKey" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Backup-DbaServiceMasterKey
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "SqlInstance",
                 "SqlCredential",
                 "KeyCredential",
                 "SecurePassword",
                 "Path",
                 "FileBaseName",
-                "EnableException",
-                "Confirm",
-                "WhatIf"
+                "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
-Describe "Backup-DbaServiceMasterKey" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     Context "Can backup a service master key" {
         BeforeAll {
             $securePassword = ConvertTo-SecureString -String "GoodPass1234!" -AsPlainText -Force
         }
 
         It "backs up the SMK" {
-            $results = Backup-DbaServiceMasterKey -SqlInstance $TestConfig.instance1 -SecurePassword $securePassword -Confirm:$false
-            $results.Status | Should -Be "Success"
-            $null = Remove-Item -Path $results.Path -ErrorAction SilentlyContinue -Confirm:$false
+            $backupResults = Backup-DbaServiceMasterKey -SqlInstance $TestConfig.instance1 -SecurePassword $securePassword -Confirm:$false
+            $backupResults.Status | Should -Be "Success"
+            $null = Remove-Item -Path $backupResults.Path -ErrorAction SilentlyContinue -Confirm:$false
         }
 
         It "backs up the SMK with a specific filename (see #9483)" {
-            $random = Get-Random
-            $results = Backup-DbaServiceMasterKey -SqlInstance $TestConfig.instance1 -SecurePassword $securePassword -FileBaseName "smk($random)" -Confirm:$false
-            [IO.Path]::GetFileNameWithoutExtension($results.Path) | Should -Be "smk($random)"
-            $results.Status | Should -Be "Success"
-            $null = Remove-Item -Path $results.Path -ErrorAction SilentlyContinue -Confirm:$false
+            $randomNum = Get-Random
+            $fileBackupResults = Backup-DbaServiceMasterKey -SqlInstance $TestConfig.instance1 -SecurePassword $securePassword -FileBaseName "smk($randomNum)" -Confirm:$false
+            [IO.Path]::GetFileNameWithoutExtension($fileBackupResults.Path) | Should -Be "smk($randomNum)"
+            $fileBackupResults.Status | Should -Be "Success"
+            $null = Remove-Item -Path $fileBackupResults.Path -ErrorAction SilentlyContinue -Confirm:$false
         }
     }
 }
diff --git a/tests/Clear-DbaConnectionPool.Tests.ps1 b/tests/Clear-DbaConnectionPool.Tests.ps1
index cd92862fd72c..210801826679 100644
--- a/tests/Clear-DbaConnectionPool.Tests.ps1
+++ b/tests/Clear-DbaConnectionPool.Tests.ps1
@@ -1,33 +1,29 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName = "dbatools",
-    $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
+    $ModuleName  = "dbatools",
+    $CommandName = "Clear-DbaConnectionPool",
+    $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe "Clear-DbaConnectionPool" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Clear-DbaConnectionPool
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters      = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "ComputerName",
                 "Credential",
                 "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
-Describe "Clear-DbaConnectionPool" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     Context "When clearing connection pool" {
         It "Doesn't throw" {
             { Clear-DbaConnectionPool } | Should -Not -Throw
diff --git a/tests/Clear-DbaLatchStatistics.Tests.ps1 b/tests/Clear-DbaLatchStatistics.Tests.ps1
index 77d72e213c8d..d5e20b76342f 100644
--- a/tests/Clear-DbaLatchStatistics.Tests.ps1
+++ b/tests/Clear-DbaLatchStatistics.Tests.ps1
@@ -1,46 +1,48 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "Clear-DbaLatchStatistics",
     $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
 )
 
-Describe "Clear-DbaLatchStatistics" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Clear-DbaLatchStatistics
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "SqlInstance",
                 "SqlCredential",
-                "EnableException",
-                "Confirm",
-                "WhatIf"
+                "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
-Describe "Clear-DbaLatchStatistics" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
+    BeforeAll {
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+    }
+
+    AfterAll {
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+    }
+
     Context "Command executes properly and returns proper info" {
         BeforeAll {
             $splatClearLatch = @{
                 SqlInstance = $TestConfig.instance1
-                Confirm = $false
+                Confirm     = $false
             }
             $results = Clear-DbaLatchStatistics @splatClearLatch
         }
 
         It "Returns success" {
-            $results.Status | Should -Be 'Success'
+            $results.Status | Should -Be "Success"
         }
     }
 }
diff --git a/tests/Clear-DbaPlanCache.Tests.ps1 b/tests/Clear-DbaPlanCache.Tests.ps1
index de7e1ef729b9..b18d54e38fe3 100644
--- a/tests/Clear-DbaPlanCache.Tests.ps1
+++ b/tests/Clear-DbaPlanCache.Tests.ps1
@@ -1,37 +1,31 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "Clear-DbaPlanCache",
     $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
 )
 
-Describe "Clear-DbaPlanCache" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Clear-DbaPlanCache
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "SqlInstance",
                 "SqlCredential",
                 "Threshold",
                 "InputObject",
-                "EnableException",
-                "Confirm",
-                "WhatIf"
+                "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
-Describe "Clear-DbaPlanCache" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     Context "When not clearing plan cache" {
         BeforeAll {
             # Make plan cache way higher than likely for a test rig
@@ -41,13 +35,13 @@ Describe "Clear-DbaPlanCache" -Tag "IntegrationTests" {
         It "Returns correct datatypes" {
             $results = Clear-DbaPlanCache -SqlInstance $TestConfig.instance1 -Threshold $threshold
             $results.Size | Should -BeOfType [dbasize]
-            $results.Status | Should -Match 'below'
+            $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'
+            $results.Status | Should -Match "below"
         }
     }
 }
diff --git a/tests/Clear-DbaWaitStatistics.Tests.ps1 b/tests/Clear-DbaWaitStatistics.Tests.ps1
index 4014ee4a8eca..2a2fcab44815 100644
--- a/tests/Clear-DbaWaitStatistics.Tests.ps1
+++ b/tests/Clear-DbaWaitStatistics.Tests.ps1
@@ -1,42 +1,48 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "Clear-DbaWaitStatistics",
     $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
 )
 
-Describe "Clear-DbaWaitStatistics" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Clear-DbaWaitStatistics
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "SqlInstance",
                 "SqlCredential",
-                "EnableException",
-                "Confirm",
-                "WhatIf"
+                "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
-Describe "Clear-DbaWaitStatistics" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
+    BeforeAll {
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+    }
+
+    AfterAll {
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+    }
+
     Context "Command executes properly and returns proper info" {
         BeforeAll {
-            $results = Clear-DbaWaitStatistics -SqlInstance $TestConfig.instance1 -Confirm:$false
+            $splatClearStats = @{
+                SqlInstance = $TestConfig.instance1
+                Confirm     = $false
+            }
+            $clearResults = Clear-DbaWaitStatistics @splatClearStats
         }
 
         It "Returns success" {
-            $results.Status | Should -Be 'Success'
+            $clearResults.Status | Should -Be "Success"
         }
     }
 }
diff --git a/tests/Connect-DbaInstance.Tests.ps1 b/tests/Connect-DbaInstance.Tests.ps1
index cb7365c8e72a..d36561c75385 100644
--- a/tests/Connect-DbaInstance.Tests.ps1
+++ b/tests/Connect-DbaInstance.Tests.ps1
@@ -88,7 +88,7 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
                 } else {
                     $propName = $param.Key
                 }
-                $server.ConnectionContext.$propName | Should -Be $param.Value
+                $server.ConnectionContext.PSObject.Properties[$propName].Value | Should -Be $param.Value
             }
         }
 
@@ -237,14 +237,14 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
     Context "multiple dedicated admin connections are properly made using strings" {
         # This might fail if a parallel test uses DAC - how can we ensure that this is the only test that is run?
         It "opens and closes the connections" {
-            $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1, $TestConfig.instance2 -DedicatedAdminConnection
+            $server = @(Connect-DbaInstance -SqlInstance $TestConfig.instance1, $TestConfig.instance2 -DedicatedAdminConnection)
             $server[0].Name | Should -Be "ADMIN:$($TestConfig.instance1)"
             $server[1].Name | Should -Be "ADMIN:$($TestConfig.instance2)"
             $null = $server | Disconnect-DbaInstance
             # DAC is not reopened in the background
             Start-Sleep -Seconds 10
-            $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1, $TestConfig.instance2 -DedicatedAdminConnection
-            $server.Count | Should -Be 2
+            $server = @(Connect-DbaInstance -SqlInstance $TestConfig.instance1, $TestConfig.instance2 -DedicatedAdminConnection)
+            $server.Status.Count | Should -Be 2
             $null = $server | Disconnect-DbaInstance
         }
     }
diff --git a/tests/Convert-DbaLsn.Tests.ps1 b/tests/Convert-DbaLsn.Tests.ps1
index 65108cbf2823..50e8fd020cce 100644
--- a/tests/Convert-DbaLsn.Tests.ps1
+++ b/tests/Convert-DbaLsn.Tests.ps1
@@ -1,60 +1,56 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "Convert-DbaLSN",
     $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
 )
 
-Describe "Convert-DbaLSN" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Convert-DbaLSN
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "LSN",
                 "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 
     Context "Converts Numeric LSN to Hex" {
         BeforeAll {
-            $LSN = '00000000020000000024300001'
-            $result = Convert-DbaLSN -Lsn $LSN
+            $numericLSN = "00000000020000000024300001"
+            $convertResults = Convert-DbaLSN -LSN $numericLSN
         }
 
         It "Should convert to 00000014:000000f3:0001" {
-            $result.Hexadecimal | Should -Be '00000014:000000f3:0001'
+            $convertResults.Hexadecimal | Should -Be "00000014:000000f3:0001"
         }
     }
 
     Context "Converts Numeric LSN to Hex without leading 0s" {
         BeforeAll {
-            $LSN = '20000000024300001'
-            $result = Convert-DbaLSN -Lsn $LSN
+            $shortLSN = "20000000024300001"
+            $shortResults = Convert-DbaLSN -LSN $shortLSN
         }
 
         It "Should convert to 00000014:000000f3:0001" {
-            $result.Hexadecimal | Should -Be '00000014:000000f3:0001'
+            $shortResults.Hexadecimal | Should -Be "00000014:000000f3:0001"
         }
     }
 
     Context "Converts Hex LSN to Numeric" {
         BeforeAll {
-            $LSN = '00000014:000000f3:0001'
-            $result = Convert-DbaLSN -Lsn $LSN
+            $hexLSN = "00000014:000000f3:0001"
+            $hexResults = Convert-DbaLSN -LSN $hexLSN
         }
 
         It "Should convert to 20000000024300001" {
-            $result.Numeric | Should -Be 20000000024300001
+            $hexResults.Numeric | Should -Be 20000000024300001
         }
     }
 }
diff --git a/tests/Convert-DbaMaskingValue.Tests.ps1 b/tests/Convert-DbaMaskingValue.Tests.ps1
index f21519aed24c..bf5cebba8ebc 100644
--- a/tests/Convert-DbaMaskingValue.Tests.ps1
+++ b/tests/Convert-DbaMaskingValue.Tests.ps1
@@ -1,15 +1,16 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
 param(
-    $ModuleName = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "Convert-DbaMaskingValue",
     $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
 )
 
-Describe "Convert-DbaMaskingValue" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Convert-DbaMaskingValue
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters      = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "Value",
                 "DataType",
                 "Nullable",
@@ -17,30 +18,25 @@ Describe "Convert-DbaMaskingValue" -Tag "UnitTests" {
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
-Describe "Convert-DbaMaskingValue" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     Context "Null values" {
         It "Should return a single 'NULL' value" {
             $value = $null
             $convertedValue = Convert-DbaMaskingValue -Value $value -Nullable:$true
-            $convertedValue.NewValue | Should -Be 'NULL'
+            $convertedValue.NewValue | Should -Be "NULL"
         }
 
         It "Should return multiple 'NULL' values" {
             $value = @($null, $null)
             $convertedValues = Convert-DbaMaskingValue -Value $value -Nullable:$true
-            $convertedValues[0].NewValue | Should -Be 'NULL'
-            $convertedValues[1].NewValue | Should -Be 'NULL'
+            $convertedValues[0].NewValue | Should -Be "NULL"
+            $convertedValues[1].NewValue | Should -Be "NULL"
         }
     }
 
@@ -106,7 +102,7 @@ Describe "Convert-DbaMaskingValue" -Tag "IntegrationTests" {
         It "Should return a NULL value and text value" {
             $value = @($null, "this is just text")
             $convertedValues = Convert-DbaMaskingValue -Value $value -Nullable:$true
-            $convertedValues[0].NewValue | Should -Be 'NULL'
+            $convertedValues[0].NewValue | Should -Be "NULL"
             $convertedValues[1].NewValue | Should -Be "'this is just text'"
         }
     }
diff --git a/tests/ConvertTo-DbaDataTable.Tests.ps1 b/tests/ConvertTo-DbaDataTable.Tests.ps1
index dcb2f1eb1a08..0f2a336c2338 100644
--- a/tests/ConvertTo-DbaDataTable.Tests.ps1
+++ b/tests/ConvertTo-DbaDataTable.Tests.ps1
@@ -1,69 +1,86 @@
-$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "")
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
+param(
+    $ModuleName  = "dbatools",
+    $CommandName = "ConvertTo-DbaDataTable",
+    $PSDefaultParameterValues = $TestConfig.Defaults
+)
+
 Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan
 $global:TestConfig = Get-TestConfig
 
-Describe "$CommandName Unit Tests" -Tag 'UnitTests' {
+Describe $CommandName -Tag UnitTests {
     Context "Validate parameters" {
-        [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object { $_ -notin ('WhatIf', 'Confirm') }
-        [object[]]$knownParameters = 'InputObject', 'TimeSpanType', 'SizeType', 'IgnoreNull', 'Raw', '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
+        BeforeAll {
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
+                "InputObject",
+                "TimeSpanType",
+                "SizeType",
+                "IgnoreNull",
+                "Raw",
+                "EnableException"
+            )
+        }
+
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
 Describe "Testing data table output when using a complex object" {
-    $obj = New-Object -TypeName psobject -Property @{
-        guid             = [system.guid]'32ccd4c4-282a-4c0d-997c-7b5deb97f9e0'
-        timespan         = New-TimeSpan -Start 2016-10-30 -End 2017-04-30
-        datetime         = Get-Date -Year 2016 -Month 10 -Day 30 -Hour 5 -Minute 52 -Second 0 -Millisecond 0
-        char             = [System.Char]'T'
-        true             = $true
-        false            = $false
-        null             = $null
-        string           = "it's a boy."
-        UInt64           = [System.UInt64]123456
-        dbadatetime      = [dbadatetime[]]$(Get-Date -Year 2024 -Month 05 -Day 19 -Hour 5 -Minute 52 -Second 0 -Millisecond 0)
-        dbadatetimeArray = [dbadatetime[]]($(Get-Date -Year 2024 -Month 05 -Day 19 -Hour 5 -Minute 52 -Second 0 -Millisecond 0), $(Get-Date -Year 2024 -Month 05 -Day 19 -Hour 5 -Minute 52 -Second 0 -Millisecond 0).AddHours(1))
-        inlining         = [pscustomobject]@{Mission = 'Keep Hank alive'}
-        inlining2        = [psobject]@{Mission = 'Keep Hank alive'}
-    }
+    BeforeAll {
+        $obj = New-Object -TypeName psobject -Property @{
+            guid             = [system.guid]"32ccd4c4-282a-4c0d-997c-7b5deb97f9e0"
+            timespan         = New-TimeSpan -Start 2016-10-30 -End 2017-04-30
+            datetime         = Get-Date -Year 2016 -Month 10 -Day 30 -Hour 5 -Minute 52 -Second 0 -Millisecond 0
+            char             = [System.Char]"T"
+            true             = $true
+            false            = $false
+            null             = $null
+            string           = "it's a boy."
+            UInt64           = [System.UInt64]123456
+            dbadatetime      = [dbadatetime[]]$(Get-Date -Year 2024 -Month 05 -Day 19 -Hour 5 -Minute 52 -Second 0 -Millisecond 0)
+            dbadatetimeArray = [dbadatetime[]]($(Get-Date -Year 2024 -Month 05 -Day 19 -Hour 5 -Minute 52 -Second 0 -Millisecond 0), $(Get-Date -Year 2024 -Month 05 -Day 19 -Hour 5 -Minute 52 -Second 0 -Millisecond 0).AddHours(1))
+            inlining         = [pscustomobject]@{Mission = "Keep Hank alive" }
+            inlining2        = [psobject]@{Mission = "Keep Hank alive" }
+        }
 
-    $innedobj = New-Object -TypeName psobject -Property @{
-        Mission = 'Keep Hank alive'
-    }
+        $innedobj = New-Object -TypeName psobject -Property @{
+            Mission = "Keep Hank alive"
+        }
 
-    Add-Member -Force -InputObject $obj -MemberType NoteProperty -Name myObject -Value $innedobj
-    $result = ConvertTo-DbaDataTable -InputObject $obj
+        Add-Member -Force -InputObject $obj -MemberType NoteProperty -Name myObject -Value $innedobj
+        $result = ConvertTo-DbaDataTable -InputObject $obj
 
-    $firstRow = $result[0].Rows[0]
+        $firstRow = $result[0].Rows[0]
+    }
     Context "Lengths" {
-        It 'Count of the Rows' {
+        It "Count of the Rows" {
             $result.Rows.Count | Should -Be 1
         }
     }
 
 
     Context "Property: guid" {
-        It 'Has a column called "guid"' {
-            $result.Columns.ColumnName | Should -Contain 'guid'
+        It "Has a column called 'guid'" {
+            $result.Columns.ColumnName | Should -Contain "guid"
         }
-        It 'Has a [guid] data type on the column "guid"' {
+        It "Has a [guid] data type on the column 'guid'" {
             $firstRow.guid | Should -BeOfType [System.guid]
         }
-        It 'Has the following guid: "32ccd4c4-282a-4c0d-997c-7b5deb97f9e0"' {
-            $firstRow.guid | Should -Be '32ccd4c4-282a-4c0d-997c-7b5deb97f9e0'
+        It "Has the following guid: '32ccd4c4-282a-4c0d-997c-7b5deb97f9e0'" {
+            $firstRow.guid | Should -Be "32ccd4c4-282a-4c0d-997c-7b5deb97f9e0"
         }
     }
 
     Context "Property: timespan" {
-        It 'Has a column called "timespan"' {
-            $result.Columns.ColumnName | Should -Contain 'timespan'
+        It "Has a column called 'timespan'" {
+            $result.Columns.ColumnName | Should -Contain "timespan"
         }
-        It 'Has a [long] data type on the column "timespan"' {
+        It "Has a [long] data type on the column 'timespan'" {
             $firstRow.timespan | Should -BeOfType [System.Int64]
-
         }
         It "Has the following timespan: 15724800000" {
             $firstRow.timespan | Should -Be 15724800000
@@ -71,10 +88,10 @@ Describe "Testing data table output when using a complex object" {
     }
 
     Context "Property: datetime" {
-        It 'Has a column called "datetime"' {
-            $result.Columns.ColumnName | Should -Contain 'datetime'
+        It "Has a column called 'datetime'" {
+            $result.Columns.ColumnName | Should -Contain "datetime"
         }
-        It 'Has a [datetime] data type on the column "datetime"' {
+        It "Has a [datetime] data type on the column 'datetime'" {
             $firstRow.datetime | Should -BeOfType [System.DateTime]
         }
         It "Has the following datetime: 2016-10-30 05:52:00.000" {
@@ -84,10 +101,10 @@ Describe "Testing data table output when using a complex object" {
     }
 
     Context "Property: char" {
-        It 'Has a column called "char"' {
-            $result.Columns.ColumnName | Should -Contain 'char'
+        It "Has a column called 'char'" {
+            $result.Columns.ColumnName | Should -Contain "char"
         }
-        It 'Has a [char] data type on the column "char"' {
+        It "Has a [char] data type on the column 'char'" {
             $firstRow.char | Should -BeOfType [System.Char]
         }
         It "Has the following char: T" {
@@ -96,10 +113,10 @@ Describe "Testing data table output when using a complex object" {
     }
 
     Context "Property: true" {
-        It 'Has a column called "true"' {
-            $result.Columns.ColumnName | Should -Contain 'true'
+        It "Has a column called 'true'" {
+            $result.Columns.ColumnName | Should -Contain "true"
         }
-        It 'Has a [bool] data type on the column "true"' {
+        It "Has a [bool] data type on the column 'true'" {
             $firstRow.true | Should -BeOfType [System.Boolean]
         }
         It "Has the following bool: true" {
@@ -108,10 +125,10 @@ Describe "Testing data table output when using a complex object" {
     }
 
     Context "Property: false" {
-        It 'Has a column called "false"' {
-            $result.Columns.ColumnName | Should -Contain 'false'
+        It "Has a column called 'false'" {
+            $result.Columns.ColumnName | Should -Contain "false"
         }
-        It 'Has a [bool] data type on the column "false"' {
+        It "Has a [bool] data type on the column 'false'" {
             $firstRow.false | Should -BeOfType [System.Boolean]
         }
         It "Has the following bool: false" {
@@ -120,10 +137,10 @@ Describe "Testing data table output when using a complex object" {
     }
 
     Context "Property: null" {
-        It 'Has a column called "null"' {
-            $result.Columns.ColumnName | Should -Contain 'null'
+        It "Has a column called 'null'" {
+            $result.Columns.ColumnName | Should -Contain "null"
         }
-        It 'Has a [null] data type on the column "null"' {
+        It "Has a [null] data type on the column 'null'" {
             $firstRow.null | Should -BeOfType [System.DBNull]
         }
         It "Has no value" {
@@ -132,10 +149,10 @@ Describe "Testing data table output when using a complex object" {
     }
 
     Context "Property: string" {
-        It 'Has a column called "string"' {
-            $result.Columns.ColumnName | Should -Contain 'string'
+        It "Has a column called 'string'" {
+            $result.Columns.ColumnName | Should -Contain "string"
         }
-        It 'Has a [string] data type on the column "string"' {
+        It "Has a [string] data type on the column 'string'" {
             $firstRow.string | Should -BeOfType [System.String]
         }
         It "Has the following string: it's a boy." {
@@ -144,10 +161,10 @@ Describe "Testing data table output when using a complex object" {
     }
 
     Context "Property: UInt64" {
-        It 'Has a column called "UInt64"' {
-            $result.Columns.ColumnName | Should -Contain 'UInt64'
+        It "Has a column called 'UInt64'" {
+            $result.Columns.ColumnName | Should -Contain "UInt64"
         }
-        It 'Has a [UInt64] data type on the column "UInt64"' {
+        It "Has a [UInt64] data type on the column 'UInt64'" {
             $firstRow.UInt64 | Should -BeOfType [System.UInt64]
         }
         It "Has the following number: 123456" {
@@ -156,16 +173,16 @@ Describe "Testing data table output when using a complex object" {
     }
 
     Context "Property: myObject" {
-        It 'Has a column called "myObject"' {
-            $result.Columns.ColumnName | Should -Contain 'myObject'
+        It "Has a column called 'myObject'" {
+            $result.Columns.ColumnName | Should -Contain "myObject"
         }
     }
 
     Context "Property: dbadatetime" {
-        It 'Has a column called "dbadatetime"' {
-            $result.Columns.ColumnName | Should -Contain 'dbadatetime'
+        It "Has a column called 'dbadatetime'" {
+            $result.Columns.ColumnName | Should -Contain "dbadatetime"
         }
-        It 'Has a [System.String] data type on the column "myObject"' {
+        It "Has a [System.String] data type on the column 'myObject'" {
             $firstRow.dbadatetime | Should -BeOfType [System.String]
         }
         It "Has the following dbadatetime: 2024-05-19 05:52:00.000" {
@@ -175,27 +192,29 @@ Describe "Testing data table output when using a complex object" {
     }
 
     Context "Property: dbadatetimeArray" {
-        It 'Has a column called "dbadatetimeArray"' {
-            $result.Columns.ColumnName | Should -Contain 'dbadatetimeArray'
+        It "Has a column called 'dbadatetimeArray'" {
+            $result.Columns.ColumnName | Should -Contain "dbadatetimeArray"
         }
-        It 'Has a [System.String] data type on the column "myObject"' {
+        It "Has a [System.String] data type on the column 'myObject'" {
             $firstRow.dbadatetimeArray | Should -BeOfType [System.String]
         }
         It "Has the following dbadatetimeArray converted to strings: 2024-05-19 05:52:00.000, 2024-05-19 06:52:00.000" {
-            $string = '2024-05-19 05:52:00.000, 2024-05-19 06:52:00.000'
+            $string = "2024-05-19 05:52:00.000, 2024-05-19 06:52:00.000"
             $firstRow.dbadatetimeArray -eq $string | Should -Be $true
         }
     }
 }
 
 Describe "Testing input parameters" {
-    $obj = New-Object -TypeName psobject -Property @{
-        timespan = New-TimeSpan -Start 2017-01-01 -End 2017-01-02
+    BeforeAll {
+        $obj = New-Object -TypeName psobject -Property @{
+            timespan = New-TimeSpan -Start 2017-01-01 -End 2017-01-02
+        }
     }
 
     Context "Verifying TimeSpanType" {
         It "Should return '1.00:00:00' when String is used" {
-            (ConvertTo-DbaDataTable -InputObject $obj -TimeSpanType String).Timespan | Should -Be '1.00:00:00'
+            (ConvertTo-DbaDataTable -InputObject $obj -TimeSpanType String).Timespan | Should -Be "1.00:00:00"
         }
         It "Should return 864000000000 when Ticks is used" {
             (ConvertTo-DbaDataTable -InputObject $obj -TimeSpanType Ticks).Timespan | Should -Be 864000000000
@@ -218,19 +237,21 @@ Describe "Testing input parameters" {
     }
 
     Context "Verifying IgnoreNull" {
-        # To be able to force null
-        function returnnull {
-            [CmdletBinding()]
-            param ()
-            New-Object -TypeName psobject -Property @{ Name = [int]1 }
-            $null
-            New-Object -TypeName psobject -Property @{ Name = [int]3 }
-        }
-
-        function returnOnlynull {
-            [CmdletBinding()]
-            param ()
-            $null
+        BeforeAll {
+            # To be able to force null
+            function returnnull {
+                [CmdletBinding()]
+                param ()
+                New-Object -TypeName psobject -Property @{ Name = [int]1 }
+                $null
+                New-Object -TypeName psobject -Property @{ Name = [int]3 }
+            }
+
+            function returnOnlynull {
+                [CmdletBinding()]
+                param ()
+                $null
+            }
         }
 
         It "Does not create row if null is in array when IgnoreNull is set" {
@@ -259,11 +280,13 @@ Describe "Testing input parameters" {
     }
 
     Context "Verifying Silent" {
-        # To be able to force null
-        function returnnull {
-            New-Object -TypeName psobject -Property @{ Name = 1 }
-            $null
-            New-Object -TypeName psobject -Property @{ Name = 3 }
+        BeforeAll {
+            # To be able to force null
+            function returnnull {
+                New-Object -TypeName psobject -Property @{ Name = 1 }
+                $null
+                New-Object -TypeName psobject -Property @{ Name = 3 }
+            }
         }
 
         It "Suppresses warning messages when Silent is used" {
@@ -273,27 +296,28 @@ Describe "Testing input parameters" {
     }
 
     Context "Verifying script properties returning null" {
-
         It "Returns string column if a script property returns null" {
-            $myobj = New-Object -TypeName psobject -Property @{ Name = 'Test' }
+            $myobj = New-Object -TypeName psobject -Property @{ Name = "Test" }
             $myobj | Add-Member -Force -MemberType ScriptProperty -Name ScriptNothing -Value { $null }
             $r = ConvertTo-DbaDataTable -InputObject $myobj
-            ($r.Columns | Where-Object ColumnName -eq ScriptNothing | Select-Object -ExpandProperty DataType).ToString() | Should -Be 'System.String'
-
+            ($r.Columns | Where-Object ColumnName -eq ScriptNothing | Select-Object -ExpandProperty DataType).ToString() | Should -Be "System.String"
         }
     }
 
     Context "Verifying a datatable gets cloned when passed in" {
-        $obj = New-Object -TypeName psobject -Property @{
-            col1 = 'col1'
-            col2 = 'col2'
+        BeforeAll {
+            $obj = New-Object -TypeName psobject -Property @{
+                col1 = "col1"
+                col2 = "col2"
+            }
+            $first = $obj | ConvertTo-DbaDataTable
+            $second = $first | ConvertTo-DbaDataTable
         }
-        $first = $obj | ConvertTo-DbaDataTable
-        $second = $first | ConvertTo-DbaDataTable
+
         It "Should have the same columns" {
             # does not add ugly RowError,RowState Table, ItemArray, HasErrors
-            $firstColumns = ($first.Columns.ColumnName | Sort-Object) -Join ','
-            $secondColumns = ($second.Columns.ColumnName | Sort-Object) -Join ','
+            $firstColumns = ($first.Columns.ColumnName | Sort-Object) -Join ","
+            $secondColumns = ($second.Columns.ColumnName | Sort-Object) -Join ","
             $firstColumns | Should -Be $secondColumns
         }
     }
diff --git a/tests/ConvertTo-DbaTimeline.Tests.ps1 b/tests/ConvertTo-DbaTimeline.Tests.ps1
index b2feda33952d..2a8a637bfab4 100644
--- a/tests/ConvertTo-DbaTimeline.Tests.ps1
+++ b/tests/ConvertTo-DbaTimeline.Tests.ps1
@@ -1,28 +1,24 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "ConvertTo-DbaTimeline",
     $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
 )
 
-Describe "ConvertTo-DbaTimeline" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command ConvertTo-DbaTimeline
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "InputObject",
                 "ExcludeRowLabel",
                 "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
diff --git a/tests/ConvertTo-DbaXESession.Tests.ps1 b/tests/ConvertTo-DbaXESession.Tests.ps1
index 5022d184b567..586ce0926e60 100644
--- a/tests/ConvertTo-DbaXESession.Tests.ps1
+++ b/tests/ConvertTo-DbaXESession.Tests.ps1
@@ -1,15 +1,16 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
 param(
-    $ModuleName = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "ConvertTo-DbaXESession",
     $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
 )
 
-Describe "ConvertTo-DbaXESession" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command ConvertTo-DbaXESession
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "InputObject",
                 "Name",
                 "OutputScriptOnly",
@@ -17,18 +18,13 @@ Describe "ConvertTo-DbaXESession" -Tag "UnitTests" {
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
-Describe "ConvertTo-DbaXESession" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
         $sql = @"
 -- Create a Queue
@@ -109,21 +105,40 @@ exec sp_trace_setstatus @TraceID, 1
 -- display trace id for future references
 select TraceID=@TraceID
 "@
-        $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2
+        $splatConnect = @{
+            SqlInstance = $TestConfig.instance2
+        }
+        $server = Connect-DbaInstance @splatConnect
         $traceid = ($server.Query($sql)).TraceID
         $sessionName = "dbatoolsci-session"
     }
 
     AfterAll {
-        $null = Remove-DbaXESession -SqlInstance $TestConfig.instance2 -Session $sessionName
-        $null = Remove-DbaTrace -SqlInstance $TestConfig.instance2 -Id $traceid
+        $splatRemoveSession = @{
+            SqlInstance = $TestConfig.instance2
+            Session     = $sessionName
+        }
+        $null = Remove-DbaXESession @splatRemoveSession
+        $splatRemoveTrace = @{
+            SqlInstance = $TestConfig.instance2
+            Id          = $traceid
+        }
+        $null = Remove-DbaTrace @splatRemoveTrace
         Remove-Item C:\windows\temp\temptrace.trc -ErrorAction SilentlyContinue
     }
 
     Context "Test Trace Conversion" {
         BeforeAll {
-            $null = Get-DbaTrace -SqlInstance $TestConfig.instance2 -Id $traceid | ConvertTo-DbaXESession -Name $sessionName
-            $results = Start-DbaXESession -SqlInstance $TestConfig.instance2 -Session $sessionName
+            $splatGetTrace = @{
+                SqlInstance = $TestConfig.instance2
+                Id          = $traceid
+            }
+            $null = Get-DbaTrace @splatGetTrace | ConvertTo-DbaXESession -Name $sessionName
+            $splatStartSession = @{
+                SqlInstance = $TestConfig.instance2
+                Session     = $sessionName
+            }
+            $results = Start-DbaXESession @splatStartSession
         }
 
         It "Returns the right results" {
diff --git a/tests/Copy-DbaAgentAlert.Tests.ps1 b/tests/Copy-DbaAgentAlert.Tests.ps1
index 075cfffb58bd..67623ec9aea9 100644
--- a/tests/Copy-DbaAgentAlert.Tests.ps1
+++ b/tests/Copy-DbaAgentAlert.Tests.ps1
@@ -1,10 +1,11 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
 param(
-    $ModuleName = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "Copy-DbaAgentAlert",
     $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
 )
 
-Describe "Copy-DbaAgentAlert" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
             $command = Get-Command Copy-DbaAgentAlert
@@ -24,8 +25,9 @@ Describe "Copy-DbaAgentAlert" -Tag "UnitTests" {
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
+        It "Has parameter: <_>" -TestCases ($expected | ForEach-Object { @{ Parameter = $PSItem } }) {
+            param($Parameter)
+            $command | Should -HaveParameter $Parameter
         }
 
         It "Should have exactly the number of expected parameters ($($expected.Count))" {
@@ -35,15 +37,15 @@ Describe "Copy-DbaAgentAlert" -Tag "UnitTests" {
     }
 }
 
-Describe "Copy-DbaAgentAlert" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
-        $alert1 = 'dbatoolsci test alert'
-        $alert2 = 'dbatoolsci test alert 2'
-        $operatorName = 'Dan the man Levitan'
-        $operatorEmail = 'levitan@dbatools.io'
-        $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2 -Database master
+        $alert1 = "dbatoolsci test alert"
+        $alert2 = "dbatoolsci test alert 2"
+        $operatorName = "Dan the man Levitan"
+        $operatorEmail = "levitan@dbatools.io"
+        $serverInstance2 = Connect-DbaInstance -SqlInstance $TestConfig.instance2 -Database master
 
-        $server.Query("EXEC msdb.dbo.sp_add_alert @name=N'$($alert1)',
+        $serverInstance2.Query("EXEC msdb.dbo.sp_add_alert @name=N'$($alert1)',
         @message_id=0,
         @severity=6,
         @enabled=1,
@@ -52,7 +54,7 @@ Describe "Copy-DbaAgentAlert" -Tag "IntegrationTests" {
         @category_name=N'[Uncategorized]',
         @job_id=N'00000000-0000-0000-0000-000000000000';")
 
-        $server.Query("EXEC msdb.dbo.sp_add_alert @name=N'$($alert2)',
+        $serverInstance2.Query("EXEC msdb.dbo.sp_add_alert @name=N'$($alert2)',
         @message_id=0,
         @severity=10,
         @enabled=1,
@@ -60,64 +62,64 @@ Describe "Copy-DbaAgentAlert" -Tag "IntegrationTests" {
         @include_event_description_in=0,
         @job_id=N'00000000-0000-0000-0000-000000000000';")
 
-        $server.Query("EXEC msdb.dbo.sp_add_operator
+        $serverInstance2.Query("EXEC msdb.dbo.sp_add_operator
         @name = N'$operatorName',
         @enabled = 1,
         @email_address = N'$operatorEmail' ;")
-        $server.Query("EXEC msdb.dbo.sp_add_notification   @alert_name = N'$($alert2)',
+        $serverInstance2.Query("EXEC msdb.dbo.sp_add_notification   @alert_name = N'$($alert2)',
         @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)'")
-        $server.Query("EXEC msdb.dbo.sp_delete_alert @name=N'$($alert2)'")
-        $server.Query("EXEC msdb.dbo.sp_delete_operator @name = '$($operatorName)'")
+        $serverCleanup2 = Connect-DbaInstance -SqlInstance $TestConfig.instance2 -Database master
+        $serverCleanup2.Query("EXEC msdb.dbo.sp_delete_alert @name=N'$($alert1)'")
+        $serverCleanup2.Query("EXEC msdb.dbo.sp_delete_alert @name=N'$($alert2)'")
+        $serverCleanup2.Query("EXEC msdb.dbo.sp_delete_operator @name = '$($operatorName)'")
 
-        $server = Connect-DbaInstance -SqlInstance $TestConfig.instance3 -Database master
-        $server.Query("EXEC msdb.dbo.sp_delete_alert @name=N'$($alert1)'")
+        $serverCleanup3 = Connect-DbaInstance -SqlInstance $TestConfig.instance3 -Database master
+        $serverCleanup3.Query("EXEC msdb.dbo.sp_delete_alert @name=N'$($alert1)'")
     }
 
     Context "When copying alerts" {
         It "Copies the sample alert" {
-            $splat = @{
+            $splatCopyAlert = @{
                 Source      = $TestConfig.instance2
                 Destination = $TestConfig.instance3
                 Alert       = $alert1
             }
-            $results = Copy-DbaAgentAlert @splat
-            $results.Name | Should -Be 'dbatoolsci test alert', 'dbatoolsci test alert'
-            $results.Type | Should -Be 'Agent Alert', 'Agent Alert Notification'
-            $results.Status | Should -Be 'Successful', 'Successful'
+            $results = Copy-DbaAgentAlert @splatCopyAlert
+            $results.Name | Should -Be "dbatoolsci test alert", "dbatoolsci test alert"
+            $results.Type | Should -Be "Agent Alert", "Agent Alert Notification"
+            $results.Status | Should -Be "Successful", "Successful"
         }
 
         It "Skips alerts where destination is missing the operator" {
-            $splatDupe = @{
+            $splatCopySkip = @{
                 Source        = $TestConfig.instance2
                 Destination   = $TestConfig.instance3
                 Alert         = $alert2
-                WarningAction = 'SilentlyContinue'
+                WarningAction = "SilentlyContinue"
             }
-            $results = Copy-DbaAgentAlert @splatDupe
+            $results = Copy-DbaAgentAlert @splatCopySkip
             $results.Status | Should -Be Skipped
-            $results.Type | Should -Be 'Agent Alert'
+            $results.Type | Should -Be "Agent Alert"
         }
 
         It "Doesn't overwrite existing alerts" {
-            $splat = @{
+            $splatCopyExisting = @{
                 Source      = $TestConfig.instance2
                 Destination = $TestConfig.instance3
                 Alert       = $alert1
             }
-            $results = Copy-DbaAgentAlert @splat
-            $results.Name | Should -Be 'dbatoolsci test alert'
-            $results.Status | Should -Be 'Skipped'
+            $results = Copy-DbaAgentAlert @splatCopyExisting
+            $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 | Should -Contain 'dbatoolsci test alert'
+            $results.Name | Should -Contain "dbatoolsci test alert"
         }
     }
 }
diff --git a/tests/Copy-DbaAgentJob.Tests.ps1 b/tests/Copy-DbaAgentJob.Tests.ps1
index 9e466da01328..bcbda029bb26 100644
--- a/tests/Copy-DbaAgentJob.Tests.ps1
+++ b/tests/Copy-DbaAgentJob.Tests.ps1
@@ -1,10 +1,11 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "Copy-DbaAgentJob",
     $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
 )
 
-Describe "Copy-DbaAgentJob" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
         $null = New-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job dbatoolsci_copyjob
         $null = New-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job dbatoolsci_copyjob_disabled
@@ -18,9 +19,10 @@ Describe "Copy-DbaAgentJob" -Tag "IntegrationTests" {
 
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Copy-DbaAgentJob
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $command = Get-Command $CommandName
+            $hasParameters = $command.Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "Source",
                 "SourceSqlCredential",
                 "Destination",
@@ -31,19 +33,12 @@ Describe "Copy-DbaAgentJob" -Tag "IntegrationTests" {
                 "DisableOnDestination",
                 "Force",
                 "InputObject",
-                "EnableException",
-                "Confirm",
-                "WhatIf"
+                "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 
@@ -63,12 +58,12 @@ Describe "Copy-DbaAgentJob" -Tag "IntegrationTests" {
 
         It "disables jobs when requested" {
             $splatCopyJob = @{
-                Source = $TestConfig.instance2
-                Destination = $TestConfig.instance3
-                Job = "dbatoolsci_copyjob_disabled"
-                DisableOnSource = $true
+                Source               = $TestConfig.instance2
+                Destination          = $TestConfig.instance3
+                Job                  = "dbatoolsci_copyjob_disabled"
+                DisableOnSource      = $true
                 DisableOnDestination = $true
-                Force = $true
+                Force                = $true
             }
             $results = Copy-DbaAgentJob @splatCopyJob
 
diff --git a/tests/Copy-DbaAgentJobCategory.Tests.ps1 b/tests/Copy-DbaAgentJobCategory.Tests.ps1
index 241c54553737..6065e7f2c579 100644
--- a/tests/Copy-DbaAgentJobCategory.Tests.ps1
+++ b/tests/Copy-DbaAgentJobCategory.Tests.ps1
@@ -1,24 +1,24 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "Copy-DbaAgentJobCategory",
     $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
 )
 
-Describe "Copy-DbaAgentJobCategory" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
-        $null = New-DbaAgentJobCategory -SqlInstance $TestConfig.instance2 -Category 'dbatoolsci test category'
+        $null = New-DbaAgentJobCategory -SqlInstance $TestConfig.instance2 -Category "dbatoolsci test category"
     }
     AfterAll {
-        $null = Remove-DbaAgentJobCategory -SqlInstance $TestConfig.instance2 -Category 'dbatoolsci test category' -Confirm:$false
-        $null = Remove-DbaAgentJobCategory -SqlInstance $TestConfig.instance3 -Category 'dbatoolsci test category' -Confirm:$false
+        $null = Remove-DbaAgentJobCategory -SqlInstance $TestConfig.instance2 -Category "dbatoolsci test category" -Confirm:$false
+        $null = Remove-DbaAgentJobCategory -SqlInstance $TestConfig.instance3 -Category "dbatoolsci test category" -Confirm:$false
     }
 
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Copy-DbaAgentJobCategory
-
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "Source",
                 "SourceSqlCredential",
                 "Destination",
@@ -28,31 +28,24 @@ Describe "Copy-DbaAgentJobCategory" -Tag "IntegrationTests" {
                 "AgentCategory",
                 "OperatorCategory",
                 "Force",
-                "EnableException",
-                "Confirm",
-                "WhatIf"
+                "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 
     Context "When copying job categories" {
         It "Returns successful results" {
-            $splat = @{
+            $splatCopyCategory = @{
                 Source      = $TestConfig.instance2
                 Destination = $TestConfig.instance3
                 JobCategory = "dbatoolsci test category"
             }
 
-            $results = Copy-DbaAgentJobCategory @splat
+            $results = Copy-DbaAgentJobCategory @splatCopyCategory
             $results.Name | Should -Be "dbatoolsci test category"
             $results.Status | Should -Be "Successful"
         }
diff --git a/tests/Copy-DbaAgentOperator.Tests.ps1 b/tests/Copy-DbaAgentOperator.Tests.ps1
index 846e46d8b17c..1c42f3d2f21e 100644
--- a/tests/Copy-DbaAgentOperator.Tests.ps1
+++ b/tests/Copy-DbaAgentOperator.Tests.ps1
@@ -1,15 +1,16 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName = "dbatools",
-    $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
+    $ModuleName  = "dbatools",
+    $CommandName = "Copy-DbaAgentOperator",
+    $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe "Copy-DbaAgentOperator" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Copy-DbaAgentOperator
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "Source",
                 "SourceSqlCredential",
                 "Destination",
@@ -17,65 +18,60 @@ Describe "Copy-DbaAgentOperator" -Tag "UnitTests" {
                 "Operator",
                 "ExcludeOperator",
                 "Force",
-                "EnableException",
-                "Confirm",
-                "WhatIf"
+                "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
-Describe "Copy-DbaAgentOperator" -Tag "IntegrationTests" {
+Describe $CommandName -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"
-        $server.Query($sql)
-        $sql = "EXEC msdb.dbo.sp_add_operator @name=N'dbatoolsci_operator2', @enabled=1, @pager_days=0"
-        $server.Query($sql)
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+        $sourceServer = Connect-DbaInstance -SqlInstance $TestConfig.instance2
+        $sqlAddOperator1 = "EXEC msdb.dbo.sp_add_operator @name=N'dbatoolsci_operator', @enabled=1, @pager_days=0"
+        $sourceServer.Query($sqlAddOperator1)
+        $sqlAddOperator2 = "EXEC msdb.dbo.sp_add_operator @name=N'dbatoolsci_operator2', @enabled=1, @pager_days=0"
+        $sourceServer.Query($sqlAddOperator2)
     }
 
     AfterAll {
-        $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2
-        $sql = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator'"
-        $server.Query($sql)
-        $sql = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator2'"
-        $server.Query($sql)
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+        $sourceCleanupServer = Connect-DbaInstance -SqlInstance $TestConfig.instance2
+        $sqlDeleteOp1Source = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator'"
+        $sourceCleanupServer.Query($sqlDeleteOp1Source)
+        $sqlDeleteOp2Source = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator2'"
+        $sourceCleanupServer.Query($sqlDeleteOp2Source)
 
-        $server = Connect-DbaInstance -SqlInstance $TestConfig.instance3
-        $sql = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator'"
-        $server.Query($sql)
-        $sql = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator2'"
-        $server.Query($sql)
+        $destCleanupServer = Connect-DbaInstance -SqlInstance $TestConfig.instance3
+        $sqlDeleteOp1Dest = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator'"
+        $destCleanupServer.Query($sqlDeleteOp1Dest)
+        $sqlDeleteOp2Dest = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator2'"
+        $destCleanupServer.Query($sqlDeleteOp2Dest)
     }
 
     Context "When copying operators" {
         It "Returns two copied operators" {
-            $splat = @{
+            $splatCopyOperators = @{
                 Source      = $TestConfig.instance2
                 Destination = $TestConfig.instance3
-                Operator    = 'dbatoolsci_operator', 'dbatoolsci_operator2'
+                Operator    = "dbatoolsci_operator", "dbatoolsci_operator2"
             }
-            $results = Copy-DbaAgentOperator @splat
+            $results = Copy-DbaAgentOperator @splatCopyOperators
             $results.Status.Count | Should -Be 2
             $results.Status | Should -Be "Successful", "Successful"
         }
 
         It "Returns one result that's skipped when copying an existing operator" {
-            $splet = @{
+            $splatCopyExisting = @{
                 Source      = $TestConfig.instance2
                 Destination = $TestConfig.instance3
-                Operator    = 'dbatoolsci_operator'
+                Operator    = "dbatoolsci_operator"
             }
-            (Copy-DbaAgentOperator @splet).Status | Should -Be "Skipped"
+            (Copy-DbaAgentOperator @splatCopyExisting).Status | Should -Be "Skipped"
         }
     }
 }

From b3c4cd3306eb06958fdd4f9aae4c02961c862dc3 Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Sat, 9 Aug 2025 06:14:30 +0200
Subject: [PATCH 02/15] Refactor and enhance integration test setup/teardown

Standardized the use of $PSDefaultParameterValues to enable exceptions during setup and cleanup in integration tests across multiple test files. Added and clarified comments, improved variable scoping, and ensured proper cleanup of test artifacts and directories. This improves test reliability and consistency.
---
 tests/Add-DbaAgDatabase.Tests.ps1             |   6 +-
 tests/Add-DbaAgListener.Tests.ps1             |  35 ++--
 tests/Add-DbaAgReplica.Tests.ps1              |  30 ++-
 tests/Add-DbaComputerCertificate.Tests.ps1    |  11 +-
 tests/Add-DbaDbMirrorMonitor.Tests.ps1        |  26 ++-
 tests/Add-DbaDbRoleMember.Tests.ps1           |   9 +-
 tests/Add-DbaExtendedProperty.Tests.ps1       |  25 ++-
 tests/Add-DbaPfDataCollectorCounter.Tests.ps1 |  24 +--
 tests/Add-DbaRegServer.Tests.ps1              |  13 +-
 tests/Add-DbaRegServerGroup.Tests.ps1         |  20 +-
 tests/Add-DbaReplArticle.Tests.ps1            |   4 +-
 tests/Add-DbaServerRoleMember.Tests.ps1       |  12 ++
 tests/Backup-DbaComputerCertificate.Tests.ps1 |  47 +++--
 tests/Backup-DbaDatabase.Tests.ps1            | 171 +++++++++---------
 tests/Backup-DbaDbCertificate.Tests.ps1       |  75 ++++----
 tests/Backup-DbaDbMasterKey.Tests.ps1         |  88 ++++++---
 tests/Backup-DbaServiceMasterKey.Tests.ps1    |  54 +++++-
 tests/Clear-DbaLatchStatistics.Tests.ps1      |   2 +-
 tests/Clear-DbaPlanCache.Tests.ps1            |   2 +-
 tests/Connect-DbaInstance.Tests.ps1           | 146 ++++++++++-----
 tests/Convert-DbaLsn.Tests.ps1                |  10 +-
 tests/ConvertTo-DbaDataTable.Tests.ps1        |   4 +-
 tests/ConvertTo-DbaTimeline.Tests.ps1         |   2 +-
 tests/ConvertTo-DbaXESession.Tests.ps1        |  15 +-
 tests/Copy-DbaAgentAlert.Tests.ps1            |  50 ++---
 tests/Copy-DbaAgentJob.Tests.ps1              |  39 +++-
 tests/Copy-DbaAgentJobCategory.Tests.ps1      |  16 +-
 tests/Copy-DbaAgentOperator.Tests.ps1         |  54 ++++--
 tests/Find-DbaUserObject.Tests.ps1            |  60 ++++--
 29 files changed, 702 insertions(+), 348 deletions(-)

diff --git a/tests/Add-DbaAgDatabase.Tests.ps1 b/tests/Add-DbaAgDatabase.Tests.ps1
index 76c9ab07cd4a..84215a158a72 100644
--- a/tests/Add-DbaAgDatabase.Tests.ps1
+++ b/tests/Add-DbaAgDatabase.Tests.ps1
@@ -52,10 +52,10 @@ Describe $CommandName -Tag IntegrationTests {
         # For negative tests, we need a database without a backup and a non existing database.
 
         # Set variables. They are available in all the It blocks.
-        $agName = "addagdb_group"
-        $existingDbWithBackup = "dbWithBackup"
+        $agName                  = "addagdb_group"
+        $existingDbWithBackup    = "dbWithBackup"
         $existingDbWithoutBackup = "dbWithoutBackup"
-        $nonexistingDb = "dbdoesnotexist"
+        $nonexistingDb           = "dbdoesnotexist"
 
         # Create the objects.
         $splatAg = @{
diff --git a/tests/Add-DbaAgListener.Tests.ps1 b/tests/Add-DbaAgListener.Tests.ps1
index 054e1acc4b5e..3d2f9b55ab6a 100644
--- a/tests/Add-DbaAgListener.Tests.ps1
+++ b/tests/Add-DbaAgListener.Tests.ps1
@@ -1,11 +1,11 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName               = "dbatools",
-    $CommandName              = "Add-DbaAgListener",
+    $ModuleName  = "dbatools",
+    $CommandName = "Add-DbaAgListener",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe $CommandName -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
             $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
@@ -32,39 +32,52 @@ Describe $CommandName -Tag "UnitTests" {
     }
 }
 
-Describe $CommandName -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
         $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
+        # For all the backups that we want to clean up after the test, we create a directory that we can delete at the end.
+        # Other files can be written there as well, maybe we change the name of that variable later. But for now we focus on backups.
         $backupPath = "$($TestConfig.Temp)\$CommandName-$(Get-Random)"
         $null = New-Item -Path $backupPath -ItemType Directory
 
+        # Explain what needs to be set up for the test:
         # To add a listener to an availablity group, we need an availability group, an ip address and a port.
         # TODO: Add some negative tests.
 
-        $agName = "addagdb_group"
+        # Set variables. They are available in all the It blocks.
+        $agName       = "addagdb_group"
         $listenerName = "listener"
-        $listenerIp = "127.0.20.1"
+        $listenerIp   = "127.0.20.1"
         $listenerPort = 14330
 
+        # Create the objects.
         $splatAg = @{
             Primary      = $TestConfig.instance3
             Name         = $agName
             ClusterType  = "None"
             FailoverMode = "Manual"
             Certificate  = "dbatoolsci_AGCert"
-            Confirm      = $false
         }
         $ag = New-DbaAvailabilityGroup @splatAg
+
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
 
     AfterAll {
-        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
-        $null = Remove-DbaAvailabilityGroup -SqlInstance $TestConfig.instance3 -AvailabilityGroup $agName -Confirm:$false
-        $null = Get-DbaEndpoint -SqlInstance $TestConfig.instance3 -Type DatabaseMirroring | Remove-DbaEndpoint -Confirm:$false
+        # Cleanup all created objects.
+        $null = Remove-DbaAvailabilityGroup -SqlInstance $TestConfig.instance3 -AvailabilityGroup $agName
+        $null = Get-DbaEndpoint -SqlInstance $TestConfig.instance3 -Type DatabaseMirroring | Remove-DbaEndpoint
 
+        # Remove the backup directory.
         Remove-Item -Path $backupPath -Recurse -ErrorAction SilentlyContinue
+
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "When creating a listener" {
@@ -85,4 +98,4 @@ Describe $CommandName -Tag "IntegrationTests" {
             $results.PortNumber | Should -Be $listenerPort
         }
     }
-} #$TestConfig.instance2 for appveyor
+} #$TestConfig.instance2 for appveyor
\ No newline at end of file
diff --git a/tests/Add-DbaAgReplica.Tests.ps1 b/tests/Add-DbaAgReplica.Tests.ps1
index 7e6b65c99dd2..a057955c5a08 100644
--- a/tests/Add-DbaAgReplica.Tests.ps1
+++ b/tests/Add-DbaAgReplica.Tests.ps1
@@ -42,9 +42,16 @@ Describe $CommandName -Tag UnitTests {
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
         $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
+        # Explain what needs to be set up for the test:
+        # To add an availability group replica, we need an availability group to work with.
+
+        # Set variables. They are available in all the It blocks.
         $primaryAgName = "dbatoolsci_agroup"
+        
+        # Create the objects.
         $splatPrimary = @{
             Primary      = $TestConfig.instance3
             Name         = $primaryAgName
@@ -55,16 +62,27 @@ Describe $CommandName -Tag IntegrationTests {
         }
         $primaryAg = New-DbaAvailabilityGroup @splatPrimary
         $replicaName = $primaryAg.PrimaryReplica
+
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
 
     AfterAll {
-        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
+        # Cleanup all created objects.
         $null = Remove-DbaAvailabilityGroup -SqlInstance $TestConfig.instance3 -AvailabilityGroup $primaryAgName -Confirm:$false -ErrorAction SilentlyContinue
         $null = Get-DbaEndpoint -SqlInstance $TestConfig.instance3 -Type DatabaseMirroring | Remove-DbaEndpoint -Confirm:$false -ErrorAction SilentlyContinue
+
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "When adding AG replicas" {
         BeforeAll {
+            # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
+            $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
             $replicaAgName = "dbatoolsci_add_replicagroup"
             $splatRepAg = @{
                 Primary      = $TestConfig.instance3
@@ -72,11 +90,19 @@ Describe $CommandName -Tag IntegrationTests {
                 ClusterType  = "None"
                 FailoverMode = "Manual"
                 Certificate  = "dbatoolsci_AGCert"
+                Confirm      = $false
             }
             $replicaAg = New-DbaAvailabilityGroup @splatRepAg
+
+            # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+            $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
         }
 
         AfterAll {
+            # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+            $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
+            # Cleanup all created objects.
             $null = Remove-DbaAvailabilityGroup -SqlInstance $TestConfig.instance3 -AvailabilityGroup $replicaAgName -Confirm:$false -ErrorAction SilentlyContinue
         }
 
@@ -96,4 +122,4 @@ Describe $CommandName -Tag IntegrationTests {
             $results.FailoverMode | Should -Be "Manual"
         }
     }
-} #$TestConfig.instance2 for appveyor
+} #$TestConfig.instance2 for appveyor
\ No newline at end of file
diff --git a/tests/Add-DbaComputerCertificate.Tests.ps1 b/tests/Add-DbaComputerCertificate.Tests.ps1
index 8cccfc9198ae..25d095a2e352 100644
--- a/tests/Add-DbaComputerCertificate.Tests.ps1
+++ b/tests/Add-DbaComputerCertificate.Tests.ps1
@@ -1,7 +1,7 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName               = "dbatools",
-    $CommandName              = "Add-DbaComputerCertificate",
+    $ModuleName  = "dbatools",
+    $CommandName = "Add-DbaComputerCertificate",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
@@ -32,6 +32,9 @@ Describe $CommandName -Tag UnitTests {
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
         $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+        
+        $certPath       = "$($TestConfig.AppveyorLabRepo)\certificates\localhost.crt"
+        $certThumbprint = "29C469578D6C6211076A09CEE5C5797EEA0C2713"
     }
 
     AfterAll {
@@ -40,8 +43,6 @@ Describe $CommandName -Tag IntegrationTests {
 
     Context "Certificate is added properly" {
         BeforeAll {
-            $certPath = "$($TestConfig.AppveyorLabRepo)\certificates\localhost.crt"
-            $certThumbprint = "29C469578D6C6211076A09CEE5C5797EEA0C2713"
             $results = Add-DbaComputerCertificate -Path $certPath
         }
 
@@ -57,4 +58,4 @@ Describe $CommandName -Tag IntegrationTests {
             $results.PSParentPath | Should -Be "Microsoft.PowerShell.Security\Certificate::LocalMachine\My"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Add-DbaDbMirrorMonitor.Tests.ps1 b/tests/Add-DbaDbMirrorMonitor.Tests.ps1
index 03ddfa21bdc3..cf74a3876b9d 100644
--- a/tests/Add-DbaDbMirrorMonitor.Tests.ps1
+++ b/tests/Add-DbaDbMirrorMonitor.Tests.ps1
@@ -13,7 +13,9 @@ Describe $CommandName -Tag UnitTests {
             $expectedParameters += @(
                 "SqlInstance",
                 "SqlCredential",
-                "EnableException"
+                "EnableException",
+                "WhatIf",
+                "Confirm"
             )
         }
 
@@ -25,23 +27,39 @@ Describe $CommandName -Tag UnitTests {
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
         $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
     }
 
     AfterAll {
-        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+        
+        # Clean up any remaining mirror monitors
+        $null = Remove-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2 -ErrorAction SilentlyContinue
+        
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "When adding mirror monitor" {
         BeforeAll {
-            $results = Add-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2
+            # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+            $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+            
+            # Set variables. They are available in all the It blocks.
+            $mirrorMonitorInstance = $TestConfig.instance2
         }
 
         AfterAll {
-            $null = Remove-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2 -ErrorAction SilentlyContinue
+            # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+            $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+            
+            # Clean up the mirror monitor created during the test
+            $null = Remove-DbaDbMirrorMonitor -SqlInstance $mirrorMonitorInstance -ErrorAction SilentlyContinue
         }
 
         It "Adds the mirror monitor" {
+            $results = Add-DbaDbMirrorMonitor -SqlInstance $mirrorMonitorInstance
             $results.MonitorStatus | Should -Be "Added"
         }
     }
diff --git a/tests/Add-DbaDbRoleMember.Tests.ps1 b/tests/Add-DbaDbRoleMember.Tests.ps1
index fe1bd5ea526e..2a042c1e8793 100644
--- a/tests/Add-DbaDbRoleMember.Tests.ps1
+++ b/tests/Add-DbaDbRoleMember.Tests.ps1
@@ -29,6 +29,7 @@ Describe $CommandName -Tag UnitTests {
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
         $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
         $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2
@@ -80,9 +81,13 @@ Describe $CommandName -Tag IntegrationTests {
         }
         $null = New-DbaDbUser @splatDbUser2Msdb
         $null = $server.Query("CREATE ROLE $role", $dbname)
+
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
 
     AfterAll {
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
         $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
         $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2
@@ -91,7 +96,7 @@ Describe $CommandName -Tag IntegrationTests {
         $null = Remove-DbaDatabase -SqlInstance $TestConfig.instance2 -Database $dbname -Confirm:$false
         $null = Remove-DbaLogin -SqlInstance $TestConfig.instance2 -Login $user1, $user2 -Confirm:$false
 
-        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "When adding a user to a role" {
@@ -215,4 +220,4 @@ Describe $CommandName -Tag IntegrationTests {
             $roleDBAfter.MemberRole | Should -Contain $role
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Add-DbaExtendedProperty.Tests.ps1 b/tests/Add-DbaExtendedProperty.Tests.ps1
index 38d9663ef813..b9af245e4e75 100644
--- a/tests/Add-DbaExtendedProperty.Tests.ps1
+++ b/tests/Add-DbaExtendedProperty.Tests.ps1
@@ -1,7 +1,7 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName               = "dbatools",
-    $CommandName              = "Add-DbaExtendedProperty",
+    $ModuleName  = "dbatools",
+    $CommandName = "Add-DbaExtendedProperty",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
@@ -29,15 +29,32 @@ Describe $CommandName -Tag UnitTests {
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
+        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+
+        # Create unique database name for this test run
         $random = Get-Random
+        $newDbName = "dbatoolsci_newdb_$random"
+        
+        # Connect to instance and clean up any existing connections
         $server2 = Connect-DbaInstance -SqlInstance $TestConfig.instance2
         $null = Get-DbaProcess -SqlInstance $server2 | Where-Object Program -match dbatools | Stop-DbaProcess -Confirm:$false -WarningAction SilentlyContinue
-        $newDbName = "dbatoolsci_newdb_$random"
+        
+        # Create test database
         $db = New-DbaDatabase -SqlInstance $server2 -Name $newDbName
+        
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
     }
 
     AfterAll {
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        
+        # Cleanup the test database
         $null = $db | Remove-DbaDatabase -Confirm:$false
+        
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "When adding extended properties" {
@@ -52,4 +69,4 @@ Describe $CommandName -Tag IntegrationTests {
             $ep.Value | Should -Be "Sup"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Add-DbaPfDataCollectorCounter.Tests.ps1 b/tests/Add-DbaPfDataCollectorCounter.Tests.ps1
index d36e1ed4b43c..8e4bfbbcb763 100644
--- a/tests/Add-DbaPfDataCollectorCounter.Tests.ps1
+++ b/tests/Add-DbaPfDataCollectorCounter.Tests.ps1
@@ -36,23 +36,23 @@ Describe $CommandName -Tag IntegrationTests {
         $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
 
-    BeforeEach {
-        $null = Get-DbaPfDataCollectorSetTemplate -Template "Long Running Queries" |
-            Import-DbaPfDataCollectorSetTemplate |
-            Get-DbaPfDataCollector |
-            Get-DbaPfDataCollectorCounter -Counter "\LogicalDisk(*)\Avg. Disk Queue Length" |
-            Remove-DbaPfDataCollectorCounter
+    Context "When adding a counter to a data collector" {
+        BeforeAll {
+            $null = Get-DbaPfDataCollectorSetTemplate -Template "Long Running Queries" |
+                Import-DbaPfDataCollectorSetTemplate |
+                Get-DbaPfDataCollector |
+                Get-DbaPfDataCollectorCounter -Counter "\LogicalDisk(*)\Avg. Disk Queue Length" |
+                Remove-DbaPfDataCollectorCounter
 
-        $results = Get-DbaPfDataCollectorSet -CollectorSet "Long Running Queries" | Get-DbaPfDataCollector |
+            $results = Get-DbaPfDataCollectorSet -CollectorSet "Long Running Queries" | Get-DbaPfDataCollector |
                 Add-DbaPfDataCollectorCounter -Counter "\LogicalDisk(*)\Avg. Disk Queue Length"
-    }
+        }
 
-    AfterAll {
-        $null = Get-DbaPfDataCollectorSet -CollectorSet "Long Running Queries" |
+        AfterAll {
+            $null = Get-DbaPfDataCollectorSet -CollectorSet "Long Running Queries" |
                 Remove-DbaPfDataCollectorSet -ErrorAction SilentlyContinue
-    }
+        }
 
-    Context "When adding a counter to a data collector" {
         It "Returns the correct DataCollectorSet" {
             $results.DataCollectorSet | Should -Be "Long Running Queries"
         }
diff --git a/tests/Add-DbaRegServer.Tests.ps1 b/tests/Add-DbaRegServer.Tests.ps1
index 2dda062d7563..470e0ebbaa46 100644
--- a/tests/Add-DbaRegServer.Tests.ps1
+++ b/tests/Add-DbaRegServer.Tests.ps1
@@ -35,16 +35,27 @@ Describe $CommandName -Tag UnitTests {
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
+        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+
         $srvName = "dbatoolsci-server1"
         $group = "dbatoolsci-group1"
         $regSrvName = "dbatoolsci-server12"
         $regSrvDesc = "dbatoolsci-server123"
         $groupobject = Add-DbaRegServerGroup -SqlInstance $TestConfig.instance1 -Name $group
+
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
     }
 
     AfterAll {
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+
         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
+
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "When adding a registered server" {
@@ -94,4 +105,4 @@ Describe $CommandName -Tag IntegrationTests {
             $results2.SqlInstance | Should -Not -BeNullOrEmpty
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Add-DbaRegServerGroup.Tests.ps1 b/tests/Add-DbaRegServerGroup.Tests.ps1
index 0645b055e588..7b8cdabd36e7 100644
--- a/tests/Add-DbaRegServerGroup.Tests.ps1
+++ b/tests/Add-DbaRegServerGroup.Tests.ps1
@@ -29,13 +29,27 @@ Describe $CommandName -Tag UnitTests {
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
-        $group = "dbatoolsci-group1"
-        $group2 = "dbatoolsci-group2"
-        $description = "group description"
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
+        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+
+        # Set variables. They are available in all the It blocks.
+        $group              = "dbatoolsci-group1"
+        $group2             = "dbatoolsci-group2"
+        $description        = "group description"
         $descriptionUpdated = "group description updated"
+
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
     }
+
     AfterAll {
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+
+        # Cleanup all created objects.
         Get-DbaRegServerGroup -SqlInstance $TestConfig.instance1 | Where-Object Name -match dbatoolsci | Remove-DbaRegServerGroup -Confirm:$false
+
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "When adding a registered server group" {
diff --git a/tests/Add-DbaReplArticle.Tests.ps1 b/tests/Add-DbaReplArticle.Tests.ps1
index 4d2b4b8864bc..f5739b8975fa 100644
--- a/tests/Add-DbaReplArticle.Tests.ps1
+++ b/tests/Add-DbaReplArticle.Tests.ps1
@@ -1,7 +1,7 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName               = "dbatools",
-    $CommandName              = "Add-DbaReplArticle",
+    $ModuleName  = "dbatools",
+    $CommandName = "Add-DbaReplArticle",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
diff --git a/tests/Add-DbaServerRoleMember.Tests.ps1 b/tests/Add-DbaServerRoleMember.Tests.ps1
index b26d05eac853..90da8a5ad984 100644
--- a/tests/Add-DbaServerRoleMember.Tests.ps1
+++ b/tests/Add-DbaServerRoleMember.Tests.ps1
@@ -29,6 +29,9 @@ Describe $CommandName -Tag UnitTests {
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
+        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+
         $server = Connect-DbaInstance -SqlInstance $TestConfig.instance2
         $login1 = "dbatoolsci_login1_$(Get-Random)"
         $login2 = "dbatoolsci_login2_$(Get-Random)"
@@ -44,14 +47,23 @@ Describe $CommandName -Tag IntegrationTests {
         $null = New-DbaLogin @splatNewLogin -Login $login1
         $null = New-DbaLogin @splatNewLogin -Login $login2
         $null = New-DbaServerRole -SqlInstance $TestConfig.instance2 -ServerRole $customServerRole -Owner sa
+
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
     }
     AfterAll {
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+
         $splatRemoveLogin = @{
             SqlInstance = $TestConfig.instance2
             Login       = $login1, $login2
             Confirm     = $false
         }
         $null = Remove-DbaLogin @splatRemoveLogin
+        $null = Remove-DbaServerRole -SqlInstance $TestConfig.instance2 -ServerRole $customServerRole -Confirm:$false
+
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "Functionality" {
diff --git a/tests/Backup-DbaComputerCertificate.Tests.ps1 b/tests/Backup-DbaComputerCertificate.Tests.ps1
index 85d4fb54ed66..2f8cc9f68f39 100644
--- a/tests/Backup-DbaComputerCertificate.Tests.ps1
+++ b/tests/Backup-DbaComputerCertificate.Tests.ps1
@@ -8,9 +8,9 @@ param(
 Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command $CommandName
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "SecurePassword",
                 "InputObject",
                 "Path",
@@ -20,49 +20,56 @@ Describe $CommandName -Tag UnitTests {
             )
         }
 
-        foreach ($param in $expected) {
-            It "Has parameter: $param" {
-                $command | Should -HaveParameter $param
-            }
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
         $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
+        # For all the backups that we want to clean up after the test, we create a directory that we can delete at the end.
+        # Other files can be written there as well, maybe we change the name of that variable later. But for now we focus on backups.
+        $backupPath = "$($TestConfig.Temp)\$CommandName-$(Get-Random)"
+        $null = New-Item -Path $backupPath -ItemType Directory
+
+        # Explain what needs to be set up for the test:
+        # To test certificate backup, we need a certificate installed on the computer.
+
+        # Set variables. They are available in all the It blocks.
         $certThumbprint = "29C469578D6C6211076A09CEE5C5797EEA0C2713"
-        $certPath = "$($TestConfig.appveyorlabrepo)\certificates\localhost.crt"
-        $backupPath = $TestConfig.Temp
+        $certPath       = "$($TestConfig.appveyorlabrepo)\certificates\localhost.crt"
 
+        # Create the objects.
         $null = Add-DbaComputerCertificate -Path $certPath
 
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
         $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
 
     AfterAll {
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
         $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
+        # Cleanup all created object.
         $null = Remove-DbaComputerCertificate -Thumbprint $certThumbprint -ErrorAction SilentlyContinue
+
+        # Remove the backup directory.
+        Remove-Item -Path $backupPath -Recurse -ErrorAction SilentlyContinue
+
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "Certificate is backed up properly" {
         BeforeAll {
-            $result = Get-DbaComputerCertificate -Thumbprint $certThumbprint | Backup-DbaComputerCertificate -Path $backupPath
-        }
-
-        AfterAll {
-            Get-ChildItem -Path $result.FullName -ErrorAction SilentlyContinue | Remove-Item -ErrorAction SilentlyContinue
+            $backupResult = Get-DbaComputerCertificate -Thumbprint $certThumbprint | Backup-DbaComputerCertificate -Path $backupPath
         }
 
         It "Returns the proper results" {
-            $result.Name | Should -Match "$certThumbprint.cer"
+            $backupResult.Name | Should -Match "$certThumbprint.cer"
         }
     }
 }
diff --git a/tests/Backup-DbaDatabase.Tests.ps1 b/tests/Backup-DbaDatabase.Tests.ps1
index 96f81a732bb8..16ccb55bdc0d 100644
--- a/tests/Backup-DbaDatabase.Tests.ps1
+++ b/tests/Backup-DbaDatabase.Tests.ps1
@@ -1,83 +1,82 @@
 #Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
 param(
-    $ModuleName               = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "Backup-DbaDatabase",
     $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
-Describe "Backup-DbaDatabase" -Tag 'UnitTests' {
+Describe $CommandName -Tag UnitTests {
     Context "Validate parameters" {
         BeforeAll {
-            $command = Get-Command Backup-DbaDatabase
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
             $expectedParameters = $TestConfig.CommonParameters
             $expectedParameters += @(
-                'SqlInstance',
-                'SqlCredential',
-                'Database',
-                'ExcludeDatabase',
-                'Path',
-                'FilePath',
-                'ReplaceInName',
-                'NoAppendDbNameInPath',
-                'CopyOnly',
-                'Type',
-                'InputObject',
-                'CreateFolder',
-                'FileCount',
-                'CompressBackup',
-                'Checksum',
-                'Verify',
-                'MaxTransferSize',
-                'BlockSize',
-                'BufferCount',
-                'AzureBaseUrl',
-                'AzureCredential',
-                'NoRecovery',
-                'BuildPath',
-                'WithFormat',
-                'Initialize',
-                'SkipTapeHeader',
-                'TimeStampFormat',
-                'IgnoreFileChecks',
-                'OutputScriptOnly',
-                'EnableException',
-                'EncryptionAlgorithm',
-                'EncryptionCertificate',
-                'IncrementPrefix',
-                'Description'
+                "SqlInstance",
+                "SqlCredential",
+                "Database",
+                "ExcludeDatabase",
+                "Path",
+                "FilePath",
+                "ReplaceInName",
+                "NoAppendDbNameInPath",
+                "CopyOnly",
+                "Type",
+                "InputObject",
+                "CreateFolder",
+                "FileCount",
+                "CompressBackup",
+                "Checksum",
+                "Verify",
+                "MaxTransferSize",
+                "BlockSize",
+                "BufferCount",
+                "AzureBaseUrl",
+                "AzureCredential",
+                "NoRecovery",
+                "BuildPath",
+                "WithFormat",
+                "Initialize",
+                "SkipTapeHeader",
+                "TimeStampFormat",
+                "IgnoreFileChecks",
+                "OutputScriptOnly",
+                "EnableException",
+                "EncryptionAlgorithm",
+                "EncryptionCertificate",
+                "IncrementPrefix",
+                "Description"
             )
         }
-        It "Should only contain our specific parameters" {
-            $actualParameters = $command.Parameters.Keys | Where-Object { $PSItem -notin "WhatIf", "Confirm" }
-            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $actualParameters | Should -BeNullOrEmpty
-        }
-
-        It "Has parameter: <_>" -ForEach $expectedParameters {
-            $command | Should -HaveParameter $PSItem
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
-Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
         $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
 
-        $DestBackupDir = "$($TestConfig.Temp)\backups"
-        if (-Not (Test-Path $DestBackupDir)) {
-            New-Item -Type Container -Path $DestBackupDir
-        }
+        # For all the backups that we want to clean up after the test, we create a directory that we can delete at the end.
+        $DestBackupDir = "$($TestConfig.Temp)\$CommandName-$(Get-Random)"
+        $null = New-Item -Type Container -Path $DestBackupDir
 
         # Write all files to the same backup destination if not otherwise specified
         $PSDefaultParameterValues['Backup-DbaDatabase:BackupDirectory'] = $DestBackupDir
 
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
         $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
     }
 
     AfterAll {
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
         $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
 
-        if (Test-Path $DestBackupDir) {
-            Remove-Item -Path $DestBackupDir -Force -Recurse
-        }
+        # Remove the backup directory.
+        Remove-Item -Path $DestBackupDir -Force -Recurse -ErrorAction SilentlyContinue
+
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "Properly backups all databases" {
@@ -86,11 +85,11 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
         }
 
         It "Should return a database name, specifically master" {
-            $results.DatabaseName | Should -Contain 'master'
+            $results.DatabaseName | Should -Contain "master"
         }
 
-        It "Should return successful restore for <_.DatabaseName>" -ForEach $results {
-            $PSItem.BackupComplete | Should -BeTrue
+        It "Should return successful restore for all databases" {
+            $results | ForEach-Object { $PSItem.BackupComplete | Should -BeTrue }
         }
     }
 
@@ -146,7 +145,7 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
 
     Context "Should take path and filename" {
         BeforeAll {
-            $results = Backup-DbaDatabase -SqlInstance $TestConfig.instance1 -Database master -BackupFileName 'PesterTest.bak'
+            $results = Backup-DbaDatabase -SqlInstance $TestConfig.instance1 -Database master -BackupFileName "PesterTest.bak"
         }
 
         It "Should report it has backed up to the path with the correct name" {
@@ -210,7 +209,7 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
 
         It "Should have backed up to $MissingPath" {
             $results.BackupFolder | Should -Be "$MissingPath"
-            $results.Path | Should -Not -BeLike '*\\*'
+            $results.Path | Should -Not -BeLike "*\\*"
         }
     }
 
@@ -232,7 +231,7 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
 
         It "Should have appended master to all backup paths" {
             foreach ($path in $results.BackupFolder) {
-                ($results.BackupFolder | Sort-Object) | Should -Be ($backupPaths | Sort-Object | ForEach-Object { [IO.Path]::Combine($_, 'master') })
+                ($results.BackupFolder | Sort-Object) | Should -Be ($backupPaths | Sort-Object | ForEach-Object { [IO.Path]::Combine($PSItem, "master") })
             }
         }
     }
@@ -248,7 +247,7 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
         }
 
         It "Should have backuped up to $DestBackupDir\PesterTest2.bak" {
-            Test-Path "$DestBackupDir\PesterTest2.bak" | Should -Be $true
+            Test-Path "$DestBackupDir\PesterTest2.bak" | Should -BeTrue
         }
     }
 
@@ -265,13 +264,13 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
 
         It "Should have written to all 3 folders" {
             $backupPaths | ForEach-Object {
-                $_ | Should -BeIn ($results.BackupFolder)
+                $PSItem | Should -BeIn ($results.BackupFolder)
             }
         }
 
         It "Should have written files with extensions" {
             foreach ($path in $results.BackupFile) {
-                [IO.Path]::GetExtension($path) | Should -Be '.bak'
+                [IO.Path]::GetExtension($path) | Should -Be ".bak"
             }
         }
     }
@@ -299,7 +298,7 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
 
         It "Should have 1 period in file extension" {
             foreach ($path in $results.BackupFile) {
-                [IO.Path]::GetExtension($path) | Should -Not -BeLike '*..*'
+                [IO.Path]::GetExtension($path) | Should -Not -BeLike "*..*"
             }
         }
     }
@@ -323,14 +322,14 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
 
     Context "Should Backup to default path if none specified" {
         BeforeAll {
-            $PSDefaultParameterValues.Remove('Backup-DbaDatabase:BackupDirectory')
+            $PSDefaultParameterValues.Remove("Backup-DbaDatabase:BackupDirectory")
             $defaultBackupPath = (Get-DbaDefaultPath -SqlInstance $TestConfig.instance1).Backup
-            $results = Backup-DbaDatabase -SqlInstance $TestConfig.instance1 -Database master -BackupFileName 'PesterTest.bak'
+            $results = Backup-DbaDatabase -SqlInstance $TestConfig.instance1 -Database master -BackupFileName "PesterTest.bak"
         }
 
         AfterAll {
             Get-ChildItem -Path $results.FullName | Remove-Item -ErrorAction SilentlyContinue
-            $PSDefaultParameterValues['Backup-DbaDatabase:BackupDirectory'] = $DestBackupDir
+            $PSDefaultParameterValues["Backup-DbaDatabase:BackupDirectory"] = $DestBackupDir
         }
 
         It "Should report it has backed up to the path with the corrrect name" {
@@ -386,7 +385,7 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
         }
 
         It "Should return successful restore" {
-            $results.RestoreComplete | Should -Be $true
+            $results.RestoreComplete | Should -BeTrue
         }
     }
 
@@ -411,15 +410,15 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
         }
 
         AfterAll {
-            $PSDefaultParameterValues['Backup-DbaDatabase:BackupDirectory'] = $DestBackupDir
+            $PSDefaultParameterValues["Backup-DbaDatabase:BackupDirectory"] = $DestBackupDir
         }
 
         It "Should return succesful backup" {
-            $results.BackupComplete | Should -Be $true
+            $results.BackupComplete | Should -BeTrue
         }
 
         It "Should have backed up to NUL:" {
-            $results.FullName[0] | Should -Be 'NUL:'
+            $results.FullName[0] | Should -Be "NUL:"
         }
     }
 
@@ -429,7 +428,7 @@ Describe "Backup-DbaDatabase" -Tag "IntegrationTests" {
         }
 
         It "Should return a string" {
-            $results.GetType().ToString() | Should -Be 'System.String'
+            $results.GetType().ToString() | Should -Be "System.String"
         }
 
         It "Should return BACKUP DATABASE [master] TO  DISK = N'c:\notexists\file.bak' WITH NOFORMAT, NOINIT, NOSKIP, REWIND, NOUNLOAD,  STATS = 1" {
@@ -447,7 +446,7 @@ go
 CREATE DATABASE encrypted
 go
 "@
-            $null = Invoke-DbaQuery -SqlInstance $TestConfig.instance2 -Query $sqlencrypt -Database Master
+            $null = Invoke-DbaQuery -SqlInstance $TestConfig.instance2 -Query $sqlencrypt -Database master
             $createdb = @"
 CREATE DATABASE ENCRYPTION KEY
 WITH ALGORITHM = AES_128
@@ -466,13 +465,13 @@ GO
 drop certificate MyServerCert
 go
 "@
-            $null = Invoke-DbaQuery -SqlInstance $TestConfig.instance2 -Query $sqldrop -Database Master
+            $null = Invoke-DbaQuery -SqlInstance $TestConfig.instance2 -Query $sqldrop -Database master
         }
 
         It "Should compress an encrypted db" {
             $results = Backup-DbaDatabase -SqlInstance $TestConfig.instance2 -Database encrypted -Compress
             Invoke-Command2 -ComputerName $TestConfig.instance2 -ScriptBlock { Remove-Item -Path $args[0] } -ArgumentList $results.FullName
-            $results.script | Should -BeLike '*D, COMPRESSION,*'
+            $results.script | Should -BeLike "*D, COMPRESSION,*"
         }
     }
 
@@ -483,7 +482,7 @@ go
         }
 
         It "Should apply the corect custom Timestamp" {
-            ($results | Where-Object { $_.BackupPath -like '*bobob*' }).count | Should -Be $results.count
+            ($results | Where-Object { $PSItem.BackupPath -like "*bobob*" }).Count | Should -Be $results.Count
         }
     }
 
@@ -514,16 +513,16 @@ go
     Context "Test Backup Encryption with Certificate" {
         # TODO: Should the master key be created at lab startup like in instance3?
         BeforeAll {
-            $securePass = ConvertTo-SecureString "estBackupDir\master\script:instance1).split('\')[1])\Full\master-Full.bak" -AsPlainText -Force
-            New-DbaDbMasterKey -SqlInstance $TestConfig.instance2 -Database Master -SecurePassword $securePass -ErrorAction SilentlyContinue -WarningAction SilentlyContinue
+            $securePass = ConvertTo-SecureString "MyStrongPassword123!" -AsPlainText -Force
+            New-DbaDbMasterKey -SqlInstance $TestConfig.instance2 -Database master -SecurePassword $securePass -ErrorAction SilentlyContinue -WarningAction SilentlyContinue
             $cert = New-DbaDbCertificate -SqlInstance $TestConfig.instance2 -Database master -Name BackupCertt -Subject BackupCertt
-            $encBackupResults = Backup-DbaDatabase -SqlInstance $TestConfig.instance2 -Database master -EncryptionAlgorithm AES128 -EncryptionCertificate BackupCertt -BackupFileName 'encryptiontest.bak' -Description "Encrypted backup"
+            $encBackupResults = Backup-DbaDatabase -SqlInstance $TestConfig.instance2 -Database master -EncryptionAlgorithm AES128 -EncryptionCertificate BackupCertt -BackupFileName "encryptiontest.bak" -Description "Encrypted backup"
             Invoke-Command2 -ComputerName $TestConfig.instance2 -ScriptBlock { Remove-Item -Path $args[0] } -ArgumentList $encBackupResults.FullName
         }
 
         AfterAll {
             Remove-DbaDbCertificate -SqlInstance $TestConfig.instance2 -Database master -Certificate BackupCertt
-            Remove-DbaDbMasterKey -SqlInstance $TestConfig.instance2 -Database Master -WarningAction SilentlyContinue -ErrorAction SilentlyContinue
+            Remove-DbaDbMasterKey -SqlInstance $TestConfig.instance2 -Database master -WarningAction SilentlyContinue -ErrorAction SilentlyContinue
         }
 
         It "Should encrypt the backup" {
@@ -551,14 +550,14 @@ go
                     $sql = "DROP CREDENTIAL [$TestConfig.azureblob]"
                     $server.Query($sql)
                 }
-                $sql = "CREATE CREDENTIAL [$TestConfig.azureblob] WITH IDENTITY = N'SHARED ACCESS SIGNATURE', SECRET = N'$env:azurepasswd'"
+                $sql = "CREATE CREDENTIAL [$($TestConfig.azureblob)] WITH IDENTITY = N'SHARED ACCESS SIGNATURE', SECRET = N'$($env:azurepasswd)'"
                 $server.Query($sql)
                 $server.Query("CREATE DATABASE dbatoolsci_azure")
                 if (Get-DbaCredential -SqlInstance $TestConfig.instance2 -name dbatools_ci) {
                     $sql = "DROP CREDENTIAL dbatools_ci"
                     $server.Query($sql)
                 }
-                $sql = "CREATE CREDENTIAL [dbatools_ci] WITH IDENTITY = N'$TestConfig.azureblobaccount', SECRET = N'$env:azurelegacypasswd'"
+                $sql = "CREATE CREDENTIAL [dbatools_ci] WITH IDENTITY = N'$($TestConfig.azureblobaccount)', SECRET = N'$($env:azurelegacypasswd)'"
                 $server.Query($sql)
             }
 
@@ -569,16 +568,16 @@ go
 
             It "backs up to Azure properly using SHARED ACCESS SIGNATURE" {
                 $results = Backup-DbaDatabase -SqlInstance $TestConfig.instance2 -AzureBaseUrl $TestConfig.azureblob -Database dbatoolsci_azure -BackupFileName dbatoolsci_azure.bak -WithFormat
-                $results.Database | Should -Be 'dbatoolsci_azure'
-                $results.DeviceType | Should -Be 'URL'
-                $results.BackupFile | Should -Be 'dbatoolsci_azure.bak'
+                $results.Database | Should -Be "dbatoolsci_azure"
+                $results.DeviceType | Should -Be "URL"
+                $results.BackupFile | Should -Be "dbatoolsci_azure.bak"
             }
 
             It "backs up to Azure properly using legacy credential" {
                 $results = Backup-DbaDatabase -SqlInstance $TestConfig.instance2 -AzureBaseUrl $TestConfig.azureblob -Database dbatoolsci_azure -BackupFileName dbatoolsci_azure2.bak -WithFormat -AzureCredential dbatools_ci
-                $results.Database | Should -Be 'dbatoolsci_azure'
-                $results.DeviceType | Should -Be 'URL'
-                $results.BackupFile | Should -Be 'dbatoolsci_azure2.bak'
+                $results.Database | Should -Be "dbatoolsci_azure"
+                $results.DeviceType | Should -Be "URL"
+                $results.BackupFile | Should -Be "dbatoolsci_azure2.bak"
             }
         }
     }
diff --git a/tests/Backup-DbaDbCertificate.Tests.ps1 b/tests/Backup-DbaDbCertificate.Tests.ps1
index d1efb8d1ab98..e95ec29d9136 100644
--- a/tests/Backup-DbaDbCertificate.Tests.ps1
+++ b/tests/Backup-DbaDbCertificate.Tests.ps1
@@ -1,15 +1,16 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
-    $ModuleName = "dbatools",
+    $ModuleName  = "dbatools",
+    $CommandName = "Backup-DbaDbCertificate",
     $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
 )
 
-Describe "Backup-DbaDbCertificate" -Tag "UnitTests" {
+Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Backup-DbaDbCertificate
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "SqlInstance",
                 "SqlCredential",
                 "Certificate",
@@ -21,26 +22,20 @@ Describe "Backup-DbaDbCertificate" -Tag "UnitTests" {
                 "Suffix",
                 "FileBaseName",
                 "InputObject",
-                "EnableException",
-                "Confirm",
-                "WhatIf"
+                "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -ForEach $expected {
-            $command | Should -HaveParameter $PSItem
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
-Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
-        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
 
         $random = Get-Random
         $db1Name = "dbatoolscli_db1_$random"
@@ -53,16 +48,20 @@ Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" {
         $db2 = New-DbaDatabase -SqlInstance $TestConfig.instance1 -Name $db2Name
         $null = New-DbaDbMasterKey -SqlInstance $TestConfig.instance1 -Database $db2Name -Password $pw
 
-        $cert1 = New-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Database $db1Name -Password $pw -Name dbatoolscli_cert1_$random
-        $cert2 = New-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Database $db1Name -Password $pw -Name dbatoolscli_cert2_$random
-        $cert3 = New-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Database $db2Name -Password $pw -Name dbatoolscli_cert3_$random
+        $cert1 = New-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Database $db1Name -Password $pw -Name "dbatoolscli_cert1_$random"
+        $cert2 = New-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Database $db1Name -Password $pw -Name "dbatoolscli_cert2_$random"
+        $cert3 = New-DbaDbCertificate -SqlInstance $TestConfig.instance1 -Database $db2Name -Password $pw -Name "dbatoolscli_cert3_$random"
 
-        $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
     AfterAll {
-        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
+        Remove-DbaDatabase -SqlInstance $TestConfig.instance1 -Database $db1Name, $db2Name -Confirm:$false
 
-        Remove-DbaDatabase -SqlInstance $TestConfig.instance1 -Database $db1Name, $db2Name
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "Can backup a database certificate" {
@@ -78,13 +77,13 @@ Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" {
         }
 
         AfterAll {
-            Remove-Item -Path $results.Path
-            Remove-Item -Path $results.Key
+            Remove-Item -Path $results.Path -ErrorAction SilentlyContinue
+            Remove-Item -Path $results.Key -ErrorAction SilentlyContinue
         }
 
         It "Returns results with proper data" {
             $results.Certificate | Should -Be $cert1.Name
-            $results.Status | Should -Match "Success"
+            $results.Status | Should -BeExactly "Success"
             $results.DatabaseID | Should -Be $db1.ID
         }
     }
@@ -103,13 +102,13 @@ Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" {
         }
 
         AfterAll {
-            Remove-Item -Path $results.Path
-            Remove-Item -Path $results.Key
+            Remove-Item -Path $results.Path -ErrorAction SilentlyContinue
+            Remove-Item -Path $results.Key -ErrorAction SilentlyContinue
         }
 
         It "Returns results with proper data" {
             $results.Certificate | Should -Be $cert1.Name
-            $results.Status | Should -Match "Success"
+            $results.Status | Should -BeExactly "Success"
             $results.DatabaseID | Should -Be $db1.ID
             [IO.Path]::GetFileNameWithoutExtension($results.Path) | Should -Be "dbatoolscli_cert1_$random"
         }
@@ -125,18 +124,18 @@ Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" {
                 Certificate        = @($invalidDBCertName, $invalidDBCertName2, $cert2.Name)
                 EncryptionPassword = $pw
                 DecryptionPassword = $pw
-                WarningAction      = "SilentlyContinue"
+                WarningAction = "SilentlyContinue"
             }
             $results = Backup-DbaDbCertificate @splatBackupInvalidCert
         }
 
         AfterAll {
-            Remove-Item -Path $results.Path
-            Remove-Item -Path $results.Key
+            Remove-Item -Path $results.Path -ErrorAction SilentlyContinue
+            Remove-Item -Path $results.Key -ErrorAction SilentlyContinue
         }
 
         It "Does warn" {
-            $WarnVar | Should -BeLike "*Database certificate(s) * not found*"
+            $WarnVar | Should -Match "Database certificate\(s\) .* not found"
         }
     }
 
@@ -152,8 +151,8 @@ Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" {
         }
 
         AfterAll {
-            Remove-Item -Path $results.Path
-            Remove-Item -Path $results.Key
+            Remove-Item -Path $results.Path -ErrorAction SilentlyContinue
+            Remove-Item -Path $results.Key -ErrorAction SilentlyContinue
         }
 
         It "Returns results with proper data" {
@@ -173,8 +172,8 @@ Describe "Backup-DbaDbCertificate" -Tag "IntegrationTests" {
         }
 
         AfterAll {
-            Remove-Item -Path $results.Path
-            Remove-Item -Path $results.Key
+            Remove-Item -Path $results.Path -ErrorAction SilentlyContinue
+            Remove-Item -Path $results.Key -ErrorAction SilentlyContinue
         }
 
         It "Returns results with proper data" {
diff --git a/tests/Backup-DbaDbMasterKey.Tests.ps1 b/tests/Backup-DbaDbMasterKey.Tests.ps1
index 5ec18ea91d01..6d3a911df160 100644
--- a/tests/Backup-DbaDbMasterKey.Tests.ps1
+++ b/tests/Backup-DbaDbMasterKey.Tests.ps1
@@ -31,54 +31,92 @@ Describe $CommandName -Tag UnitTests {
 }
 
 Describe $CommandName -Tag IntegrationTests {
-    Context "Can backup a database master key" {
-        BeforeAll {
-            $instance = $TestConfig.instance1
-            $database = "tempdb"
-            $password = ConvertTo-SecureString -String "GoodPass1234!" -AsPlainText -Force
+    BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
+        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+
+        # For all the backups that we want to clean up after the test, we create a directory that we can delete at the end.
+        # Other files can be written there as well, maybe we change the name of that variable later. But for now we focus on backups.
+        $backupPath = "$($TestConfig.Temp)\$CommandName-$(Get-Random)"
+        $null = New-Item -Path $backupPath -ItemType Directory
+
+        # Explain what needs to be set up for the test:
+        # To test backing up a database master key, we need a database with a master key created.
+        # We'll create the master key if it doesn't exist, and track files created for cleanup.
+
+        # Set variables. They are available in all the It blocks.
+        $testInstance    = $TestConfig.instance1
+        $testDatabase    = "tempdb"
+        $masterKeyPass   = ConvertTo-SecureString -String "GoodPass1234!" -AsPlainText -Force
+        $filesToRemove   = @()
 
-            if (-not (Get-DbaDbMasterKey -SqlInstance $instance -Database $database)) {
-                $null = New-DbaDbMasterKey -SqlInstance $instance -Database $database -Password $password -Confirm:$false
+        # Create the objects.
+        if (-not (Get-DbaDbMasterKey -SqlInstance $testInstance -Database $testDatabase)) {
+            $splatNewKey = @{
+                SqlInstance = $testInstance
+                Database    = $testDatabase
+                Password    = $masterKeyPass
+                Confirm     = $false
             }
+            $null = New-DbaDbMasterKey @splatNewKey
         }
 
-        AfterAll {
-            Get-DbaDbMasterKey -SqlInstance $instance -Database $database | Remove-DbaDbMasterKey -Confirm:$false
-        }
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
+    }
+
+    AfterAll {
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+
+        # Cleanup all created objects.
+        Get-DbaDbMasterKey -SqlInstance $testInstance -Database $testDatabase | Remove-DbaDbMasterKey -Confirm:$false
 
+        # Remove the backup directory.
+        Remove-Item -Path $backupPath -Recurse -ErrorAction SilentlyContinue
+
+        # Remove any tracked files.
+        Remove-Item -Path $filesToRemove -ErrorAction SilentlyContinue
+
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
+    }
+
+    Context "Can backup a database master key" {
         It "Backs up the database master key" {
             $splatBackup = @{
-                SqlInstance    = $instance
-                Database       = $database
-                SecurePassword = $password
+                SqlInstance    = $testInstance
+                Database       = $testDatabase
+                SecurePassword = $masterKeyPass
+                Path           = $backupPath
                 Confirm        = $false
             }
             $results = Backup-DbaDbMasterKey @splatBackup
             $results | Should -Not -BeNullOrEmpty
-            $results.Database | Should -Be $database
+            $results.Database | Should -Be $testDatabase
             $results.Status | Should -Be "Success"
-            $results.DatabaseID | Should -Be (Get-DbaDatabase -SqlInstance $instance -Database $database).ID
+            $results.DatabaseID | Should -Be (Get-DbaDatabase -SqlInstance $testInstance -Database $testDatabase).ID
 
-            $null = Remove-Item -Path $results.Path -ErrorAction SilentlyContinue -Confirm:$false
+            # File will be cleaned up with the backupPath directory in AfterAll
         }
 
         It "Backs up the database master key with a specific filename (see #9484)" {
             $random = Get-Random
-            $splatBackup = @{
-                SqlInstance    = $instance
-                Database       = $database
-                SecurePassword = $password
+            $splatBackupWithName = @{
+                SqlInstance    = $testInstance
+                Database       = $testDatabase
+                SecurePassword = $masterKeyPass
+                Path           = $backupPath
                 FileBaseName   = "dbatoolscli_dbmasterkey_$random"
                 Confirm        = $false
             }
-            $results = Backup-DbaDbMasterKey @splatBackup
+            $results = Backup-DbaDbMasterKey @splatBackupWithName
             $results | Should -Not -BeNullOrEmpty
-            $results.Database | Should -Be $database
+            $results.Database | Should -Be $testDatabase
             $results.Status | Should -Be "Success"
-            $results.DatabaseID | Should -Be (Get-DbaDatabase -SqlInstance $instance -Database $database).ID
+            $results.DatabaseID | Should -Be (Get-DbaDatabase -SqlInstance $testInstance -Database $testDatabase).ID
             [IO.Path]::GetFileNameWithoutExtension($results.Path) | Should -Be "dbatoolscli_dbmasterkey_$random"
-            $null = Remove-Item -Path $results.Path -ErrorAction SilentlyContinue -Confirm:$false
-        }
 
+            # File will be cleaned up with the backupPath directory in AfterAll
+        }
     }
 }
diff --git a/tests/Backup-DbaServiceMasterKey.Tests.ps1 b/tests/Backup-DbaServiceMasterKey.Tests.ps1
index a7b2fced4d2d..ff7a0dd6d7c2 100644
--- a/tests/Backup-DbaServiceMasterKey.Tests.ps1
+++ b/tests/Backup-DbaServiceMasterKey.Tests.ps1
@@ -28,23 +28,69 @@ Describe $CommandName -Tag UnitTests {
 }
 
 Describe $CommandName -Tag IntegrationTests {
+    BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
+        # For all the backups that we want to clean up after the test, we create a directory that we can delete at the end.
+        # Other files can be written there as well, maybe we change the name of that variable later. But for now we focus on backups.
+        $backupPath = "$($TestConfig.Temp)\$CommandName-$(Get-Random)"
+        $null = New-Item -Path $backupPath -ItemType Directory
+
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+    }
+
+    AfterAll {
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
+        # Remove the backup directory.
+        Remove-Item -Path $backupPath -Recurse -ErrorAction SilentlyContinue
+
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
+    }
+
     Context "Can backup a service master key" {
         BeforeAll {
             $securePassword = ConvertTo-SecureString -String "GoodPass1234!" -AsPlainText -Force
         }
 
+        AfterAll {
+            # Clean up any remaining files that weren't in the backup directory
+            if ($smkBackupPath) {
+                Remove-Item -Path $smkBackupPath -ErrorAction SilentlyContinue
+            }
+            if ($fileBackupPath) {
+                Remove-Item -Path $fileBackupPath -ErrorAction SilentlyContinue
+            }
+        }
+
         It "backs up the SMK" {
-            $backupResults = Backup-DbaServiceMasterKey -SqlInstance $TestConfig.instance1 -SecurePassword $securePassword -Confirm:$false
+            $splatBackup = @{
+                SqlInstance    = $TestConfig.instance1
+                SecurePassword = $securePassword
+                Path           = $backupPath
+                Confirm        = $false
+            }
+            $backupResults = Backup-DbaServiceMasterKey @splatBackup
             $backupResults.Status | Should -Be "Success"
-            $null = Remove-Item -Path $backupResults.Path -ErrorAction SilentlyContinue -Confirm:$false
+            $smkBackupPath = $backupResults.Path
         }
 
         It "backs up the SMK with a specific filename (see #9483)" {
             $randomNum = Get-Random
-            $fileBackupResults = Backup-DbaServiceMasterKey -SqlInstance $TestConfig.instance1 -SecurePassword $securePassword -FileBaseName "smk($randomNum)" -Confirm:$false
+            $splatFileBackup = @{
+                SqlInstance    = $TestConfig.instance1
+                SecurePassword = $securePassword
+                Path           = $backupPath
+                FileBaseName   = "smk($randomNum)"
+                Confirm        = $false
+            }
+            $fileBackupResults = Backup-DbaServiceMasterKey @splatFileBackup
             [IO.Path]::GetFileNameWithoutExtension($fileBackupResults.Path) | Should -Be "smk($randomNum)"
             $fileBackupResults.Status | Should -Be "Success"
-            $null = Remove-Item -Path $fileBackupResults.Path -ErrorAction SilentlyContinue -Confirm:$false
+            $fileBackupPath = $fileBackupResults.Path
         }
     }
 }
diff --git a/tests/Clear-DbaLatchStatistics.Tests.ps1 b/tests/Clear-DbaLatchStatistics.Tests.ps1
index d5e20b76342f..b0e99bfe07cc 100644
--- a/tests/Clear-DbaLatchStatistics.Tests.ps1
+++ b/tests/Clear-DbaLatchStatistics.Tests.ps1
@@ -2,7 +2,7 @@
 param(
     $ModuleName  = "dbatools",
     $CommandName = "Clear-DbaLatchStatistics",
-    $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
+    $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
 Describe $CommandName -Tag UnitTests {
diff --git a/tests/Clear-DbaPlanCache.Tests.ps1 b/tests/Clear-DbaPlanCache.Tests.ps1
index b18d54e38fe3..89f63c93789a 100644
--- a/tests/Clear-DbaPlanCache.Tests.ps1
+++ b/tests/Clear-DbaPlanCache.Tests.ps1
@@ -2,7 +2,7 @@
 param(
     $ModuleName  = "dbatools",
     $CommandName = "Clear-DbaPlanCache",
-    $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
+    $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
 Describe $CommandName -Tag UnitTests {
diff --git a/tests/Connect-DbaInstance.Tests.ps1 b/tests/Connect-DbaInstance.Tests.ps1
index d36561c75385..3cd4ba0bc265 100644
--- a/tests/Connect-DbaInstance.Tests.ps1
+++ b/tests/Connect-DbaInstance.Tests.ps1
@@ -1,16 +1,59 @@
-$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "")
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
+param(
+    $ModuleName  = "dbatools",
+    $CommandName = "Connect-DbaInstance",
+    $PSDefaultParameterValues = $TestConfig.Defaults
+)
+
 Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan
 $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', 'ApplicationIntent', 'AzureUnsupported', 'BatchSeparator', 'ClientName', 'ConnectTimeout', 'EncryptConnection', 'FailoverPartner', 'LockTimeout', 'MaxPoolSize', 'MinPoolSize', 'MinimumVersion', 'MultipleActiveResultSets', 'MultiSubnetFailover', 'NetworkProtocol', 'NonPooledConnection', 'PacketSize', 'PooledConnectionLifetime', 'SqlExecutionModes', 'StatementTimeout', 'TrustServerCertificate', 'WorkstationId', 'AlwaysEncrypted', 'AppendConnectionString', 'SqlConnectionOnly', 'AzureDomain', 'Tenant', 'AccessToken', 'DedicatedAdminConnection', 'DisableException'
-        $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 -Tag UnitTests {
+    Context "Parameter validation" {
+        BeforeAll {
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
+                "SqlInstance",
+                "SqlCredential",
+                "Database",
+                "ApplicationIntent",
+                "AzureUnsupported",
+                "BatchSeparator",
+                "ClientName",
+                "ConnectTimeout",
+                "EncryptConnection",
+                "FailoverPartner",
+                "LockTimeout",
+                "MaxPoolSize",
+                "MinPoolSize",
+                "MinimumVersion",
+                "MultipleActiveResultSets",
+                "MultiSubnetFailover",
+                "NetworkProtocol",
+                "NonPooledConnection",
+                "PacketSize",
+                "PooledConnectionLifetime",
+                "SqlExecutionModes",
+                "StatementTimeout",
+                "TrustServerCertificate",
+                "WorkstationId",
+                "AlwaysEncrypted",
+                "AppendConnectionString",
+                "SqlConnectionOnly",
+                "AzureDomain",
+                "Tenant",
+                "AccessToken",
+                "DedicatedAdminConnection",
+                "DisableException"
+            )
+        }
+
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
+
     Context "Validate alias" {
         It "Should contain the alias: cdi" {
             (Get-Alias cdi) | Should -Not -BeNullOrEmpty
@@ -18,7 +61,7 @@ Describe "$CommandName Unit Tests" -Tag 'UnitTests' {
     }
 }
 
-Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     AfterAll {
         Get-DbaConnectedInstance | Disconnect-DbaInstance
         Clear-DbaConnectionPool
@@ -26,55 +69,58 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
 
     if ($env:azuredbpasswd -eq "failstoooften") {
         Context "Connect to Azure" {
-            $securePassword = ConvertTo-SecureString $env:azuredbpasswd -AsPlainText -Force
-            $cred = New-Object System.Management.Automation.PSCredential ($TestConfig.azuresqldblogin, $securePassword)
+            BeforeAll {
+                $securePassword = ConvertTo-SecureString $env:azuredbpasswd -AsPlainText -Force
+                $cred = New-Object System.Management.Automation.PSCredential ($TestConfig.azuresqldblogin, $securePassword)
+            }
 
             It "Should login to Azure" {
                 $s = Connect-DbaInstance -SqlInstance psdbatools.database.windows.net -SqlCredential $cred -Database test
-                $s.Name | Should -match 'psdbatools.database.windows.net'
-                $s.DatabaseEngineType | Should -Be 'SqlAzureDatabase'
+                $s.Name | Should -match "psdbatools.database.windows.net"
+                $s.DatabaseEngineType | Should -Be "SqlAzureDatabase"
             }
 
             It "Should keep the same database context" {
                 $s = Connect-DbaInstance -SqlInstance psdbatools.database.windows.net -SqlCredential $cred -Database test
                 $results = Invoke-DbaQuery -SqlInstance $s -Query "select db_name() as dbname"
-                $results.dbname | Should -Be 'test'
+                $results.dbname | Should -Be "test"
             }
 
             It "Should keep the same database context again" {
                 $s = Connect-DbaInstance -SqlInstance psdbatools.database.windows.net -SqlCredential $cred -Database test
                 $results = Invoke-DbaQuery -SqlInstance $s -Query "select db_name() as dbname"
-                $results.dbname | Should -Be 'test'
+                $results.dbname | Should -Be "test"
                 $results = Invoke-DbaQuery -SqlInstance $s -Query "select db_name() as dbname"
-                $results.dbname | Should -Be 'test'
+                $results.dbname | Should -Be "test"
             }
 
             It "Should keep the same database context" {
                 $s = Connect-DbaInstance -SqlInstance psdbatools.database.windows.net -SqlCredential $cred -Database test
                 $server = Connect-DbaInstance -SqlInstance $s
-                $server.Query("select db_name() as dbname").dbname | Should -Be 'test'
+                $server.Query("select db_name() as dbname").dbname | Should -Be "test"
             }
         }
     }
 
     Context "connection is properly made using a string" {
         BeforeAll {
-            $params = @{
-                'BatchSeparator'           = 'GO'
-                'ConnectTimeout'           = 1
-                'Database'                 = 'tempdb'
-                'LockTimeout'              = 1
-                'MaxPoolSize'              = 20
-                'MinPoolSize'              = 1
-                'NetworkProtocol'          = 'TcpIp'
-                'PacketSize'               = 4096
-                'PooledConnectionLifetime' = 600
-                'WorkstationId'            = 'MadeUpServer'
-                'SqlExecutionModes'        = 'ExecuteSql'
-                'StatementTimeout'         = 0
-                'ApplicationIntent'        = 'ReadOnly'
+            $splatConnection = @{
+                BatchSeparator           = "GO"
+                ConnectTimeout           = 1
+                Database                 = "tempdb"
+                LockTimeout              = 1
+                MaxPoolSize              = 20
+                MinPoolSize              = 1
+                NetworkProtocol          = "TcpIp"
+                PacketSize               = 4096
+                PooledConnectionLifetime = 600
+                WorkstationId            = "MadeUpServer"
+                SqlExecutionModes        = "ExecuteSql"
+                StatementTimeout         = 0
+                ApplicationIntent        = "ReadOnly"
             }
-            $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1 @params
+            $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1 @splatConnection
+            $params = $splatConnection
         }
 
         It "returns the proper name" {
@@ -83,8 +129,8 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
 
         It "sets connectioncontext parameters that are provided" {
             foreach ($param in $params.GetEnumerator()) {
-                if ($param.Key -eq 'Database') {
-                    $propName = 'DatabaseName'
+                if ($param.Key -eq "Database") {
+                    $propName = "DatabaseName"
                 } else {
                     $propName = $param.Key
                 }
@@ -101,8 +147,8 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
         }
 
         It "keeps the same database context" {
-            $null = $server.Databases['msdb'].Tables.Count
-            $server.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be 'tempdb'
+            $null = $server.Databases["msdb"].Tables.Count
+            $server.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be "tempdb"
         }
 
         It "sets StatementTimeout to 0" {
@@ -125,12 +171,12 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
 
         It "keeps the same database context" {
             # Before #8962 this changed the context to msdb
-            $null = $server.Databases['msdb'].Tables.Count
-            $server.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be 'tempdb'
+            $null = $server.Databases["msdb"].Tables.Count
+            $server.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be "tempdb"
         }
     }
 
-    if ($TestConfig.instance1 -match 'localhost') {
+    if ($TestConfig.instance1 -match "localhost") {
         Context "connection is properly made using a dot" {
             BeforeAll {
                 $newinstance = $TestConfig.instance1.Replace("localhost", ".")
@@ -146,7 +192,7 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
             }
 
             It "keeps the same database context" {
-                $null = $server.Databases['msdb'].Tables.Count
+                $null = $server.Databases["msdb"].Tables.Count
                 # This currently fails!
                 #$server.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be 'tempdb'
             }
@@ -155,7 +201,7 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
 
     Context "connection is properly made using a connection object" {
         BeforeAll {
-            Set-DbatoolsConfig -FullName commands.connect-dbainstance.smo.computername.source -Value 'instance.ComputerName'
+            Set-DbatoolsConfig -FullName commands.connect-dbainstance.smo.computername.source -Value "instance.ComputerName"
             [Microsoft.Data.SqlClient.SqlConnection]$sqlconnection = "Data Source=$($TestConfig.instance1);Initial Catalog=tempdb;Integrated Security=True;Encrypt=False;Trust Server Certificate=True"
             $server = Connect-DbaInstance -SqlInstance $sqlconnection
             Set-DbatoolsConfig -FullName commands.connect-dbainstance.smo.computername.source -Value $null
@@ -170,7 +216,7 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
         }
 
         It "keeps the same database context" {
-            $null = $server.Databases['msdb'].Tables.Count
+            $null = $server.Databases["msdb"].Tables.Count
             # This currently fails!
             #$server.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be 'tempdb'
         }
@@ -187,14 +233,14 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
 
         It "clones when using parameter Database" {
             $serverClone = Connect-DbaInstance -SqlInstance $server -Database tempdb
-            $server.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be 'master'
-            $serverClone.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be 'tempdb'
+            $server.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be "master"
+            $serverClone.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be "tempdb"
         }
 
         It "clones when using parameter ApplicationIntent" {
             $serverClone = Connect-DbaInstance -SqlInstance $server -ApplicationIntent ReadOnly
             $server.ConnectionContext.ApplicationIntent | Should -BeNullOrEmpty
-            $serverClone.ConnectionContext.ApplicationIntent | Should -Be 'ReadOnly'
+            $serverClone.ConnectionContext.ApplicationIntent | Should -Be "ReadOnly"
         }
 
         It "clones when using parameter NonPooledConnection" {
@@ -205,14 +251,14 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
 
         It "clones when using parameter StatementTimeout" {
             $serverClone = Connect-DbaInstance -SqlInstance $server -StatementTimeout 123
-            $server.ConnectionContext.StatementTimeout | Should -Be (Get-DbatoolsConfigValue -FullName 'sql.execution.timeout')
+            $server.ConnectionContext.StatementTimeout | Should -Be (Get-DbatoolsConfigValue -FullName "sql.execution.timeout")
             $serverClone.ConnectionContext.StatementTimeout | Should -Be 123
         }
 
         It "clones when using parameter DedicatedAdminConnection" {
             $serverClone = Connect-DbaInstance -SqlInstance $server -DedicatedAdminConnection
-            $server.ConnectionContext.ServerInstance | Should -Not -Match '^ADMIN:'
-            $serverClone.ConnectionContext.ServerInstance | Should -Match '^ADMIN:'
+            $server.ConnectionContext.ServerInstance | Should -Not -Match "^ADMIN:"
+            $serverClone.ConnectionContext.ServerInstance | Should -Match "^ADMIN:"
             $serverClone | Disconnect-DbaInstance
         }
 
@@ -228,7 +274,7 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
 
     Context "multiple connections are properly made using strings" {
         It "returns the proper names" {
-            $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1, $TestConfig.instance2
+            $server = @(Connect-DbaInstance -SqlInstance $TestConfig.instance1, $TestConfig.instance2)
             $server[0].Name | Should -Be $TestConfig.instance1
             $server[1].Name | Should -Be $TestConfig.instance2
         }
@@ -248,4 +294,4 @@ Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
             $null = $server | Disconnect-DbaInstance
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Convert-DbaLsn.Tests.ps1 b/tests/Convert-DbaLsn.Tests.ps1
index 50e8fd020cce..2dd7cec55314 100644
--- a/tests/Convert-DbaLsn.Tests.ps1
+++ b/tests/Convert-DbaLsn.Tests.ps1
@@ -55,8 +55,8 @@ Describe $CommandName -Tag UnitTests {
     }
 }
 
-<#
-    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 guidance.
-#>
+#
+#    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 guidance.
+#
\ No newline at end of file
diff --git a/tests/ConvertTo-DbaDataTable.Tests.ps1 b/tests/ConvertTo-DbaDataTable.Tests.ps1
index 0f2a336c2338..7731f9a6547d 100644
--- a/tests/ConvertTo-DbaDataTable.Tests.ps1
+++ b/tests/ConvertTo-DbaDataTable.Tests.ps1
@@ -29,7 +29,7 @@ Describe $CommandName -Tag UnitTests {
     }
 }
 
-Describe "Testing data table output when using a complex object" {
+Describe $CommandName -Tag UnitTests, "DataTableOutput" {
     BeforeAll {
         $obj = New-Object -TypeName psobject -Property @{
             guid             = [system.guid]"32ccd4c4-282a-4c0d-997c-7b5deb97f9e0"
@@ -205,7 +205,7 @@ Describe "Testing data table output when using a complex object" {
     }
 }
 
-Describe "Testing input parameters" {
+Describe $CommandName -Tag UnitTests, "InputParameters" {
     BeforeAll {
         $obj = New-Object -TypeName psobject -Property @{
             timespan = New-TimeSpan -Start 2017-01-01 -End 2017-01-02
diff --git a/tests/ConvertTo-DbaTimeline.Tests.ps1 b/tests/ConvertTo-DbaTimeline.Tests.ps1
index 2a8a637bfab4..8bad46bf3b59 100644
--- a/tests/ConvertTo-DbaTimeline.Tests.ps1
+++ b/tests/ConvertTo-DbaTimeline.Tests.ps1
@@ -2,7 +2,7 @@
 param(
     $ModuleName  = "dbatools",
     $CommandName = "ConvertTo-DbaTimeline",
-    $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
+    $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
 Describe $CommandName -Tag UnitTests {
diff --git a/tests/ConvertTo-DbaXESession.Tests.ps1 b/tests/ConvertTo-DbaXESession.Tests.ps1
index 586ce0926e60..e658dd03f4bb 100644
--- a/tests/ConvertTo-DbaXESession.Tests.ps1
+++ b/tests/ConvertTo-DbaXESession.Tests.ps1
@@ -1,8 +1,8 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
     $ModuleName  = "dbatools",
     $CommandName = "ConvertTo-DbaXESession",
-    $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
+    $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
 Describe $CommandName -Tag UnitTests {
@@ -26,6 +26,9 @@ Describe $CommandName -Tag UnitTests {
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
         $sql = @"
 -- Create a Queue
 declare @rc int
@@ -111,9 +114,15 @@ select TraceID=@TraceID
         $server = Connect-DbaInstance @splatConnect
         $traceid = ($server.Query($sql)).TraceID
         $sessionName = "dbatoolsci-session"
+
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
 
     AfterAll {
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
         $splatRemoveSession = @{
             SqlInstance = $TestConfig.instance2
             Session     = $sessionName
@@ -125,6 +134,8 @@ select TraceID=@TraceID
         }
         $null = Remove-DbaTrace @splatRemoveTrace
         Remove-Item C:\windows\temp\temptrace.trc -ErrorAction SilentlyContinue
+
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "Test Trace Conversion" {
diff --git a/tests/Copy-DbaAgentAlert.Tests.ps1 b/tests/Copy-DbaAgentAlert.Tests.ps1
index 67623ec9aea9..c04affbaf57c 100644
--- a/tests/Copy-DbaAgentAlert.Tests.ps1
+++ b/tests/Copy-DbaAgentAlert.Tests.ps1
@@ -1,16 +1,16 @@
-#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0"}
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
 param(
     $ModuleName  = "dbatools",
     $CommandName = "Copy-DbaAgentAlert",
-    $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
+    $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
 Describe $CommandName -Tag UnitTests {
     Context "Parameter validation" {
         BeforeAll {
-            $command = Get-Command Copy-DbaAgentAlert
-            $expected = $TestConfig.CommonParameters
-            $expected += @(
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
                 "Source",
                 "SourceSqlCredential",
                 "Destination",
@@ -19,30 +19,28 @@ Describe $CommandName -Tag UnitTests {
                 "ExcludeAlert",
                 "IncludeDefaults",
                 "Force",
-                "EnableException",
-                "Confirm",
-                "WhatIf"
+                "EnableException"
             )
         }
 
-        It "Has parameter: <_>" -TestCases ($expected | ForEach-Object { @{ Parameter = $PSItem } }) {
-            param($Parameter)
-            $command | Should -HaveParameter $Parameter
-        }
-
-        It "Should have exactly the number of expected parameters ($($expected.Count))" {
-            $hasparms = $command.Parameters.Values.Name
-            Compare-Object -ReferenceObject $expected -DifferenceObject $hasparms | Should -BeNullOrEmpty
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
-        $alert1 = "dbatoolsci test alert"
-        $alert2 = "dbatoolsci test alert 2"
-        $operatorName = "Dan the man Levitan"
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
+        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+
+        # Set variables for test alerts and operator
+        $alert1        = "dbatoolsci test alert"
+        $alert2        = "dbatoolsci test alert 2"
+        $operatorName  = "Dan the man Levitan"
         $operatorEmail = "levitan@dbatools.io"
+
+        # Connect to instance and create test objects
         $serverInstance2 = Connect-DbaInstance -SqlInstance $TestConfig.instance2 -Database master
 
         $serverInstance2.Query("EXEC msdb.dbo.sp_add_alert @name=N'$($alert1)',
@@ -66,12 +64,20 @@ Describe $CommandName -Tag IntegrationTests {
         @name = N'$operatorName',
         @enabled = 1,
         @email_address = N'$operatorEmail' ;")
+        
         $serverInstance2.Query("EXEC msdb.dbo.sp_add_notification   @alert_name = N'$($alert2)',
         @operator_name = N'$operatorName',
         @notification_method = 1 ;")
+
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
     }
 
     AfterAll {
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+
+        # Clean up test objects
         $serverCleanup2 = Connect-DbaInstance -SqlInstance $TestConfig.instance2 -Database master
         $serverCleanup2.Query("EXEC msdb.dbo.sp_delete_alert @name=N'$($alert1)'")
         $serverCleanup2.Query("EXEC msdb.dbo.sp_delete_alert @name=N'$($alert2)'")
@@ -79,6 +85,8 @@ Describe $CommandName -Tag IntegrationTests {
 
         $serverCleanup3 = Connect-DbaInstance -SqlInstance $TestConfig.instance3 -Database master
         $serverCleanup3.Query("EXEC msdb.dbo.sp_delete_alert @name=N'$($alert1)'")
+        
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "When copying alerts" {
@@ -102,7 +110,7 @@ Describe $CommandName -Tag IntegrationTests {
                 WarningAction = "SilentlyContinue"
             }
             $results = Copy-DbaAgentAlert @splatCopySkip
-            $results.Status | Should -Be Skipped
+            $results.Status | Should -Be "Skipped"
             $results.Type | Should -Be "Agent Alert"
         }
 
@@ -122,4 +130,4 @@ Describe $CommandName -Tag IntegrationTests {
             $results.Name | Should -Contain "dbatoolsci test alert"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Copy-DbaAgentJob.Tests.ps1 b/tests/Copy-DbaAgentJob.Tests.ps1
index bcbda029bb26..d30dc27871e1 100644
--- a/tests/Copy-DbaAgentJob.Tests.ps1
+++ b/tests/Copy-DbaAgentJob.Tests.ps1
@@ -7,14 +7,43 @@ param(
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
-        $null = New-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job dbatoolsci_copyjob
-        $null = New-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job dbatoolsci_copyjob_disabled
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
+        # For all the backups that we want to clean up after the test, we create a directory that we can delete at the end.
+        # Other files can be written there as well, maybe we change the name of that variable later. But for now we focus on backups.
+        $backupPath = "$($TestConfig.Temp)\$CommandName-$(Get-Random)"
+        $null = New-Item -Path $backupPath -ItemType Directory
+
+        # Explain what needs to be set up for the test:
+        # To test copying agent jobs, we need to create test jobs on the source instance that can be copied to the destination
+
+        # Set variables. They are available in all the It blocks.
+        $sourceJobName         = "dbatoolsci_copyjob"
+        $sourceJobDisabledName = "dbatoolsci_copyjob_disabled"
+
+        # Create the objects.
+        $null = New-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job $sourceJobName
+        $null = New-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job $sourceJobDisabledName
         $sourcejobs = Get-DbaAgentJob -SqlInstance $TestConfig.instance2
         $destjobs = Get-DbaAgentJob -SqlInstance $TestConfig.instance3
+
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
+
     AfterAll {
-        $null = Remove-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job dbatoolsci_copyjob, dbatoolsci_copyjob_disabled -Confirm:$false
-        $null = Remove-DbaAgentJob -SqlInstance $TestConfig.instance3 -Job dbatoolsci_copyjob, dbatoolsci_copyjob_disabled -Confirm:$false
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
+        # Cleanup all created objects.
+        $null = Remove-DbaAgentJob -SqlInstance $TestConfig.instance2 -Job dbatoolsci_copyjob, dbatoolsci_copyjob_disabled -Confirm:$false -ErrorAction SilentlyContinue
+        $null = Remove-DbaAgentJob -SqlInstance $TestConfig.instance3 -Job dbatoolsci_copyjob, dbatoolsci_copyjob_disabled -Confirm:$false -ErrorAction SilentlyContinue
+
+        # Remove the backup directory.
+        Remove-Item -Path $backupPath -Recurse -ErrorAction SilentlyContinue
+
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "Parameter validation" {
@@ -73,4 +102,4 @@ Describe $CommandName -Tag IntegrationTests {
             (Get-DbaAgentJob -SqlInstance $TestConfig.instance3 -Job dbatoolsci_copyjob_disabled).Enabled | Should -BeFalse
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Copy-DbaAgentJobCategory.Tests.ps1 b/tests/Copy-DbaAgentJobCategory.Tests.ps1
index 6065e7f2c579..1ef05701d465 100644
--- a/tests/Copy-DbaAgentJobCategory.Tests.ps1
+++ b/tests/Copy-DbaAgentJobCategory.Tests.ps1
@@ -2,16 +2,30 @@
 param(
     $ModuleName  = "dbatools",
     $CommandName = "Copy-DbaAgentJobCategory",
-    $PSDefaultParameterValues = ($TestConfig = Get-TestConfig).Defaults
+    $PSDefaultParameterValues = $TestConfig.Defaults
 )
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
+        # Set up test category for the integration tests
         $null = New-DbaAgentJobCategory -SqlInstance $TestConfig.instance2 -Category "dbatoolsci test category"
+
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
+
     AfterAll {
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
+        # Cleanup all created categories
         $null = Remove-DbaAgentJobCategory -SqlInstance $TestConfig.instance2 -Category "dbatoolsci test category" -Confirm:$false
         $null = Remove-DbaAgentJobCategory -SqlInstance $TestConfig.instance3 -Category "dbatoolsci test category" -Confirm:$false
+
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "Parameter validation" {
diff --git a/tests/Copy-DbaAgentOperator.Tests.ps1 b/tests/Copy-DbaAgentOperator.Tests.ps1
index 1c42f3d2f21e..a727d9ca19b6 100644
--- a/tests/Copy-DbaAgentOperator.Tests.ps1
+++ b/tests/Copy-DbaAgentOperator.Tests.ps1
@@ -30,27 +30,42 @@ Describe $CommandName -Tag UnitTests {
 
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
+        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
         $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
+        # Set variables. They are available in all the It blocks.
+        $operatorName1 = "dbatoolsci_operator"
+        $operatorName2 = "dbatoolsci_operator2"
+
+        # Create the operators on the source server.
         $sourceServer = Connect-DbaInstance -SqlInstance $TestConfig.instance2
-        $sqlAddOperator1 = "EXEC msdb.dbo.sp_add_operator @name=N'dbatoolsci_operator', @enabled=1, @pager_days=0"
-        $sourceServer.Query($sqlAddOperator1)
-        $sqlAddOperator2 = "EXEC msdb.dbo.sp_add_operator @name=N'dbatoolsci_operator2', @enabled=1, @pager_days=0"
-        $sourceServer.Query($sqlAddOperator2)
+        $sqlAddOperator1 = "EXEC msdb.dbo.sp_add_operator @name=N'$operatorName1', @enabled=1, @pager_days=0"
+        $null = $sourceServer.Query($sqlAddOperator1)
+        $sqlAddOperator2 = "EXEC msdb.dbo.sp_add_operator @name=N'$operatorName2', @enabled=1, @pager_days=0"
+        $null = $sourceServer.Query($sqlAddOperator2)
+
+        # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
+        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
     }
 
     AfterAll {
-        $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
-        $sourceCleanupServer = Connect-DbaInstance -SqlInstance $TestConfig.instance2
-        $sqlDeleteOp1Source = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator'"
-        $sourceCleanupServer.Query($sqlDeleteOp1Source)
-        $sqlDeleteOp2Source = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator2'"
-        $sourceCleanupServer.Query($sqlDeleteOp2Source)
+        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
+        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+
+        # Cleanup all created objects.
+        $sourceCleanupServer = Connect-DbaInstance -SqlInstance $TestConfig.instance2 -ErrorAction SilentlyContinue
+        $sqlDeleteOp1Source = "EXEC msdb.dbo.sp_delete_operator @name=N'$operatorName1'"
+        $null = $sourceCleanupServer.Query($sqlDeleteOp1Source)
+        $sqlDeleteOp2Source = "EXEC msdb.dbo.sp_delete_operator @name=N'$operatorName2'"
+        $null = $sourceCleanupServer.Query($sqlDeleteOp2Source)
+
+        $destCleanupServer = Connect-DbaInstance -SqlInstance $TestConfig.instance3 -ErrorAction SilentlyContinue
+        $sqlDeleteOp1Dest = "EXEC msdb.dbo.sp_delete_operator @name=N'$operatorName1'"
+        $null = $destCleanupServer.Query($sqlDeleteOp1Dest)
+        $sqlDeleteOp2Dest = "EXEC msdb.dbo.sp_delete_operator @name=N'$operatorName2'"
+        $null = $destCleanupServer.Query($sqlDeleteOp2Dest)
 
-        $destCleanupServer = Connect-DbaInstance -SqlInstance $TestConfig.instance3
-        $sqlDeleteOp1Dest = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator'"
-        $destCleanupServer.Query($sqlDeleteOp1Dest)
-        $sqlDeleteOp2Dest = "EXEC msdb.dbo.sp_delete_operator @name=N'dbatoolsci_operator2'"
-        $destCleanupServer.Query($sqlDeleteOp2Dest)
+        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
     Context "When copying operators" {
@@ -58,20 +73,21 @@ Describe $CommandName -Tag IntegrationTests {
             $splatCopyOperators = @{
                 Source      = $TestConfig.instance2
                 Destination = $TestConfig.instance3
-                Operator    = "dbatoolsci_operator", "dbatoolsci_operator2"
+                Operator    = @($operatorName1, $operatorName2)
             }
             $results = Copy-DbaAgentOperator @splatCopyOperators
             $results.Status.Count | Should -Be 2
-            $results.Status | Should -Be "Successful", "Successful"
+            $results.Status | Should -Be @("Successful", "Successful")
         }
 
         It "Returns one result that's skipped when copying an existing operator" {
             $splatCopyExisting = @{
                 Source      = $TestConfig.instance2
                 Destination = $TestConfig.instance3
-                Operator    = "dbatoolsci_operator"
+                Operator    = $operatorName1
             }
-            (Copy-DbaAgentOperator @splatCopyExisting).Status | Should -Be "Skipped"
+            $copyResult = Copy-DbaAgentOperator @splatCopyExisting
+            $copyResult.Status | Should -Be "Skipped"
         }
     }
 }
diff --git a/tests/Find-DbaUserObject.Tests.ps1 b/tests/Find-DbaUserObject.Tests.ps1
index 81c8741f000c..6e0488af80e9 100644
--- a/tests/Find-DbaUserObject.Tests.ps1
+++ b/tests/Find-DbaUserObject.Tests.ps1
@@ -1,39 +1,63 @@
-$CommandName = $MyInvocation.MyCommand.Name.Replace(".Tests.ps1", "")
+#Requires -Module @{ ModuleName="Pester"; ModuleVersion="5.0" }
+param(
+    $ModuleName  = "dbatools",
+    $CommandName = "Find-DbaUserObject",
+    $PSDefaultParameterValues = $TestConfig.Defaults
+)
+
 Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan
 $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', 'Pattern', '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 -Tag UnitTests {
+    Context "Parameter validation" {
+        BeforeAll {
+            $hasParameters = (Get-Command $CommandName).Parameters.Values.Name | Where-Object { $PSItem -notin ("WhatIf", "Confirm") }
+            $expectedParameters = $TestConfig.CommonParameters
+            $expectedParameters += @(
+                "SqlInstance",
+                "SqlCredential",
+                "Pattern",
+                "EnableException"
+            )
+        }
+
+        It "Should have the expected parameters" {
+            Compare-Object -ReferenceObject $expectedParameters -DifferenceObject $hasParameters | Should -BeNullOrEmpty
         }
     }
 }
 
-Describe "$commandname Integration Tests" -Tags "IntegrationTests" {
+Describe $CommandName -Tag IntegrationTests {
     Context "Command finds User Objects for SA" {
         BeforeAll {
-            $null = New-DbaDatabase -SqlInstance $TestConfig.instance2 -Name 'dbatoolsci_userObject' -Owner 'sa'
+            $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+            $null = New-DbaDatabase -SqlInstance $TestConfig.instance2 -Name "dbatoolsci_userObject" -Owner "sa"
+            $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
+            
+            $results = Find-DbaUserObject -SqlInstance $TestConfig.instance2 -Pattern "sa"
         }
+        
         AfterAll {
-            $null = Remove-DbaDatabase -SqlInstance $TestConfig.instance2 -Database 'dbatoolsci_userObject' -Confirm:$false
+            $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+            $null = Remove-DbaDatabase -SqlInstance $TestConfig.instance2 -Database "dbatoolsci_userObject" -Confirm:$false
         }
 
-        $results = Find-DbaUserObject -SqlInstance $TestConfig.instance2 -Pattern sa
         It "Should find a specific Database Owned by sa" {
-            $results.Where( {$_.name -eq 'dbatoolsci_userobject'}).Type | Should Be "Database"
+            $results.Where( {$PSItem.name -eq "dbatoolsci_userobject"}).Type | Should -Be "Database"
         }
+        
         It "Should find more than 10 objects Owned by sa" {
-            $results.Count | Should BeGreaterThan 10
+            $results.Count | Should -BeGreaterThan 10
         }
     }
+    
     Context "Command finds User Objects" {
-        $results = Find-DbaUserObject -SqlInstance $TestConfig.instance2
-        It "Should find resutls" {
-            $results | Should Not Be Null
+        BeforeAll {
+            $results = Find-DbaUserObject -SqlInstance $TestConfig.instance2
+        }
+        
+        It "Should find results" {
+            $results | Should -Not -BeNull
         }
     }
-}
+}
\ No newline at end of file

From 1f17830b00715d96d6e27afd839e0a4d4445f5aa Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Sat, 9 Aug 2025 07:42:28 +0200
Subject: [PATCH 03/15] Enhance formatter to preserve alignment and avoid
 unnecessary writes

Updated Invoke-DbatoolsFormatter to use custom PSSA settings that preserve manually aligned hashtables and assignment operators. The script now only writes files if formatting changes are detected, reducing unnecessary file writes.
---
 public/Invoke-DbatoolsFormatter.ps1 | 62 +++++++++++++++++++++++++++--
 1 file changed, 59 insertions(+), 3 deletions(-)

diff --git a/public/Invoke-DbatoolsFormatter.ps1 b/public/Invoke-DbatoolsFormatter.ps1
index 257af695f4e6..07b8e0b9ce4c 100644
--- a/public/Invoke-DbatoolsFormatter.ps1
+++ b/public/Invoke-DbatoolsFormatter.ps1
@@ -5,6 +5,8 @@ function Invoke-DbatoolsFormatter {
 
     .DESCRIPTION
         Uses PSSA's Invoke-Formatter to format the target files and saves it without the BOM.
+        Preserves manually aligned hashtables and assignment operators.
+        Only writes files if formatting changes are detected.
 
     .PARAMETER Path
         The path to the ps1 file that needs to be formatted
@@ -57,6 +59,48 @@ function Invoke-DbatoolsFormatter {
         $CBHRex = [regex]'(?smi)\s+\<\#[^#]*\#\>'
         $CBHStartRex = [regex]'(?<spaces>[ ]+)\<\#'
         $CBHEndRex = [regex]'(?<spaces>[ ]*)\#\>'
+
+        # Create custom formatter settings that preserve alignment
+        $customSettings = @{
+            IncludeRules = @(
+                'PSPlaceOpenBrace',
+                'PSPlaceCloseBrace',
+                'PSUseConsistentIndentation',
+                'PSUseConsistentWhitespace'
+            )
+            Rules        = @{
+                PSPlaceOpenBrace           = @{
+                    Enable             = $true
+                    OnSameLine         = $true
+                    NewLineAfter       = $true
+                    IgnoreOneLineBlock = $true
+                }
+                PSPlaceCloseBrace          = @{
+                    Enable             = $true
+                    NewLineAfter       = $false
+                    IgnoreOneLineBlock = $true
+                    NoEmptyLineBefore  = $false
+                }
+                PSUseConsistentIndentation = @{
+                    Enable              = $true
+                    Kind                = 'space'
+                    PipelineIndentation = 'IncreaseIndentationForFirstPipeline'
+                    IndentationSize     = 4
+                }
+                PSUseConsistentWhitespace  = @{
+                    Enable                          = $true
+                    CheckInnerBrace                 = $true
+                    CheckOpenBrace                  = $true
+                    CheckOpenParen                  = $true
+                    CheckOperator                   = $false  # This is key - don't mess with operator spacing
+                    CheckPipe                       = $true
+                    CheckPipeForRedundantWhitespace = $false
+                    CheckSeparator                  = $true
+                    CheckParameter                  = $false
+                }
+            }
+        }
+
         $OSEOL = "`n"
         if ($psVersionTable.Platform -ne 'Unix') {
             $OSEOL = "`r`n"
@@ -71,7 +115,9 @@ function Invoke-DbatoolsFormatter {
                 Stop-Function -Message "Cannot find or resolve $p" -Continue
             }
 
-            $content = Get-Content -Path $realPath -Raw -Encoding UTF8
+            $originalContent = Get-Content -Path $realPath -Raw -Encoding UTF8
+            $content = $originalContent
+
             if ($OSEOL -eq "`r`n") {
                 # See #5830, we are in Windows territory here
                 # Is the file containing at least one `r ?
@@ -85,7 +131,8 @@ function Invoke-DbatoolsFormatter {
             #strip ending empty lines
             $content = $content -replace "(?s)$OSEOL\s*$"
             try {
-                $content = Invoke-Formatter -ScriptDefinition $content -Settings CodeFormattingOTBS -ErrorAction Stop
+                # Use custom settings instead of CodeFormattingOTBS
+                $content = Invoke-Formatter -ScriptDefinition $content -Settings $customSettings -ErrorAction Stop
             } catch {
                 Write-Message -Level Warning "Unable to format $p"
             }
@@ -118,7 +165,16 @@ function Invoke-DbatoolsFormatter {
                 #trim whitespace lines
                 $realContent += $line.Replace("`t", "    ").TrimEnd()
             }
-            [System.IO.File]::WriteAllText($realPath, ($realContent -Join "$OSEOL"), $Utf8NoBomEncoding)
+
+            $finalContent = $realContent -Join "$OSEOL"
+
+            # Only write the file if there are actual changes
+            if ($finalContent -ne $originalContent) {
+                Write-Message -Level Verbose "Formatting changes detected in $realPath"
+                [System.IO.File]::WriteAllText($realPath, $finalContent, $Utf8NoBomEncoding)
+            } else {
+                Write-Message -Level Verbose "No formatting changes needed for $realPath"
+            }
         }
     }
 }
\ No newline at end of file

From b07ac96cd1b07e00f4320a15d84570b3adf9df72 Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Sat, 9 Aug 2025 07:51:17 +0200
Subject: [PATCH 04/15] Improve file handling in Invoke-DbatoolsFormatter

Added checks to skip directories and non-PowerShell files, improved error handling for file read/write operations, and ensured only valid content is processed. These changes enhance robustness and prevent errors when processing invalid or unreadable files.
---
 public/Invoke-DbatoolsFormatter.ps1 | 44 +++++++++++++++++++++++++----
 1 file changed, 39 insertions(+), 5 deletions(-)

diff --git a/public/Invoke-DbatoolsFormatter.ps1 b/public/Invoke-DbatoolsFormatter.ps1
index 07b8e0b9ce4c..28e1c26ef694 100644
--- a/public/Invoke-DbatoolsFormatter.ps1
+++ b/public/Invoke-DbatoolsFormatter.ps1
@@ -68,7 +68,7 @@ function Invoke-DbatoolsFormatter {
                 'PSUseConsistentIndentation',
                 'PSUseConsistentWhitespace'
             )
-            Rules        = @{
+            Rules       = @{
                 PSPlaceOpenBrace           = @{
                     Enable             = $true
                     OnSameLine         = $true
@@ -115,7 +115,29 @@ function Invoke-DbatoolsFormatter {
                 Stop-Function -Message "Cannot find or resolve $p" -Continue
             }
 
-            $originalContent = Get-Content -Path $realPath -Raw -Encoding UTF8
+            # Skip directories and non-PowerShell files
+            if (Test-Path -Path $realPath -PathType Container) {
+                Write-Message -Level Verbose "Skipping directory: $realPath"
+                continue
+            }
+
+            if ($realPath -notmatch '\.ps1$|\.psm1$|\.psd1$') {
+                Write-Message -Level Verbose "Skipping non-PowerShell file: $realPath"
+                continue
+            }
+
+            try {
+                $originalContent = Get-Content -Path $realPath -Raw -Encoding UTF8
+            } catch {
+                Stop-Function -Message "Unable to read file $realPath : $($_.Exception.Message)" -Continue
+            }
+
+            # If Get-Content failed, originalContent might be null or empty
+            if (-not $originalContent) {
+                Write-Message -Level Verbose "Skipping empty or unreadable file: $realPath"
+                continue
+            }
+
             $content = $originalContent
 
             if ($OSEOL -eq "`r`n") {
@@ -134,8 +156,16 @@ function Invoke-DbatoolsFormatter {
                 # Use custom settings instead of CodeFormattingOTBS
                 $content = Invoke-Formatter -ScriptDefinition $content -Settings $customSettings -ErrorAction Stop
             } catch {
-                Write-Message -Level Warning "Unable to format $p"
+                Write-Message -Level Warning "Unable to format $realPath : $($_.Exception.Message)"
+                continue
+            }
+
+            # Ensure $content is a string before processing
+            if (-not $content -or $content -isnot [string]) {
+                Write-Message -Level Warning "Formatter returned unexpected content type for $realPath"
+                continue
             }
+
             #match the ending indentation of CBH with the starting one, see #4373
             $CBH = $CBHRex.Match($content).Value
             if ($CBH) {
@@ -170,8 +200,12 @@ function Invoke-DbatoolsFormatter {
 
             # Only write the file if there are actual changes
             if ($finalContent -ne $originalContent) {
-                Write-Message -Level Verbose "Formatting changes detected in $realPath"
-                [System.IO.File]::WriteAllText($realPath, $finalContent, $Utf8NoBomEncoding)
+                try {
+                    Write-Message -Level Verbose "Formatting changes detected in $realPath"
+                    [System.IO.File]::WriteAllText($realPath, $finalContent, $Utf8NoBomEncoding)
+                } catch {
+                    Stop-Function -Message "Unable to write file $realPath : $($_.Exception.Message)" -Continue
+                }
             } else {
                 Write-Message -Level Verbose "No formatting changes needed for $realPath"
             }

From 4b4c3b5d20f6bf9c6930a32a9d3ea5de5b10f57a Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Sat, 9 Aug 2025 08:04:14 +0200
Subject: [PATCH 05/15] Improve formatting comparison in
 Invoke-DbatoolsFormatter

Enhances the formatter to compare processed, formatted content rather than raw content, ensuring that only meaningful formatting changes trigger file writes. Also applies CBH (Comment-Based Help) fixes and whitespace normalization to both the original and formatted content for accurate comparison.
---
 public/Invoke-DbatoolsFormatter.ps1 | 51 ++++++++++++++++++++++-------
 1 file changed, 40 insertions(+), 11 deletions(-)

diff --git a/public/Invoke-DbatoolsFormatter.ps1 b/public/Invoke-DbatoolsFormatter.ps1
index 28e1c26ef694..d2ad580c3766 100644
--- a/public/Invoke-DbatoolsFormatter.ps1
+++ b/public/Invoke-DbatoolsFormatter.ps1
@@ -68,7 +68,7 @@ function Invoke-DbatoolsFormatter {
                 'PSUseConsistentIndentation',
                 'PSUseConsistentWhitespace'
             )
-            Rules       = @{
+            Rules        = @{
                 PSPlaceOpenBrace           = @{
                     Enable             = $true
                     OnSameLine         = $true
@@ -150,36 +150,55 @@ function Invoke-DbatoolsFormatter {
                 }
             }
 
-            #strip ending empty lines
+            # Strip ending empty lines from both original and working content
             $content = $content -replace "(?s)$OSEOL\s*$"
+            $originalStripped = $originalContent -replace "(?s)$OSEOL\s*$"
+
             try {
-                # Use custom settings instead of CodeFormattingOTBS
+                # Format the content
                 $content = Invoke-Formatter -ScriptDefinition $content -Settings $customSettings -ErrorAction Stop
+                # Also format the original to compare
+                $originalFormatted = Invoke-Formatter -ScriptDefinition $originalStripped -Settings $customSettings -ErrorAction Stop
             } catch {
                 Write-Message -Level Warning "Unable to format $realPath : $($_.Exception.Message)"
                 continue
             }
 
-            # Ensure $content is a string before processing
+            # Ensure both contents are strings before processing
             if (-not $content -or $content -isnot [string]) {
                 Write-Message -Level Warning "Formatter returned unexpected content type for $realPath"
                 continue
             }
 
-            #match the ending indentation of CBH with the starting one, see #4373
+            if (-not $originalFormatted -or $originalFormatted -isnot [string]) {
+                Write-Message -Level Warning "Formatter returned unexpected content type for original in $realPath"
+                continue
+            }
+
+            # Apply CBH fix to formatted content
             $CBH = $CBHRex.Match($content).Value
             if ($CBH) {
-                #get starting spaces
                 $startSpaces = $CBHStartRex.Match($CBH).Groups['spaces']
                 if ($startSpaces) {
-                    #get end
                     $newCBH = $CBHEndRex.Replace($CBH, "$startSpaces#>")
                     if ($newCBH) {
-                        #replace the CBH
                         $content = $content.Replace($CBH, $newCBH)
                     }
                 }
             }
+
+            # Apply CBH fix to original formatted content
+            $originalCBH = $CBHRex.Match($originalFormatted).Value
+            if ($originalCBH) {
+                $startSpaces = $CBHStartRex.Match($originalCBH).Groups['spaces']
+                if ($startSpaces) {
+                    $newOriginalCBH = $CBHEndRex.Replace($originalCBH, "$startSpaces#>")
+                    if ($newOriginalCBH) {
+                        $originalFormatted = $originalFormatted.Replace($originalCBH, $newOriginalCBH)
+                    }
+                }
+            }
+
             $Utf8NoBomEncoding = New-Object System.Text.UTF8Encoding $False
             $correctCase = @(
                 'DbaInstanceParameter'
@@ -187,19 +206,29 @@ function Invoke-DbatoolsFormatter {
                 'PSCustomObject'
                 'PSItem'
             )
+
+            # Process the formatted content
             $realContent = @()
             foreach ($line in $content.Split("`n")) {
                 foreach ($item in $correctCase) {
                     $line = $line -replace $item, $item
                 }
-                #trim whitespace lines
                 $realContent += $line.Replace("`t", "    ").TrimEnd()
             }
-
             $finalContent = $realContent -Join "$OSEOL"
 
+            # Process the original formatted content the same way
+            $originalProcessed = @()
+            foreach ($line in $originalFormatted.Split("`n")) {
+                foreach ($item in $correctCase) {
+                    $line = $line -replace $item, $item
+                }
+                $originalProcessed += $line.Replace("`t", "    ").TrimEnd()
+            }
+            $originalFinalContent = $originalProcessed -Join "$OSEOL"
+
             # Only write the file if there are actual changes
-            if ($finalContent -ne $originalContent) {
+            if ($finalContent -ne $originalFinalContent) {
                 try {
                     Write-Message -Level Verbose "Formatting changes detected in $realPath"
                     [System.IO.File]::WriteAllText($realPath, $finalContent, $Utf8NoBomEncoding)

From 05eb89782d276dfefc75dcc0e5ae1becc20fe38c Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Sat, 9 Aug 2025 08:42:53 +0200
Subject: [PATCH 06/15] Refactor Invoke-DbatoolsFormatter for improved
 formatting

Simplifies the formatter by removing custom alignment-preserving settings and redundant code. Now uses a placeholder approach to preserve aligned assignments, streamlines file type checks, and only writes files if actual formatting changes are detected. Improves maintainability and reliability of the formatting process.
---
 public/Invoke-DbatoolsFormatter.ps1 | 150 +++++++---------------------
 1 file changed, 36 insertions(+), 114 deletions(-)

diff --git a/public/Invoke-DbatoolsFormatter.ps1 b/public/Invoke-DbatoolsFormatter.ps1
index d2ad580c3766..2c724b63cb3a 100644
--- a/public/Invoke-DbatoolsFormatter.ps1
+++ b/public/Invoke-DbatoolsFormatter.ps1
@@ -5,8 +5,6 @@ function Invoke-DbatoolsFormatter {
 
     .DESCRIPTION
         Uses PSSA's Invoke-Formatter to format the target files and saves it without the BOM.
-        Preserves manually aligned hashtables and assignment operators.
-        Only writes files if formatting changes are detected.
 
     .PARAMETER Path
         The path to the ps1 file that needs to be formatted
@@ -59,48 +57,6 @@ function Invoke-DbatoolsFormatter {
         $CBHRex = [regex]'(?smi)\s+\<\#[^#]*\#\>'
         $CBHStartRex = [regex]'(?<spaces>[ ]+)\<\#'
         $CBHEndRex = [regex]'(?<spaces>[ ]*)\#\>'
-
-        # Create custom formatter settings that preserve alignment
-        $customSettings = @{
-            IncludeRules = @(
-                'PSPlaceOpenBrace',
-                'PSPlaceCloseBrace',
-                'PSUseConsistentIndentation',
-                'PSUseConsistentWhitespace'
-            )
-            Rules        = @{
-                PSPlaceOpenBrace           = @{
-                    Enable             = $true
-                    OnSameLine         = $true
-                    NewLineAfter       = $true
-                    IgnoreOneLineBlock = $true
-                }
-                PSPlaceCloseBrace          = @{
-                    Enable             = $true
-                    NewLineAfter       = $false
-                    IgnoreOneLineBlock = $true
-                    NoEmptyLineBefore  = $false
-                }
-                PSUseConsistentIndentation = @{
-                    Enable              = $true
-                    Kind                = 'space'
-                    PipelineIndentation = 'IncreaseIndentationForFirstPipeline'
-                    IndentationSize     = 4
-                }
-                PSUseConsistentWhitespace  = @{
-                    Enable                          = $true
-                    CheckInnerBrace                 = $true
-                    CheckOpenBrace                  = $true
-                    CheckOpenParen                  = $true
-                    CheckOperator                   = $false  # This is key - don't mess with operator spacing
-                    CheckPipe                       = $true
-                    CheckPipeForRedundantWhitespace = $false
-                    CheckSeparator                  = $true
-                    CheckParameter                  = $false
-                }
-            }
-        }
-
         $OSEOL = "`n"
         if ($psVersionTable.Platform -ne 'Unix') {
             $OSEOL = "`r`n"
@@ -115,29 +71,13 @@ function Invoke-DbatoolsFormatter {
                 Stop-Function -Message "Cannot find or resolve $p" -Continue
             }
 
-            # Skip directories and non-PowerShell files
+            # Skip directories
             if (Test-Path -Path $realPath -PathType Container) {
                 Write-Message -Level Verbose "Skipping directory: $realPath"
                 continue
             }
 
-            if ($realPath -notmatch '\.ps1$|\.psm1$|\.psd1$') {
-                Write-Message -Level Verbose "Skipping non-PowerShell file: $realPath"
-                continue
-            }
-
-            try {
-                $originalContent = Get-Content -Path $realPath -Raw -Encoding UTF8
-            } catch {
-                Stop-Function -Message "Unable to read file $realPath : $($_.Exception.Message)" -Continue
-            }
-
-            # If Get-Content failed, originalContent might be null or empty
-            if (-not $originalContent) {
-                Write-Message -Level Verbose "Skipping empty or unreadable file: $realPath"
-                continue
-            }
-
+            $originalContent = Get-Content -Path $realPath -Raw -Encoding UTF8
             $content = $originalContent
 
             if ($OSEOL -eq "`r`n") {
@@ -150,55 +90,48 @@ function Invoke-DbatoolsFormatter {
                 }
             }
 
-            # Strip ending empty lines from both original and working content
+            #strip ending empty lines
             $content = $content -replace "(?s)$OSEOL\s*$"
-            $originalStripped = $originalContent -replace "(?s)$OSEOL\s*$"
 
-            try {
-                # Format the content
-                $content = Invoke-Formatter -ScriptDefinition $content -Settings $customSettings -ErrorAction Stop
-                # Also format the original to compare
-                $originalFormatted = Invoke-Formatter -ScriptDefinition $originalStripped -Settings $customSettings -ErrorAction Stop
-            } catch {
-                Write-Message -Level Warning "Unable to format $realPath : $($_.Exception.Message)"
-                continue
+            # Preserve aligned assignments before formatting
+            # Look for patterns with multiple spaces before OR after the = sign
+            $alignedPatterns = [regex]::Matches($content, '(?m)^\s*(\$\w+|\w+)\s{2,}=\s*.+$|^\s*(\$\w+|\w+)\s*=\s{2,}.+$')
+            $placeholders = @{}
+
+            foreach ($match in $alignedPatterns) {
+                $placeholder = "___ALIGNMENT_PLACEHOLDER_$($placeholders.Count)___"
+                $placeholders[$placeholder] = $match.Value
+                $content = $content.Replace($match.Value, $placeholder)
             }
 
-            # Ensure both contents are strings before processing
-            if (-not $content -or $content -isnot [string]) {
-                Write-Message -Level Warning "Formatter returned unexpected content type for $realPath"
-                continue
+            try {
+                $formattedContent = Invoke-Formatter -ScriptDefinition $content -Settings CodeFormattingOTBS -ErrorAction Stop
+                if ($formattedContent) {
+                    $content = $formattedContent
+                }
+            } catch {
+                # Just silently continue - the formatting might still work partially
             }
 
-            if (-not $originalFormatted -or $originalFormatted -isnot [string]) {
-                Write-Message -Level Warning "Formatter returned unexpected content type for original in $realPath"
-                continue
+            # Restore the aligned patterns
+            foreach ($key in $placeholders.Keys) {
+                $content = $content.Replace($key, $placeholders[$key])
             }
 
-            # Apply CBH fix to formatted content
+            #match the ending indentation of CBH with the starting one, see #4373
             $CBH = $CBHRex.Match($content).Value
             if ($CBH) {
+                #get starting spaces
                 $startSpaces = $CBHStartRex.Match($CBH).Groups['spaces']
                 if ($startSpaces) {
+                    #get end
                     $newCBH = $CBHEndRex.Replace($CBH, "$startSpaces#>")
                     if ($newCBH) {
+                        #replace the CBH
                         $content = $content.Replace($CBH, $newCBH)
                     }
                 }
             }
-
-            # Apply CBH fix to original formatted content
-            $originalCBH = $CBHRex.Match($originalFormatted).Value
-            if ($originalCBH) {
-                $startSpaces = $CBHStartRex.Match($originalCBH).Groups['spaces']
-                if ($startSpaces) {
-                    $newOriginalCBH = $CBHEndRex.Replace($originalCBH, "$startSpaces#>")
-                    if ($newOriginalCBH) {
-                        $originalFormatted = $originalFormatted.Replace($originalCBH, $newOriginalCBH)
-                    }
-                }
-            }
-
             $Utf8NoBomEncoding = New-Object System.Text.UTF8Encoding $False
             $correctCase = @(
                 'DbaInstanceParameter'
@@ -206,37 +139,26 @@ function Invoke-DbatoolsFormatter {
                 'PSCustomObject'
                 'PSItem'
             )
-
-            # Process the formatted content
             $realContent = @()
             foreach ($line in $content.Split("`n")) {
                 foreach ($item in $correctCase) {
                     $line = $line -replace $item, $item
                 }
+                #trim whitespace lines
                 $realContent += $line.Replace("`t", "    ").TrimEnd()
             }
-            $finalContent = $realContent -Join "$OSEOL"
 
-            # Process the original formatted content the same way
-            $originalProcessed = @()
-            foreach ($line in $originalFormatted.Split("`n")) {
-                foreach ($item in $correctCase) {
-                    $line = $line -replace $item, $item
-                }
-                $originalProcessed += $line.Replace("`t", "    ").TrimEnd()
-            }
-            $originalFinalContent = $originalProcessed -Join "$OSEOL"
+            $newContent = $realContent -Join "$OSEOL"
 
-            # Only write the file if there are actual changes
-            if ($finalContent -ne $originalFinalContent) {
-                try {
-                    Write-Message -Level Verbose "Formatting changes detected in $realPath"
-                    [System.IO.File]::WriteAllText($realPath, $finalContent, $Utf8NoBomEncoding)
-                } catch {
-                    Stop-Function -Message "Unable to write file $realPath : $($_.Exception.Message)" -Continue
-                }
+            # Compare without empty lines to detect real changes
+            $originalNonEmpty = ($originalContent -split "[\r\n]+" | Where-Object { $_.Trim() }) -join ""
+            $newNonEmpty = ($newContent -split "[\r\n]+" | Where-Object { $_.Trim() }) -join ""
+
+            if ($originalNonEmpty -ne $newNonEmpty) {
+                [System.IO.File]::WriteAllText($realPath, $newContent, $Utf8NoBomEncoding)
+                Write-Message -Level Verbose "Updated: $realPath"
             } else {
-                Write-Message -Level Verbose "No formatting changes needed for $realPath"
+                Write-Message -Level Verbose "No changes needed: $realPath"
             }
         }
     }

From 21da25c076867558a2a75d35f08af8c500f7c2d2 Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Sat, 9 Aug 2025 08:44:39 +0200
Subject: [PATCH 07/15] Add progress reporting to Invoke-DbatoolsFormatter

Enhanced Invoke-DbatoolsFormatter to display progress when formatting multiple files, including status updates for each file, error handling, and a summary of processed and updated files. This improves user feedback during batch operations.
---
 public/Invoke-DbatoolsFormatter.ps1 | 40 ++++++++++++++++++++++++++++-
 1 file changed, 39 insertions(+), 1 deletion(-)

diff --git a/public/Invoke-DbatoolsFormatter.ps1 b/public/Invoke-DbatoolsFormatter.ps1
index 2c724b63cb3a..4380d83ad538 100644
--- a/public/Invoke-DbatoolsFormatter.ps1
+++ b/public/Invoke-DbatoolsFormatter.ps1
@@ -29,6 +29,11 @@ function Invoke-DbatoolsFormatter {
         PS C:\> Invoke-DbatoolsFormatter -Path C:\dbatools\public\Get-DbaDatabase.ps1
 
         Reformats C:\dbatools\public\Get-DbaDatabase.ps1 to dbatools' standards
+
+    .EXAMPLE
+        PS C:\> Get-ChildItem *.ps1 | Invoke-DbatoolsFormatter
+
+        Reformats all .ps1 files in the current directory, showing progress for the batch operation
     #>
     [CmdletBinding()]
     param (
@@ -61,22 +66,44 @@ function Invoke-DbatoolsFormatter {
         if ($psVersionTable.Platform -ne 'Unix') {
             $OSEOL = "`r`n"
         }
+
+        # Collect all paths for progress tracking
+        $allPaths = @()
     }
     process {
         if (Test-FunctionInterrupt) { return }
-        foreach ($p in $Path) {
+        # Collect all paths from pipeline
+        $allPaths += $Path
+    }
+    end {
+        if (Test-FunctionInterrupt) { return }
+
+        $totalFiles = $allPaths.Count
+        $currentFile = 0
+        $processedFiles = 0
+        $updatedFiles = 0
+
+        foreach ($p in $allPaths) {
+            $currentFile++
+
             try {
                 $realPath = (Resolve-Path -Path $p -ErrorAction Stop).Path
             } catch {
+                Write-Progress -Activity "Formatting PowerShell files" -Status "Error resolving path: $p" -PercentComplete (($currentFile / $totalFiles) * 100) -CurrentOperation "File $currentFile of $totalFiles"
                 Stop-Function -Message "Cannot find or resolve $p" -Continue
+                continue
             }
 
             # Skip directories
             if (Test-Path -Path $realPath -PathType Container) {
+                Write-Progress -Activity "Formatting PowerShell files" -Status "Skipping directory: $realPath" -PercentComplete (($currentFile / $totalFiles) * 100) -CurrentOperation "File $currentFile of $totalFiles"
                 Write-Message -Level Verbose "Skipping directory: $realPath"
                 continue
             }
 
+            $fileName = Split-Path -Leaf $realPath
+            Write-Progress -Activity "Formatting PowerShell files" -Status "Processing: $fileName" -PercentComplete (($currentFile / $totalFiles) * 100) -CurrentOperation "File $currentFile of $totalFiles"
+
             $originalContent = Get-Content -Path $realPath -Raw -Encoding UTF8
             $content = $originalContent
 
@@ -157,9 +184,20 @@ function Invoke-DbatoolsFormatter {
             if ($originalNonEmpty -ne $newNonEmpty) {
                 [System.IO.File]::WriteAllText($realPath, $newContent, $Utf8NoBomEncoding)
                 Write-Message -Level Verbose "Updated: $realPath"
+                $updatedFiles++
             } else {
                 Write-Message -Level Verbose "No changes needed: $realPath"
             }
+
+            $processedFiles++
         }
+
+        # Complete the progress bar
+        Write-Progress -Activity "Formatting PowerShell files" -Status "Complete" -PercentComplete 100 -CurrentOperation "Processed $processedFiles files, updated $updatedFiles"
+        Start-Sleep -Milliseconds 500  # Brief pause to show completion
+        Write-Progress -Activity "Formatting PowerShell files" -Completed
+
+        # Summary message
+        Write-Message -Level Verbose "Formatting complete: Processed $processedFiles files, updated $updatedFiles files"
     }
 }
\ No newline at end of file

From 43ea064f1baa0b29fadfc28d95a627bb7328b1a5 Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Sat, 9 Aug 2025 09:50:07 +0200
Subject: [PATCH 08/15] Fix formatting and minor style issues in test scripts

This commit addresses whitespace, indentation, and minor style inconsistencies across multiple test scripts. No functional changes were made; these updates improve code readability and maintain consistent formatting throughout the test suite.
---
 public/Add-DbaAgDatabase.ps1                  |  2 +-
 tests/Add-DbaAgReplica.Tests.ps1              |  2 +-
 tests/Add-DbaComputerCertificate.Tests.ps1    |  2 +-
 tests/Add-DbaDbMirrorMonitor.Tests.ps1        | 10 ++++----
 tests/Add-DbaExtendedProperty.Tests.ps1       | 10 ++++----
 tests/Add-DbaPfDataCollectorCounter.Tests.ps1 | 24 +++++++++----------
 tests/Add-DbaRegServerGroup.Tests.ps1         |  2 +-
 tests/Add-DbaReplArticle.Tests.ps1            |  2 +-
 tests/Backup-DbaComputerCertificate.Tests.ps1 |  2 +-
 tests/Backup-DbaDatabase.Tests.ps1            |  2 +-
 tests/Backup-DbaDbCertificate.Tests.ps1       |  4 ++--
 tests/Backup-DbaDbMasterKey.Tests.ps1         |  2 +-
 tests/Backup-DbaServiceMasterKey.Tests.ps1    |  2 +-
 tests/Clear-DbaConnectionPool.Tests.ps1       |  2 +-
 tests/Clear-DbaLatchStatistics.Tests.ps1      |  2 +-
 tests/Clear-DbaPlanCache.Tests.ps1            |  2 +-
 tests/Clear-DbaWaitStatistics.Tests.ps1       |  2 +-
 tests/Convert-DbaMaskingValue.Tests.ps1       |  2 +-
 tests/ConvertTo-DbaDataTable.Tests.ps1        |  2 +-
 tests/ConvertTo-DbaTimeline.Tests.ps1         |  2 +-
 tests/ConvertTo-DbaXESession.Tests.ps1        |  2 +-
 tests/Copy-DbaAgentAlert.Tests.ps1            |  4 ++--
 tests/Copy-DbaAgentJobCategory.Tests.ps1      |  2 +-
 tests/Copy-DbaAgentOperator.Tests.ps1         |  2 +-
 tests/Find-DbaUserObject.Tests.ps1            | 12 +++++-----
 25 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/public/Add-DbaAgDatabase.ps1 b/public/Add-DbaAgDatabase.ps1
index 353d2711e71c..6aaae6ba8761 100644
--- a/public/Add-DbaAgDatabase.ps1
+++ b/public/Add-DbaAgDatabase.ps1
@@ -561,4 +561,4 @@ function Add-DbaAgDatabase {
         }
         Write-Progress @progress -Completed
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Add-DbaAgReplica.Tests.ps1 b/tests/Add-DbaAgReplica.Tests.ps1
index a057955c5a08..3f1ad5e67c34 100644
--- a/tests/Add-DbaAgReplica.Tests.ps1
+++ b/tests/Add-DbaAgReplica.Tests.ps1
@@ -50,7 +50,7 @@ Describe $CommandName -Tag IntegrationTests {
 
         # Set variables. They are available in all the It blocks.
         $primaryAgName = "dbatoolsci_agroup"
-        
+
         # Create the objects.
         $splatPrimary = @{
             Primary      = $TestConfig.instance3
diff --git a/tests/Add-DbaComputerCertificate.Tests.ps1 b/tests/Add-DbaComputerCertificate.Tests.ps1
index 25d095a2e352..23ff7181dd7a 100644
--- a/tests/Add-DbaComputerCertificate.Tests.ps1
+++ b/tests/Add-DbaComputerCertificate.Tests.ps1
@@ -32,7 +32,7 @@ Describe $CommandName -Tag UnitTests {
 Describe $CommandName -Tag IntegrationTests {
     BeforeAll {
         $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
-        
+
         $certPath       = "$($TestConfig.AppveyorLabRepo)\certificates\localhost.crt"
         $certThumbprint = "29C469578D6C6211076A09CEE5C5797EEA0C2713"
     }
diff --git a/tests/Add-DbaDbMirrorMonitor.Tests.ps1 b/tests/Add-DbaDbMirrorMonitor.Tests.ps1
index cf74a3876b9d..9afd1072ace2 100644
--- a/tests/Add-DbaDbMirrorMonitor.Tests.ps1
+++ b/tests/Add-DbaDbMirrorMonitor.Tests.ps1
@@ -34,10 +34,10 @@ Describe $CommandName -Tag IntegrationTests {
     AfterAll {
         # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
         $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
-        
+
         # Clean up any remaining mirror monitors
         $null = Remove-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2 -ErrorAction SilentlyContinue
-        
+
         # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
@@ -45,7 +45,7 @@ Describe $CommandName -Tag IntegrationTests {
         BeforeAll {
             # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
             $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
-            
+
             # Set variables. They are available in all the It blocks.
             $mirrorMonitorInstance = $TestConfig.instance2
         }
@@ -53,7 +53,7 @@ Describe $CommandName -Tag IntegrationTests {
         AfterAll {
             # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
             $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
-            
+
             # Clean up the mirror monitor created during the test
             $null = Remove-DbaDbMirrorMonitor -SqlInstance $mirrorMonitorInstance -ErrorAction SilentlyContinue
         }
@@ -63,4 +63,4 @@ Describe $CommandName -Tag IntegrationTests {
             $results.MonitorStatus | Should -Be "Added"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Add-DbaExtendedProperty.Tests.ps1 b/tests/Add-DbaExtendedProperty.Tests.ps1
index b9af245e4e75..3c27180c4d86 100644
--- a/tests/Add-DbaExtendedProperty.Tests.ps1
+++ b/tests/Add-DbaExtendedProperty.Tests.ps1
@@ -35,14 +35,14 @@ Describe $CommandName -Tag IntegrationTests {
         # Create unique database name for this test run
         $random = Get-Random
         $newDbName = "dbatoolsci_newdb_$random"
-        
+
         # Connect to instance and clean up any existing connections
         $server2 = Connect-DbaInstance -SqlInstance $TestConfig.instance2
         $null = Get-DbaProcess -SqlInstance $server2 | Where-Object Program -match dbatools | Stop-DbaProcess -Confirm:$false -WarningAction SilentlyContinue
-        
+
         # Create test database
         $db = New-DbaDatabase -SqlInstance $server2 -Name $newDbName
-        
+
         # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
         $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
     }
@@ -50,10 +50,10 @@ Describe $CommandName -Tag IntegrationTests {
     AfterAll {
         # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
         $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
-        
+
         # Cleanup the test database
         $null = $db | Remove-DbaDatabase -Confirm:$false
-        
+
         # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
diff --git a/tests/Add-DbaPfDataCollectorCounter.Tests.ps1 b/tests/Add-DbaPfDataCollectorCounter.Tests.ps1
index 8e4bfbbcb763..635493218d6e 100644
--- a/tests/Add-DbaPfDataCollectorCounter.Tests.ps1
+++ b/tests/Add-DbaPfDataCollectorCounter.Tests.ps1
@@ -45,20 +45,20 @@ Describe $CommandName -Tag IntegrationTests {
                 Remove-DbaPfDataCollectorCounter
 
             $results = Get-DbaPfDataCollectorSet -CollectorSet "Long Running Queries" | Get-DbaPfDataCollector |
-                Add-DbaPfDataCollectorCounter -Counter "\LogicalDisk(*)\Avg. Disk Queue Length"
-        }
+            Add-DbaPfDataCollectorCounter -Counter "\LogicalDisk(*)\Avg. Disk Queue Length"
+    }
 
-        AfterAll {
-            $null = Get-DbaPfDataCollectorSet -CollectorSet "Long Running Queries" |
-                Remove-DbaPfDataCollectorSet -ErrorAction SilentlyContinue
-        }
+    AfterAll {
+        $null = Get-DbaPfDataCollectorSet -CollectorSet "Long Running Queries" |
+            Remove-DbaPfDataCollectorSet -ErrorAction SilentlyContinue
+    }
 
-        It "Returns the correct DataCollectorSet" {
-            $results.DataCollectorSet | Should -Be "Long Running Queries"
-        }
+    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"
-        }
+    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-DbaRegServerGroup.Tests.ps1 b/tests/Add-DbaRegServerGroup.Tests.ps1
index 7b8cdabd36e7..fdf27ebcda69 100644
--- a/tests/Add-DbaRegServerGroup.Tests.ps1
+++ b/tests/Add-DbaRegServerGroup.Tests.ps1
@@ -111,4 +111,4 @@ Describe $CommandName -Tag IntegrationTests {
             $results.SqlInstance | Should -Not -BeNullOrEmpty
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Add-DbaReplArticle.Tests.ps1 b/tests/Add-DbaReplArticle.Tests.ps1
index f5739b8975fa..5634aa9dd9a3 100644
--- a/tests/Add-DbaReplArticle.Tests.ps1
+++ b/tests/Add-DbaReplArticle.Tests.ps1
@@ -31,4 +31,4 @@ Describe $CommandName -Tag UnitTests {
 
 <#
     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/Backup-DbaComputerCertificate.Tests.ps1 b/tests/Backup-DbaComputerCertificate.Tests.ps1
index 2f8cc9f68f39..08efb56c47e9 100644
--- a/tests/Backup-DbaComputerCertificate.Tests.ps1
+++ b/tests/Backup-DbaComputerCertificate.Tests.ps1
@@ -72,4 +72,4 @@ Describe $CommandName -Tag IntegrationTests {
             $backupResult.Name | Should -Match "$certThumbprint.cer"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Backup-DbaDatabase.Tests.ps1 b/tests/Backup-DbaDatabase.Tests.ps1
index 16ccb55bdc0d..c0b290f5bdc4 100644
--- a/tests/Backup-DbaDatabase.Tests.ps1
+++ b/tests/Backup-DbaDatabase.Tests.ps1
@@ -581,4 +581,4 @@ go
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Backup-DbaDbCertificate.Tests.ps1 b/tests/Backup-DbaDbCertificate.Tests.ps1
index e95ec29d9136..4726452abaca 100644
--- a/tests/Backup-DbaDbCertificate.Tests.ps1
+++ b/tests/Backup-DbaDbCertificate.Tests.ps1
@@ -124,7 +124,7 @@ Describe $CommandName -Tag IntegrationTests {
                 Certificate        = @($invalidDBCertName, $invalidDBCertName2, $cert2.Name)
                 EncryptionPassword = $pw
                 DecryptionPassword = $pw
-                WarningAction = "SilentlyContinue"
+                WarningAction      = "SilentlyContinue"
             }
             $results = Backup-DbaDbCertificate @splatBackupInvalidCert
         }
@@ -181,4 +181,4 @@ Describe $CommandName -Tag IntegrationTests {
             $results.Certificate | Should -Be $cert1.Name, $cert2.Name, $cert3.Name
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Backup-DbaDbMasterKey.Tests.ps1 b/tests/Backup-DbaDbMasterKey.Tests.ps1
index 6d3a911df160..708f05e60f31 100644
--- a/tests/Backup-DbaDbMasterKey.Tests.ps1
+++ b/tests/Backup-DbaDbMasterKey.Tests.ps1
@@ -119,4 +119,4 @@ Describe $CommandName -Tag IntegrationTests {
             # File will be cleaned up with the backupPath directory in AfterAll
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Backup-DbaServiceMasterKey.Tests.ps1 b/tests/Backup-DbaServiceMasterKey.Tests.ps1
index ff7a0dd6d7c2..8d5091b0ba2d 100644
--- a/tests/Backup-DbaServiceMasterKey.Tests.ps1
+++ b/tests/Backup-DbaServiceMasterKey.Tests.ps1
@@ -93,4 +93,4 @@ Describe $CommandName -Tag IntegrationTests {
             $fileBackupPath = $fileBackupResults.Path
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Clear-DbaConnectionPool.Tests.ps1 b/tests/Clear-DbaConnectionPool.Tests.ps1
index 210801826679..42aee5f2a547 100644
--- a/tests/Clear-DbaConnectionPool.Tests.ps1
+++ b/tests/Clear-DbaConnectionPool.Tests.ps1
@@ -29,4 +29,4 @@ Describe $CommandName -Tag IntegrationTests {
             { 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 b0e99bfe07cc..1a6a40f1137a 100644
--- a/tests/Clear-DbaLatchStatistics.Tests.ps1
+++ b/tests/Clear-DbaLatchStatistics.Tests.ps1
@@ -45,4 +45,4 @@ Describe $CommandName -Tag IntegrationTests {
             $results.Status | Should -Be "Success"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Clear-DbaPlanCache.Tests.ps1 b/tests/Clear-DbaPlanCache.Tests.ps1
index 89f63c93789a..573a1faab9cc 100644
--- a/tests/Clear-DbaPlanCache.Tests.ps1
+++ b/tests/Clear-DbaPlanCache.Tests.ps1
@@ -44,4 +44,4 @@ Describe $CommandName -Tag IntegrationTests {
             $results.Status | Should -Match "below"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Clear-DbaWaitStatistics.Tests.ps1 b/tests/Clear-DbaWaitStatistics.Tests.ps1
index 2a2fcab44815..fc9e042ae5a5 100644
--- a/tests/Clear-DbaWaitStatistics.Tests.ps1
+++ b/tests/Clear-DbaWaitStatistics.Tests.ps1
@@ -45,4 +45,4 @@ Describe $CommandName -Tag IntegrationTests {
             $clearResults.Status | Should -Be "Success"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Convert-DbaMaskingValue.Tests.ps1 b/tests/Convert-DbaMaskingValue.Tests.ps1
index bf5cebba8ebc..770455de1723 100644
--- a/tests/Convert-DbaMaskingValue.Tests.ps1
+++ b/tests/Convert-DbaMaskingValue.Tests.ps1
@@ -116,4 +116,4 @@ Describe $CommandName -Tag IntegrationTests {
             { Convert-DbaMaskingValue -Value "whatever" -EnableException } | Should -Throw "Please enter a data type"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/ConvertTo-DbaDataTable.Tests.ps1 b/tests/ConvertTo-DbaDataTable.Tests.ps1
index 7731f9a6547d..35468356f524 100644
--- a/tests/ConvertTo-DbaDataTable.Tests.ps1
+++ b/tests/ConvertTo-DbaDataTable.Tests.ps1
@@ -43,7 +43,7 @@ Describe $CommandName -Tag UnitTests, "DataTableOutput" {
             UInt64           = [System.UInt64]123456
             dbadatetime      = [dbadatetime[]]$(Get-Date -Year 2024 -Month 05 -Day 19 -Hour 5 -Minute 52 -Second 0 -Millisecond 0)
             dbadatetimeArray = [dbadatetime[]]($(Get-Date -Year 2024 -Month 05 -Day 19 -Hour 5 -Minute 52 -Second 0 -Millisecond 0), $(Get-Date -Year 2024 -Month 05 -Day 19 -Hour 5 -Minute 52 -Second 0 -Millisecond 0).AddHours(1))
-            inlining         = [pscustomobject]@{Mission = "Keep Hank alive" }
+            inlining         = [PSCustomObject]@{Mission = "Keep Hank alive" }
             inlining2        = [psobject]@{Mission = "Keep Hank alive" }
         }
 
diff --git a/tests/ConvertTo-DbaTimeline.Tests.ps1 b/tests/ConvertTo-DbaTimeline.Tests.ps1
index 8bad46bf3b59..851822a08cda 100644
--- a/tests/ConvertTo-DbaTimeline.Tests.ps1
+++ b/tests/ConvertTo-DbaTimeline.Tests.ps1
@@ -27,4 +27,4 @@ Describe $CommandName -Tag UnitTests {
     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 guidance.
-#>
+#>
\ No newline at end of file
diff --git a/tests/ConvertTo-DbaXESession.Tests.ps1 b/tests/ConvertTo-DbaXESession.Tests.ps1
index e658dd03f4bb..e6a00921bbba 100644
--- a/tests/ConvertTo-DbaXESession.Tests.ps1
+++ b/tests/ConvertTo-DbaXESession.Tests.ps1
@@ -158,4 +158,4 @@ select TraceID=@TraceID
             $results.Targets.Name | Should -Be "package0.event_file"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Copy-DbaAgentAlert.Tests.ps1 b/tests/Copy-DbaAgentAlert.Tests.ps1
index c04affbaf57c..370ea11b44ee 100644
--- a/tests/Copy-DbaAgentAlert.Tests.ps1
+++ b/tests/Copy-DbaAgentAlert.Tests.ps1
@@ -64,7 +64,7 @@ Describe $CommandName -Tag IntegrationTests {
         @name = N'$operatorName',
         @enabled = 1,
         @email_address = N'$operatorEmail' ;")
-        
+
         $serverInstance2.Query("EXEC msdb.dbo.sp_add_notification   @alert_name = N'$($alert2)',
         @operator_name = N'$operatorName',
         @notification_method = 1 ;")
@@ -85,7 +85,7 @@ Describe $CommandName -Tag IntegrationTests {
 
         $serverCleanup3 = Connect-DbaInstance -SqlInstance $TestConfig.instance3 -Database master
         $serverCleanup3.Query("EXEC msdb.dbo.sp_delete_alert @name=N'$($alert1)'")
-        
+
         # As this is the last block we do not need to reset the $PSDefaultParameterValues.
     }
 
diff --git a/tests/Copy-DbaAgentJobCategory.Tests.ps1 b/tests/Copy-DbaAgentJobCategory.Tests.ps1
index 1ef05701d465..5b3d51056cf4 100644
--- a/tests/Copy-DbaAgentJobCategory.Tests.ps1
+++ b/tests/Copy-DbaAgentJobCategory.Tests.ps1
@@ -76,4 +76,4 @@ Describe $CommandName -Tag IntegrationTests {
             $secondCopyResults.Status | Should -Be "Skipped"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Copy-DbaAgentOperator.Tests.ps1 b/tests/Copy-DbaAgentOperator.Tests.ps1
index a727d9ca19b6..50d80bf46b76 100644
--- a/tests/Copy-DbaAgentOperator.Tests.ps1
+++ b/tests/Copy-DbaAgentOperator.Tests.ps1
@@ -90,4 +90,4 @@ Describe $CommandName -Tag IntegrationTests {
             $copyResult.Status | Should -Be "Skipped"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Find-DbaUserObject.Tests.ps1 b/tests/Find-DbaUserObject.Tests.ps1
index 6e0488af80e9..fecd9acd965f 100644
--- a/tests/Find-DbaUserObject.Tests.ps1
+++ b/tests/Find-DbaUserObject.Tests.ps1
@@ -33,29 +33,29 @@ Describe $CommandName -Tag IntegrationTests {
             $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
             $null = New-DbaDatabase -SqlInstance $TestConfig.instance2 -Name "dbatoolsci_userObject" -Owner "sa"
             $PSDefaultParameterValues.Remove('*-Dba*:EnableException')
-            
+
             $results = Find-DbaUserObject -SqlInstance $TestConfig.instance2 -Pattern "sa"
         }
-        
+
         AfterAll {
             $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
             $null = Remove-DbaDatabase -SqlInstance $TestConfig.instance2 -Database "dbatoolsci_userObject" -Confirm:$false
         }
 
         It "Should find a specific Database Owned by sa" {
-            $results.Where( {$PSItem.name -eq "dbatoolsci_userobject"}).Type | Should -Be "Database"
+            $results.Where( { $PSItem.name -eq "dbatoolsci_userobject" }).Type | Should -Be "Database"
         }
-        
+
         It "Should find more than 10 objects Owned by sa" {
             $results.Count | Should -BeGreaterThan 10
         }
     }
-    
+
     Context "Command finds User Objects" {
         BeforeAll {
             $results = Find-DbaUserObject -SqlInstance $TestConfig.instance2
         }
-        
+
         It "Should find results" {
             $results | Should -Not -BeNull
         }

From 47d4537e04e4a0f2a28d421a5e4ffb67f75bf8a7 Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Sun, 10 Aug 2025 23:56:40 +0200
Subject: [PATCH 09/15] replace from dev since no changes

---
 public/Add-DbaAgDatabase.ps1 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/public/Add-DbaAgDatabase.ps1 b/public/Add-DbaAgDatabase.ps1
index 6aaae6ba8761..353d2711e71c 100644
--- a/public/Add-DbaAgDatabase.ps1
+++ b/public/Add-DbaAgDatabase.ps1
@@ -561,4 +561,4 @@ function Add-DbaAgDatabase {
         }
         Write-Progress @progress -Completed
     }
-}
\ No newline at end of file
+}

From b1bc8683fa83a6b382656565950db87131ec3c97 Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Mon, 11 Aug 2025 06:49:24 +0200
Subject: [PATCH 10/15] Refactor and clean up integration tests

Simplified and cleaned up integration tests in Add-DbaDbMirrorMonitor.Tests.ps1 by removing redundant parameter handling and streamlining setup/teardown logic. In Connect-DbaInstance.Tests.ps1, variable naming was improved, unnecessary array casts were removed, and minor comment and assertion updates were made for clarity and consistency.
---
 tests/Add-DbaDbMirrorMonitor.Tests.ps1 | 32 +++-----------------------
 tests/Connect-DbaInstance.Tests.ps1    | 17 +++++++-------
 2 files changed, 11 insertions(+), 38 deletions(-)

diff --git a/tests/Add-DbaDbMirrorMonitor.Tests.ps1 b/tests/Add-DbaDbMirrorMonitor.Tests.ps1
index 9afd1072ace2..0684b3b9de5b 100644
--- a/tests/Add-DbaDbMirrorMonitor.Tests.ps1
+++ b/tests/Add-DbaDbMirrorMonitor.Tests.ps1
@@ -13,9 +13,7 @@ Describe $CommandName -Tag UnitTests {
             $expectedParameters += @(
                 "SqlInstance",
                 "SqlCredential",
-                "EnableException",
-                "WhatIf",
-                "Confirm"
+                "EnableException"
             )
         }
 
@@ -26,40 +24,16 @@ Describe $CommandName -Tag UnitTests {
 }
 
 Describe $CommandName -Tag IntegrationTests {
-    BeforeAll {
-        # We want to run all commands in the BeforeAll block with EnableException to ensure that the test fails if the setup fails.
-        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
-    }
-
-    AfterAll {
-        # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
-        $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
-
-        # Clean up any remaining mirror monitors
-        $null = Remove-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2 -ErrorAction SilentlyContinue
-
-        # As this is the last block we do not need to reset the $PSDefaultParameterValues.
-    }
-
     Context "When adding mirror monitor" {
         BeforeAll {
-            # We want to run all commands outside of the BeforeAll block without EnableException to be able to test for specific warnings.
-            $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
-
-            # Set variables. They are available in all the It blocks.
-            $mirrorMonitorInstance = $TestConfig.instance2
+            $results = Add-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2
         }
 
         AfterAll {
-            # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
-            $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
-
-            # Clean up the mirror monitor created during the test
-            $null = Remove-DbaDbMirrorMonitor -SqlInstance $mirrorMonitorInstance -ErrorAction SilentlyContinue
+            $null = Remove-DbaDbMirrorMonitor -SqlInstance $TestConfig.instance2
         }
 
         It "Adds the mirror monitor" {
-            $results = Add-DbaDbMirrorMonitor -SqlInstance $mirrorMonitorInstance
             $results.MonitorStatus | Should -Be "Added"
         }
     }
diff --git a/tests/Connect-DbaInstance.Tests.ps1 b/tests/Connect-DbaInstance.Tests.ps1
index 3cd4ba0bc265..0e9d39f65c24 100644
--- a/tests/Connect-DbaInstance.Tests.ps1
+++ b/tests/Connect-DbaInstance.Tests.ps1
@@ -104,7 +104,7 @@ Describe $CommandName -Tag IntegrationTests {
 
     Context "connection is properly made using a string" {
         BeforeAll {
-            $splatConnection = @{
+            $params = @{
                 BatchSeparator           = "GO"
                 ConnectTimeout           = 1
                 Database                 = "tempdb"
@@ -119,8 +119,7 @@ Describe $CommandName -Tag IntegrationTests {
                 StatementTimeout         = 0
                 ApplicationIntent        = "ReadOnly"
             }
-            $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1 @splatConnection
-            $params = $splatConnection
+            $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1 @params
         }
 
         It "returns the proper name" {
@@ -194,7 +193,7 @@ Describe $CommandName -Tag IntegrationTests {
             It "keeps the same database context" {
                 $null = $server.Databases["msdb"].Tables.Count
                 # This currently fails!
-                #$server.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be 'tempdb'
+                #$server.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be "tempdb"
             }
         }
     }
@@ -218,7 +217,7 @@ Describe $CommandName -Tag IntegrationTests {
         It "keeps the same database context" {
             $null = $server.Databases["msdb"].Tables.Count
             # This currently fails!
-            #$server.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be 'tempdb'
+            #$server.ConnectionContext.ExecuteScalar("select db_name()") | Should -Be "tempdb"
         }
     }
 
@@ -274,7 +273,7 @@ Describe $CommandName -Tag IntegrationTests {
 
     Context "multiple connections are properly made using strings" {
         It "returns the proper names" {
-            $server = @(Connect-DbaInstance -SqlInstance $TestConfig.instance1, $TestConfig.instance2)
+            $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1, $TestConfig.instance2
             $server[0].Name | Should -Be $TestConfig.instance1
             $server[1].Name | Should -Be $TestConfig.instance2
         }
@@ -283,14 +282,14 @@ Describe $CommandName -Tag IntegrationTests {
     Context "multiple dedicated admin connections are properly made using strings" {
         # This might fail if a parallel test uses DAC - how can we ensure that this is the only test that is run?
         It "opens and closes the connections" {
-            $server = @(Connect-DbaInstance -SqlInstance $TestConfig.instance1, $TestConfig.instance2 -DedicatedAdminConnection)
+            $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1, $TestConfig.instance2 -DedicatedAdminConnection
             $server[0].Name | Should -Be "ADMIN:$($TestConfig.instance1)"
             $server[1].Name | Should -Be "ADMIN:$($TestConfig.instance2)"
             $null = $server | Disconnect-DbaInstance
             # DAC is not reopened in the background
             Start-Sleep -Seconds 10
-            $server = @(Connect-DbaInstance -SqlInstance $TestConfig.instance1, $TestConfig.instance2 -DedicatedAdminConnection)
-            $server.Status.Count | Should -Be 2
+            $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1, $TestConfig.instance2 -DedicatedAdminConnection
+            $server.Count | Should -Be 2
             $null = $server | Disconnect-DbaInstance
         }
     }

From 881e3911f9f2aaf04b6fb6d160017d7cb6915080 Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Mon, 11 Aug 2025 07:23:37 +0200
Subject: [PATCH 11/15] Handle missing backup files in test cleanup

Added checks for the existence of backup files before attempting to remove them in Connect-DbaInstance integration tests. This prevents errors if the backup file does not exist.
---
 tests/Connect-DbaInstance.Tests.ps1 | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/tests/Connect-DbaInstance.Tests.ps1 b/tests/Connect-DbaInstance.Tests.ps1
index 0e9d39f65c24..a59cebb9790b 100644
--- a/tests/Connect-DbaInstance.Tests.ps1
+++ b/tests/Connect-DbaInstance.Tests.ps1
@@ -264,10 +264,16 @@ Describe $CommandName -Tag IntegrationTests {
         It "clones when using Backup-DabInstace" {
             $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1 -Database tempdb
             $results = Backup-DbaDatabase -SqlInstance $server -Database msdb
-            Remove-Item -Path $results.FullName
+            if ($results.FullName) {
+                Remove-Item -Path $results.FullName -ErrorAction SilentlyContinue
+            }
+
             $results = Backup-DbaDatabase -SqlInstance $server -Database msdb -WarningVariable warn
             $warn | Should -BeNullOrEmpty
-            Remove-Item -Path $results.FullName
+
+            if ($results.FullName) {
+                Remove-Item -Path $results.FullName -ErrorAction SilentlyContinue
+            }
         }
     }
 

From 380fb4ec6ab80d53eaf7ff0a28a7a20871fd2862 Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Mon, 11 Aug 2025 08:14:13 +0200
Subject: [PATCH 12/15] Update Backup-DbaDatabase tests to use IgnoreFileChecks

Added the -IgnoreFileChecks parameter to Backup-DbaDatabase calls in integration tests to bypass file checks. This ensures the tests run without file validation issues.
---
 tests/Connect-DbaInstance.Tests.ps1 | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/Connect-DbaInstance.Tests.ps1 b/tests/Connect-DbaInstance.Tests.ps1
index a59cebb9790b..daf859d6f755 100644
--- a/tests/Connect-DbaInstance.Tests.ps1
+++ b/tests/Connect-DbaInstance.Tests.ps1
@@ -263,12 +263,12 @@ Describe $CommandName -Tag IntegrationTests {
 
         It "clones when using Backup-DabInstace" {
             $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1 -Database tempdb
-            $results = Backup-DbaDatabase -SqlInstance $server -Database msdb
+            $results = Backup-DbaDatabase -SqlInstance $server -Database msdb -IgnoreFileChecks
             if ($results.FullName) {
                 Remove-Item -Path $results.FullName -ErrorAction SilentlyContinue
             }
 
-            $results = Backup-DbaDatabase -SqlInstance $server -Database msdb -WarningVariable warn
+            $results = Backup-DbaDatabase -SqlInstance $server -Database msdb -WarningVariable warn -IgnoreFileChecks
             $warn | Should -BeNullOrEmpty
 
             if ($results.FullName) {

From 9fe7433b4f2d7e008c1670a596889d069df2619e Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Mon, 11 Aug 2025 08:19:49 +0200
Subject: [PATCH 13/15] Improve certificate backup test assertions

Updated the test to check for at least 3 results and verify that each expected certificate is present, rather than requiring exactly 3 results. This makes the test more robust to additional certificates.
---
 tests/Backup-DbaDbCertificate.Tests.ps1 | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/Backup-DbaDbCertificate.Tests.ps1 b/tests/Backup-DbaDbCertificate.Tests.ps1
index 4726452abaca..8c733ce5eb32 100644
--- a/tests/Backup-DbaDbCertificate.Tests.ps1
+++ b/tests/Backup-DbaDbCertificate.Tests.ps1
@@ -177,8 +177,10 @@ Describe $CommandName -Tag IntegrationTests {
         }
 
         It "Returns results with proper data" {
-            $results | Should -HaveCount 3
-            $results.Certificate | Should -Be $cert1.Name, $cert2.Name, $cert3.Name
+            $results | Should -BeGreaterOrEqual 3
+            $results.Certificate | Should -Contain $cert1.Name
+            $results.Certificate | Should -Contain $cert2.Name
+            $results.Certificate | Should -Contain $cert3.Name
         }
     }
 }
\ No newline at end of file

From 3f1164a048f31dafecd4cb3c15d9ebed81cd3254 Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Mon, 11 Aug 2025 08:32:04 +0200
Subject: [PATCH 14/15] Ah, this was the wrong branch, revert

This reverts commit 9fe7433b4f2d7e008c1670a596889d069df2619e.
---
 tests/Backup-DbaDbCertificate.Tests.ps1 | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/tests/Backup-DbaDbCertificate.Tests.ps1 b/tests/Backup-DbaDbCertificate.Tests.ps1
index 8c733ce5eb32..4726452abaca 100644
--- a/tests/Backup-DbaDbCertificate.Tests.ps1
+++ b/tests/Backup-DbaDbCertificate.Tests.ps1
@@ -177,10 +177,8 @@ Describe $CommandName -Tag IntegrationTests {
         }
 
         It "Returns results with proper data" {
-            $results | Should -BeGreaterOrEqual 3
-            $results.Certificate | Should -Contain $cert1.Name
-            $results.Certificate | Should -Contain $cert2.Name
-            $results.Certificate | Should -Contain $cert3.Name
+            $results | Should -HaveCount 3
+            $results.Certificate | Should -Be $cert1.Name, $cert2.Name, $cert3.Name
         }
     }
 }
\ No newline at end of file

From 9dbdee1aec54e103fa824d21001979249183a753 Mon Sep 17 00:00:00 2001
From: Chrissy LeMaire <potatoqualitee@users.noreply.github.com>
Date: Mon, 11 Aug 2025 08:34:09 +0200
Subject: [PATCH 15/15] fix afterall

---
 tests/Backup-DbaDatabase.Tests.ps1  | 1 +
 tests/Connect-DbaInstance.Tests.ps1 | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/tests/Backup-DbaDatabase.Tests.ps1 b/tests/Backup-DbaDatabase.Tests.ps1
index c0b290f5bdc4..b64a67b47960 100644
--- a/tests/Backup-DbaDatabase.Tests.ps1
+++ b/tests/Backup-DbaDatabase.Tests.ps1
@@ -72,6 +72,7 @@ Describe $CommandName -Tag IntegrationTests {
     AfterAll {
         # We want to run all commands in the AfterAll block with EnableException to ensure that the test fails if the cleanup fails.
         $PSDefaultParameterValues['*-Dba*:EnableException'] = $true
+        $PSDefaultParameterValues.Remove('Backup-DbaDatabase:BackupDirectory')
 
         # Remove the backup directory.
         Remove-Item -Path $DestBackupDir -Force -Recurse -ErrorAction SilentlyContinue
diff --git a/tests/Connect-DbaInstance.Tests.ps1 b/tests/Connect-DbaInstance.Tests.ps1
index daf859d6f755..a59cebb9790b 100644
--- a/tests/Connect-DbaInstance.Tests.ps1
+++ b/tests/Connect-DbaInstance.Tests.ps1
@@ -263,12 +263,12 @@ Describe $CommandName -Tag IntegrationTests {
 
         It "clones when using Backup-DabInstace" {
             $server = Connect-DbaInstance -SqlInstance $TestConfig.instance1 -Database tempdb
-            $results = Backup-DbaDatabase -SqlInstance $server -Database msdb -IgnoreFileChecks
+            $results = Backup-DbaDatabase -SqlInstance $server -Database msdb
             if ($results.FullName) {
                 Remove-Item -Path $results.FullName -ErrorAction SilentlyContinue
             }
 
-            $results = Backup-DbaDatabase -SqlInstance $server -Database msdb -WarningVariable warn -IgnoreFileChecks
+            $results = Backup-DbaDatabase -SqlInstance $server -Database msdb -WarningVariable warn
             $warn | Should -BeNullOrEmpty
 
             if ($results.FullName) {