diff --git a/functions/New-DbaDatabase.ps1 b/functions/New-DbaDatabase.ps1
index f5ff37fbde0f..68f7c95037a6 100644
--- a/functions/New-DbaDatabase.ps1
+++ b/functions/New-DbaDatabase.ps1
@@ -114,6 +114,7 @@ function New-DbaDatabase {
         [parameter(Mandatory, ValueFromPipeline)]
         [DbaInstanceParameter[]]$SqlInstance,
         [PSCredential]$SqlCredential,
+        [Alias('Database')]
         [string[]]$Name,
         [string]$Collation,
         [string]$Recoverymodel,
diff --git a/internal/functions/Connect-SqlInstance.ps1 b/internal/functions/Connect-SqlInstance.ps1
index 6ef8acea9e4d..60d68ca69015 100644
--- a/internal/functions/Connect-SqlInstance.ps1
+++ b/internal/functions/Connect-SqlInstance.ps1
@@ -55,328 +55,19 @@ function Connect-SqlInstance {
         Connect to the Server sql2014 with native credentials.
     #>
     [CmdletBinding()]
-    [Diagnostics.CodeAnalysis.SuppressMessageAttribute("PSAvoidDefaultValueSwitchParameter", "")]
-    [Diagnostics.CodeAnalysis.SuppressMessageAttribute("PSAvoidUsingEmptyCatchBlock", "")]
     param (
         [Parameter(Mandatory)]
-        [object]$SqlInstance,
-        [object]$SqlCredential,
+        [DbaInstanceParameter]$SqlInstance,
+        [PSCredential]$SqlCredential,
         [int]$StatementTimeout,
         [int]$MinimumVersion,
         [switch]$AzureUnsupported,
         [switch]$NonPooled
     )
-
-    #region Utility functions
-    function Invoke-TEPPCacheUpdate {
-        [CmdletBinding()]
-        param (
-            [System.Management.Automation.ScriptBlock]$ScriptBlock
-        )
-
-        try {
-            [ScriptBlock]::Create($scriptBlock).Invoke()
-        } catch {
-            # If the SQL Server version doesn't support the feature, we ignore it and silently continue
-            if ($_.Exception.InnerException.InnerException.GetType().FullName -eq "Microsoft.SqlServer.Management.Sdk.Sfc.InvalidVersionEnumeratorException") {
-                return
-            }
-
-            if ($ENV:APPVEYOR_BUILD_FOLDER -or ([Sqlcollaborative.Dbatools.Message.MEssageHost]::DeveloperMode)) { throw }
-            else {
-                Write-Message -Level Warning -Message "Failed TEPP Caching: $($scriptBlock.ToString() | Select-String '"(.*?)"' | ForEach-Object { $_.Matches[0].Groups[1].Value })" -ErrorRecord $_ 3>$null
-            }
-        }
-    }
-    #endregion Utility functions
-
-    #region Ensure Credential integrity
-    <#
-    Usually, the parameter type should have been not object but off the PSCredential type.
-    When binding null to a PSCredential type parameter on PS3-4, it'd then show a prompt, asking for username and password.
-
-    In order to avoid that and having to refactor lots of functions (and to avoid making regular scripts harder to read), we created this workaround.
-    #>
-    if ($SqlCredential) {
-        if ($SqlCredential.GetType() -ne [System.Management.Automation.PSCredential]) {
-            throw "The credential parameter was of a non-supported type. Only specify PSCredentials such as generated from Get-Credential. Input was of type $($SqlCredential.GetType().FullName)"
-        }
-    }
-    #endregion Ensure Credential integrity
-
-    if ($instance.ComputerName -match "database\.windows\.net" -and -not $instance.InputObject.ConnectionContext.IsOpen) {
-        $isAzure = $true
-        if (-not (Test-Bound -ParameterName ConnectTimeout)) {
-            $ConnectTimeout = 30
-        }
-
-        if ($SqlCredential) {
-            $azureconnstring = "Server=tcp:$($instance.ComputerName),$($instance.Port);Initial Catalog=$Database;Persist Security Info=False;User ID=$($SqlCredential.UserName);Password=$($($SqlCredential.GetNetworkCredential()).Password);MultipleActiveResultSets=$MultipleActiveResultSets;Encrypt=True;TrustServerCertificate=$TrustServerCertificate;Connection Timeout=$ConnectTimeout;"
-            $azureconnstring = $azureconnstring + 'Application Name = "dbatools PowerShell module - dbatools.io"'
-        }
-        if ($SqlCredential.UserName -like "*\*" -or $SqlCredential.UserName -like "*@*") {
-            $azureconnstring = $azureconnstring + 'Authentication="Active Directory Password";Application Name = "dbatools PowerShell module - dbatools.io"'
-        } else {
-            $azureconnstring = "Server=tcp:$($instance.ComputerName),$($instance.Port);Initial Catalog=$Database;Persist Security Info=False;MultipleActiveResultSets=$MultipleActiveResultSets;Encrypt=True;TrustServerCertificate=$TrustServerCertificate;Connection Timeout=$ConnectTimeout;"
-            $azureconnstring = $azureconnstring + 'Authentication="Active Directory Integrated"; Application Name = "dbatools PowerShell module - dbatools.io"'
-        }
-        try {
-            $sqlconn = New-Object System.Data.SqlClient.SqlConnection $azureconnstring
-            $serverconn = New-Object Microsoft.SqlServer.Management.Common.ServerConnection $sqlconn
-            $server = New-Object Microsoft.SqlServer.Management.Smo.Server $serverconn
-        } catch {
-            Stop-Function -Message "Failure" -ErrorRecord $_ -Continue
-        }
-    }
-
-    #region Safely convert input into instance parameters
-    <#
-    This is a bit ugly, but:
-    In some cases functions would directly pass their own input through when the parameter on the calling function was typed as [object[]].
-    This would break the base parameter class, as it'd automatically be an array and the parameterclass is not designed to handle arrays (Shouldn't have to).
-
-    Note: Multiple servers in one call were never supported, those old functions were liable to break anyway and should be fixed soonest.
-    #>
-    if ($SqlInstance.GetType() -eq [Sqlcollaborative.Dbatools.Parameter.DbaInstanceParameter]) {
-        [DbaInstanceParameter]$ConvertedSqlInstance = $SqlInstance
-        if ($ConvertedSqlInstance.Type -like "SqlConnection") {
-            [DbaInstanceParameter]$ConvertedSqlInstance = New-Object Microsoft.SqlServer.Management.Smo.Server($ConvertedSqlInstance.InputObject)
-        }
+    if ($SqlInstance.InputObject.GetType().Name -eq 'Server') {
+        $SqlInstance.InputObject.Refresh()
+        return $SqlInstance.InputObject
     } else {
-        [DbaInstanceParameter]$ConvertedSqlInstance = [DbaInstanceParameter]($SqlInstance | Select-Object -First 1)
-
-        if ($SqlInstance.Count -gt 1) {
-            Write-Message -Level Warning -EnableException $true -Message "More than on server was specified when calling Connect-SqlInstance from $((Get-PSCallStack)[1].Command)"
-        }
-    }
-    #endregion Safely convert input into instance parameters
-
-    #region Input Object was a server object
-    if ($ConvertedSqlInstance.InputObject.GetType() -eq [Microsoft.SqlServer.Management.Smo.Server] -or ($isAzure -and $instance.InputObject.ConnectionContext.IsOpen)) {
-        $server = $ConvertedSqlInstance.InputObject
-        $authtypeSMO = $SqlCredential.UserName -like '*\*'
-        if ($server.ConnectionContext.IsOpen -eq $false) {
-            if ($NonPooled) {
-                # When the Connect method is called, the connection is not automatically released.
-                # The Disconnect method must be called explicitly to release the connection to the connection pool.
-                # https://docs.microsoft.com/en-us/sql/relational-databases/server-management-objects-smo/create-program/disconnecting-from-an-instance-of-sql-server
-                $server.ConnectionContext.Connect()
-            } elseif ($authtypeSMO -eq "Windows Authentication with Credential") {
-                # Make it connect in a natural way, hard to explain.
-                # See https://docs.microsoft.com/en-us/sql/relational-databases/server-management-objects-smo/create-program/connecting-to-an-instance-of-sql-server
-                $null = $server.Information.Version
-
-                # Sometimes, however, the above may not connect as promised. Force it.
-                # See https://github.com/sqlcollaborative/dbatools/pull/4426
-                if ($server.ConnectionContext.IsOpen -eq $false) {
-                    $server.ConnectionContext.Connect()
-                }
-            } else {
-                # SqlConnectionObject.Open() enables connection pooling does not support
-                # alternative Windows Credentials and passes default credentials
-                # See https://github.com/sqlcollaborative/dbatools/pull/3809
-                $server.ConnectionContext.SqlConnectionObject.Open()
-            }
-        }
-
-        # Register the connected instance, so that the TEPP updater knows it's been connected to and starts building the cache
-        [Sqlcollaborative.Dbatools.TabExpansion.TabExpansionHost]::SetInstance($ConvertedSqlInstance.FullSmoName.ToLower(), $server.ConnectionContext.Copy(), ($server.ConnectionContext.FixedServerRoles -match "SysAdmin"))
-
-        # Update cache for instance names
-        if ([Sqlcollaborative.Dbatools.TabExpansion.TabExpansionHost]::Cache["sqlinstance"] -notcontains $ConvertedSqlInstance.FullSmoName.ToLower()) {
-            [Sqlcollaborative.Dbatools.TabExpansion.TabExpansionHost]::Cache["sqlinstance"] += $ConvertedSqlInstance.FullSmoName.ToLower()
-        }
-
-        # Update lots of registered stuff
-        if (-not [Sqlcollaborative.Dbatools.TabExpansion.TabExpansionHost]::TeppSyncDisabled) {
-            $FullSmoName = $ConvertedSqlInstance.FullSmoName.ToLower()
-            foreach ($scriptBlock in ([Sqlcollaborative.Dbatools.TabExpansion.TabExpansionHost]::TeppGatherScriptsFast)) {
-                Invoke-TEPPCacheUpdate -ScriptBlock $scriptBlock
-            }
-        }
-
-        # Make ComputerName easily available in the server object
-        if (-not $server.ComputerName) {
-            if (-not $server.NetName -or $SqlInstance -match '\.') {
-                $parsedcomputername = $ConvertedSqlInstance.ComputerName
-            } else {
-                $parsedcomputername = $server.NetName
-            }
-            Add-Member -InputObject $server -NotePropertyName ComputerName -NotePropertyValue $parsedcomputername -Force
-        }
-        return $server
-    }
-    #endregion Input Object was a server object
-
-    #region Input Object was anything else
-    if (-not $isAzure) {
-        $server = New-Object Microsoft.SqlServer.Management.Smo.Server $ConvertedSqlInstance.FullSmoName
-        $server.ConnectionContext.ApplicationName = "dbatools PowerShell module - dbatools.io"
-    }
-
-    if ($ConvertedSqlInstance.IsConnectionString) { $server.ConnectionContext.ConnectionString = $ConvertedSqlInstance.InputObject }
-
-    try {
-        if (Test-Bound -ParameterName 'StatementTimeout') {
-            $server.ConnectionContext.StatementTimeout = $StatementTimeout
-        }
-        if (-not $isAzure) {
-            $server.ConnectionContext.ConnectTimeout = [Sqlcollaborative.Dbatools.Connection.ConnectionHost]::SqlConnectionTimeout
-        }
-        if ($null -ne $SqlCredential.UserName -and -not $isAzure) {
-            $username = ($SqlCredential.UserName).TrimStart("\")
-
-            # support both ad\username and username@ad
-            if ($username -like "*\*" -or $username -like "*@*") {
-                if ($username -like "*\*") {
-                    $domain, $login = $username.Split("\")
-                    $authtype = "Windows Authentication with Credential"
-                    if ($domain) {
-                        $formatteduser = "$login@$domain"
-                    } else {
-                        $formatteduser = $username.Split("\")[1]
-                    }
-                } else {
-                    $formatteduser = $SqlCredential.UserName
-                }
-
-                $server.ConnectionContext.LoginSecure = $true
-                $server.ConnectionContext.ConnectAsUser = $true
-                $server.ConnectionContext.ConnectAsUserName = $formatteduser
-                $server.ConnectionContext.ConnectAsUserPassword = ($SqlCredential).GetNetworkCredential().Password
-            } else {
-                $authtype = "SQL Authentication"
-                $server.ConnectionContext.LoginSecure = $false
-                $server.ConnectionContext.set_Login($username)
-                $server.ConnectionContext.set_SecurePassword($SqlCredential.Password)
-            }
-        }
-    } catch { }
-
-    try {
-        if ($NonPooled) {
-            # When the Connect method is called, the connection is not automatically released.
-            # The Disconnect method must be called explicitly to release the connection to the connection pool.
-            # https://docs.microsoft.com/en-us/sql/relational-databases/server-management-objects-smo/create-program/disconnecting-from-an-instance-of-sql-server
-            $server.ConnectionContext.Connect()
-        } elseif ($authtype -eq "Windows Authentication with Credential") {
-            # Make it connect in a natural way, hard to explain.
-            # See https://docs.microsoft.com/en-us/sql/relational-databases/server-management-objects-smo/create-program/connecting-to-an-instance-of-sql-server
-            $null = $server.Information.Version
-
-            # Sometimes, however, the above may not connect as promised. Force it.
-            # See https://github.com/sqlcollaborative/dbatools/pull/4426
-            if ($server.ConnectionContext.IsOpen -eq $false) {
-                $server.ConnectionContext.Connect()
-            }
-        } else {
-            # SqlConnectionObject.Open() enables connection pooling does not support
-            # alternative Windows Credentials and passes default credentials
-            # See https://github.com/sqlcollaborative/dbatools/pull/3809
-            $server.ConnectionContext.SqlConnectionObject.Open()
-        }
-    } catch {
-        $message = $_.Exception.InnerException.InnerException
-        if ($message) {
-            # This is messy but it works to provide users with straightforward & detailed errors
-            $message = $message.ToString()
-            $message = ($message -Split '-->')[0]
-            $message = ($message -Split 'at System.Data.SqlClient')[0]
-            $message = ($message -Split 'at System.Data.ProviderBase')[0]
-
-            if ($message -match "network path was not found") {
-                $message = "Can't connect to $sqlinstance`: System.Data.SqlClient.SqlException (0x80131904): A network-related or instance-specific error occurred while establishing a connection to SQL Server. The server was not found or was not accessible. Verify that the instance name is correct and that SQL Server is configured to allow remote connections."
-            }
-
-            throw "Can't connect to $ConvertedSqlInstance`: $message "
-        } else {
-            throw $_
-        }
-    }
-
-    if ($MinimumVersion -and $server.VersionMajor) {
-        if ($server.versionMajor -lt $MinimumVersion) {
-            throw "SQL Server version $MinimumVersion required - $server not supported."
-        }
-    }
-
-    if ($AzureUnsupported -and $server.DatabaseEngineType -eq "SqlAzureDatabase") {
-        throw "Azure SQL Database not supported"
-    }
-
-    #'PrimaryFilePath' seems the culprit for slow SMO on databases
-    $Fields2000_Db = 'Collation', 'CompatibilityLevel', 'CreateDate', 'ID', 'IsAccessible', 'IsFullTextEnabled', 'IsSystemObject', 'IsUpdateable', 'LastBackupDate', 'LastDifferentialBackupDate', 'LastLogBackupDate', 'Name', 'Owner', 'ReadOnly', 'RecoveryModel', 'ReplicationOptions', 'Status', 'Version'
-    $Fields200x_Db = $Fields2000_Db + @('BrokerEnabled', 'DatabaseSnapshotBaseName', 'IsMirroringEnabled', 'Trustworthy')
-    $Fields201x_Db = $Fields200x_Db + @('ActiveConnections', 'AvailabilityDatabaseSynchronizationState', 'AvailabilityGroupName', 'ContainmentType', 'EncryptionEnabled')
-
-    $Fields2000_Login = 'CreateDate', 'DateLastModified', 'DefaultDatabase', 'DenyWindowsLogin', 'IsSystemObject', 'Language', 'LanguageAlias', 'LoginType', 'Name', 'Sid', 'WindowsLoginAccessType'
-    $Fields200x_Login = $Fields2000_Login + @('AsymmetricKey', 'Certificate', 'Credential', 'ID', 'IsDisabled', 'IsLocked', 'IsPasswordExpired', 'MustChangePassword', 'PasswordExpirationEnabled', 'PasswordPolicyEnforced')
-    $Fields201x_Login = $Fields200x_Login + @('PasswordHashAlgorithm')
-
-    try {
-        if ($Server.ServerType -ne 'SqlAzureDatabase') {
-            $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.Trigger], 'IsSystemObject')
-            $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.Schema], 'IsSystemObject')
-            $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.SqlAssembly], 'IsSystemObject')
-            $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.Table], 'IsSystemObject')
-            $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.View], 'IsSystemObject')
-            $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.StoredProcedure], 'IsSystemObject')
-            $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.UserDefinedFunction], 'IsSystemObject')
-
-            if ($server.VersionMajor -eq 8) {
-                # 2000
-                $initFieldsDb = New-Object System.Collections.Specialized.StringCollection
-                [void]$initFieldsDb.AddRange($Fields2000_Db)
-                $initFieldsLogin = New-Object System.Collections.Specialized.StringCollection
-                [void]$initFieldsLogin.AddRange($Fields2000_Login)
-                $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.Database], $initFieldsDb)
-                $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.Login], $initFieldsLogin)
-            } elseif ($server.VersionMajor -eq 9 -or $server.VersionMajor -eq 10) {
-                # 2005 and 2008
-                $initFieldsDb = New-Object System.Collections.Specialized.StringCollection
-                [void]$initFieldsDb.AddRange($Fields200x_Db)
-                $initFieldsLogin = New-Object System.Collections.Specialized.StringCollection
-                [void]$initFieldsLogin.AddRange($Fields200x_Login)
-                $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.Database], $initFieldsDb)
-                $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.Login], $initFieldsLogin)
-            } else {
-                # 2012 and above
-                $initFieldsDb = New-Object System.Collections.Specialized.StringCollection
-                [void]$initFieldsDb.AddRange($Fields201x_Db)
-                $initFieldsLogin = New-Object System.Collections.Specialized.StringCollection
-                [void]$initFieldsLogin.AddRange($Fields201x_Login)
-                $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.Database], $initFieldsDb)
-                $server.SetDefaultInitFields([Microsoft.SqlServer.Management.Smo.Login], $initFieldsLogin)
-            }
-        }
-    } catch {
-        # perhaps a DLL issue, continue going
-    }
-
-    # Register the connected instance, so that the TEPP updater knows it's been connected to and starts building the cache
-    [Sqlcollaborative.Dbatools.TabExpansion.TabExpansionHost]::SetInstance($ConvertedSqlInstance.FullSmoName.ToLower(), $server.ConnectionContext.Copy(), ($server.ConnectionContext.FixedServerRoles -match "SysAdmin"))
-
-    # Update cache for instance names
-    if ([Sqlcollaborative.Dbatools.TabExpansion.TabExpansionHost]::Cache["sqlinstance"] -notcontains $ConvertedSqlInstance.FullSmoName.ToLower()) {
-        [Sqlcollaborative.Dbatools.TabExpansion.TabExpansionHost]::Cache["sqlinstance"] += $ConvertedSqlInstance.FullSmoName.ToLower()
-    }
-
-    # Update lots of registered stuff
-    if (-not [Sqlcollaborative.Dbatools.TabExpansion.TabExpansionHost]::TeppSyncDisabled) {
-        $FullSmoName = $ConvertedSqlInstance.FullSmoName.ToLower()
-        foreach ($scriptBlock in ([Sqlcollaborative.Dbatools.TabExpansion.TabExpansionHost]::TeppGatherScriptsFast)) {
-            Invoke-TEPPCacheUpdate -ScriptBlock $scriptBlock
-        }
-    }
-
-    if (-not $server.ComputerName) {
-        if (-not $server.NetName -or $SqlInstance -match '\.') {
-            $parsedcomputername = $ConvertedSqlInstance.ComputerName
-        } else {
-            $parsedcomputername = $server.NetName
-        }
-        Add-Member -InputObject $server -NotePropertyName ComputerName -NotePropertyValue $parsedcomputername -Force
+        Connect-DbaInstance @PSBoundParameters -ClientName "dbatools PowerShell module - dbatools.io"
     }
