pscodebeamer.tests.ps1


BeforeAll {
    Import-Module -Name "C:\Users\brandkzy\OneDrive - Schaeffler\Documents\PowerShell\Modules\PSCodeBeamer\pscodebeamer.psm1"

    # inside Schaeffler_codebeamer_help._functions.ps1 there is one fuction which give default values for creating new item.
    . .\Schaeffler_codebeamer_help._functions.ps1

    # Setting The enviroment decalred on Top to be avaiable on every test
    $script:server = "codebeamer-test.schaeffler.com:8443"

    # $cred = Get-Credential -Message "Please enter your production credential for server: $server. Created Session will be used for the rest of the test."
    $script:cred = Use-CBCredential -CodebeamerProduction

    $script:testSession = New-CBSession -Server $server -Credential $cred

    # Scip creating new item
    $script:newItem = $true
    $AvoidprojectsID = @(70,84,54)
    $script:avoidField = @("Test Case","Test Cases")

    # I wanted to give test a bit of randomness So in few test function we will get random project, random tracker and Create one item
    do{
        $script:Projects = Get-CBProject -CBSession $testSession

        $index = Get-Random -Minimum 0 -Maximum ($Projects.Length -1)
        #getting Random Project from your Server
        $script:projectID =  $Projects[$index].id

    } while ($script:projectID -in $AvoidprojectsID)


    # To avoid creating Baslines in every test here pleas provide some values for
    # tracker
    $script:hardcodedTrackerID = 1304814

    # baseline of Tracker Above
    $script:hardcodedBaslineID = 1304774

    # trackerItem of above Tracker
    $script:hardcodedTrackerItemID = 378090

    # summary of tracker item above
    $script:nameValueFromBaselineAndVersion = "test2"

    # first version of tracker item above
    $script:Version = 1

    #some later version of $script:hardcodedTrackerItemID
    $script:laterVersion = 25

    #UserName
    $script:userName = "brandkzy"
    $script:email = "brandkzy@schaeffler.com"
    $script:firstName = "Krzysztof"

    # for Copy-cbItem Tests
    $script:hardcodedCopyDestinationTrackerItem = 388450

}
# Begin a new Pester test block
Describe "New-CBSession Fuction Tests" {

    Context "Connection Successfully Confirmed" {

        It "Should seturn variable with headers and server" {
            # Assert
            $testSession.server | Should -BeExactly $server
            $testSession.headers.Keys -join "," | should -BeExactly "Authorization,content-type"
        }
    }

    Context "Error Handling" {

        It "Should return error when wrong Server name is provided" {
            $invalidServer = "invalid-Server.schaeffler.com:8443"
            $expectedError = "An error occurred while sending the request."


            { throw New-CBSession -Server $invalidServer -Credential $cred  -ErrorAction Stop} | Should -Throw -ExpectedMessage $expectedError
        }
    }
}

Describe "Get-CBProject Fuction Tests" {

    Context "Basic Functionality" {

        It "Should return a project when given valid ID" {

        # Act
        $result = Get-CBProject -ProjectID $script:projectID -CBSession $script:testSession

        # Assert
        $result | Should -Not -BeNullOrEmpty
        $result | Should -BeOfType 'PSCustomObject'
        $result.ID | Should -Be $script:projectID

        Write-Host "Project ID in Test: $script:projectID" -ForegroundColor Magenta
    }

        It "Should return Project List" {

            # Act
            $result = Get-CBProject -CBSession $script:testSession

            # Assert
            $result.length | Should -BeExactly $script:Projects.length
        }
    }

    Context "Error Handling" {
            It "Should throw an error when given invalid Project ID" {
            # Arrange
            $invalidMockID = 28396532
            $expectedMessage = "Project with ID: $invalidMockID does not exist on Server: $Server. Please Recheck Project ID"

            # Act & Assert
            { throw Get-CBProject -ProjectID $invalidMockID -CBSession $script:testSession -ErrorAction Stop } | Should -Throw -ExpectedMessage $expectedMessage
        }
    }
}

