Jenkinsfile.scheduled

#!groovy

def initializeEnvironment() {
  env.DRIVER_DISPLAY_NAME = 'Cassandra C# Driver'
  env.DRIVER_METRIC_TYPE = 'oss'
  if (env.GIT_URL.contains('riptano/csharp-driver')) {
    env.DRIVER_DISPLAY_NAME = 'private ' + env.DRIVER_DISPLAY_NAME
    env.DRIVER_METRIC_TYPE = 'oss-private'
  } else if (env.GIT_URL.contains('csharp-dse-driver')) {
    env.DRIVER_DISPLAY_NAME = 'DSE C# Driver'
    env.DRIVER_METRIC_TYPE = 'dse'
  }

  env.GIT_SHA = "${env.GIT_COMMIT.take(7)}"
  env.GITHUB_PROJECT_URL = "https://${GIT_URL.replaceFirst(/(git@|http:\/\/|https:\/\/)/, '').replace(':', '/').replace('.git', '')}"
  env.GITHUB_BRANCH_URL = "${GITHUB_PROJECT_URL}/tree/${env.BRANCH_NAME}"
  env.GITHUB_COMMIT_URL = "${GITHUB_PROJECT_URL}/commit/${env.GIT_COMMIT}"

  if (env.OS_VERSION.split('/')[0] == 'win') {    
    env.HOME = 'C:\\Users\\Admin'
    env.HOME_WSL = '/mnt/c/Users/Admin'

    powershell label: 'Copy SSL files', script: '''
      wsl bash --login -c "cp -r $env:HOME_WSL/ccm/ssl `$HOME/ssl"
    '''
    
    powershell label: 'Download Apache Cassandra® or DataStax Enterprise', script: '''
      rm $Env:HOME\\environment.txt
      rm $Env:HOME\\driver-environment.ps1

      wsl bash --login -c "$Env:CCM_ENVIRONMENT_SHELL_WINDOWS $Env:SERVER_VERSION"
      wsl bash --login -c "cp ~/environment.txt $ENV:HOME_WSL"
      
      $data = get-content "$Env:HOME\\environment.txt"
      $data = $data -replace "`n","`r`n"
      $newData = ""
	    $data | foreach {
          $v1,$v2 = $_.split("=",2)
          echo "1: $v1 2: $v2"
          $newData += "`r`n`$Env:$v1='$v2'"
      }
      $newData += "`r`n`$Env:CASSANDRA_VERSION=`$Env:CCM_CASSANDRA_VERSION"
      "$newData" | Out-File -filepath $Env:HOME\\driver-environment.ps1
    '''
    
    if (env.SERVER_VERSION.split('-')[0] == 'dse') {
      powershell label: 'Update environment for DataStax Enterprise', script: '''
          . $Env:HOME\\driver-environment.ps1

          $newData = "`r`n`$Env:DSE_BRANCH=`"$Env:CCM_BRANCH`""
          $newData += "`r`n`$Env:DSE_VERSION=`"$Env:CCM_VERSION`""
          $newData += "`r`n`$Env:DSE_INITIAL_IPPREFIX=`"127.0.0.`""
          $newData += "`r`n`$Env:DSE_IN_REMOTE_SERVER=`"false`""

          "$newData" | Out-File -filepath $Env:HOME\\driver-environment.ps1 -append
      '''
    }
    
    powershell label: 'Set additional environment variables for windows tests', script: '''
      $newData = "`r`n`$Env:PATH+=`";$env:JAVA_HOME\\bin`""
      $newData += "`r`n`$Env:SIMULACRON_PATH=`"$Env:SIMULACRON_PATH_WINDOWS`""
      $newData += "`r`n`$Env:CCM_USE_WSL=`"true`""
      $newData += "`r`n`$Env:CCM_SSL_PATH=`"/root/ssl`""

      "$newData" | Out-File -filepath $Env:HOME\\driver-environment.ps1 -append
    '''

    powershell label: 'Display .NET and environment information', script: '''
      # Load CCM and driver configuration environment variables
      cat $Env:HOME\\driver-environment.ps1
      . $Env:HOME\\driver-environment.ps1

      dotnet --version

      gci env:* | sort-object name
    '''
  } else {
    sh label: 'Download Apache Cassandra® or DataStax Enterprise', script: '''#!/bin/bash -le
      . ${CCM_ENVIRONMENT_SHELL} ${SERVER_VERSION}

      echo "CASSANDRA_VERSION=${CCM_CASSANDRA_VERSION}" >> ${HOME}/environment.txt
    '''
//https://learn.microsoft.com/en-us/dotnet/core/compatibility/cryptography/5.0/default-cipher-suites-for-tls-on-linux
    sh label: 'Setup custom openssl.cnf due to .NET 5+ TLS changes on Linux', script: '''#!/bin/bash -le
      cat >> /home/jenkins/openssl.cnf << OPENSSL_EOF
openssl_conf = default_conf

[default_conf]
ssl_conf = ssl_sect

[ssl_sect]
system_default = system_default_sect

[system_default_sect]
MinProtocol = TLSv1
CipherString = @SECLEVEL=2:kEECDH:kRSA:kEDH:kPSK:kDHEPSK:kECDHEPSK:-aDSS:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM8
Ciphersuites = TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:TLS_AES_128_CCM_SHA256
OPENSSL_EOF
      echo "OPENSSL_CONF=/home/jenkins/openssl.cnf" >> ${HOME}/environment.txt
    '''
    if (env.SERVER_VERSION.split('-')[0] == 'dse') {
      env.DSE_FIXED_VERSION = env.SERVER_VERSION.split('-')[1]
      sh label: 'Update environment for DataStax Enterprise', script: '''#!/bin/bash -le
        rm ${HOME}/.ccm/config
        cat > ${HOME}/.ccm/config << CONF_EOL
[repositories]
cassandra = https://repo.aws.dsinternal.org/artifactory/apache-mirror/cassandra
dse = http://repo-public.aws.dsinternal.org/tar/enterprise/dse-%s-bin.tar.gz
ddac = http://repo-public.aws.dsinternal.org/tar/enterprise/ddac-%s-bin.tar.gz
CONF_EOL

        cat >> ${HOME}/environment.txt << ENVIRONMENT_EOF
CCM_PATH=${HOME}/ccm
DSE_INITIAL_IPPREFIX=127.0.0.
DSE_IN_REMOTE_SERVER=false
CCM_CASSANDRA_VERSION=${DSE_FIXED_VERSION} # maintain for backwards compatibility
CCM_VERSION=${DSE_FIXED_VERSION}
CCM_SERVER_TYPE=dse
DSE_VERSION=${DSE_FIXED_VERSION}
CCM_DISTRIBUTION=dse
CASSANDRA_VERSION=${DSE_FIXED_VERSION}
CCM_BRANCH=${DSE_FIXED_VERSION}
DSE_BRANCH=${DSE_FIXED_VERSION}
JDK=1.8
ENVIRONMENT_EOF
      '''
    }
    
    if (env.SERVER_VERSION.split('-')[0] == 'hcd') {
      env.HCD_FIXED_VERSION = env.SERVER_VERSION.split('-')[1]
      sh label: 'Update environment for HCD', script: '''#!/bin/bash -le
        cat >> ${HOME}/environment.txt << ENVIRONMENT_EOF
CCM_PATH=${HOME}/ccm
CCM_CASSANDRA_VERSION=${HCD_FIXED_VERSION} # maintain for backwards compatibility
CASSANDRA_VERSION=${HCD_FIXED_VERSION}
CCM_DISTRIBUTION=hcd
ENVIRONMENT_EOF
        '''
    }

    sh label: 'Display .NET and environment information', script: '''#!/bin/bash -le
      # Load CCM and driver configuration environment variables
      set -o allexport
      . ${HOME}/environment.txt
      set +o allexport

      if [ ${DOTNET_VERSION} = 'mono' ]; then
        mono --version
      else
        dotnet --version
      fi
      printenv | sort
    '''
  }
}

