build.gradle

/*******************************************************************************
* Copyright (c) 2015 IBM Corp.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/

apply plugin: 'base'
apply plugin: 'eclipse'

if (hasProperty('versionFile')) {
    apply from: versionFile
} else {
    apply from: 'LARS_versions.gradle'
}

boolean haveAnyTestsFailed = false;

loadProperties("${rootProject.rootDir}/test-utils/src/main/resources/config.properties");


// General configuration for all projects
// Set up support for fatTests which rely on a running test server
subprojects {

    apply plugin: 'java'
    apply plugin: 'eclipse'
    apply plugin: 'findbugs'
    
    sourceCompatibility = 1.7
    targetCompatibility = 1.7

    repositories {
        mavenCentral()
    }
    
    sourceSets {
        fat {
            compileClasspath += sourceSets.main.output
            runtimeClasspath += sourceSets.main.output
        }
    }
    
    findbugs {
        sourceSets = [sourceSets.main]
        def excludeFile = file("findbugs.exclude.xml")
        if (excludeFile.exists()) {
            excludeFilter = excludeFile
        }
    }
    
    findbugsMain {
        reports {
            xml.enabled = false
            html.enabled = true
        }
    }
    
    configurations {
        fatCompile.extendsFrom testCompile
    }
    
    check {
        dependsOn 'testFat'
    }
    
    test {
        reports.html.enabled = false
        filter.includeTestsMatching '*Test'
        
        ignoreFailures = true
        afterTest { desc, result ->
            if (result.resultType == TestResult.ResultType.FAILURE) {
                haveAnyTestsFailed = true
            }
        }
    }
    
    task testFat(type: Test) {
        group 'verification'
        description 'Start test server and run the fat tests'
        
        testClassesDir = sourceSets.fat.output.classesDir
        classpath = sourceSets.fat.runtimeClasspath
        
        dependsOn fatClasses
        dependsOn 'prepareTestWorkingDir'
        dependsOn ':server:createTestUsrDir'
        dependsOn ':server:startTestMongod'
        finalizedBy ':server:stopTestMongod'
        dependsOn ':server:startTestServer'
        finalizedBy ':server:stopTestServer'
        shouldRunAfter 'test'
        inputs.files({tasks.prepareTestResources})
        reports.html.enabled = false;
        
        ignoreFailures = true
        afterTest { desc, result ->
            if (result.resultType == TestResult.ResultType.FAILURE) {
                haveAnyTestsFailed = true
            }
        }
        
        if (project.hasProperty('massiveServer')) {
            systemProperty 'massiveServer', massiveServer
        }
        
        if (project.hasProperty('fatFilter')) {
            systemProperty 'fatFilter', fatFilter
        }
        
        workingDir file('build/test-working')
    }
    
    task prepareTestWorkingDir {
        dependsOn 'prepareTestResources'
        doLast {
            mkdir('build/test-working')
        }
    }
    
    task prepareTestResources (type:Copy) {
        from 'src/fat/testResources'
        into 'build/test-working/resources'
        exclude '**/*.zip'
        exclude '**/*.jar'
        exclude '**/*.esa'
    }
    
    File testResourcesDir = file('src/fat/testResources')
    def subProj = delegate
    if (testResourcesDir.exists()) {
        testResourcesDir.eachDirRecurse({ dir ->
            if (dir.name.endsWith('.esa') || dir.name.endsWith('.jar') || dir.name.endsWith('.zip')) {
                String relativeTargetPath = dir.parentFile.absolutePath.minus(testResourcesDir.absolutePath)
                Task task = task "create-${relativeTargetPath}-${dir.name}" (type: Zip) {
                    archiveName = dir.name
                    from dir
                    destinationDir = subProj.file('build/test-working/resources' + relativeTargetPath)
                }
                prepareTestResources.dependsOn task
                prepareTestResources.outputs.files(task)
            }
        })
    }
    
    task testReport(type: TestReport) {
        tasks.withType(Test).each({
            reportOn it.binResultsDir
            it.finalizedBy testReport
        })
        destinationDir testReportDir
    }
    
    // We have the JDT prefs checked in so disable the tasks which write it
    eclipseJdt.enabled = false
    cleanEclipseJdt.enabled = false
}


task dist(type: Sync) {
    description 'Produce distribution archives, and copy them to the build/distributions directory'
    group 'distribution'
    into 'build/distributions'
    from subprojects*.getTasksByName('dist', false)
}