Describe "Get-CBProjectMemberList Fuction Tests" {

    Context "Basic Functionality" {

            It "Should return list of tracker from Project limited by -Size Paramater" {
            # Act
            $result = Get-CBProjectMemberList -ProjectID $script:projectID -CBSession $script:testSession -Size 2
            ($result | Measure-Object).Count | Should -BeExactly 2
        }
    }

    Context "Error Handling" {

            It "Should throw an error when given invalid Project ID" {

            # Arrange
            $invalidMockID = '28396532'
            $expectedMessage = "Project with ID: $invalidMockID does not exist on Server: $Server. Please Recheck Project ID"

            # Act & Assert
            { throw Get-CBProjectMemberList -ProjectID $invalidMockID -CBSession $script:testSession -ErrorAction Stop } | Should -Throw -ExpectedMessage $expectedMessage
        }
    }
}

Describe "Get-CBProjectTrackerList Fuction Tests" {

    Context "Basic Functionality" {

        It "Should return list of tracker from Project" {
            # Act
            $result = Get-CBProjectTrackerList -ProjectID $script:projectID -CBSession $script:testSession

            $index = Get-Random -Minimum 0 -Maximum ($result.Length -1)
            $script:trackersIDList = $result.id
            #Tracker ID be used for remaining test

            $script:trackerID = $result[$index].id

            Write-Host "Tracker ID to be used in the rest of the test: $script:trackerID" -ForegroundColor Magenta

            $script:trackerID | Should -BeGreaterThan 0
            $result[0].type | Should -BeExactly "TrackerReference"
        }
    }

    Context "Error Handling" {

            It "Should throw an error when given invalid Project ID" {
            # Arrange
            $invalidMockID = '28396532'
            $expectedMessage = "Project with ID: $invalidMockID does not exist on Server: $Server. Please Recheck Project ID"

            # Act & Assert
            { throw Get-CBProjectTrackerList -ProjectID $invalidMockID -CBSession $script:testSession -ErrorAction Stop } | Should -Throw -ExpectedMessage $expectedMessage
        }
    }
}

Describe "Get-CBTrackerConfiguration Function Tests" {

    Context "Basic Functionality" {

        It "Should Return Object with two properties BasicInformation & Fields" {

            # Act & Assert
            $result = Get-CBTrackerConfiguration -TrackerID $script:trackerID -CBSession $script:testSession
            $result.basicInformation.trackerId | Should -BeExactly $script:trackerID
            $result.basicInformation.projectId | Should -BeExactly $script:projectID
            $result.fields | Should -not -BeNullOrEmpty
            $script:TrackerConfiguration = $result
        }

        It "Should Return Mandatory Fields in Tracker" {
            $result = Get-CBTrackerConfiguration -TrackerID $script:trackerID -CBSession $script:testSession -MandatoryFields

            if(-not $result) {
                Write-Host "No Mandatory Fields Found in TrackerID: $script:trackerID" -ForegroundColor Magenta
                $result = (Get-CBTrackerConfiguration -TrackerID $script:trackerID -CBSession $script:testSession).fields | Where-Object {$_.typeId -eq 10}
                $result.typeId | Should -Contain 10
            } else {
                $result[0].mandatory | should -be $true
            }

        }
    }
    Context "Error Handling" {

        It " Should return error when provided wrong Tracker ID" {

            $invalidTrackerID = 2839651
            $expectedError = "Tracker ID: $invalidTrackerID most likely doesn't exist. Please recheck Tracker ID or Server."

            { throw Get-CBTrackerConfiguration -TrackerID $invalidTrackerID -CBSession $script:testSession -ErrorAction Stop } | Should -Throw -ExpectedMessage $expectedError
        }
    }
}



Describe "Get-CbTrackerSchema Function Tests" {

    It "Should return Mandatory Fields of Tracker or null if none are found" {

        $result = get-CbTrackerSchema -TrackerID $script:trackerID -CBSession $script:testSession
            | Where-Object {$_.mandatoryInStatuses.id -contains 0}

        if(-not $result) {
            Write-Host "No Mandatory Fields Found in TrackerID: $script:trackerID" -ForegroundColor Magenta
            $result = (Get-CBTrackerConfiguration -TrackerID $script:trackerID -CBSession $script:testSession).fields | Where-Object {$_.typeId -eq 10}
            $result.typeId | Should -Contain 10
        } else {
            $result[0].mandatoryInStatuses | Should -not -BeNullOrEmpty
        }

        $script:fieldNames = New-Object System.Collections.ArrayList
            # I have to do this Sorry Future Krzysztof!!!!
            foreach ($field in $result.name){
                if($field -notin $script:avoidField) {
                    $script:fieldNames.add($field)
                }
            }

            foreach ($field in  $script:fieldNames) {
                Write-Host "Field Name used in Test: $($field)" -ForegroundColor Magenta
            }
    }
}


