Jenkinsfile.js

#!/usr/bin/env groovy

/*
 * Copyright (C) 2019 - present Instructure, Inc.
 *
 * This file is part of Canvas.
 *
 * Canvas is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Affero General Public License as published by the Free
 * Software Foundation, version 3 of the License.
 *
 * Canvas is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Affero General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

def runCoverage() {
  def flags = load 'build/new-jenkins/groovy/commit-flags.groovy'
  return env.RUN_COVERAGE == '1' || flags.forceRunCoverage() ? '1' : ''
}

def isForceFailure() {
  def flags = load 'build/new-jenkins/groovy/commit-flags.groovy'
  return flags.isForceFailureJS() ? "1" : ''
}

def getImageTagVersion() {
  def flags = load 'build/new-jenkins/groovy/commit-flags.groovy'
  // total hack, we shouldnt do it like this. but until there is a better
  // way of passing info across builds, this is path of least resistance..
  // also, it didnt seem to work with multiple return statements, so i'll
  // just go ahead and leave this monstrosity here.
  return env.RUN_COVERAGE == '1' ? 'master' : flags.getImageTagVersion()
}

def copyFiles(dockerName, dockerPath, hostPath) {
  sh "mkdir -vp ./$hostPath"
  sh "docker cp \$(docker ps -qa -f name=$dockerName):/usr/src/app/$dockerPath ./$hostPath"
}

def withSentry(block) {
  def credentials = load 'build/new-jenkins/groovy/credentials.groovy'
  credentials.withSentryCredentials(block)
}

def runInSeriesOrParallel(isSeries, stagesMap) {
  if (isSeries) {
    echo "running tests in series: ${stagesMap.keys}"
    stagesMap.each { name, block ->
      stage(name) {
        block()
      }
    }
  } else {
    echo "running tests in parallel: ${stagesMap.keys}"
    parallel(stagesMap)
  }
}

pipeline {
  agent { label 'canvas-docker' }
  options { ansiColor('xterm') }

  environment {
    COMPOSE_FILE = 'docker-compose.new-jenkins.canvas.yml:docker-compose.new-jenkins-karma.yml'
    COVERAGE = runCoverage()
    FORCE_FAILURE = isForceFailure()
    SENTRY_URL="https://sentry.insops.net"
    SENTRY_ORG="instructure"
    SENTRY_PROJECT="master-javascript-build"
  }

  stages {
    stage('Setup') {
      steps {
        timeout(time: 10) {
          sh 'build/new-jenkins/print-env-excluding-secrets.sh'
          sh 'build/new-jenkins/docker-cleanup.sh'
          sh 'rm -vrf ./tmp/*'
          sh 'build/new-jenkins/docker-compose-pull.sh'
          sh 'docker-compose build'
        }
      }
    }

    stage('Test Stage Coordinator') {
      steps {
        timeout(time: 60) {
          script {
            def tests = [:]

            tests['Jest'] = {
              withEnv(['CONTAINER_NAME=tests-jest']) {
                try {
                  withSentry { sh 'build/new-jenkins/js/tests-jest.sh'
                  }
                  if (env.COVERAGE == '1') {
                    copyFiles(env.CONTAINER_NAME, 'coverage-jest', "./tmp/${env.CONTAINER_NAME}-coverage")
                  }
                } finally {
                  copyFiles(env.CONTAINER_NAME, 'coverage-js', "./tmp/${env.CONTAINER_NAME}")
                }
              }
            }

            tests['Packages'] = {
              withEnv(['CONTAINER_NAME=tests-packages']) {
                try {
                  withSentry { sh 'build/new-jenkins/js/tests-packages.sh' }
                } finally {
                  copyFiles(env.CONTAINER_NAME, 'packages', "./tmp/${env.CONTAINER_NAME}")
                }
              }
            }

            tests['canvas_quizzes'] = {
              sh 'build/new-jenkins/js/tests-quizzes.sh'
            }

            ['coffee', 'jsa', 'jsg', 'jsh'].each { group ->
              tests["Karma - Spec Group - ${group}"] = {
                withEnv(["CONTAINER_NAME=tests-karma-${group}", "JSPEC_GROUP=${group}"]) {
                  try {
                    withSentry { sh 'build/new-jenkins/js/tests-karma.sh' }
                    if (env.COVERAGE == '1') {
                      copyFiles(env.CONTAINER_NAME, 'coverage-karma', "./tmp/${env.CONTAINER_NAME}-coverage")
                    }
                  } finally {
                    copyFiles(env.CONTAINER_NAME, 'coverage-js', "./tmp/${env.CONTAINER_NAME}")
                  }
                }
              }
            }

            runInSeriesOrParallel(env.COVERAGE == '1', tests)
          }
        }
      }
    }


    stage('Upload Coverage') {
      when { expression { env.COVERAGE == '1' } }
      steps {
        timeout(time: 10) {
          sh 'build/new-jenkins/js/coverage-report.sh'
          archiveArtifacts(artifacts: 'coverage-report-js/**/*')
          uploadCoverage([
              uploadSource: "/coverage-report-js/report-html",
              uploadDest: "canvas-lms-js/coverage"
          ])
        }
      }
    }
  }

  post {
    always {
      script {
        junit allowEmptyResults: true, testResults: 'tmp/**/*.xml'
        sh 'find ./tmp -path "*.xml"'
      }
    }
    cleanup {
      sh 'build/new-jenkins/docker-cleanup.sh --allow-failure'
    }
  }
}