Jenkinsfile.sdk

@Library('lisk-jenkins') _

def setup(start_application=false) {
	cleanWs()
	unstash 'build'
	if(start_application) {
		nvm(getNodejsVersion()) {
			dir('framework') {
				sh '''
				# teardown_*() should have killed all node processes but we want to be sure
				# this shouldn't hurt assuming the 'lisk-core' jenkins nodes have 1 executor
				killall --verbose --wait node || true
				for database in $( psql --tuples-only --command='SELECT datname FROM pg_database WHERE datdba = (SELECT usesysid FROM pg_user WHERE usename = current_user);' |awk '{ print $1 }' ); do
				  dropdb --if-exists $database
				done
				createdb lisk_dev
				NODE_ENV=test LISK_CONSOLE_LOG_LEVEL=debug NEWRELIC_LICENSE_KEY= node test/test_app >.app.log 2>&1 &
				'''
			}
		}
		// wait for the Core API to be reachable
		timeout(1) {
			waitUntil {
				script {
					def api_available = sh script: 'curl http://localhost:4000/api/node/constants >/dev/null', returnStatus: true
					return (api_available == 0)
				}
			}
		}
	}
}

def run_mocha(test_name) {
	ansiColor('xterm') {
		timestamps {
			nvm(getNodejsVersion()) {
				dir('framework') {
					sh 'npm run mocha:' + "${test_name}" + ' ${MOCHA_OPTIONS:-$DEFAULT_MOCHA_OPTIONS}'
				}
			}
		}
	}
}

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

def teardown_mocha(test_name) {
	// teardown_mocha() gets called in post actions and so we don't want it to fail
	try {
		nvm(getNodejsVersion()) {
			dir('framework') {
				sh """
				rm -rf coverage_mocha_${test_name}; mkdir -p coverage_mocha_${test_name}
				cp test/mocha/.coverage-${test_name}/* coverage_mocha_${test_name}/ || true
				"""
			}
		}
	} catch(err) {
		println "Could gather coverage statistics from mocha:\n${err}"
	}
	dir('framework') {
		stash name: "coverage_mocha_${test_name}", includes: "coverage_mocha_${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()
}

def teardown_jest(test_name) {
	// teardown_mocha() gets called in post actions and so we don't want it to fail
	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 jest:\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: 'MOCHA_OPTIONS', defaultValue: '-- --grep @slow|@unstable --invert', description: 'Please check readme to see available test tags. Example: `-- --grep something`', ),
		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: 'LOG_DB_EVENTS', defaultValue: 'false', description: 'To get detailed info on db events log.', ),
		string(name: 'SILENT', defaultValue: 'true', description: 'To turn off test debug logs.', )
	 ])
])

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

	environment {
		MAX_TASK_LIMIT = '20'
		DEFAULT_MOCHA_OPTIONS = "-- --grep @slow|@unstable --invert"
	}

	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 ci
					npm run bootstrap
					npm run build
					# needed by one of the "Functional HTTP GET tests"
					git rev-parse HEAD > framework/REVISION
					'''
				}
				stash name: 'build'
			}
		}
		stage('Lint') {
			steps {
				setup()
				nvm(getNodejsVersion()) {
					sh '''
					npm run lint
					'''
				}
			}
		}
		stage('Test') {
			parallel {
				stage('Lisk Elements') {
					agent { node { label 'lisk-elements' }}
					steps {
						setup()
						nvm(getNodejsVersion()) {
							sh 'npx lerna run test --ignore lisk-{framework,commander}'
						}
					}
					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 Commander') {
					agent { node { label 'lisk-commander' }}
					steps {
						setup()
						nvm(getNodejsVersion()) {
							dir('commander') {
								sh '''
								rm -rf coverage_commander; mkdir -p coverage_commander
								LISK_COMMANDER_CONFIG_DIR=$WORKSPACE/.lisk npm test
								cp -r .nyc_output/* ./coverage_commander
								'''
								stash name: "coverage_commander", includes: "coverage_commander/*", allowEmpty: true
							}
						}
					}
					post {
						cleanup {
							// Save all the test results
							sh 'rm -f $WORKSPACE/.lisk/config.lock'
						}
					}
				}
				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-framework' }}
					steps {
						setup()
						run_jest('integration')
					}
					post {
						cleanup {
							teardown_jest('integration')
						}
					}
				}
				stage('Lisk Framework Functional') {
					agent { node { label 'lisk-framework' }}
					steps {
						setup(true)
						run_jest('functional')
					}
					post {
						cleanup {
							teardown_jest('functional')
						}
					}
				}
			}
		}
		stage('Legacy Framework test (mocha)') {
			parallel {
				stage('Functional HTTP GET tests') {
					agent { node { label 'lisk-framework' }}
					steps {
						setup(true)
						run_mocha('functional:get')
					}
					post {
						cleanup {
							teardown_mocha('get')
						}
					}
				}
				stage('Functional HTTP POST tests') {
					agent { node { label 'lisk-framework' }}
					steps {
						setup(true)
						run_mocha('functional:post')
					}
					post {
						cleanup {
							teardown_mocha('post')
						}
					}
				}
				stage('Functional HTTP PUT tests') {
					agent { node { label 'lisk-framework' }}
					steps {
						setup(true)
						run_mocha('functional:put')
					}
					post {
						cleanup {
							teardown_mocha('put')
						}
					}
				}
				stage ('Functional WS tests') {
					agent { node { label 'lisk-framework' }}
					steps {
						setup(true)
						run_mocha('functional:ws')
					}
					post {
						cleanup {
							teardown_mocha('ws')
						}
					}
				}
				stage('Unit tests') {
					agent { node { label 'lisk-framework' }}
					steps {
						setup()
						run_mocha('unit')
					}
					post {
						cleanup {
							teardown_mocha('unit')
						}
					}
				}
				stage('Integration tests') {
					agent { node { label 'lisk-framework' }}
					options {
						timeout(time: 10, unit: 'MINUTES')
					}
					steps {
						setup()
						run_mocha('integration')
					}
					post {
						cleanup {
							teardown_mocha('integration')
						}
					}
				}
			}
		}
	}
	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_mocha_unit"
				} catch(err) {
					println "Could not unstash mocha_unit. 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_commander/* ./.nyc_output
					cp coverage_jest_unit/coverage-final.json ./.nyc_output/coverage-framework-unit.json
					cp -r coverage_mocha_unit/* ./.nyc_output
				'''
				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