Describe "Get-CBTrackerChild Fuction Tests" {

    Context "Should return Tracker Item ID or null if Tracker doesn't have items" {

        It "Should Return ID or null" {

            $result =  Get-CBTrackerChild -TrackerID $script:trackerID -CBSession $script:testSession

            if($result) {
                $result.id | Should -Not -BeNullOrEmpty
                $result[0].id.gettype().name | Should -be "Int64"

            } else {
                $result | Should -Be $null
            }
        }
    }

    Context "Error Handling" {

        It "Should Return Error When provided invalid TrackerID" {

            $invalidTrackerID = 76254231
            $expectedError = "Tracker ID: $invalidTrackerID most likely doesn't exist. Please recheck Tracker ID or Server."

            {throw Get-CBTrackerChild -TrackerID $invalidTrackerID -CBSession $script:testSession -ErrorAction Stop } | Should -Throw -ExpectedMessage $expectedError
        }
    }
}

Describe "Get-CBTrackerField Function Test" {

    Context "Should return information about field using Parameter set by ID and By Name" {

        It "By Field Name" {
           $result =  Get-CBTrackerField -TrackerID $script:trackerID -Name ($script:fieldNames | Select-Object -First 1) -CBSession $script:testSession
           $result.name | Should -Contain ($script:fieldNames | Select-Object -First 1)
           $script:fieldId = $result.id
        }

        It "By Field ID" {
           $result =  Get-CBTrackerField -TrackerID $script:trackerID -ID $script:fieldId -CBSession $script:testSession
           $result.name | Should -BeExactly ($script:fieldNames | Select-Object -First 1)

        }

        It "Default Set" {
            # Arrange
            $type = "FieldReference"
            # Act
            $result = get-CBTrackerField -TrackerID $script:trackerID -CBSession $script:testSession
            $result[0].type | Should -BeExactly $type
            $result[0].trackerId | Should -BeExactly $script:trackerID

        }

        It "DetailSet Set" {

            # Arrange
            $resultObject = get-CBTrackerField -TrackerID $script:trackerID -CBSession $script:testSession

            # Act
            $result = get-CBTrackerField -TrackerID $script:trackerID -CBSession $script:testSession -AllDetails
            $result.length | Should -BeExactly $resultObject.length
        }
    }
    Context "Error Handling"{

        It "Should return error when providing incorrect Field ID" {

            # Arrange
            $trackerID = 354277
            $invalidFieldID = 11133
            $expectedError = "Field ID: $invalidFieldID most likely doesn't exist. Please recheck Field ID or Server."
            # Act
            { throw get-CBTrackerField -TrackerID $script:trackerID -CBSession $script:testSession -ID $invalidFieldID  -ErrorAction Stop } | Should -Throw -ExpectedMessage $expectedError

        }

        It "Throws error for invalid Tracker ID" {

            # Arrange
            $invalidTrackerID = 111111111
            $expectedError = "Tracker ID: $invalidTrackerID most likely doesn't exist. Please recheck Tracker ID or Server."
            # Act
            { throw get-CBTrackerField -TrackerID $invalidTrackerID -CBSession $script:testSession -ErrorAction Stop } | Should -Throw -ExpectedMessage $expectedError
        }
    }
}

Describe "ConvertTo-CbField Function Tests" {

    Context "Should Return Field Values ready to be use in creating or editing in Codebeamer API" {

        It "Creating Fields Object with Default Values" {

            $result = convertTo-CbField -Field $script:fieldNames -TrackerID $script:trackerID -CBSession $script:testSession -DefaultValues

            Compare-Object -ReferenceObject $script:fieldNames -DifferenceObject $result.name | Should -BeNullOrEmpty
            $script:fieldForNewItem = $result
        }
    }
    Context "Error Handling"{

        It "Should return error when prdovided incorrect Tracker ID" {

            # Arrange
            $invalidTrackerID = 12143881
            $expectedError = "Tracker ID: $invalidTrackerID most likely doesn't exist. Please recheck Tracker ID or Server."
            # Act
            { throw convertTo-CbField -TrackerID $invalidTrackerID -CBSession $script:testSession -ErrorAction Stop } | Should -Throw -ExpectedMessage $expectedError
        }
    }
}