def initializeEnvironmentStep() {
  initializeEnvironment()
  if (env.BUILD_STATED_SLACK_NOTIFIED != 'true') {
    notifySlack()
  }
}

def installDependencies() {
  if (env.OS_VERSION.split('/')[0] == 'win') {
    powershell label: 'Download saxon', script: '''
      [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
      mkdir saxon
      Invoke-WebRequest -OutFile saxon/saxon9he.jar -Uri https://repo1.maven.org/maven2/net/sf/saxon/Saxon-HE/9.8.0-12/Saxon-HE-9.8.0-12.jar
    '''
  } else {
    sh label: 'Download saxon', script: '''#!/bin/bash -le
      mkdir saxon
      curl -L -o saxon/saxon9he.jar https://repo1.maven.org/maven2/net/sf/saxon/Saxon-HE/9.8.0-12/Saxon-HE-9.8.0-12.jar
    '''

    if (env.DOTNET_VERSION == 'mono') {
      sh label: 'Install required packages for mono builds', script: '''#!/bin/bash -le
        # Define alias for Nuget
        nuget() {
          mono /usr/local/bin/nuget.exe "$@"
        }
        export -f nuget

        nuget install NUnit.Runners -Version 3.6.1 -OutputDirectory testrunner
      '''
    }
  }
}

