Jenkinsfile.sdk

@Library('lisk-jenkins') _

def setup() {
	cleanWs()
	unstash 'build'
}

def run_jest(test_name) {
	ansiColor('xterm') {
		timestamps {
			nvm(getNodejsVersion()) {
				dir('framework') {
					sh 'npm run test:' + "${test_name}" + ' ${JEST_OPTIONS}'
				}
			}
		}
	}
}

def teardown_jest(test_name) {
	try {
		nvm(getNodejsVersion()) {
			sh """
			rm -rf coverage_jest_${test_name}; mkdir -p coverage_jest_${test_name}
			cp framework/.coverage/${test_name}/coverage-final.json coverage_jest_${test_name}/ || echo "Jest lcov coverage not found"
			"""
		}
	} catch(err) {
		println "Could gather coverage statistics from test:\n${err}"
	}
	stash name: "coverage_jest_${test_name}", includes: "coverage_jest_${test_name}/*", allowEmpty: true
	timeout(1) {
		sh 'killall --verbose --wait node || true'
	}
	dir('framework') {
		sh """
		mv .app.log lisk_${test_name}.stdout.txt || true
		mv logs/devnet/lisk.log lisk_${test_name}.log || true
		"""
		archiveArtifacts artifacts: 'lisk_*.log', allowEmptyArchive: true
		archiveArtifacts artifacts: 'lisk_*.stdout.txt', allowEmptyArchive: true
	}
	cleanWs()
}

properties([
	parameters([
		string(name: 'JEST_OPTIONS', defaultValue: '', description: 'Additional jest options that you want to provide to test runner. Example: `-- --config=<path>`'),
		// read by the application
		string(name: 'LOG_LEVEL', defaultValue: 'error', description: 'To get desired build log output change the log level', ),
		string(name: 'FILE_LOG_LEVEL', defaultValue: 'error', description: 'To get desired file log output change the log level', ),
		// used by tests
		string(name: 'SILENT', defaultValue: 'true', description: 'To turn off test debug logs.', )
	 ])
])

