Xester.psm1

Write-Verbose 'Importing from [C:\projects\xester\Xester\private]'
# .\Xester\private\Disable-SSLValidation.ps1
function Disable-SSLValidation
{
    <#
    .SYNOPSIS
        Disables SSL certificate validation
    .DESCRIPTION
        Disable-SSLValidation disables SSL certificate validation by using reflection to implement the System.Net.ICertificatePolicy class.
        Author: Matthew Graeber (@mattifestation)
        License: BSD 3-Clause
    .NOTES
        Reflection is ideal in situations when a script executes in an environment in which you cannot call csc.ese to compile source code.
        If compiling code is an option, then implementing System.Net.ICertificatePolicy in C# and Add-Type is trivial.
    .LINK
        http://www.exploit-monday.com
    #>

    Set-StrictMode -Version 2
    # You have already run this function if ([System.Net.ServicePointManager]::CertificatePolicy.ToString() -eq 'IgnoreCerts') { Return }
    $Domain = [AppDomain]::CurrentDomain
    $DynAssembly = New-Object System.Reflection.AssemblyName('IgnoreCerts')
    $AssemblyBuilder = $Domain.DefineDynamicAssembly($DynAssembly, [System.Reflection.Emit.AssemblyBuilderAccess]::Run)
    $ModuleBuilder = $AssemblyBuilder.DefineDynamicModule('IgnoreCerts', $false)
    $TypeBuilder = $ModuleBuilder.DefineType('IgnoreCerts', 'AutoLayout, AnsiClass, Class, Public, BeforeFieldInit', [System.Object], [System.Net.ICertificatePolicy])
    $TypeBuilder.DefineDefaultConstructor('PrivateScope, Public, HideBySig, SpecialName, RTSpecialName') | Out-Null
    $MethodInfo = [System.Net.ICertificatePolicy].GetMethod('CheckValidationResult')
    $MethodBuilder = $TypeBuilder.DefineMethod($MethodInfo.Name, 'PrivateScope, Public, Virtual, HideBySig, VtableLayoutMask', $MethodInfo.CallingConvention, $MethodInfo.ReturnType, ([Type[]] ($MethodInfo.GetParameters() | ForEach-Object {$_.ParameterType})))
    $ILGen = $MethodBuilder.GetILGenerator()
    $ILGen.Emit([Reflection.Emit.Opcodes]::Ldc_I4_1)
    $ILGen.Emit([Reflection.Emit.Opcodes]::Ret)
    $TypeBuilder.CreateType() | Out-Null

    # Disable SSL certificate validation
    [System.Net.ServicePointManager]::CertificatePolicy = New-Object IgnoreCerts
    return $true
}