def buildDriver() {
  if (env.OS_VERSION.split('/')[0] == 'win') {
    powershell label: "Install required packages and build the driver for ${env.DOTNET_VERSION}", script: '''
        dotnet restore src
        dotnet restore src
      '''
  } else {
    if (env.DOTNET_VERSION == 'mono') {
      sh label: 'Build the driver for mono', script: '''#!/bin/bash -le
        export BuildMonoOnly=True
        export RunCodeAnalyzers=False
        export MSBuildSDKsPath=/home/jenkins/dotnetcli/sdk/$(dotnet --version)/Sdks
        msbuild /t:restore /v:m /p:RestoreDisableParallel=true src/Cassandra.sln || true
        msbuild /t:restore /v:m /p:RestoreDisableParallel=true src/Cassandra.sln
        msbuild /p:Configuration=Release /v:m /p:RestoreDisableParallel=true /p:DynamicConstants=LINUX src/Cassandra.sln || true
        msbuild /p:Configuration=Release /v:m /p:RestoreDisableParallel=true /p:DynamicConstants=LINUX src/Cassandra.sln
      '''
    } else {
      sh label: "Work around nuget issue", script: '''#!/bin/bash -le
        mkdir -p /tmp/NuGetScratch
        chmod -R ugo+rwx /tmp/NuGetScratch
      '''
      sh label: "Install required packages and build the driver for ${env.DOTNET_VERSION}", script: '''#!/bin/bash -le
        dotnet restore src || true
        dotnet restore src
      '''
    }
  }
}

def executeTests(perCommitSchedule) {
  
  if (perCommitSchedule) {
    env.DOTNET_TEST_FILTER = "(TestCategory!=long)&(TestCategory!=memory)&(TestCategory!=realclusterlong)&(TestCategory!=cloud)"
    env.MONO_TEST_FILTER = "cat != long && cat != memory && cat != realclusterlong && cat != cloud"
  } else {
    env.DOTNET_TEST_FILTER = "(TestCategory!=long)&(TestCategory!=memory)&(TestCategory!=cloud)"
    env.MONO_TEST_FILTER = "cat != long && cat != memory && cat != cloud"
  }
  
  if (env.OS_VERSION.split('/')[0] == 'win') {
    catchError {
      powershell label: "Execute tests for ${env.DOTNET_VERSION}", script: '''
        . $env:HOME\\Documents\\WindowsPowerShell\\Microsoft.PowerShell_profile.ps1
        . $Env:HOME\\driver-environment.ps1
        dotnet test src/Cassandra.IntegrationTests/Cassandra.IntegrationTests.csproj -v n -f $Env:DOTNET_VERSION -c Release --filter $Env:DOTNET_TEST_FILTER --logger "xunit;LogFilePath=../../TestResult_xunit.xml" -- RunConfiguration.TargetPlatform=x64
      '''
    }
    powershell label: 'Convert the test results using saxon', script: '''
      java -jar saxon/saxon9he.jar -o:TestResult.xml TestResult_xunit.xml tools/JUnitXml.xslt
    '''
  } else {
    if (env.DOTNET_VERSION == 'mono') {
      catchError {
        sh label: 'Execute tests for mono', script: '''#!/bin/bash -le
          # Load CCM and driver configuration environment variables
          set -o allexport
          . ${HOME}/environment.txt
          set +o allexport

          # Fix Java version at Java8 for now because of dependencies in DSE.
          # TODO: This should last us through testing against Cassandra 4.1.x at least but
          # will eventually need to be made more generic.
          . ${JABBA_SHELL}
          jabba use 1.8

          mono ./testrunner/NUnit.ConsoleRunner.3.6.1/tools/nunit3-console.exe src/Cassandra.IntegrationTests/bin/Release/net462/Cassandra.IntegrationTests.dll --where "$MONO_TEST_FILTER" --labels=All --result:"TestResult_nunit.xml"
        '''
      }
      sh label: 'Convert the test results using saxon', script: '''#!/bin/bash -le
        java -jar saxon/saxon9he.jar -o:TestResult.xml TestResult_nunit.xml tools/nunit3-junit.xslt
      '''
    } else {
      catchError {
        sh label: "Execute tests for ${env.DOTNET_VERSION}", script: '''#!/bin/bash -le
          # Load CCM and driver configuration environment variables
          set -o allexport
          . ${HOME}/environment.txt
          set +o allexport

          # Fix Java version at Java8 for now because of dependencies in DSE.
          # TODO: This should last us through testing against Cassandra 4.1.x at least but
          # will eventually need to be made more generic.
          . ${JABBA_SHELL}
          jabba use 1.8

          export OPENSSL_CONF=/home/jenkins/openssl.cnf

          dotnet test src/Cassandra.IntegrationTests/Cassandra.IntegrationTests.csproj -v n -f ${DOTNET_VERSION} -c Release --filter $DOTNET_TEST_FILTER --logger "xunit;LogFilePath=../../TestResult_xunit.xml"
        '''
      }
      sh label: 'Convert the test results using saxon', script: '''#!/bin/bash -le
        java -jar saxon/saxon9he.jar -o:TestResult.xml TestResult_xunit.xml tools/JUnitXml.xslt
      '''
    } 
  }
}

