Jenkinsfile.internal

/*
 * Copyright (c) 2021-2024 tracetronic GmbH
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

/*
=============
Prerequisites
=============
* Global environment variables set:
- EMAIL_RECIPIENTS
- TG_AUTH_KEY
- ET_V1_VERSION
- ET_V2_VERSION
- TG_VERSION
* Jenkins plugins installed:
- https://plugins.jenkins.io/timestamper
- https://plugins.jenkins.io/gradle/
*/

@Library(['tracetronic-jenkins-lib', 'internal-cxs-jenkins-lib']) _

pipeline {
    options {
        buildDiscarder(logRotator(daysToKeepStr: '14'))
        timestamps()
    }

    agent {
        label 'docker && linux' // linux only to keep windows docker runners free, so they can run the systemTests job
    }

    environment {
        authKey = credentials('TG_authkey_test_report_upload')
        pipeline_report_dir = "report2TG/build-$env.BUILD_NUMBER"
        PRODUCT_NAME = "ecu-test-execution-plugin"
        TEST_LEVEL = "pipeline"
        JENKINS_VERSION = "2.426.3"
    }

    tools {
        jdk 'JDK17'
    }

    parameters {
        string(name: 'CONTAINER_TEST_DATA_BRANCH', defaultValue: 'main', description: 'The specified branch name to use for testing.')
        string(name: 'ET_VERSION', defaultValue: '2023.4.0', description: 'The specified ecu.test version to use for testing.')
        string(name: 'ET_V1_VERSION', defaultValue: '2023.3.0', description: 'The specified ecu.test v1 version to use for testing.')
        string(name: 'ET_V2_VERSION', defaultValue: '2024.4.0', description: 'The specified ecu.test v2 version to use for testing.')
        string(name: 'TG_VERSION', defaultValue: '1.180.0', description: 'The specified test.guide version to use for testing.')
    }

    stages {
        stage ('Set Product Version') {
            steps {
                script {
                    echo "Reading properties from gradle.properties"
                    gradle_properties = readProperties file: 'gradle.properties'
                    env.PRODUCT_VERSION = gradle_properties['version']
                    echo "Product Version set to: ${env.PRODUCT_VERSION}"
                }
            }
        }
        stage('Unit Tests') {
            steps {
                catchError(stageResult: 'UNSTABLE', buildResult: 'UNSTABLE') {
                        cmd '"./gradlew" clean unitTest'
                }
            }
        }
        stage('Integration Tests') {
            steps {
                catchError(stageResult: 'UNSTABLE', buildResult: 'UNSTABLE') {
                    cmd '"./gradlew" integrationTest'
                }
            }
        }

        stage('Publish Code Coverage') {
            steps {
                jacoco execPattern: '**/build/jacoco/unitTest.exec,**/build/jacoco/integrationTest.exec',
                       classPattern: '**/build/classes/groovy/main',
                       sourcePattern: '**/src/main/groovy',
                       exclusionPattern: '**/build/classes/groovy/test'
            }
        }

        stage('Run Parallel') {
            failFast false
            parallel {
                stage('System Tests') {
                    // The needed artifact is only built for main and pull requests -> skip this job otherwise
                    when { branch pattern: "PR-\\d+|main", comparator: "REGEXP"}
                    steps {
                        build job: '../systemTests', parameters: [string(name: 'artifactName', value: "${JOB_BASE_NAME}"), string(name: 'commitHash', value: "${GIT_COMMIT}")]
                    }
                }
                stage('Container Tests') {
                    stages {
                        stage('Prepare Resources') {
                            steps {
                                script {
                                    catchError(stageResult: 'UNSTABLE', buildResult: 'UNSTABLE') {
                                        copyArtifacts fingerprintArtifacts: true, projectName: "../containerTestData/${params.CONTAINER_TEST_DATA_BRANCH}", selector: lastSuccessful()
                                    }
                                    def properties = readFile('src/test/resources/containerTest.properties')
                                        .replaceAll(/ET_VERSION=.*/, "ET_VERSION=${params.ET_VERSION}")
                                        .replaceAll(/ET_V1_VERSION=.*/, "ET_V1_VERSION=${params.ET_V1_VERSION}")
                                        .replaceAll(/ET_V2_VERSION=.*/, "ET_V2_VERSION=${params.ET_V2_VERSION}")
                                        .replaceAll(/TG_VERSION=.*/, "TG_VERSION=${params.TG_VERSION}")
                                    writeFile(file: 'src/test/resources/containerTest.properties', text: properties)
                                }
                            }
                        }
                        stage('Run Container Tests') {
                            steps {
                                catchError(stageResult: 'UNSTABLE', buildResult: 'UNSTABLE') {
                                    cmd '"./gradlew" containerTest -Dspock.skip.sandbox=false'
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    post {
        always {
            script {
                catchError(stageResult: 'FAILURE', buildResult: 'FAILURE') {
                    withEnv(["TEST_LEVEL=unit"]) {
                    Xml2TG((long) currentBuild.startTimeInMillis, "build/test-results/unitTest/", "JUnit", ,"uploadJson", [:], [:], "${TESTGUIDE_url}", "${authKey}", "${TESTGUIDE_projectID}")

                    }
                    withEnv(["TEST_LEVEL=integration"]) {
                        Xml2TG((long) currentBuild.startTimeInMillis, "build/test-results/integrationTest/", "JUnit", ,"uploadJson", [:], [:], "${TESTGUIDE_url}", "${authKey}", "${TESTGUIDE_projectID}")
                    }
                    withEnv(["TEST_LEVEL=system"]) {
                        Xml2TG((long) currentBuild.startTimeInMillis, "build/test-results/containerTest/", "JUnit", ,"uploadJson", [:], [:], "${TESTGUIDE_url}", "${authKey}", "${TESTGUIDE_projectID}")
                    }
                }
            }
        }
        unsuccessful {
            mail to: "${env.EMAIL_RECIPIENTS}",
                subject: "${JOB_NAME} - Build #${BUILD_NUMBER} - ${currentBuild.currentResult}",
                body: "Check console output at ${BUILD_URL} to view the results."
        }
        cleanup {
            dir("${pipeline_report_dir}") {
                    pipeline2ATX(true)
            }
            uploadJson2TG("${TESTGUIDE_url}", "${authKey}", "${TESTGUIDE_projectID}", "${pipeline_report_dir}/**", '')
        }
    }
}