node {
  def rootPath = "/src/rancher-validation/"
  def job_name = "${JOB_NAME}"
  if (job_name.contains('/')) { 
    job_names = job_name.split('/')
    job_name = job_names[job_names.size() - 1] 
  }

  def provisionContainer = "${job_name}${env.BUILD_NUMBER}_prov"
  def testContainer = "${job_name}${env.BUILD_NUMBER}_test"

  def provisionResultsOut = "provision-results.xml"
  def testResultsOut = "api-results.xml"
  def imageName = "rancher-validation-${job_name}${env.BUILD_NUMBER}"
  def testsDir = "tests/v3_api/"
  def rancherConfig = "rancher_env.config"

  def TESTS_TO_RUN =  [ "test_wl", "test_dns_record", "test_rbac","test_connectivity", "test_ingress",
                        "test_secrets", "test_registry", "test_service_discovery", "test_websocket"]

  def WINDOWS_PYTEST_OPTIONS = "-k \"test_ingress or test_rbac or test_sa or test_secrets or test_service_discovery or test_workload\""

  if (env.RANCHER_SKIP_INGRESS == "True") { 
    TESTS_TO_RUN = TESTS_TO_RUN - ["test_ingress"]
  }

  def LINUX_PYTEST_OPTIONS = "-k \"" + TESTS_TO_RUN.join(" or ") +"\""
  def PYTEST_OPTIONS = LINUX_PYTEST_OPTIONS

  def branch = "master"
  if ("${env.branch}" != "null" && "${env.branch}" != "") {
    branch = "${env.branch}"
  }

  println "Branch env: ${env.branch}"
  println "Branch: ${branch}"

  wrap([$class: 'AnsiColorBuildWrapper', 'colorMapName': 'XTerm', 'defaultFg': 2, 'defaultBg':1]) {
    withFolderProperties {
      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: 'ADMIN_PASSWORD', variable: 'ADMIN_PASSWORD'),
                        string(credentialsId: 'USER_PASSWORD', variable: 'USER_PASSWORD'),
                        string(credentialsId: 'RANCHER_GKE_CREDENTIAL', variable: 'RANCHER_GKE_CREDENTIAL')]) {
        stage('Checkout') {
          deleteDir()
          checkout([
                    $class: 'GitSCM',
                    branches: [[name: "*/${branch}"]],
                    extensions: scm.extensions + [[$class: 'CleanCheckout']],
                    userRemoteConfigs: scm.userRemoteConfigs
                  ])
        }

        dir ("tests/validation") {
          stage('Configure and Build') {
            if (env.AWS_SSH_PEM_KEY && env.AWS_SSH_KEY_NAME) {
              dir(".ssh") {
                def decoded = new String(env.AWS_SSH_PEM_KEY.decodeBase64())
                writeFile file: env.AWS_SSH_KEY_NAME, text: decoded
              }
            }
            sh "./tests/v3_api/scripts/configure.sh"
            sh "./tests/v3_api/scripts/build.sh"
          }
          try {
            stage('Run provisioning and validation Tests') {
              try {
                sh "docker run --name ${provisionContainer}  --env-file .env " +
                  "${imageName} /bin/bash -c \'pytest -v -s --junit-xml=${provisionResultsOut} ${PYTEST_PROVISION_OPTIONS} ${testsDir}\'"

                // copy file containing CATTLE_TEST_URL & ADMIN_TOKEN and load into environment variables
                sh "docker cp ${provisionContainer}:${rootPath}${testsDir}${rancherConfig} ."
                load rancherConfig

                if (env.RANCHER_TEST_OS == 'windows') {
                  PYTEST_OPTIONS = WINDOWS_PYTEST_OPTIONS
                }

                sh "docker run --name ${testContainer}  --env-file .env " +
                  "${imageName} /bin/bash -c \'export RANCHER_CLUSTER_NAME=${env.CLUSTER_NAME} && pytest -v -s --junit-xml=${testResultsOut} ${PYTEST_OPTIONS} ${testsDir}\'"
              } catch(err) {
                echo 'Test run had failures. Collecting results...'
                echo "Error: " + err
              }

            }

            stage('Test report') {
              sh "docker cp ${provisionContainer}:${rootPath}${provisionResultsOut} ."
              step([$class: 'JUnitResultArchiver', testResults: "**/${provisionResultsOut}"])

              sh "docker cp ${testContainer}:${rootPath}${testResultsOut} ."
              step([$class: 'JUnitResultArchiver', testResults: "**/${testResultsOut}"])
              
              sh "docker rm -v ${provisionContainer}"
              sh "docker rm -v ${testContainer}"
              sh "docker rmi ${imageName}"
            }
          } catch(err){
            sh "docker stop ${provisionContainer}"
            sh "docker rm -v ${provisionContainer}"

            sh "docker stop ${testContainer}"
            sh "docker rm -v ${testContainer}"

            sh "docker rmi ${imageName}"

            echo "Error: " + err
          }
        }
      }
    }
  }
}