#!groovy
node {
    def rootPath = "/root/go/src/github.com/rancher/rancher/tests/v2/validation/"
    def job_name = "${JOB_NAME}"
    if (job_name.contains('/')) { 
      job_names = job_name.split('/')
      job_name = job_names[job_names.size() - 1] 
    }
    def testContainer = "${job_name}${env.BUILD_NUMBER}_test"
    def upgradeTestContainer = "${job_name}${env.BUILD_NUMBER}-2_test"
    def imageName = "rancher-validation-${job_name}${env.BUILD_NUMBER}"
    def testsDir = "github.com/rancher/rancher/tests/v2/validation/${env.TEST_PACKAGE}"
    def testResultsOut = "results.xml"
    def upgradeTestResultsOut = "results_upgrade.xml"
    def localPipelinePath = "./tests/v2/validation/pipeline/"
    def testResultsJSON = "results.json"
    def envFile = ".env"
    def rancherConfig = "rancher_env.config"
    def branch = "release/v2.8"
    if ("${env.BRANCH}" != "null" && "${env.BRANCH}" != "") {
      branch = "${env.BRANCH}"
    }
    def repo = scm.userRemoteConfigs
    if ("${env.REPO}" != "null" && "${env.REPO}" != "") {
      repo = [[url: "${env.REPO}"]]
    }
    def timeout = "60m"
    if ("${env.TIMEOUT}" != "null" && "${env.TIMEOUT}" != "") {
      timeout = "${env.TIMEOUT}" 
    }
    wrap([$class: 'AnsiColorBuildWrapper', 'colorMapName': 'XTerm', 'defaultFg': 2, 'defaultBg':1]) {
      withFolderProperties {
        paramsMap = []
        params.each {
          if (it.value && it.value.trim() != "") {
              paramsMap << "$it.key=$it.value"
          }
        }
        withCredentials([ string(credentialsId: 'AWS_ACCESS_KEY_ID', variable: 'AWS_ACCESS_KEY_ID'),
                          string(credentialsId: 'AWS_SECRET_ACCESS_KEY', variable: 'AWS_SECRET_ACCESS_KEY'),
                          string(credentialsId: 'AWS_ACCESS_KEY_ID', variable: 'RANCHER_EKS_ACCESS_KEY'),
                          string(credentialsId: 'AWS_SECRET_ACCESS_KEY', variable: 'RANCHER_EKS_SECRET_KEY'),
                          string(credentialsId: 'DO_ACCESSKEY', variable: 'DO_ACCESSKEY'),
                          string(credentialsId: 'AWS_SSH_PEM_KEY', variable: 'AWS_SSH_PEM_KEY'),
                          string(credentialsId: 'RANCHER_SSH_KEY', variable: 'RANCHER_SSH_KEY'),
                          string(credentialsId: 'AZURE_SUBSCRIPTION_ID', variable: 'AZURE_SUBSCRIPTION_ID'),
                          string(credentialsId: 'AZURE_TENANT_ID', variable: 'AZURE_TENANT_ID'),
                          string(credentialsId: 'AZURE_CLIENT_ID', variable: 'AZURE_CLIENT_ID'),
                          string(credentialsId: 'AZURE_CLIENT_SECRET', variable: 'AZURE_CLIENT_SECRET'),
                          string(credentialsId: 'AZURE_AKS_SUBSCRIPTION_ID', variable: 'RANCHER_AKS_SUBSCRIPTION_ID'),
                          string(credentialsId: 'AZURE_TENANT_ID', variable: 'RANCHER_AKS_TENANT_ID'),
                          string(credentialsId: 'AZURE_CLIENT_ID', variable: 'RANCHER_AKS_CLIENT_ID'),
                          string(credentialsId: 'AZURE_CLIENT_SECRET', variable: 'RANCHER_AKS_SECRET_KEY'),
                          string(credentialsId: 'RANCHER_REGISTRY_USER_NAME', variable: 'RANCHER_REGISTRY_USER_NAME'),
                          string(credentialsId: 'RANCHER_REGISTRY_PASSWORD', variable: 'RANCHER_REGISTRY_PASSWORD'),
                          string(credentialsId: 'RANCHER_AD_SPECIAL_CHAR_PASSWORD', variable: 'RANCHER_AD_SPECIAL_CHAR_PASSWORD'),
                          string(credentialsId: 'ADMIN_PASSWORD', variable: 'ADMIN_PASSWORD'),
                          string(credentialsId: 'USER_PASSWORD', variable: 'USER_PASSWORD'),
                          string(credentialsId: 'RANCHER_GKE_CREDENTIAL', variable: 'RANCHER_GKE_CREDENTIAL'),
                          string(credentialsId: 'RANCHER_AUTH_USER_PASSWORD', variable: 'RANCHER_AUTH_USER_PASSWORD'),
                          string(credentialsId: 'RANCHER_HOSTNAME_OR_IP_ADDRESS', variable: 'RANCHER_HOSTNAME_OR_IP_ADDRESS'),
                          string(credentialsId: 'RANCHER_CA_CERTIFICATE', variable: 'RANCHER_CA_CERTIFICATE'),
                          string(credentialsId: 'RANCHER_SERVICE_ACCOUNT_NAME', variable: 'RANCHER_SERVICE_ACCOUNT_NAME'),
                          string(credentialsId: 'RANCHER_SERVICE_ACCOUNT_PASSWORD', variable: 'RANCHER_SERVICE_ACCOUNT_PASSWORD'),
                          string(credentialsId: 'RANCHER_USER_SEARCH_BASE', variable: 'RANCHER_USER_SEARCH_BASE'),
                          string(credentialsId: 'RANCHER_DEFAULT_LOGIN_DOMAIN', variable: 'RANCHER_DEFAULT_LOGIN_DOMAIN'),
                          string(credentialsId: 'RANCHER_OPENLDAP_SERVICE_ACCOUNT_NAME', variable: 'RANCHER_OPENLDAP_SERVICE_ACCOUNT_NAME'),
                          string(credentialsId: 'RANCHER_OPENLDAP_SERVICE_ACCOUNT_PASSWORD', variable: 'RANCHER_OPENLDAP_SERVICE_ACCOUNT_PASSWORD'),
                          string(credentialsId: 'RANCHER_OPENLDAP_USER_SEARCH_BASE', variable: 'RANCHER_OPENLDAP_USER_SEARCH_BASE'),
                          string(credentialsId: 'RANCHER_OPENLDAP_AUTH_USER_PASSWORD', variable: 'RANCHER_OPENLDAP_AUTH_USER_PASSWORD'),
                          string(credentialsId: 'RANCHER_OPENLDAP_HOSTNAME_OR_IP_ADDRESS', variable: 'RANCHER_OPENLDAP_HOSTNAME_OR_IP_ADDRESS'),
                          string(credentialsId: 'RANCHER_OPENLDAP_SPECIAL_CHAR_PASSWORD', variable: 'RANCHER_OPENLDAP_SPECIAL_CHAR_PASSWORD'),
                          string(credentialsId: 'RANCHER_FREEIPA_SERVICE_ACCOUNT_NAME', variable: 'RANCHER_FREEIPA_SERVICE_ACCOUNT_NAME'),
                          string(credentialsId: 'RANCHER_FREEIPA_SERVICE_ACCOUNT_PASSWORD', variable: 'RANCHER_FREEIPA_SERVICE_ACCOUNT_PASSWORD'),
                          string(credentialsId: 'RANCHER_FREEIPA_USER_SEARCH_BASE', variable: 'RANCHER_FREEIPA_USER_SEARCH_BASE'),
                          string(credentialsId: 'RANCHER_FREEIPA_GROUP_SEARCH_BASE', variable: 'RANCHER_FREEIPA_GROUP_SEARCH_BASE'),
                          string(credentialsId: 'RANCHER_FREEIPA_AUTH_USER_PASSWORD', variable: 'RANCHER_FREEIPA_AUTH_USER_PASSWORD'),
                          string(credentialsId: 'RANCHER_FREEIPA_HOSTNAME_OR_IP_ADDRESS', variable: 'RANCHER_FREEIPA_HOSTNAME_OR_IP_ADDRESS'),
                          string(credentialsId: 'RANCHER_FREEIPA_SPECIAL_CHAR_PASSWORD', variable: 'RANCHER_FREEIPA_SPECIAL_CHAR_PASSWORD'),
                          string(credentialsId: 'RANCHER_VALID_TLS_CERT', variable: 'RANCHER_VALID_TLS_CERT'),
                          string(credentialsId: 'RANCHER_VALID_TLS_KEY', variable: 'RANCHER_VALID_TLS_KEY'),
                          string(credentialsId: 'RANCHER_BYO_TLS_CERT', variable: 'RANCHER_BYO_TLS_CERT'),
                          string(credentialsId: 'RANCHER_BYO_TLS_KEY', variable: 'RANCHER_BYO_TLS_KEY'),
                          string(credentialsId: 'QASE_AUTOMATION_TOKEN', variable: 'QASE_AUTOMATION_TOKEN'),
                          string(credentialsId: 'RANCHER_LINODE_ACCESSKEY', variable: "RANCHER_LINODE_ACCESSKEY")]) {

        withEnv(paramsMap) {
          stage('Checkout') {
            deleteDir()
            checkout([
                      $class: 'GitSCM',
                      branches: [[name: "*/${branch}"]],
                      extensions: scm.extensions + [[$class: 'CleanCheckout']],
                      userRemoteConfigs: repo
                    ])
          }
          dir ("./") {
            try {
              stage('Configure and Build') {
                if (env.AWS_SSH_PEM_KEY && env.AWS_SSH_KEY_NAME) {
                  dir("./tests/v2/validation/.ssh") {
                    def decoded = new String(AWS_SSH_PEM_KEY.decodeBase64())
                    writeFile file: AWS_SSH_KEY_NAME, text: decoded
                  }
                }

                dir("./tests/v2/validation") {
                  def filename = "config.yaml"
                  def configContents = env.CONFIG

                  writeFile file: filename, text: configContents
                  env.CATTLE_TEST_CONFIG = "/go/src/github.com/rancher/rancher/tests/v2/validation/"+filename
                }

                sh "./tests/v2/validation/configure.sh"
                sh "./tests/v2/validation/build.sh"
              }
              stage('Run Validation Tests') {
                try {
                  echo envFile
                  sh "docker run --name ${testContainer} -t --env-file ${envFile} " +
                  "${imageName} sh -c \"/go/bin/gotestsum --format standard-verbose --packages=${testsDir} --junitfile ${testResultsOut} -- ${GOTEST_TESTCASE} -timeout=${timeout} -v" +
                  ".${rootPath}pipeline/scripts/build_qase_reporter.sh;" +
                  ".${rootPath}reporter\""
                } catch(err) {
                  echo 'Test run had failures. Collecting results...'
                }
              }
              stage('upgrade') {
                  upgradeParams = [
                  string(name: 'RANCHER_HA_HOSTNAME', value: "${RANCHER_HA_HOSTNAME}"),
                  string(name: 'RANCHER_CHART_VERSION', value: "${RANCHER_CHART_VERSION}"),
                  string(name: 'RANCHER_HA_CERT_OPTION', value: "${RANCHER_HA_CERT_OPTION}"),
                  string(name: 'RANCHER_HA_KUBECONFIG', value: "${RANCHER_HA_KUBECONFIG}")
                  ]
                  build job: 'rancher-v3_ha_upgrade', parameters: upgradeParams
              }
                            
              stage ('post upgrade tests') {
                try {
                  sh "docker run --name ${upgradeTestContainer} -t --env-file ${envFile} " +
                    "${imageName} sh -c \"/root/go/bin/gotestsum --format standard-verbose --packages=${testsDir} --junitfile ${upgradeTestResultsOut} -- ${GOTEST_TESTCASE_2} -timeout=${timeout} -v" +
                    ".${rootPath}pipeline/scripts/build_qase_reporter.sh;" +
                    ".${rootPath}reporter\""
                } catch(err) {
                  echo 'Test run had failures. Collecting results...'
                }
              }
              stage('delete') {
                CATTLE_TEST_URL = "http://${RANCHER_HA_HOSTNAME}"
                deleteParams = [
                string(name: 'CATTLE_TEST_URL', value: "${CATTLE_TEST_URL}"),

                ]
                build job: 'rancher-v3_ha_delete', parameters: deleteParams
              }
                     
              stage('Test Report') {
                sh "docker cp ${testContainer}:${rootPath}${testResultsOut} ."
                sh "docker cp ${upgradeTestContainer}:${rootPath}${upgradeTestResultsOut} ."
                sh "./rancher/tests/v2/validation/pipeline/reporter"
                step([$class: 'JUnitResultArchiver', testResults: "**/${testResultsOut}"])
                step([$class: 'JUnitResultArchiver', testResults: "**/${upgradeTestResultsOut}"])
                sh "docker stop ${testContainer}"
                sh "docker rm -v ${testContainer}"
                sh "docker stop ${upgradeTestContainer}"
                sh "docker rm -v ${upgradeTestContainer}"
                sh "docker rmi -f ${imageName}"
              }           
            } catch(err) {           
                sh "docker stop ${testContainer}"
                sh "docker rm -v ${testContainer}"
                sh "docker stop ${upgradeTestContainer}"
                sh "docker rm -v ${upgradeTestContainer}"
                sh "docker rmi -f ${imageName}"
            } // catch
          } // dir
        } // withEnv
      } // withCredentials
    } // withFolderProperties
  } // wrap
}// node