Describe "New-CBItem Function Tests" {

    Context "Should Create New item" {

        It "Should create Item with given Field Objects provided from convertTo-CbField" -Skip:$script:newItem {

            # Act
            $result = New-CBItem -TrackerID $script:trackerID -cbsession $script:testSession -FieldValues $script:fieldForNewItem


            # Assert
            $assert = Get-CBItem -ItemID $result.id -CBSession $script:testSession

            $result.id | Should -BeExactly $assert.id
            $result.tracker.id | Should -BeExactly $script:trackerID

            $script:trackerItemID = $result.id

            Write-Host "New Item in Tracker: $script:trackerID created. New Item ID: $($result.id)" -ForegroundColor Magenta
        }
    }
    Context "Error Handling" {

        It "Should REturn error when providing wrong Tracker ID" {
            # Arrange
            $invalidTrackerID = 12143881
            $expectedError = "Tracker ID: $invalidTrackerID most likely doesn't exist. Please recheck Tracker ID or Server."
            # Act
            { throw New-CBItem -TrackerID $invalidTrackerID -CBSession $script:testSession -FieldValues $script:fieldForNewItem -ErrorAction Stop } | Should -Throw -ExpectedMessage $expectedError
        }
    }
}

Describe "Get-CBItemField Function Tests" {

    Context "Testing Parameters Sets and Parameters -Field, -ExlucdeField" {
        It "Should Return list of readOnlyFields and editableFields" {
        # Arrange

        $readOnlyFields = "readOnlyFields"
        $editableFields = "editableFields"


        $result = get-CBItemField -ItemID $script:trackerItemID -CBSession $script:testSession
        $result.psobject.Members.name | Should -Contain $readOnlyFields
        $result.psobject.Members.name | Should -Contain $editableFields
    }

    It "Should Return only fields specified in paramater -field" {

        # Act
        $result = get-CBItemField -ItemID $script:trackerItemID -CBSession $script:testSession -Field ($script:fieldForNewItem | Select-Object -ExpandProperty Name)
        $result.name.count | Should -BeExactly $script:fieldForNewItem.count

        foreach ($fieldName in $result.name) {

            ($script:fieldForNewItem | Select-Object -ExpandProperty Name) | Should -Contain $fieldName

        }
    }

        It "Should return Fields list exluding one field"  {
            $result = get-CBItemField -ItemID $script:trackerItemID -CBSession $script:testSession -ExcludeField ($script:fieldForNewItem | Select-Object -ExpandProperty Name)

            foreach ($fieldName in $result.name) {

                ($script:fieldForNewItem | Select-Object -ExpandProperty Name) | Should -Not -Contain $fieldName

            }
        }
    }
}