pipeline {
	agent { node { label 'lisk-sdk' } }

	environment {
		MAX_TASK_LIMIT = '20'
	}

	stages {
		stage('Cancel previous build') {
			steps {
				script {
					if (env.CHANGE_ID) {
						// we are build a pull request, try cancelling previous build
						cancelPreviousBuild()
					}
				}
			}
		}
		stage('Build') {
			steps {
				nvm(getNodejsVersion()) {
					sh '''
					npm i -g yarn
					yarn
					yarn build
					# needed by one of the "Functional HTTP GET tests"
					git rev-parse HEAD > framework/REVISION
					'''
				}
				stash name: 'build'
			}
		}
		stage('Lint') {
			steps {
				nvm(getNodejsVersion()) {
					sh '''
					yarn lint
					'''
				}
			}
		}
		stage('Format') {
			steps {
				nvm(getNodejsVersion()) {
					sh '''
					npm run format
					if [ -z "$(git status --untracked-files=no --porcelain)" ]; then
						echo "All files formatted"
					else
						echo "Running format is required"
						exit 1
					fi
					'''
				}
			}
		}
		stage('Test') {
			parallel {
				stage('Lisk Elements') {
					agent { node { label 'lisk-elements' }}
					steps {
						setup()
						nvm(getNodejsVersion()) {
							sh 'npx lerna run test:ci --ignore lisk-{framework,commander,@liskhq/lisk-framework-*} --ignore @liskhq/lisk-p2p'
						}
					}
					post {
						cleanup {
							// Save all the test results
							sh '''
								rm -rf coverage_elements; mkdir -p coverage_elements
								for f in $( find elements/*/.coverage/ -type f ); do
								  cp $f coverage_elements/$( sha1sum $f | cut -d ' ' -f 1 )_$( basename $f )
								done
							'''
							stash name: "coverage_elements", includes: "coverage_elements/*", allowEmpty: true
						}
					}
				}
				stage('Lisk Elements / @liskhq/lisk-p2p') {
					agent { node { label 'lisk-sdk-quirky' }}
					steps {
						setup()
						nvm(getNodejsVersion()) {
							sh 'npx lerna run test:ci --scope @liskhq/lisk-p2p'
						}
					}
				}
				stage('Lisk Commander') {
					agent { node { label 'lisk-commander' }}
					steps {
						setup()
						nvm(getNodejsVersion()) {
							sh 'npx lerna run test:ci --scope=lisk-commander'
						}
						sh 'mv commander/.coverage/ coverage_commander/ || echo "Jest coverage not found"'
						stash name: "coverage_commander", includes: "coverage_commander/*", allowEmpty: true
					}
				}
				stage('Lisk Client End-to-End') {
					agent { node { label 'lisk-client' }}
					steps {
						setup()
						wrap([$class: 'Xvfb', parallelBuild: true, autoDisplayName: true]) {
							nvm(getNodejsVersion()) {
								sh 'npx lerna run test:e2e --scope=@liskhq/lisk-client'
							}
						}
					}
				}
				stage('Lisk Framework Unit') {
					agent { node { label 'lisk-framework' }}
					steps {
						setup()
						run_jest('unit')
					}
					post {
						cleanup {
							teardown_jest('unit')
						}
					}
				}
				stage('Lisk Framework Integration') {
					agent { node { label 'lisk-sdk-quirky' }}
					steps {
						setup()
						run_jest('integration')
					}
					post {
						cleanup {
							teardown_jest('integration')
						}
					}
				}
				stage('Lisk Framework Functional') {
					agent { node { label 'lisk-sdk-quirky' }}
					steps {
						setup()
						run_jest('functional')
					}
					post {
						cleanup {
							teardown_jest('functional')
						}
					}
				}
				stage('Lisk Framework Plugins Unit') {
					agent { node { label 'lisk-framework' }}
					steps {
						setup()
						nvm(getNodejsVersion()) {
							sh 'npx lerna run test:unit --scope=@liskhq/lisk-framework-*'
						}
					}
					post {
						cleanup {
							// Save all the test results
							sh '''
								rm -rf coverage_framework_plugins; mkdir -p coverage_framework_plugins
								for f in $( find framework-plugins/*/.coverage/ -type f ); do
								  cp $f coverage_framework_plugins/$( sha1sum $f | cut -d ' ' -f 1 )_$( basename $f )
								done
							'''
							stash name: "coverage_framework_plugins", includes: "coverage_framework_plugins/*", allowEmpty: true
						}
					}
				}
				stage('Lisk Framework Plugins Integration') {
					agent { node { label 'lisk-framework' }}
					steps {
						setup()
						nvm(getNodejsVersion()) {
							sh 'npx lerna run test:integration --scope=@liskhq/lisk-framework-* --concurrency 1'
						}
					}
				}
				stage('Lisk Framework Plugins Functional') {
					agent { node { label 'lisk-sdk-quirky' }}
					steps {
						setup()
						nvm(getNodejsVersion()) {
							sh 'npx lerna run test:functional --scope=@liskhq/lisk-framework-* --concurrency 1'
						}
					}
				}
			}
		}
	}
	post {
		always {
			script {
				try {
					unstash "coverage_elements"
				} catch(err) {
					println "Could not unstash elements. Continuing."
				}
				try {
					unstash "coverage_commander"
				} catch(err) {
					println "Could not unstash commander. Continuing."
				}
				try {
					unstash "coverage_jest_unit"
				} catch(err) {
					println "Could not unstash jest_unit. Continuing."
				}
				try {
					unstash "coverage_framework_plugins"
				} catch(err) {
					println "Could not unstash framework_plugins. Continuing."
				}
				sh '''
					rm -rf .nyc_output; mkdir -p .nyc_output
					rm -rf ci_coverage; mkdir -p ci_coverage
					cp -r coverage_elements/* ./.nyc_output
					cp -r coverage_framework_plugins/* ./.nyc_output
					cp -r coverage_commander/* ./.nyc_output
					cp coverage_jest_unit/coverage-final.json ./.nyc_output/coverage-framework-unit.json
				'''
				try {
					nvm(getNodejsVersion()) {
						sh '''
						npx nyc merge ./.nyc_output ci_coverage/coverage.json
						node scripts/map_coverage.js ci_coverage/coverage.json
						'''
					}
					cobertura coberturaReportFile: 'coverage/cobertura-coverage.xml'
				} catch(err) {
					println "Could not report coverage statistics:\n${err}"
				}
				currentBuild.result = 'SUCCESS'
				if (env.BRANCH_NAME == 'master') {
					step([$class: 'MasterCoverageAction', scmVars: [GIT_URL: env.GIT_URL]])
				}
				if (env.CHANGE_ID != null) {
					step([$class: 'CompareCoverageAction', publishResultAs: 'statusCheck', scmVars: [GIT_URL: env.GIT_URL]])
				}
			}
		}
		cleanup {
			cleanWs()
		}
	}
}
// vim: filetype=groovy