def notifySlack(status = 'started') {
  // Set the global pipeline scoped environment (this is above each matrix)
  env.BUILD_STATED_SLACK_NOTIFIED = 'true'

  def osVersionDescription = 'Ubuntu'
  if (params.CI_SCHEDULE_OS_VERSION == 'win/cs') {
    osVersionDescription = 'Windows'
  }

  def buildType = 'Per-Commit'
  def changeLogMsg = getFirstChangeLogEntry()
  if (params.CI_SCHEDULE != 'DEFAULT-PER-COMMIT') {
    buildType = "${params.CI_SCHEDULE.toLowerCase().capitalize()}-${osVersionDescription}"
  }

  def color = 'good' // Green
  if (status.equalsIgnoreCase('aborted')) {
    color = '#808080' // Grey
  } else if (status.equalsIgnoreCase('unstable')) {
    color = 'warning' // Orange
  } else if (status.equalsIgnoreCase('failed')) {
    color = 'danger' // Red
  } else if (status.equalsIgnoreCase("started")) {
    color = '#fde93f' // Yellow
  }

  def message = """<${env.RUN_DISPLAY_URL}|Build ${env.DRIVER_DISPLAY_NAME} #${env.BUILD_NUMBER} - ${buildType}> ${status}
Commit <${env.GITHUB_COMMIT_URL}|${env.GIT_SHA}> on branch <${env.GITHUB_BRANCH_URL}|${env.BRANCH_NAME}>"""

  if (!changeLogMsg.equalsIgnoreCase("")) {
    message += """: _${changeLogMsg}_"""
  }

  if (!status.equalsIgnoreCase('Started')) {
    message += """
${status} after ${currentBuild.durationString - ' and counting'}"""
  }

  slackSend color: "${color}",
            channel: "#csharp-driver-dev-bots",
            message: "${message}"
}

@NonCPS
def getFirstChangeLogEntry() {
  def changeLogSets = currentBuild.changeSets
  def changeLogSetsSize = changeLogSets.size()
  if (changeLogSets.size() > 0) {
    def firstChangeLogSet = changeLogSets[changeLogSets.size() - 1]
    def entries = firstChangeLogSet.items;
    if (entries.length > 0) {
      return entries[entries.length - 1].msg;
    }
  }
  return "";
}

