build.gradle

import de.undercouch.gradle.tasks.download.Download

plugins {
	id "de.undercouch.download" version "1.2"
}
apply from: 'execute.gradle'
apply from: 'servers.gradle'

ext {
	windows = System.properties['os.name'].toLowerCase().contains('windows')
	testsToExecute = ~/.*/
	if (project.hasProperty('tests')) testsToExecute = tests
}

task clean << {
	if (buildDir.exists()) buildDir.deleteDir()
}

task downloadServers(type: Download) {
	src servers.collect { it.value.downloadUrl } - null
	file('.downloads').mkdir()
	dest file('.downloads')
	overwrite false
}

task test << {
	def failedProjects = []
	projectDir.eachDirMatch(testsToExecute) { dir ->
		dir.eachFileMatch(/stagemonitor-integration-test.properties/) { propertiesFile ->
			Properties props = new Properties()
			propertiesFile.withInputStream { props.load(it) }
			println "\n####################"
			println "# ${dir.path - projectDir.path}"
			println "####################"
			checkCompatibilityAndExecuteTest(props, dir, failedProjects)
		}
	}
	assert failedProjects == []
	println "# All tests where executed successfully"
}
test.dependsOn clean
test.dependsOn downloadServers

private void checkCompatibilityAndExecuteTest(Properties props, dir, failedProjects) {
	if (isLocalJavaVersionCompatible(props.javaVersions.split(/\s*,\s*/))) {
		props.server.split(/\s*,\s*/).each { server ->
			assert servers[server]
			def srv = servers[server]
			if (isLocalJavaVersionCompatible(srv.javaVersions, srv.openJdk)) {
				if (!executeTest(dir, props, server)) {
					failedProjects << (dir.path - projectDir.path)
				}
			} else {
				println "# This server is skipped because the local version of java is not compatible with it."
			}
		}
	} else {
		println "This test is skipped because the local version of java is not compatible with it."
	}
}

boolean executeTest(File dir, Properties props, String serverName) {
	Closeable serverShutDown = {}
	try {
		println serverName
		def server = servers[serverName]
		if (!isLocalJavaVersionCompatible(server.javaVersions)) {
			println "This server is skipped because the local version of java is not compatible with it."
			return true
		}
		server.install()

		if (props.buildCommand) assert execute(props.buildCommand, dir).exitValue() == 0

		println "# deploying..."
		server.deploy(dir, props)

		serverShutDown = startServer(server, dir, props)
		waitForIt(props.baseUrl)
		executeTestScript(dir, props)
		println "Successfully executed tests"
		return true
	} catch (Exception | AssertionError e) {
		println "An error occured while executing tests"
		e.printStackTrace()
		return false
	} finally {
		if (!project.hasProperty('noShutdown')) {
			serverShutDown.close()
			if (buildDir.exists()) buildDir.deleteDir()
		} else {
			Runtime.getRuntime().addShutdownHook { serverShutDown.close() }
			Thread.currentThread().join()
		}
	}
}

Closeable startServer(def server, File testDir, Properties props) {
	println "# starting server..."
	def proc = server.start(testDir, props)

	return {
		println "# stopping server..."
		server.stop(proc)
		println "# server stopped"
	} as Closeable
}

task startServer << {
	assert servers.keySet().contains(server)
	def srv = servers[server]
	srv.install()
	Runtime.getRuntime().addShutdownHook { srv.stop() }
	srv.start(null, null).waitFor()
}

void executeTestScript(File testDir, Properties props) {
	GroovyShell shell = new GroovyShell(new Binding([props: props, execute: execute]))
	if (!props.skipDefaultTestScript) {
		shell.evaluate(file('DefaultTestScript.groovy'))
	}

	testDir.eachFileMatch("TestScript.groovy") { shell.evaluate(it) }
}

void waitForIt(String url, int timeoutSec = 300) {
	long timeout = System.currentTimeMillis() + timeoutSec * 1000
	while (timeout > System.currentTimeMillis()) {
		try {
			url.toURL().text
			println "# started server"
			return
		} catch (Exception e) {
			sleep(100)
		}
	}
	throw new IllegalStateException("# The server failed to start within ${timeoutSec} sec")
}

boolean isLocalJavaVersionCompatible(compatibleVersions, boolean openJdkIsCompatible = true) {
    println "Local Java version: ${System.getProperty('java.specification.version')}; compatible versions: $compatibleVersions; OpenJDK: $openJdkIsCompatible"
	if (!openJdkIsCompatible && System.getProperty("java.vm.name").contains("OpenJDK")) {
		return false
	}
	compatibleVersions.any { System.getProperty('java.specification.version') == it }
}

task wrapper(type: Wrapper) {
	gradleVersion = "2.5"
}