-    return $server
-    #endregion Input Object was anything else
 }
\ No newline at end of file
diff --git a/tests/Get-DbaRepPublication.Tests.ps1 b/tests/Get-DbaRepPublication.Tests.ps1
index 54dcf1f242f2..a5c70428d266 100644
--- a/tests/Get-DbaRepPublication.Tests.ps1
+++ b/tests/Get-DbaRepPublication.Tests.ps1
@@ -6,7 +6,7 @@ Write-Host -Object "Running $PSCommandpath" -ForegroundColor Cyan
 Describe "$commandname Unit Tests" -Tag 'UnitTests' {
     Context "Validate parameters" {
         [object[]]$params = (Get-Command $CommandName).Parameters.Keys | Where-Object {$_ -notin ('whatif', 'confirm')}
-        [object[]]$knownParameters = 'SqlInstance','Database','SqlCredential','PublicationType','EnableException'
+        [object[]]$knownParameters = 'SqlInstance', 'Database', 'SqlCredential', 'PublicationType', '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
@@ -71,14 +71,6 @@ Describe "$commandname Unit Tests" -Tag 'UnitTests' {
                 $Results.PublicationType | Should Be "Snapshot"
             }
 
-            It "Stops if the SqlInstance does not exist" {
-
-                Mock Connect-SqlInstance -MockWith { Throw }
-
-                { Get-DbaRepPublication -sqlinstance MockServerName -EnableException} | should Throw
-
-            }
-
             It "Stops if validate set for PublicationType is not met" {
 
                 { Get-DbaRepPublication -SqlInstance MockServerName -PublicationType NotAPubType } | should Throw
diff --git a/tests/Get-DbaServerRole.Tests.ps1 b/tests/Get-DbaServerRole.Tests.ps1
index 705894c43af6..34df377ce3bc 100644
--- a/tests/Get-DbaServerRole.Tests.ps1
+++ b/tests/Get-DbaServerRole.Tests.ps1
@@ -11,30 +11,12 @@ Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan
 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','ServerRole','ExcludeServerRole','ExcludeFixedRole','EnableException'
+        [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'ServerRole', 'ExcludeServerRole', 'ExcludeFixedRole', '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
         }
     }
-    Context "Input validation" {
-        BeforeAll {
-            Mock Stop-Function { } -ModuleName dbatools
-        }
-        It "Should Call Stop-Function if instance does not exist or connection failure" {
-            Set-DbatoolsConfig -FullName sql.connection.timeout -Value 1
-            Get-DbaServerRole -SqlInstance Dummy | Should Be
-        }
-        It "Validates that Stop Function Mock has been called" {
-            $assertMockParams = @{
-                'CommandName' = 'Stop-Function'
-                'Times'       = 1
-                'Exactly'     = $true
-                'Module'      = 'dbatools'
-            }
-            Assert-MockCalled @assertMockParams
-        }
-    }
 }
 
 Describe "$CommandName Integration Tests" -Tags "IntegrationTests" {
diff --git a/tests/Invoke-DbaDbDbccUpdateUsage.Tests.ps1 b/tests/Invoke-DbaDbDbccUpdateUsage.Tests.ps1
index 8dfff3b7f974..71ed8def36a2 100644
--- a/tests/Invoke-DbaDbDbccUpdateUsage.Tests.ps1
+++ b/tests/Invoke-DbaDbDbccUpdateUsage.Tests.ps1
@@ -5,7 +5,7 @@ Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan
 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','Table','Index','NoInformationalMessages','CountRows','EnableException'
+        [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'Database', 'Table', 'Index', 'NoInformationalMessages', 'CountRows', '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
@@ -14,15 +14,15 @@ Describe "$CommandName Unit Tests" -Tag 'UnitTests' {
 }
 Describe "$commandname Integration Test" -Tag "IntegrationTests" {
     BeforeAll {
-        $server = Connect-SqlInstance -SqlInstance $script:instance1
+        $server = Connect-DbaInstance -SqlInstance $script:instance1
         $random = Get-Random
         $tableName = "dbatools_getdbtbl1"
 
         $dbname = "dbatoolsci_getdbUsage$random"
-        $null = $server.Query("CREATE DATABASE $dbname")
-        $null = $server.Query("CREATE TABLE $tableName (id int)", $dbname)
-        $null = $server.Query("CREATE CLUSTERED INDEX [PK_Id] ON $tableName ([id] ASC)", $dbname)
-        $null = $server.Query("INSERT $tableName(id) SELECT object_id FROM sys.objects", $dbname)
+        $db = New-DbaDatabase -SqlInstance $script:instance1 -Name $dbname
+        $null = $db.Query("CREATE TABLE $tableName (id int)", $dbname)
+        $null = $db.Query("CREATE CLUSTERED INDEX [PK_Id] ON $tableName ([id] ASC)", $dbname)
+        $null = $db.Query("INSERT $tableName(id) SELECT object_id FROM sys.objects", $dbname)
     }
     AfterAll {
         $null = Get-DbaDatabase -SqlInstance $script:instance1 -Database $dbname | Remove-DbaDatabase -Confirm:$false
diff --git a/tests/Invoke-DbaDbDecryptObject.Tests.ps1 b/tests/Invoke-DbaDbDecryptObject.Tests.ps1
index 53afa23e7ce2..581f9922c820 100644
--- a/tests/Invoke-DbaDbDecryptObject.Tests.ps1
+++ b/tests/Invoke-DbaDbDecryptObject.Tests.ps1
@@ -5,7 +5,7 @@ Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan
 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','ObjectName','EncodingType','ExportDestination','EnableException'
+        [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'Database', 'ObjectName', 'EncodingType', 'ExportDestination', '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
@@ -24,12 +24,8 @@ Describe "$CommandName Integration Tests" -Tags "UnitTests" {
         # Remove the database if it exists
         Remove-DbaDatabase -SqlInstance $script:instance1 -Database $dbname -Confirm:$false
 
-        # Get a server object
-        $server = Connect-DbaInstance -SqlInstance $script:instance1
-
         # Create the database
-        $server = Connect-DbaInstance -SqlInstance $script:instance1
-        $server.Query("CREATE DATABASE $dbname;")
+        $db = New-DbaDatabase -SqlInstance $script:instance1 -Name $dbname
 
         # Setup the code for the encrypted function
         $queryFunction = "
@@ -57,7 +53,7 @@ BEGIN
 END
         "
         # Create the encrypted function
-        $server.Databases[$dbname].Query($queryFunction)
+        $db.Query($queryFunction)
 
         # Setup the query for the encrypted stored procedure
         $queryStoredProcedure = "
@@ -80,7 +76,7 @@ END
         "
 
         # Create the encrypted stored procedure
-        $server.Databases[$dbname].Query($queryStoredProcedure)
+        $db.Query($queryStoredProcedure)
 
         # Check if DAC is enabled
         $config = Get-DbaSpConfigure -SqlInstance $script:instance1 -ConfigName RemoteDacConnectionsEnabled
diff --git a/tests/New-DbaDacProfile.Tests.ps1 b/tests/New-DbaDacProfile.Tests.ps1
index 30a3f0342833..6b7f4b52fe3a 100644
--- a/tests/New-DbaDacProfile.Tests.ps1
+++ b/tests/New-DbaDacProfile.Tests.ps1
@@ -5,7 +5,7 @@ Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan
 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','Path','ConnectionString','PublishOptions','EnableException'
+        [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'Database', 'Path', 'ConnectionString', 'PublishOptions', '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
@@ -16,9 +16,7 @@ Describe "$CommandName Unit Tests" -Tag 'UnitTests' {
 Describe "$CommandName Integration Tests" -Tags "IntegrationTests" {
     BeforeAll {
         $dbname = "dbatoolsci_publishprofile"
-        $server = Connect-DbaInstance -SqlInstance $script:instance1
-        $null = $server.Query("Create Database [$dbname]")
-        $db = Get-DbaDatabase -SqlInstance $script:instance1 -Database $dbname
+        $db = New-DbaDatabase -SqlInstance $script:instance1 -Name $dbname
         $null = $db.Query("CREATE TABLE dbo.example (id int);
             INSERT dbo.example
             SELECT top 100 1
diff --git a/tests/New-DbaDbMaskingConfig.Tests.ps1 b/tests/New-DbaDbMaskingConfig.Tests.ps1
index a1fc3ed4dda2..1bdce50401d9 100644
--- a/tests/New-DbaDbMaskingConfig.Tests.ps1
+++ b/tests/New-DbaDbMaskingConfig.Tests.ps1
@@ -15,29 +15,29 @@ Describe "$CommandName Unit Tests" -Tag 'UnitTests' {
 
 Describe "$CommandName Integration Tests" -Tag "IntegrationTests" {
     BeforeAll {
-        $db = "dbatoolsci_maskconfig"
+        $dbname = "dbatoolsci_maskconfig"
         $sql = "CREATE TABLE [dbo].[people](
                     [fname] [varchar](50) NULL,
                     [lname] [varchar](50) NULL,
                     [dob] [datetime] NULL
-                ) ON [PRIMARY]
-                GO
-                INSERT INTO people (fname, lname, dob) VALUES ('Joe','Schmoe','2/2/2000')
+                ) ON [PRIMARY]"
+        $db = New-DbaDatabase -SqlInstance $script:instance1 -Name $dbname
+        $db.Query($sql)
+        $sql = "INSERT INTO people (fname, lname, dob) VALUES ('Joe','Schmoe','2/2/2000')
                 INSERT INTO people (fname, lname, dob) VALUES ('Jane','Schmee','2/2/1950')"
-        New-DbaDatabase -SqlInstance $script:instance1 -Name $db
-        Invoke-DbaQuery -SqlInstance $script:instance1 -Query $sql -Database $db
+        $db.Query($sql)
     }
     AfterAll {
-        Remove-DbaDatabase -SqlInstance $script:instance1 -Database $db -Confirm:$false
+        Remove-DbaDatabase -SqlInstance $script:instance1 -Database $dbname -Confirm:$false
         $results | Remove-Item -Confirm:$false -ErrorAction Ignore
     }
 
     Context "Command works" {
 
         It "Should output a file with specific content" {
-            $results = New-DbaDbMaskingConfig -SqlInstance $script:instance1 -Database $db -Path C:\temp
+            $results = New-DbaDbMaskingConfig -SqlInstance $script:instance1 -Database $dbname -Path C:\temp
             $results.Directory.Name | Should -Be temp
-            $results.FullName | Should -FileContentMatch $db
+            $results.FullName | Should -FileContentMatch $dbname
             $results.FullName | Should -FileContentMatch fname
         }
     }
diff --git a/tests/Stop-DbaXESession.Tests.ps1 b/tests/Stop-DbaXESession.Tests.ps1
index ed1c8acff20c..a04696ed5851 100644
--- a/tests/Stop-DbaXESession.Tests.ps1
+++ b/tests/Stop-DbaXESession.Tests.ps1
@@ -5,7 +5,7 @@ Write-Host -Object "Running $PSCommandPath" -ForegroundColor Cyan
 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','Session','AllSessions','InputObject','EnableException'
+        [object[]]$knownParameters = 'SqlInstance', 'SqlCredential', 'Session', 'AllSessions', 'InputObject', 'EnableException'
         $knownParameters += [System.Management.Automation.PSCmdlet]::CommonParameters
         It "Should only contain our specific parameters" {
             (@(Compare-Object -ReferenceObject ($knownParameters | Where-Object {$_}) -DifferenceObject $params).Count ) | Should Be 0
@@ -16,20 +16,17 @@ Describe "$CommandName Unit Tests" -Tag 'UnitTests' {
 Describe "$CommandName Integration Tests" -Tags "IntegrationTests" {
     BeforeAll {
         $server = Connect-DbaInstance -SqlInstance $script:instance2
-        $conn = $server.ConnectionContext
-        # Get the systemhealth session
-        $systemhealth = Get-DbaXESession -SqlInstance $server -Session system_health
         # Create a valid session and start it
-        $conn.ExecuteNonQuery("CREATE EVENT SESSION [dbatoolsci_session_valid] ON SERVER ADD EVENT sqlserver.lock_acquired;")
-        $dbatoolsciValid = Get-DbaXESession -SqlInstance $server -Session dbatoolsci_session_valid
+        $server.Query("CREATE EVENT SESSION [dbatoolsci_session_valid] ON SERVER ADD EVENT sqlserver.lock_acquired;")
+        $dbatoolsciValid = Get-DbaXESession -SqlInstance $script:instance2 -Session dbatoolsci_session_valid
         $dbatoolsciValid.Start()
         # Record the Status of all sessions
-        $allSessions = Get-DbaXESession -SqlInstance $server
+        $allSessions = Get-DbaXESession -SqlInstance $script:instance2
     }
     BeforeEach {
-        $systemhealth.Refresh()
-        if (-Not $systemhealth.IsRunning) {
-            $systemhealth.Start()
+        $dbatoolsciValid.Refresh()
+        if (-Not $dbatoolsciValid.IsRunning) {
+            $dbatoolsciValid.Start()
         }
     }
     AfterAll {
@@ -38,40 +35,40 @@ Describe "$CommandName Integration Tests" -Tags "IntegrationTests" {
             $session.Refresh()
             if ($session.Status -eq "Stopped") {
                 if ($session.IsRunning) {
-                    $session.Stop()
+                    $session | Stop-DbaXESession
                 }
             } else {
                 if (-Not $session.IsRunning) {
-                    $session.Start()
+                    $session | Start-DbaXESession
                 }
             }
         }
 
         # Drop created objects
-        $conn.ExecuteNonQuery("IF EXISTS(SELECT * FROM sys.server_event_sessions WHERE name = 'dbatoolsci_session_valid') DROP EVENT SESSION [dbatoolsci_session_valid] ON SERVER;")
+        $server = Connect-DbaInstance -SqlInstance $script:instance2
+        $server.Query("IF EXISTS(SELECT * FROM sys.server_event_sessions WHERE name = 'dbatoolsci_session_valid') DROP EVENT SESSION [dbatoolsci_session_valid] ON SERVER;")
     }
 
     Context "Verifying command works" {
+        $server = Connect-DbaInstance -SqlInstance $script:instance2
         It "stops the system_health session" {
-            $systemhealth | Stop-DbaXESession
-            $systemhealth.Refresh()
-            $systemhealth.IsRunning | Should Be $false
+            $dbatoolsciValid | Stop-DbaXESession
+            $dbatoolsciValid.Refresh()
+            $dbatoolsciValid.IsRunning | Should Be $false
         }
 
         It "does not change state if XE session is already stopped" {
-            if ($systemhealth.IsRunning) {
-                $systemhealth.Stop()
+            if ($dbatoolsciValid.IsRunning) {
+                $dbatoolsciValid.Stop()
             }
-            Stop-DbaXESession $server -Session $systemhealth.Name -WarningAction SilentlyContinue
-            $systemhealth.Refresh()
-            $systemhealth.IsRunning | Should Be $false
+            Stop-DbaXESession -SqlInstance $server -Session $dbatoolsciValid.Name -WarningAction SilentlyContinue
+            $dbatoolsciValid.Refresh()
+            $dbatoolsciValid.IsRunning | Should Be $false
         }
 
         It "stops all XE Sessions except the system ones if -AllSessions is used" {
             Stop-DbaXESession $server -AllSessions -WarningAction SilentlyContinue
-            $systemhealth.Refresh()
             $dbatoolsciValid.Refresh()
-            $systemhealth.IsRunning | Should Be $true
             $dbatoolsciValid.IsRunning | Should Be $false
         }
     }
diff --git a/tests/pester.groups.ps1 b/tests/pester.groups.ps1
index 8c69b0206ba5..0c26e2fc3a8d 100644
--- a/tests/pester.groups.ps1
+++ b/tests/pester.groups.ps1
@@ -51,7 +51,8 @@ $TestsRunGroups = @{
         'Test-DbaAgentJobOwner',
         'Resume-DbaAgDbDataMovement',
         'Get-DbaDbMasterKey',
-        'Test-DbaAgentJobOwner'
+        'Test-DbaAgentJobOwner',
+        'Stop-DbaXESession'
     )
     # do not run everywhere
     "disabled"          = @()