def describeScheduledTestingStage() {
  script {
    def type = params.CI_SCHEDULE.toLowerCase().capitalize()
    def serverVersionDescription = "almost all server version(s) in the matrix"
    def osVersionDescription = 'Ubuntu 18.04 LTS'
    if (env.OS_VERSION == 'win/cs') {
      osVersionDescription = 'Windows 10'
    }    
    currentBuild.displayName = "#${env.BUILD_NUMBER} - ${type} (${osVersionDescription})"
    currentBuild.description = "${type} scheduled testing for ${serverVersionDescription} on ${osVersionDescription}"
  }
}

// branch pattern for cron
branchPatternCron = ~"(master)"

pipeline {
  agent none

  // Global pipeline timeout
  options {
    disableConcurrentBuilds()
    timeout(time: 10, unit: 'HOURS')
    buildDiscarder(logRotator(artifactNumToKeepStr: '10', // Keep only the last 10 artifacts
                              numToKeepStr: '50'))        // Keep only the last 50 build records
  }

  parameters {
    choice(
      name: 'CI_SCHEDULE',
      choices: ['NIGHTLY', 'WEEKLY'],
      description: '''<table style="width:100%">
                        <col width="20%">
                        <col width="80%">
                        <tr>
                          <th align="left">Choice</th>
                          <th align="left">Description</th>
                        </tr>
                        <tr>
                          <td><strong>ubuntu/bionic64/csharp-driver</strong></td>
                          <td>Ubuntu 18.04 LTS x86_64</td>
                        </tr>
                      </table>''')
    choice(
      name: 'CI_SCHEDULE_OS_VERSION',
      choices: ['ubuntu/bionic64/csharp-driver'],
      description: 'CI testing operating system version to utilize')
  }

  triggers {
    parameterizedCron(branchPatternCron.matcher(env.BRANCH_NAME).matches() ? """
      # Every weeknight (Monday - Friday) around 20:00 and 22:00 Pacific / 05:00 and 07:00 Central Europe
      H 22 * * 1-5 %CI_SCHEDULE=NIGHTLY;CI_SCHEDULE_OS_VERSION=ubuntu/bionic64/csharp-driver

      # Every Saturday around 01:00 and 05:00 Pacific / 10:00 and 14:00 Central Europe
      H 5 * * 6 %CI_SCHEDULE=WEEKLY;CI_SCHEDULE_OS_VERSION=ubuntu/bionic64/csharp-driver
    """ : "")
  }

  environment {
    DOTNET_CLI_TELEMETRY_OPTOUT = '1'
    SIMULACRON_PATH = '/home/jenkins/simulacron.jar'
    SIMULACRON_PATH_WINDOWS = 'C:\\Users\\Admin\\simulacron.jar'
    CCM_ENVIRONMENT_SHELL = '/usr/local/bin/ccm_environment.sh'
    CCM_ENVIRONMENT_SHELL_WINDOWS = '/mnt/c/Users/Admin/ccm_environment.sh'
    JABBA_SHELL = '/usr/lib/jabba/jabba.sh'
    BuildAllTargets = 'True'
    RunCodeAnalyzers = 'True'
  }

  stages {
    stage('Nightly-Ubuntu') {
      when {
        beforeAgent true
        allOf {
          expression { params.CI_SCHEDULE == 'NIGHTLY' }
          expression { params.CI_SCHEDULE_OS_VERSION == 'ubuntu/bionic64/csharp-driver' }
          not { buildingTag() }
        }
      }

      environment {
        OS_VERSION = "${params.CI_SCHEDULE_OS_VERSION}"
      }

      // ##
      // # Building on Linux
      // #   - Do not build using net framework
      // #   - Target all Apache Cassandra� and DataStax Enterprise versions for netcoreapp2.1
      // ##
      // H 0 * * 1-5 %CI_SCHEDULE=NIGHTLY;CI_SCHEDULE_DOTNET_VERSION=ALL;CI_SCHEDULE_SERVER_VERSION=2.2 3.11 dse-5.1 dse-6.7;CI_SCHEDULE_OS_VERSION=ubuntu/bionic64/csharp-driver
      // H 1 * * 1-5 %CI_SCHEDULE=NIGHTLY;CI_SCHEDULE_DOTNET_VERSION=netcoreapp2.1;CI_SCHEDULE_SERVER_VERSION=ALL;CI_SCHEDULE_OS_VERSION=ubuntu/bionic64/csharp-driver
      matrix {
        axes {
          axis {
            name 'SERVER_VERSION'
            values '2.1',     // Legacy Apache Cassandra�
                  '2.2',     // Legacy Apache Cassandra�
                  '3.0',     // Previous Apache Cassandra�
                  '3.11',    // latest 3.11.x Apache Cassandra�
                  '4.0',    // Previous 4.0.x Apache Cassandra�
                  '4.1',    // Latest 4.1.x Apache Cassandra�
                  '5.0', // Development Apache Cassandra�
                  'dse-5.1.35', // Legacy DataStax Enterprise
                  'dse-6.0.18', // Previous DataStax Enterprise
                  'dse-6.7.17', // Previous DataStax Enterprise
                  'dse-6.8.30',  // Previous DataStax Enterprise
                  'dse-6.9.3',  // Latest DataStax Enterprise
                  'hcd-1.0.0'  // Hyper-Converged Database
          }
          axis {
            name 'DOTNET_VERSION'
            values 'mono', 'net8'
          }
        }
        excludes {
          exclude {
            axis {
              name 'DOTNET_VERSION'
              values 'mono'
            }
            axis {
              name 'SERVER_VERSION'
              values '2.1', '3.0', 'dse-6.0.18'
            }
          }
        }

        agent {
          label "${OS_VERSION}"
        }

        stages {
          stage('Initialize-Environment') {
            steps {
              initializeEnvironmentStep()
            }
          }
          stage('Describe-Build') {
            steps {
              describeScheduledTestingStage()
            }
          }
          stage('Install-Dependencies') {
            steps {
              installDependencies()
            }
          }
          stage('Build-Driver') {
            steps {
              buildDriver()
            }
          }
          stage('Execute-Tests') {
            steps {
              executeTests(false)
            }
            post {
              always {
                junit testResults: '**/TestResult.xml'
              }
            }
          }
        }
      }
      post {
        aborted {
          notifySlack('aborted')
        }
        success {
          notifySlack('completed')
        }
        unstable {
          notifySlack('unstable')
        }
        failure {
          notifySlack('FAILED')
        }
      }
    }
    
    stage('Weekly-Ubuntu') {
      when {
        beforeAgent true
        allOf {
          expression { params.CI_SCHEDULE == 'WEEKLY' }
          expression { params.CI_SCHEDULE_OS_VERSION == 'ubuntu/bionic64/csharp-driver' }
          not { buildingTag() }
        }
      }

      environment {
        OS_VERSION = "${params.CI_SCHEDULE_OS_VERSION}"
      }

      matrix {
        axes {
          axis {
            name 'SERVER_VERSION'
            values '2.1',     // Legacy Apache Cassandra�
                  '2.2',     // Legacy Apache Cassandra�
                  '3.0',     // Previous Apache Cassandra�
                  '3.11',    // latest 3.11.x Apache Cassandra�
                  '4.0',    // Previous 4.0.x Apache Cassandra�
                  '4.1',    // Latest 4.1.x Apache Cassandra�
                  '5.0', // Development Apache Cassandra�
                  'dse-5.1.35', // Legacy DataStax Enterprise
                  'dse-6.0.18', // Previous DataStax Enterprise
                  'dse-6.7.17', // Previous DataStax Enterprise
                  'dse-6.8.30',  // Previous DataStax Enterprise
                  'dse-6.9.3',  // Latest DataStax Enterprise
                  'hcd-1.0.0'  // Hyper-Converged Database
          }
          axis {
            name 'DOTNET_VERSION'
            values 'mono', 'net8'
          }
        }

        agent {
          label "${OS_VERSION}"
        }

        stages {
          stage('Initialize-Environment') {
            steps {
              initializeEnvironmentStep()
            }
          }
          stage('Describe-Build') {
            steps {
              describeScheduledTestingStage()
            }
          }
          stage('Install-Dependencies') {
            steps {
              installDependencies()
            }
          }
          stage('Build-Driver') {
            steps {
              buildDriver()
            }
          }
          stage('Execute-Tests') {
            steps {
              executeTests(false)
            }
            post {
              always {
                junit testResults: '**/TestResult.xml'
              }
            }
          }
        }
      }
      post {
        aborted {
          notifySlack('aborted')
        }
        success {
          notifySlack('completed')
        }
        unstable {
          notifySlack('unstable')
        }
        failure {
          notifySlack('FAILED')
        }
      }
    }
  }
}