/**
 * If the zip file doesn't contain the all the files in the toCheck
 * list, throws an exception.
 */
boolean checkZipContents(zipFileName, toCheck) {
    FileTree tree = zipTree(zipFileName)
    tree.visit { FileVisitDetails details ->
        def foundFiles = []
        toCheck.each {
            if (details.getPath().equals(it)) {
                foundFiles << it
            }
        }
        foundFiles.each {
            toCheck.remove(it)
        }
    }
    
    if (toCheck) {
        throw new GradleException("Couldn't find files '${toCheck}' in the zip file '${zipFileName}'")
    }
}

task globalTestReport(type: TestReport) {
    description 'Produce a test report for all projects and fail the build if any tests failed'
    
    subprojects.each { subproj ->
        subproj.tasks.withType(Test).each {
            reportOn it.binResultsDir
            it.finalizedBy globalTestReport
            shouldRunAfter it
        }
    }
    destinationDir file('build/reports/test')
    doLast {
        if (haveAnyTestsFailed) {
            URI reportUri = new File(destinationDir, "index.html").toURI();
            reportUri = new URI(reportUri.scheme, "", reportUri.path, null);
            throw new Exception("Tests have failed. For more information, see the test report: ${reportUri}")
        }
    }
}

// Make the gradle eclipse tools play nicely with this non-java project
task afterEclipseImport << {
    Node node = new XmlParser().parse(file('.project'));
    
    node.depthFirst().each {
        if (it.name() == "nature" && it.value() == ["org.eclipse.jdt.core.javanature"]) {
            it.parent().remove(it)
        }
        if (it.name() == "buildSpec") {
            it.parent().remove(it)
        }
    }
    
    XmlNodePrinter printer = new XmlNodePrinter(new PrintWriter(file('.project')))
    printer.preserveWhitespace = true
    printer.print(node)
}

// Function to load configuration properties from a normal
// java properties file. This seems to be necessary to allow
// properties that are visible to both gradle script and java
// testcases
void loadProperties(String fileName) {
    Properties properties = new Properties();
    File propertiesFile = new File(fileName);
    propertiesFile.withInputStream {
        properties.load(it);
    }
        
    properties.propertyNames().each {
        project.ext.set(it, properties.get(it));
    }
    
}

// If a Java 6 VM is available, set up the bootclasspath and path to java.exe for
// other projects to use.
if(hasProperty("java6Home")) {
	def java_lib_dir = java6Home + File.separator + "jre" + File.separator + "lib"
	def java_bin_dir = java6Home + File.separator + "jre" + File.separator + "bin"
	def java_executable = java_bin_dir + File.separator + "java.exe"
	File java_exe_file = new File(java_executable)
	if (!java_exe_file.exists()) {
		java_executable = java_bin_dir + File.separator + "java"
		java_exe_file = new File(java_executable)
		if (!java_exe_file.exists()) {
			throw new GradleException("java6Home property was specified but no exectuable could be found. java6Home was "
				+ java6Home + " and " + java_executable + " couldn't be found") 
		}
	}

	// The set of jars needed for the bootclasspath varies depending on which JVM is being used
	// so this code has to search for them.	
	def jars = [];
	try {
		new File(java_lib_dir).eachFileRecurse {
			if (it.path =~/\.jar$/) {
				jars.add(it.path)
			}
		}
		new File(java_bin_dir).eachFileRecurse {
			if (it.path =~/\.jar$/) {
				jars.add(it.path)
			}
		}
	} catch (FileNotFoundException e) {
		// do nothing. The check below will fail the build
	}
	if (jars.size() == 0) {
		throw new GradleException("the java6Home property was specified but no jar files were found in the expected JRE lib directory. java6Home was "
			+ java6Home + " and no jars were found in " + java_lib_dir)
	}

	ext.java6BootClasspath = jars.iterator().join(File.pathSeparator)
	ext.java6Executable = java_executable
	logger.warn("Will execute client-lib-tests with JVM at " + java6Executable)
	logger.debug("bootstrapclasspath for Java 6 projects set to:\n" + java6BootClasspath)

} else {
	logger.warn("java6Home property was not set, so the bootstrapclasspath for client-lib will not be sets,"
		+" and client-lib-tests will be executed on the current JVM") 
}