Describe "Set-Cbitem Function Tests" {

    It "Should Modify existing Tracker Item with given Value" {
        # Arrange
            $Scriptblock = {
            $_.type -eq "IntegerFieldValue" `
        -or $_.type -eq "WikiTextFieldValue" `
        -or $_.type -eq "TextFieldValue" `
        -or $_.type -eq "BoolFieldValue" `
        -or $_.type -eq "DateFieldValue" `
        -or $_.type -eq "DurationFieldValue" `
        -and $_.name -ne "Description Format"
        }
        $integer = 1
        $wikiText = "Set-CBITem NEW WikiTextFieldValue"
        $TextField = "Set-CBITem NEW TextFieldValue"
        $boolValue = $true
        $date = Get-date -Format 'yyyy-MM-ddThh:mm:ss.fff'
        $duration = 36000
        $FieldsObjects = ((Get-CBItemField -ItemID $script:trackerItemID -CBSession $script:testSession).editablefields | Where-Object $Scriptblock)

        switch ($FieldsObjects) {
            {$_.type -eq "IntegerFieldValue"  } {
                if($_.value) { $_.value = $integer } else { $_ | Add-member -NotePropertyName value -NotePropertyValue $integer }
            }
            {$_.type -eq "WikiTextFieldValue" } {
                if($_.value) { $_.value = $wikiText } else { $_ | Add-member -NotePropertyName value -NotePropertyValue $wikiText }
            }
            {$_.type -eq "TextFieldValue"  } {
                if($_.value) { $_.value = $TextField } else { $_ | Add-member -NotePropertyName value -NotePropertyValue $TextField }
            }
            {$_.type -eq "BoolFieldValue"     } {
                if($_.value) { $_.value = $boolValue } else { $_ | Add-member -NotePropertyName value -NotePropertyValue $boolValue }
            }
            {$_.type -eq "DateFieldValue"     } {
                if($_.value) { $_.value = $date } else { $_ | Add-member -NotePropertyName value -NotePropertyValue $date }
            }
            {$_.type -eq "DurationFieldValue" } {
                if($_.value) { $_.value = $duration } else { $_ | Add-member -NotePropertyName value -NotePropertyValue $duration }
            }
        }
        # Act & Assert
        Set-CBItem -ItemID $script:trackerItemID -FieldValues $FieldsObjects -CBSession $script:testSession

        $fieldsObjectAfterUpdate = ((Get-CBItemField -ItemID $script:trackerItemID -CBSession $script:testSession).editablefields | Where-Object $Scriptblock)

        Compare-Object -ReferenceObject $($FieldsObjects.value) -DifferenceObject $($fieldsObjectAfterUpdate.value) | Should -BeNullOrEmpty
    }

    Context "Error Handling" {

        It "Should return error when provided incorrect Item ID" {
            #Arrange
            $invalidItemID = 24865124
            $errorMessage = "Not accessible tracker item ids: ({0})." -f 24865124

            { throw Set-CBItem -ItemID $invalidItemID -CBSession $script:testSession -FieldValues $script:fieldForNewItem -ErrorAction Stop } | Should -Throw -ExpectedMessage $errorMessage
        }
    }
}

Describe "Get-CBItem Function Tests" {

    Context "Parameter Sets Test" {

        It "Should call Get-CBItem" {

            # Act
            $result =  Get-CBItem -ItemID $script:trackerItemID -cbsession $script:testSession

            # Assert
            $result | Should -Not -BeNullOrEmpty
            $result.id | Should -BeExactly $script:trackerItemID

        }

        It "Should return Item Description from Baseline" {

            # Act
            $result = Get-CBItem -ItemID  $script:hardcodedTrackerItemID -cbsession $script:testSession -BaselineID $script:hardcodedBaslineID

            # Assert
            $result.name | Should -BeExactly $script:nameValueFromBaselineAndVersion
        }

        It "Should return Item Description from Version" {

            # $Act & Assert
            $result = Get-CBItem -ItemID $script:hardcodedTrackerItemID  -cbsession $script:testSession -Version $script:Version
            $result.name | Should -BeExactly  $script:nameValueFromBaselineAndVersion
        }
    }

    Context "Error Handling" {

        It "Should return error when non-existing version is provided" {

            $invalidVersion = 1232124
            $expectedError = "Version: $invalidVersion of Item $script:hardcodedTrackerItemID most likely doesn't exist. Please recheck Version."

            { throw Get-CBItem -ItemID $script:hardcodedTrackerItemID -cbsession $script:testSession -Version $invalidVersion -ErrorAction Stop } | Should -Throw -ExpectedMessage $expectedError
        }

        It "Should report error for items not found with BaseLine parameter" {

            $invalidBaselineID = 10
            $expectedError = "BaseLineID: $invalidBaselineID of Item $script:hardcodedTrackerItemID most likely doesn't exist. Please recheck BaseLine."
            { throw Get-CBItem -ItemID $script:hardcodedTrackerItemID -cbsession $script:testSession -BaselineID $invalidBaselineID  -ErrorAction Stop} | Should -Throw -ExpectedMessage $expectedError
        }
    }
}