# .\Xester\private\Get-TestRunSet.ps1
function Get-TestRunSet {
    <#
    .DESCRIPTION
        This function will Gather TestRun data.
    .PARAMETER RestServer
        A Rest Server is required.
    .PARAMETER TestRunId
        A TestRunId Id is optional.
    .PARAMETER StatusId
        A StatusId Id is optional.
    .PARAMETER TestRun_Manager_ID
        A StatusId Id is optional.
    .EXAMPLE
        Get-TestRunSet -RestServer localhost -TestRunId 1
    .EXAMPLE
        Get-TestRunSet -RestServer localhost -StatusId 1
    .EXAMPLE
        Get-TestRunSet -RestServer localhost -TestRun_Manager_ID 1
    .NOTES
        This will return a hashtable of data from the database.
    #>

    [CmdletBinding(
        SupportsShouldProcess = $true,
        ConfirmImpact = "Low"
    )]
    [OutputType([hashtable])]
    [OutputType([Boolean])]
    param(
        [Parameter(Mandatory=$true)][string]$RestServer,
        [Parameter(Mandatory=$false)][int]$TestRunId,
        [Parameter(Mandatory=$false)][int]$StatusId,
        [Parameter(Mandatory=$false)][int]$TestRun_Manager_ID
    )
    begin {
        if ($TestRunId){
            # Filter on the TestRunId
            $Url = "/testrun?filter=ID,eq,$TestRunId&transform=true"
        } elseif ($StatusId){
            # Filter on the STATUS_ID
            $Url = "/testrun?filter=STATUS_ID,eq,$StatusId&transform=true"
        } elseif ($TestRun_Manager_ID) {
            # Filter on the TestRun_Manager_ID
            $Url = "/testrun?filter=TestRun_Manager_ID,eq,$TestRun_Manager_ID&transform=true"
        } else {
            # No Filter
            $Url = "/testrun?transform=true"
        }
    }
    process
    {
        if ($pscmdlet.ShouldProcess("Get-TestRunSet"))
        {
            try
            {
                Write-Log -Message "Gathering TestRun Data" -MsgType DEBUG -Logfile $Logfile -LogLevel $LogLevel
                # Make the rest call to Get the data
                Invoke-XesterRestCall -RestServer $RestServer -URI "$Url" -Method Get
            }
            catch
            {
                $ErrorMessage = $_.Exception.Message
                $FailedItem = $_.Exception.ItemName
                Throw "Get-TestRunSet: $ErrorMessage $FailedItem"
            }
        }
        else
        {
            # -WhatIf was used.
            return $false
        }
    }
}
# .\Xester\private\Get-XsTimeStamp.ps1
function Get-XsTimeStamp {
    <#
    .DESCRIPTION
        This function will return a TimeStamp.
    .PARAMETER RestServer
        A Rest Server is required.
    .EXAMPLE
        Get-XsTimeStamp
    .NOTES
        This will return a TimeStamp.
    #>

    [CmdletBinding()]
    [OutputType([string])]
    param()
    try
    {
        Get-Date -Format "MMddyyyy-HH:mm:ss"
    }
    catch
    {
        $ErrorMessage = $_.Exception.Message
        $FailedItem = $_.Exception.ItemName
        Throw "Get-XsTimeStamp: $ErrorMessage $FailedItem"
    }
}
# .\Xester\private\Update-TestRun.ps1
function Update-TestRun {
    <#
    .DESCRIPTION
        This function will Update the TestRun Data - Simple fields.
    .PARAMETER RestServer
        A Rest Server is required.
    .PARAMETER TestRunId
        A TestRunId Id is required.
    .PARAMETER Status
        A Status is required.
    .PARAMETER Result
        A Result is required.
    .PARAMETER TestRun_Manager_ID
        A TestRun_Manager_ID is required.
    .EXAMPLE
        Update-TestRun -RestServer localhost -Status 2 -TestRunId 1 -Result 2 -TestRun_Manager_ID 1
    .NOTES
        This will return a hashtable of data from the PPS database.
    #>

    [CmdletBinding(
        SupportsShouldProcess = $true,
        ConfirmImpact = "Low"
    )]
    [OutputType([hashtable])]
    [OutputType([Boolean])]
    param(
        [Parameter(Mandatory=$true)][string]$RestServer,
        [Parameter(Mandatory=$true)][int]$Status,
        [Parameter(Mandatory=$true)][int]$TestRunId,
        [Parameter(Mandatory=$true)][int]$Result,
        [Parameter(Mandatory=$true)][int]$TestRun_Manager_ID
    )
    begin {
        $body = @{
            STATUS_ID = "$Status"
            RESULT_ID = "$Result"
            TestRun_Manager_ID = "$TestRun_Manager_ID"
        }
        $body = $body | ConvertTo-Json
    }
    process
    {
        if ($pscmdlet.ShouldProcess("Update-TestRun"))
        {
            try
            {
                Write-Log -Message "Updating the TestRun ID: $TestRunId" -MsgType DEBUG -Logfile $Logfile -LogLevel $LogLevel
                # Make the rest call to update the data
                $Url = "/testrun/$TestRunId"
                Invoke-XesterRestCall -RestServer $RestServer -URI "$Url" -Method Put -Body $body
            }
            catch
            {
                $ErrorMessage = $_.Exception.Message
                $FailedItem = $_.Exception.ItemName
                Throw "Update-TestRun: $ErrorMessage $FailedItem"
            }
        }
        else
        {
            # -WhatIf was used.
            return $false
        }
    }
}
Write-Verbose 'Importing from [C:\projects\xester\Xester\public]'
# .\Xester\public\Get-XSqmanData.ps1
function Get-XsQmanData {
    <#
    .DESCRIPTION
        This function will Gather Qman data.
    .PARAMETER RestServer
        A Rest Server is required.
    .PARAMETER QmanId
        A Qman Id is required.
    .EXAMPLE
        Get-XSqmanData -RestServer localhost -QmanId 1
    .NOTES
        This will return a hashtable of data from the PPS database.
    #>

    [CmdletBinding(
        SupportsShouldProcess = $true,
        ConfirmImpact = "Low"
    )]
    [OutputType([hashtable])]
    [OutputType([Boolean])]
    param(
        [Parameter(Mandatory=$true)][string]$RestServer,
        [Parameter(Mandatory=$true)][int]$QmanId
    )
    begin {
    }
    process
    {
        if ($pscmdlet.ShouldProcess("Get-XSqmanData"))
        {
            try
            {
                Write-Log -Message "Getting the Qman Data" -MsgType DEBUG -Logfile $Logfile -LogLevel $LogLevel
                # Make the rest call to Get the data
                $Url = "/queue_manager/$QmanId"
                Invoke-XesterRestCall -RestServer $RestServer -URI "$Url" -Method Get
            }
            catch
            {
                $ErrorMessage = $_.Exception.Message
                $FailedItem = $_.Exception.ItemName
                Throw "Get-XSqmanData: $ErrorMessage $FailedItem"
            }
        }
        else
        {
            # -WhatIf was used.
            return $false
        }
    }
}
# .\Xester\public\Invoke-XesterRestCall.ps1
function Invoke-XesterRestCall
{
    <#
    .DESCRIPTION
        This function will Perform a Rest Call to a Specific XesterUI Server.
    .PARAMETER RestServer
        A Rest Server is required.(Hostname or IP, not full URL)
    .PARAMETER URI
        A URI is required.
    .PARAMETER Method
        A Method is Required.
    .PARAMETER Body
        A Method is Optional.
    .EXAMPLE
        Invoke-XesterRestCall -RestServer localhost -URI "/queue_manager/1?transform=true" -Method Get
    .NOTES
        This will return a hashtable of data from the PPS database.
    #>

    [CmdletBinding()]
    [OutputType([hashtable])]
    param(
        [Parameter(Mandatory = $true)][string]$RestServer,
        [Parameter(Mandatory = $true)][string]$URI,
        [ValidateSet("GET", "POST", "PUT", "DELETE")]
        [Parameter(Mandatory = $true)][string]$Method,
        [Parameter(Mandatory = $false)]$Body
    )
    try
    {
        $fullURL = "http://" + $RestServer + "/XesterUI/api/index.php" + $URI
        if ($null -eq $Body)
        {
            $RestParams = @{
                Method = "$Method"
                URI    = "$fullURL"
            }
        }
        else
        {
            $RestParams = @{
                Method = "$Method"
                URI    = "$fullURL"
                Body   = $Body
            }
        }
        Write-Log -Message "RestCall Details; FullUrl: $FullURL - Method: $Method" -LogLevel $LogLevel -MsgType DEBUG -Logfile $Logfile | Out-Null
        Invoke-RestMethod @RestParams
    }
    catch
    {
        $ErrorMessage = $_.Exception.Message
        $FailedItem = $_.Exception.ItemName
        Throw "Invoke-XesterRestCall: $ErrorMessage $FailedItem"
    }
}
# .\Xester\public\Reset-QueuedTestSet.ps1
function Reset-QueuedTestSet {
    <#
    .DESCRIPTION
        This function will Update the TestRun Data - Simple fields.
    .PARAMETER RestServer
        A Rest Server is required.
    .EXAMPLE
        Reset-QueuedTestSet -RestServer localhost
    .NOTES
        This will return a hashtable of data from the PPS database.
    #>

    [CmdletBinding(
        SupportsShouldProcess = $true,
        ConfirmImpact = "Low"
    )]
    [OutputType([hashtable])]
    [OutputType([Boolean])]
    param(
        [Parameter(Mandatory=$true)][string]$RestServer
    )
    begin {
    }
    process
    {
        if ($pscmdlet.ShouldProcess("Reset-QueuedTestSet"))
        {
            try
            {
                Write-Log -Message "Setting all Queued Tests to Submitted." -MsgType DEBUG -Logfile $Logfile -LogLevel $LogLevel
                # Get the List of Queued Tests.
                $TestRunSet = (Get-TestRunSet -RestServer $RestServer -StatusId 6).testrun
                foreach ($TestRun in $TestRunSet){
                    $TestRunId = $TestRun.ID
                    Write-Log -Message "Setting TestRunID: $TestRunId to Submitted." -MsgType DEBUG -Logfile $Logfile -LogLevel $LogLevel
                    Update-TestRun -RestServer localhost -Status 5 -TestRunId $TestRunId -Result 6 -TestRun_Manager_ID 9999 | Out-Null
                }
            }
            catch
            {
                $ErrorMessage = $_.Exception.Message
                $FailedItem = $_.Exception.ItemName
                Throw "Reset-QueuedTestSet: $ErrorMessage $FailedItem"
            }
        }
        else
        {
            # -WhatIf was used.
            return $false
        }
    }
}
# .\Xester\public\Update-XSqmanData.ps1
function Update-XsQmanData {
    <#
    .DESCRIPTION
        This function will Update the Qman Data
    .PARAMETER RestServer
        A Rest Server is required.
    .PARAMETER Status
        A Status is required.
    .PARAMETER QmanId
        A Qman Id is required.
    .PARAMETER QmanLogFile
        A QmanLogFile is optional.
    .EXAMPLE
        Update-XSqmanData -RestServer localhost -Status 2 -QmanId 1 -QmanLogFile "c:\test\test.log"
    .NOTES
        This will return a hashtable of data from the PPS database.
    #>

    [CmdletBinding(
        SupportsShouldProcess = $true,
        ConfirmImpact = "Low"
    )]
    [OutputType([hashtable])]
    [OutputType([Boolean])]
    param(
        [Parameter(Mandatory=$true)][string]$RestServer,
        [Parameter(Mandatory=$true)][int]$Status,
        [Parameter(Mandatory=$false)][string]$QmanLogFile,
        [Parameter(Mandatory=$true)][int]$QmanId
    )
    begin {
        $HeartBeat = Get-XsTimeStamp
        if(($null -eq $QmanLogFile) -or ($QmanLogFile -eq "")){
            $body = @{
                STATUS_ID = "$Status"
                Heartbeat = "$HeartBeat"
            }
        } else {
            $body = @{
                STATUS_ID = "$Status"
                Log_File = "$QmanLogFile"
                Heartbeat = "$HeartBeat"
            }
        }
        $body = $body | ConvertTo-Json
    }
    process
    {
        if ($pscmdlet.ShouldProcess("Update-XSqmanData"))
        {
            try
            {
                Write-Log -Message "Updating the Qman" -MsgType DEBUG -Logfile $Logfile -LogLevel $LogLevel
                # Make the rest call to update the data
                $Url = "/queue_manager/$QmanId"
                Invoke-XesterRestCall -RestServer $RestServer -URI "$Url" -Method Put -Body $body
            }
            catch
            {
                $ErrorMessage = $_.Exception.Message
                $FailedItem = $_.Exception.ItemName
                Throw "Update-XSqmanData: $ErrorMessage $FailedItem"
            }
        }
        else
        {
            # -WhatIf was used.
            return $false
        }
    }
}
Write-Verbose 'Importing from [C:\projects\xester\Xester\classes]'