Xester.psm1

Write-Verbose 'Importing from [C:\projects\xester\Xester\private]'
# .\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-TmanData.ps1
function Get-TmanData {
    <#
    .DESCRIPTION
        This function will Gather TestRun data.
    .PARAMETER RestServer
        A Rest Server is required.
    .PARAMETER StatusId
        A StatusId Id is optional.
    .EXAMPLE
        Get-TmanData -RestServer localhost -StatusId 2
    .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]$StatusId
    )
    begin {
        if ($StatusId){
            # Filter on the STATUS_ID
            $Url = "/testrun_manager?filter=STATUS_ID,eq,$StatusId&transform=true"
        } else {
            # No Filter
            $Url = "/testrun_manager?transform=true"
        }
    }
    process
    {
        if ($pscmdlet.ShouldProcess("Get-TmanData"))
        {
            try
            {
                Write-Log -Message "Gathering TestRun Manager 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-TmanData: $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\Complete-CancelledTestSet.ps1
function Complete-CancelledTestSet {
    <#
    .DESCRIPTION
        This function will set all Cancelled TestRuns to Aborted.
    .PARAMETER RestServer
        A Rest Server is required.
    .EXAMPLE
        Complete-CancelledTestSet -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("Complete-CancelledTestSet"))
        {
            try
            {
                Write-Log -Message "Setting all Cancelled Tests to Complete-Aborted." -MsgType DEBUG -Logfile $Logfile -LogLevel $LogLevel
                # Get the List of Queued Tests.
                $TestRunSet = (Get-TestRunSet -RestServer $RestServer -StatusId 10).testrun
                foreach ($TestRun in $TestRunSet){
                    $TestRunId = $TestRun.ID
                    Write-Log -Message "Setting TestRunID: $TestRunId to Complete-Aborted." -MsgType DEBUG -Logfile $Logfile -LogLevel $LogLevel
                    Update-TestRun -RestServer localhost -Status 9 -TestRunId $TestRunId -Result 5 -TestRun_Manager_ID 9999 | Out-Null
                }
            }
            catch
            {
                $ErrorMessage = $_.Exception.Message
                $FailedItem = $_.Exception.ItemName
                Throw "Complete-CancelledTestSet: $ErrorMessage $FailedItem"
            }
        }
        else
        {
            # -WhatIf was used.
            return $false
        }
    }
}
# .\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-AssignQueuedTestSet.ps1
function Invoke-AssignQueuedTestSet {
    <#
    .DESCRIPTION
        This function will set all Cancelled TestRuns to Aborted.
    .PARAMETER RestServer
        A Rest Server is required.
    .EXAMPLE
        Invoke-AssignQueuedTestSet -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("Invoke-AssignQueuedTestSet"))
        {
            try
            {
                Write-Log -Message "Attempting to Assign Queued Tests." -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
                    # Query for Running TestRun Managers
                    $TmanList = (Get-TmanData -RestServer $RestServer -StatusId 2).testrun_manager
                    if(($TmanList | Measure-Object).count -ne 0){
                        :ManagerLoop foreach($TestRunManager in $TmanList){
                            $Tman_ID = $TestRunManager.ID
                            # Assign the test to the Manager and break the loop.
                            Write-Log -Message "Assigning TestRunID: $TestRunId to TmanID: $Tman_ID." -MsgType DEBUG -Logfile $Logfile -LogLevel $LogLevel
                            Update-TestRun -RestServer localhost -Status 7 -TestRunId $TestRunId -Result 6 -TestRun_Manager_ID $Tman_ID | Out-Null
                            break ManagerLoop
                        }
                    } else {
                        Write-log -Message "There are no TestRun Managers Available" -Logfile $logfile -LogLevel $logLevel -MsgType INFO
                    }
                }
            }
            catch
            {
                $ErrorMessage = $_.Exception.Message
                $FailedItem = $_.Exception.ItemName
                Throw "Invoke-AssignQueuedTestSet: $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 all queued testruns to Submitted.
    .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-SubmittedTestSet.ps1
function Update-SubmittedTestSet {
    <#
    .DESCRIPTION
        This function will Update the TestRun Data - Simple fields.
    .PARAMETER RestServer
        A Rest Server is required.
    .EXAMPLE
        Update-SubmittedTestSet -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("Update-SubmittedTestSet"))
        {
            try
            {
                Write-Log -Message "Setting all submitted tests to Queued." -MsgType DEBUG -Logfile $Logfile -LogLevel $LogLevel
                # Get the List of Queued Tests.
                $TestRunSet = (Get-TestRunSet -RestServer $RestServer -StatusId 5).testrun
                foreach ($TestRun in $TestRunSet){
                    $TestRunId = $TestRun.ID
                    Write-Log -Message "Setting TestRunID: $TestRunId to Queued." -MsgType DEBUG -Logfile $Logfile -LogLevel $LogLevel
                    Update-TestRun -RestServer localhost -Status 6 -TestRunId $TestRunId -Result 6 -TestRun_Manager_ID 9999 | Out-Null
                }
            }
            catch
            {
                $ErrorMessage = $_.Exception.Message
                $FailedItem = $_.Exception.ItemName
                Throw "Update-SubmittedTestSet: $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]'