Describe "Get-CBTrackerTransition Function Tests" {

    It "Should return list of tracker state transitions" {

        # Act
        $result = Get-CBTrackerTransition -TrackerID $script:hardcodedTrackerID -CBSession $script:testSession
        $result.ID | Should -Not -BeNullOrEmpty
    }

    It "Should return error when prdovided incorrect Tracker ID" {

        $invalidTrackerID = 111111111
        $expectedError = "Tracker ID: $invalidTrackerID most likely doesn't exist. Please recheck Tracker ID or Server."

        { throw Get-CBTrackerTransition -TrackerID $invalidTrackerID -CBSession $script:testSession -ErrorAction Stop} | Should -Throw -ExpectedMessage $expectedError
    }
}



Describe "Set-CBItemLock, Get-CbItemlock, Edit Locked Item with Set-CbItem & Set-CBItemLock with '-unlock' " {

    It "Should lock an item for a set duration" {
        # Arrange
        $duration = '1:30h'

        # Act
        $result = Set-CBItemLock -ItemID $script:hardcodedTrackerItemID -Lock -Duration $duration -cbSession $script:testSession

        # Assert
        $result | Should -Contain "$script:hardcodedTrackerItemID Locked"
    }

    It "Should return Object with locked details" {
        $name= $env:USERNAME
        # Act
        $result = get-cbitemLock -ItemID $script:hardcodedTrackerItemID -cbSession $script:testSession

        # Assert
        $result.user.name | Should -BeExactly $name
    }

    It "Should Return Error when trying to edit locked Item with Command Set-CbItem" {

         # Arrange

        $editFieldTemplate = @'
        {
        "fieldId": 80,
        "name": "Description",
        "value": "edit after lock test",
        "sharedFieldNames": [],
        "type": "WikiTextFieldValue"
        }
'@


        $expectedMessage = "currently locked by"

        $json = $editFieldTemplate | ConvertFrom-Json

        { Set-CbItem -ItemID $script:hardcodedTrackerItemID -FieldValues $json -cbSession $script:testSession} | Select-String -Pattern $expectedMessage
    }

    It "Should Unlock an item" {

        # Act
        $result = Set-CBItemLock -ItemID $script:hardcodedTrackerItemID -cbSession $script:testSession -Unlock

        # Assert
        $result | Should -Contain "$script:hardcodedTrackerItemID Unlocked"
    }
}

Describe "Restore-CBitem Function Tests" {

    Context "Testing the process of resetting an item to a specific version." {
        It "Should reset Item To Version 1" {
            # Arrange
            $itemID = 378091
            $defaultVersion = 1
            $trackerID = 1304673

            # Act
            reset-CBitem -ItemID $itemID -ToVersion $defaultVersion -TrackerID $trackerID -CBSession $script:testSession | Out-Null

            # Takign Head Version (live)
            $result = Get-CBItem -ItemID $itemID -CBSession $script:testSession
            # Assert
            $result.assignedTo | Should -BeNullOrEmpty
            $result.customFields| Should -BeNullOrEmpty
            $result.teams | Should -BeNullOrEmpty
            $result.priority.name  | Should -BeExactly "Unset"
            $result.status.name | Should -BeExactly "New"
            $result.categories | Should -BeNullOrEmpty
            $result.subjects | Should -BeNullOrEmpty
            $result.severities | Should -BeNullOrEmpty
        }

        It "Should reset Item back to Version 51" {
            # Arrange
            $itemID = 378091
            $version = 51
            $trackerID = 1304673

            # Act
            reset-CBitem -ItemID $itemID -ToVersion $version -TrackerID $trackerID -CBSession $script:testSession | Out-Null
            # Takign Head Version (live)
            $result = Get-CBItem -ItemID $itemID -CBSession $script:testSession
            $versionedResult = Get-CBItem -ItemID $itemID -CBSession $script:testSession -Version $version

            # Assert
            $result.parent.name | Should -BeExactly $versionedResult.parent.name
            $result.assignedTo.name | Should -BeExactly $versionedResult.assignedTo.name
            $result.teams.name | Should -BeExactly  $versionedResult.teams.name
            $result.priority.name  | Should -BeExactly  $versionedResult.priority.name
            $result.categories.name | Should -BeExactly $versionedResult.categories.name
            $result.subjects.name | Should -BeExactly  $versionedResult.subjects.name
            $result.severities.name | Should -BeExactly $versionedResult.severities.name

        }
    }
}
Describe "Find-CBUser FunctionTests" {
    Context "Should return user or users based on search criteria: Name,Email,FirstName,LastName,UserStatus,ProjectId" {
        It "Should Return one user searching by Name" {
            $result = Find-CBUser -name $script:userName -CBSession $script:testSession
            $result.count | Should -BeExactly 1
        }
        It "Should Return Two users searching by email" {
            $result = Find-CBUser -email $script:email -CBSession $script:testSession
            # I have Two accounts ;) with same email if you have only one account email change it to one
            $result.count | Should -BeExactly 2
        }
    }
    Context "Error Handling" {
        It "Should return an Error when no search criteria are specified" {
            $errorMessage = "Response status code does not indicate success: 400 ()."
            { Find-CBUser -CBSession $script:testSession -ErrorAction Stop } | Should -Throw -ExpectedMessage $errorMessage
        }
    }
}

