Jenkins: The Automation Engine

Jenkins serves as an open-source automation server for Continuous Integration and Delivery (CI/CD). This cross-platform tool manages IBM DevOps Test UI execution (formerly IBM Rational Functional Tester), providing a centralized hub for automation workflows.

Git: Versatile Version Control

Git functions as a distributed version control system and a fundamental DevOps tool. This system tracks all repository changes, allowing teams to maintain a detailed development history through adding, staging, committing, and pushing modifications.

Streamlining IBM DevOps Test UI with Git and Jenkins

Integrating Git and Jenkins provides a robust framework for executing IBM DevOps Test UI scripts.In this workflow, Git stores the Jenkinsfile, which Jenkins retrieves via the Script Path "Jenkinsfile". This process ensures testing environments remain synchronized with the latest GitHub updates.

Workflow Overview

1. Pipeline Configuration: Define the pipeline as code using a Jenkinsfile in Git.

2. Build Trigger: Jenkins executes the pipeline upon detecting Git updates or manual triggers.

3. Execution & Monitoring: The pipeline runs IBM DevOps Test UI playbacks with real-time status tracking.

Prerequisites

For seamless integration, the following prerequisites must be configured in your Jenkins environment:

1. Git Plugin: The Git plugin must be installed to enable communication with the source control repository and pull the Jenkinsfile.
   
   
   

2. Global Credentials Configuration: Establish secure communication between Jenkins and GitHub by configuring global credentials. This involves utilizing a GitHub Personal Access Token (PAT) to authorize repository access.
   

   • Generate a GitHub Personal Access Token: Within your GitHub account settings, generate a new Personal Access Token. This token acts as a secure key, granting Jenkins the necessary permissions to retrieve your versioned Jenkinsfile from the repository.
     
     

   • Access Jenkins Credentials: Navigate to Manage Jenkins -> Credentials -> System -> Global credentials (unrestricted).
     
     
     
   • Add Credential: Select Username with password as the credential Kind.
     
     
     
   • Input Details: Enter the GitHub username and use the Personal Access Token as the password. Assign a unique ID (e.g.,github-auth) to identify these credentials.
     
     
     

   Note: Ensure that your automation command points to the correct local Jenkins agent path where the IBM DevOps Test UI scripts are cloned, as the execution engine requires local access to the test assets even though the Jenkinsfile is sourced from GitHub.
   

3. Installation of IBM DevOps Test UI Plugin: You must use the Jenkins Plugin Manager to install the IBM DevOps Test UI plugin. For detailed configuration steps within Jenkins, refer to the link.

Implementation Steps

Follow these steps to configure the integration between Git and Jenkins for automated IBM DevOps Test UI execution.

1. Create a Jenkins pipeline project.

2. After creating the Jenkins pipeline project, access the Configure menu. Use the provided link to set up the project using the Pipeline script from SCM option.

3. The Pipeline script from SCM option allows Jenkins to pull build logic directly from Git. This approach enables the pipeline to automatically retrieve the latest Jenkinsfile and execute the IBM DevOps Test UI assets as defined in the script.
   
   
   

4. Enter the GitHub Repository URL and select the previously configured Global Credentials (from prerequisite step).
   
   
   
5. Create a text file named Jenkinsfile (case-sensitive) in the Git repository. Refer to this documentation link for more details about the Jenkinsfile.
   
   
6. In this workflow, the Jenkinsfile acts as the orchestrator. While the IBM DevOps Test UI scripts reside on the local drive of the Jenkins agent, storing the Jenkinsfile in Github provides full Pipeline as Code benefits. This file will serve as the Script Path during the configuration in step 8.
   
   
7. To create the necessary execution command line parameters, select Pipeline Syntax. Further information regarding parameters and pipeline syntax can be found in this documentation link.
   
   
   
8. The Pipeline Syntax generated in the previous step will be used in the Jenkinsfile. Refer to the following sample format for a Jenkinsfile structure:
   
   pipeline {



       agent any

       stages {

           stage('Build') {

               steps {

                echo 'Building..'    

               }

           }

          stage('IBM DevOps Test UI script execution phase') {

               steps {

                   echo("************************** Web UI Test - IBM DevOps Test UI Start **************************")

                   step([$class: 'RTWProductHelper', configfile: '', exportReportFileName: '', exportReportFolder: 'D:\\Jenkins_rep', exportReportFormat: 'HTML', exportReportType: 'unified', exportReportUsage: true, exportstatreportlist: '', exportstats: '', exportstatsformat: '', exportstatshtml: '', imports: '', imsharedloc: 'D:\\IBM\\IBMIMShared', labels: '', name: 'Jenkins_Test_UI', overwrite: 'true', project: 'google', protocolinput: '', publish: '', publishfor: '', publishreports: '', quiet: 'false', results: '', suite: 'test.testsuite', swapdatasets: '', usercomments: '', varfile: '', vmargs: '', workspace: 'D:\\workspace2'])

                   echo("************************** Web UI Test - IBM DevOps Test UI End **************************")

                         }

         }        

       }

   }



   If you prefer to execute multiple tests simultaneously using the suite parameter in your Jenkinsfile, you have a couple of great options:

   • Specific Tests: Execute a chosen list of tests by separating each with a colon (e.g.,-suite "test1:test2:test3").

   • Folder Wildcards: Run all tests within a specific folder using a wildcard enclosed in quotes (e.g.,-suite "*").

   You can explore additional customization options from this documentation link.
   
   
9. In the Jenkins configuration, the Script Path field specifies the location of the Jenkinsfile within the repository. Jenkins uses this file to manage the entire testing workflow for the execution of DevOps Test UI scripts.
   
   
10. You have the flexibility to place the Jenkinsfile within any GitHub repository branch. As detailed in step 4, the following visual demonstrates the Jenkinsfile location inside a Git repository, specifically highlighting its presence in the main branch:
    
    
    
11. Enter the specific branch name (e.g., */main) where the Jenkinsfile resides, ensuring Jenkins monitors the correct path for execution logic. Alternatively, specifying only the wildcard  ** in the Branch Specifier field instructs Jenkins to examine all branches in the repository for the Jenkinsfile.
    
    
    
12. Click on Save and Apply changes.
    
    
    
13. Navigate back to the Pipeline dashboard page.
    
    
14. Click on Build now in the Pipeline dashboard to trigger the build.
    
    
    
15. Once the build is triggered, click on the build number to monitor the status. This Status section displays the Git repository, the branch, and any recent changes to the Jenkinsfile.
    
    
16. In the example below, Build #8 indicates no changes occurred in the Jenkinsfile. Conversely, Build #7 reflects an update, as a modification was made to the Jenkinsfile prior to that execution.
    
    Build #8
    
    
    
    Build #7
    
    
17. The Stage View of the Pipeline project also displays the recent commits made to the Jenkinsfile.
    
    
    
18. Navigate to the Console Output section for the detailed output of the execution.
    
    
    

Conclusion: Embracing Pipeline as Code

Integrating Git and Jenkins establishes a resilient 'Pipeline as Code' framework for IBM DevOps Test UI automation, offering key advantages:

• Enhanced Auditability: Git stores the Jenkinsfile, tracking all changes for a transparent history.

• Rapid Troubleshooting: Centralized real-time console logs allow quick identification and resolution of test failures.

• Scalable Automation: Execution logic managed as code enables easy environment configuration and pipeline recovery.

This guide provides the crucial steps to build a professional, automated framework that eliminates manual test execution and accelerates your DevOps testing lifecycle. By detailing the integration of Git and Jenkins, you can successfully implement a reliable 'Pipeline as Code' system for IBM DevOps Test UI.