Describe "Get-CBTrackerTree Function Tests" {
    Context "Basic Functionality" {
        It "Returns tracker tree for a valid project" {
            $projects = Get-CBProject -CBSession $script:testSession
            $result = Get-CBTrackerTree -ProjectID $projects[0].id -CBSession $script:testSession
            $result | Should -Not -BeNullOrEmpty
            $result.isFolder | Should -Contain $true
        }
    }
    Context "Error Handling" {
        It "Throws for invalid project ID" {
            { Get-CBTrackerTree -ProjectID 99999999 -CBSession $script:testSession -ErrorAction Stop } | Should -Throw
        }
    }
}

Describe "Get-CBItemFieldOptions Function Tests" {
    Context "Basic Functionality" {
        It "Returns options for a valid field name" {
            $itemID = $script:hardcodedTrackerItemID
            $result = Get-CBItemFieldOptions -ItemID $itemID -FieldName "Status" -CBSession $script:testSession
            $result | Should -Not -BeNullOrEmpty
        }
        It "Returns options for a valid field ID" {
            $itemID = $script:hardcodedTrackerItemID
            $field = Get-CBItemField -ItemID $itemID -CBSession $script:testSession -Field "Status"
            $fieldID = $field.fieldId
            $result = Get-CBItemFieldOptions -ItemID $itemID -FieldID $fieldID -CBSession $script:testSession
            $result.type[0] | Should -BeExactly "ChoiceOptionReference"
        }
    }
    Context "Error Handling" {
        It "Throws for invalid ItemID" {
            { Get-CBItemFieldOptions -ItemID 99999999 -FieldName "Status" -CBSession $script:testSession -ErrorAction Stop } | Should -Throw
        }
        It "Throws for invalid FieldName" {
            $itemID = $script:hardcodedTrackerItemID
            { Get-CBItemFieldOptions -ItemID $itemID -FieldName "NotARealField" -CBSession $script:testSession -ErrorAction Stop } | Should -Throw
        }
    }
}

Describe "Invoke-CBQL Function Tests" {
    Context "Basic Functionality" {
        It "Returns items for a valid CBQL query" {
            $query = "tracker.id=$script:hardcodedTrackerID"
            $result = Invoke-CBQL -cbQLString $query -CBSession $script:testSession
            $result | Should -Not -BeNullOrEmpty
        }
    }
    Context "Should Return empty string or null when no result is found" {
        It "Throws for invalid CBQL query" {
            $invalidQuery = "tracker.id=99999999"
            $result = Invoke-CBQL -cbQLString $invalidQuery -CBSession $script:testSession -ErrorAction Stop
            $result | Should -BeNullOrEmpty
        }
    }
}
Describe "Get-CBTrackerOutline Function Tests" {
    Context "Basic Functionality" {
        It "Returns outline for a valid tracker ID" {
            $result = Get-CBTrackerOutline -TrackerID $script:hardcodedTrackerID -CBSession $script:testSession
            $result | Should -Not -BeNullOrEmpty
        }
    }
    Context "Error Handling" {
        It "Throws for invalid TrackerID" {
            { Get-CBTrackerOutline -TrackerID 99999999 -CBSession $script:testSession -ErrorAction Stop } | Should -Throw
        }
    }
}