build.gradle

apply plugin: "idea"

apply plugin: "war"
// apply plugin: "com.google.cloud.tools.appengine"
// see https://github.com/GoogleCloudPlatform/app-gradle-plugin/issues/125
project.pluginManager.apply com.google.cloud.tools.gradle.appengine.standard.AppEngineStandardPlugin

apply plugin: "checkstyle"
apply plugin: "pmd"
apply plugin: "com.github.spotbugs"
apply plugin: "jacoco"
apply plugin: "cz.habarta.typescript-generator"

def appengineVersion = "1.9.81"
def checkstyleVersion = "8.33"
def pmdVersion = "6.24.0"
def spotbugsVersion = "4.0.6"
def jacocoVersion = "0.8.5"

buildscript {
    repositories {
        jcenter()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "com.google.cloud.tools:appengine-gradle-plugin:2.3.0"
        classpath "gradle.plugin.com.github.spotbugs.snom:spotbugs-gradle-plugin:4.4.3"
        classpath("cz.habarta.typescript-generator:typescript-generator-gradle-plugin:2.24.612") {
            exclude group: "org.gradle"
        }
        classpath "com.google.guava:guava:29.0-jre"
    }
}

configurations {
    staticAnalysis
}

repositories {
    jcenter()
}

def objectify = "com.googlecode.objectify:objectify:5.1.22"
def testng = "org.testng:testng:7.2.0"

dependencies {
    staticAnalysis("com.puppycrawl.tools:checkstyle:${checkstyleVersion}")
    staticAnalysis("net.sourceforge.pmd:pmd-java:${pmdVersion}")
    staticAnalysis("com.github.spotbugs:spotbugs:${spotbugsVersion}")
    staticAnalysis("org.jacoco:org.jacoco.build:${jacocoVersion}")

    annotationProcessor(objectify)

    implementation("com.google.appengine:appengine-api-1.0-sdk:${appengineVersion}")

    // This dependency needs to be resolved individually
    // because the main dependency (appengine-gcs-client) does not have its transitive dependencies up-to-date
    implementation("com.google.appengine.tools:appengine-gcs-client:0.8.1") {
        // Use the newer servlet library instead
        exclude group: "javax.servlet", module: "servlet-api"
    }
    implementation("com.google.api-client:google-api-client-appengine:1.30.9") {
        // Use the newer servlet library instead
        exclude group: "javax.servlet", module: "servlet-api"
    }
    implementation("com.google.apis:google-api-services-storage:v1-rev20200430-1.30.9")

    implementation("com.google.code.gson:gson:2.8.6")
    implementation("com.google.guava:guava:29.0-jre")
    implementation(objectify)
    implementation("com.googlecode.owasp-java-html-sanitizer:owasp-java-html-sanitizer:20200615.1")
    implementation("com.mailjet:mailjet-client:4.5.0")
    implementation("com.sendgrid:sendgrid-java:4.6.0")
    implementation("com.sun.jersey:jersey-client:1.19.4")
    implementation("com.sun.jersey:jersey-core:1.19.4")
    implementation("com.sun.jersey.contribs:jersey-multipart:1.19.4")
    implementation("javax.servlet:javax.servlet-api:3.1.0")
    implementation("org.jsoup:jsoup:1.13.1")

    testAnnotationProcessor(testng)

    testImplementation("com.google.appengine:appengine-api-stubs:${appengineVersion}")
    testImplementation("com.google.appengine:appengine-remote-api:${appengineVersion}")
    testImplementation("com.google.appengine:appengine-testing:${appengineVersion}")
    testImplementation("com.tngtech.archunit:archunit:0.11.0")
    testImplementation("org.seleniumhq.selenium:selenium-java:3.141.59")
    testImplementation(testng)
    // For access to Google APIs such as HTTP transport, authentication and JSON parsing
    testImplementation("com.google.api-client:google-api-client:1.30.9")
    // For supporting authorization code flow locally
    testImplementation("com.google.oauth-client:google-oauth-client-jetty:1.30.6")
    // For using Gmail API
    testImplementation("com.google.apis:google-api-services-gmail:v1-rev20200601-1.30.9")
    // For using JMeter APIs
    testImplementation("org.apache.jmeter:ApacheJMeter_core:5.3") {
        exclude group: "org.apache.jmeter", module: "bom"
    }
    testImplementation("org.apache.jmeter:ApacheJMeter_http:5.3") {
        exclude group: "org.apache.jmeter", module: "bom"
    }

}

sourceSets {
    main {
        java {
            srcDir "src/main/java"
            include "**/*.java"
        }
        resources {
            srcDir "src/main/resources"
            exclude "**/*.java"
        }
    }
    test {
        java {
            srcDir "src/test/java"
            srcDir "src/e2e/java"
            srcDir "src/lnp/java"
            srcDir "src/client/java"
            include "**/*.java"
        }
        resources {
            srcDir "src/test/resources"
            srcDir "src/e2e/resources"
            srcDir "src/lnp/resources"
            srcDir "src/client/resources"
            exclude "**/*.java"
        }
    }
}

tasks.withType(cz.habarta.typescript.generator.gradle.GenerateTask) {
    jsonLibrary = "jackson2"
    optionalAnnotations = [
        "javax.annotation.Nullable"
    ]
    outputFileType = "implementationFile"
    outputKind = "module"
    indentString = "  "
    jackson2Configuration = [
        fieldVisibility: "ANY",
        getterVisibility: "NONE",
        isGetterVisibility: "NONE",
        setterVisibility: "NONE",
        creatorVisibility: "NONE",
    ]
    mapEnum = "asEnum"
    nonConstEnums = true
}

task generateApiOutputFormat(type: cz.habarta.typescript.generator.gradle.GenerateTask) {
    classPatterns = [
        "teammates.ui.output.**",
        "teammates.common.datatransfer.questions.**"
    ]
    removeTypeNameSuffix = "Data"
    outputFile = "src/web/types/api-output.ts"
    excludeClassPatterns = [
        "teammates.ui.output.**Builder"
    ]
    excludeClasses = [
        "teammates.ui.output.SessionResultsData\$NameInfo"
    ]
}

task generateApiRequestFormat(type: cz.habarta.typescript.generator.gradle.GenerateTask) {
    classPatterns = [
        "teammates.ui.request.**",
        "teammates.common.util.EmailType"
    ]
    outputFile = "src/web/types/api-request.ts"
}

task generateApiEndpoints(type: cz.habarta.typescript.generator.gradle.GenerateTask) {
    classPatterns = [
        "teammates.ui.endpoints.**"
    ]
    jsonLibrary = 'jackson2'
    jackson2Configuration = [
        'enumsUsingToString': true
    ]
    outputFile = "src/web/types/api-endpoints.ts"
}

generateApiOutputFormat.dependsOn classes
generateApiRequestFormat.dependsOn classes
generateApiEndpoints.dependsOn classes

task generateTypes {
    dependsOn generateApiOutputFormat
    dependsOn generateApiRequestFormat
    dependsOn generateApiEndpoints
}

// SETUP TASKS

task createConfigs {
    description "Sets up the project by obtaining necessary files and configurations points."
    group "Setup"
    doLast {
        def templatesToCopy = [
            "gradle.template.properties",
            "src/main/resources/build.template.properties",
            "src/web/environments/config.template.ts",
            "src/test/resources/test.template.properties",
            "src/lnp/resources/test.template.properties",
            "src/e2e/resources/test.template.properties",
            "src/client/resources/client.template.properties",
            "src/main/webapp/WEB-INF/appengine-web.template.xml"
        ]
        templatesToCopy.findAll {
            !(new File(it.replace(".template", ""))).exists()
        }.each {
            filename -> copy {
                from filename
                into filename.startsWith("src/") ? new File(filename).getParent() : "${projectDir}"
                rename '(.*).template(.*)', '$1$2'
            }
        }
    }
}

// IDE SETUP TASKS (MAINTENANCE MODE ONLY)

// Use a different buildDir for IntelliJ builds to avoid conflict with CLI builds.
// IDE detection is achieved by checking `idea.paths.selector`, a system property that IntelliJ sets.
// Note that this property is not documented and may change anytime.
if (System.getProperty('idea.paths.selector') != null) {
    // Nest the buildDir inside IntelliJ's default project compiler output directory
    buildDir = new File(projectDir, 'out/build')
}

idea {
    module {
        // Exclude the CLI build directory
        excludeDirs += [file('build')]
    }
}

task downloadDependencies {
    doFirst {
        configurations.compileClasspath.resolve()
    }
}

task downloadTestDependencies {
    doFirst {
        configurations.testCompileClasspath.resolve()
    }
}

task downloadLinters {
    doFirst {
        configurations.staticAnalysis.resolve()
    }
}

// RUN SERVER TASKS

compileJava.options.encoding = "UTF-8"
compileTestJava.options.encoding = "UTF-8"

processResources {
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

processTestResources {
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

appengine {
    tools {
        if (project.properties['cloud.sdk.home'] != null) {
            cloudSdkHome = project.properties['cloud.sdk.home']
        }
    }
    run {
        port = 8080
        jvmFlags = ["-Xss2m", "-Dfile.encoding=UTF-8",
                // Absolute paths are not supported, the following is relative to the project directory
                // These only specify the datastore/blobstore paths, but search indexes are still generated in WEB-INF/appengine-generated
                "-Ddatastore.backing_store=../../appengine-generated/local_db.bin",
                "-Dblobstore.backing_store=../../appengine-generated"]
        automaticRestart = true
    }
    deploy {
        String buildPropertiesPath = "${projectDir}/src/main/resources/build.properties"
        boolean propsExists = new File(buildPropertiesPath).exists()
        Properties props = new Properties()
        if (propsExists) {
            file(buildPropertiesPath).withReader {
                props.load(it)
            }
        }
        projectId = propsExists ? props['app.id'] : null
        version = propsExists ? props['app.version'] : null
        stopPreviousVersion = false
        promote = false
    }
}

// STATIC ANALYSIS TASKS

def isWindows = System.getProperty("os.name").toLowerCase().contains("windows")

checkstyle {
    toolVersion = checkstyleVersion
    configFile = file("static-analysis/teammates-checkstyle.xml")
}

pmd {
    toolVersion = pmdVersion
    consoleOutput = true
    ruleSetFiles = files("static-analysis/teammates-pmd.xml", "static-analysis/teammates-pmdMain.xml")
    ruleSets = []
}

spotbugs {
    reportLevel = "low"
    toolVersion = spotbugsVersion
    includeFilter = file("$rootProject.projectDir/static-analysis/teammates-spotbugs.xml")
}

tasks.withType(com.github.spotbugs.snom.SpotBugsTask) {
    reports {
        xml.enabled = false
        html.enabled = false
        text.enabled = true
    }
}

spotbugsMain {
    finalizedBy "printSpotbugsMainViolations"
}

task printSpotbugsMainViolations {
    onlyIf {
        file("${buildDir}/reports/spotbugs/main.txt").exists()
    }
    doFirst {
        print new File("${buildDir}/reports/spotbugs/main.txt").getText("UTF-8")
    }
}

spotbugsTest {
    finalizedBy "printSpotbugsTestViolations"
}

task printSpotbugsTestViolations {
    onlyIf {
        file("${buildDir}/reports/spotbugs/test.txt").exists()
    }
    doFirst {
        print new File("${buildDir}/reports/spotbugs/test.txt").getText("UTF-8")
    }
}

task lintMain {
    dependsOn checkstyleMain, pmdMain, spotbugsMain
}

task lintTest {
    dependsOn checkstyleTest, pmdTest, spotbugsTest
}

import org.gradle.internal.serialize.PlaceholderException

def checkTestNgFailureClosure = { descriptor, result ->
    if (result.exception instanceof PlaceholderException
            && result.exception.toString().startsWith("org.gradle.api.internal.tasks.testing.TestSuiteExecutionException")) {
        result.exception.printStackTrace()
        throw new GradleException("Detected TestNG failure")
    }
}

def isTravis = System.getenv("TRAVIS") != null
def isAppVeyor = System.getenv("APPVEYOR") != null

// Displays full exception; to be run after the test fails after the last retry
def afterTestClosure = { descriptor, result ->
    if (result.resultType == TestResult.ResultType.FAILURE && result.exception != null && result.exception.getMessage() != null) {
        println ""

        def msg = result.exception.getMessage()
        def shouldDisplayAsDiff = msg.indexOf("<<[expected>") != -1
        if (shouldDisplayAsDiff) {
            def expectedFileName = "expected-${descriptor.getClassName()}"
            def actualFileName = "actual-${descriptor.getClassName()}"
            file("${expectedFileName}").text = msg[(msg.indexOf("<<[expected>") + 12)..(msg.indexOf("</expected]>>") - 1)]
            file("${actualFileName}").text = msg[(msg.indexOf("<<[actual>") + 10)..(msg.indexOf("</actual]>>") - 1)]
            def diffCommand = isWindows ? "FC" : "diff"
            def process = "${diffCommand} ${expectedFileName} ${actualFileName}".execute()
            println process.getText()
            process.waitFor()
            if (!isAppVeyor && !isTravis) { // CI does not allow deleting files
                def deleteCommand = isWindows ? "del" : "rm"
                "${deleteCommand} ${expectedFileName}".execute()
                "${deleteCommand} ${actualFileName}".execute()
            }
        } else {
            println "${result.exception.getClass().getName()}: ${result.exception.getMessage()}"
        }

        for (StackTraceElement ste : result.exception.getStackTrace()) {
            if (ste.getClassName().contains("NativeMethodAccessorImpl")) {
                // Everything after this line is the internal workings of TestNG, not important for us
                println "\t..."
                break
            }
            println "\tat ${ste.getClassName()}.${ste.getMethodName()}(${ste.getFileName()}:${ste.getLineNumber()})"
        }
    }
}

task architectureTest(type: Test) {
    useTestNG()
    options.suites "src/test/resources/testng-architecture.xml"
    options.useDefaultListeners = true
    ignoreFailures false
    maxHeapSize = "1g"
    reports.html.enabled = false
    reports.junitXml.enabled = false
    jvmArgs "-Xss2m", "-Dfile.encoding=UTF-8"
    afterTest afterTestClosure
    afterSuite checkTestNgFailureClosure
    testLogging {
        events "passed"
    }
}

architectureTest.dependsOn testClasses
architectureTest.shouldRunAfter lintMain, lintTest

task lint {
    description "Runs the entire static analysis tasks for back-end."
    group "Static analysis"
    dependsOn lintMain, lintTest, architectureTest
}

// TEST TASKS

def numOfTestRetries = 4

task lnpTests(type: Test) {
    systemProperty "random.testing.seed", new Random().nextInt() // re-run tests even if they are up-to-date
    useTestNG()
    options.suites "src/lnp/resources/testng-lnp.xml"
    options.useDefaultListeners = true
    ignoreFailures false
    maxHeapSize = "1g"
    reports.html.enabled = false
    reports.junitXml.enabled = false
    jvmArgs "-Xss2m", "-Dfile.encoding=UTF-8"
    afterTest afterTestClosure
    afterSuite checkTestNgFailureClosure
    testLogging {
        events "passed", "failed", "skipped"
    }
    // Display the L&P test results in the build
    def outputCache = new LinkedList<String>()
    beforeTest { TestDescriptor td -> outputCache.clear() } // clear output cache before the test starts
    onOutput { TestDescriptor td, TestOutputEvent toe -> // put output in the cache
        outputCache.add(toe.getMessage())
        while (outputCache.size() > 2) outputCache.remove() // keep only last 2 result lines
    }
    afterTest { TestDescriptor td ->
        if (outputCache.size() > 0) {
            println(" L&P results for ${td.className}:")
            outputCache.each { print(" > $it") }
        }
    }
}

task componentTests(type: Test) {
    description "Runs the full unit and integration test suite."
    group "Test"
    useTestNG()
    options.suites "src/test/resources/testng-component.xml"
    options.useDefaultListeners = true
    ignoreFailures false
    maxHeapSize = "1g"
    reports.html.enabled = false
    reports.junitXml.enabled = false
    if (isTravis) {
        jvmArgs "-Xss2m", "-Dfile.encoding=UTF-8", "-Djava.io.tmpdir=" + System.getenv("TRAVIS_BUILD_DIR")
    } else {
        jvmArgs "-Xss2m", "-Dfile.encoding=UTF-8"
    }
    afterTest afterTestClosure
    afterSuite checkTestNgFailureClosure
    testLogging {
        events "passed"
    }
}

task e2eTests {
    description "Runs the full E2E test suite and retries failed test up to ${numOfTestRetries} times."
    group "Test"
}

(1..numOfTestRetries + 1).each { id ->
    def isFirstTry = id == 1
    def isLastRetry = id == numOfTestRetries + 1

    task "e2eTestTry${id}"(type: Test) {
        useTestNG()
        options.suites isFirstTry ? "src/e2e/resources/testng-e2e.xml" : file("${buildDir}/reports/e2e-test-try-${id - 1}/testng-failed.xml")
        options.outputDirectory = file("${buildDir}/reports/e2e-test-try-${id}")
        options.useDefaultListeners = true
        ignoreFailures = !isLastRetry
        maxHeapSize = "1g"
        reports.html.enabled = false
        reports.junitXml.enabled = false
        if (isTravis) {
            jvmArgs "-Xss2m", "-Dfile.encoding=UTF-8", "-Djava.io.tmpdir=" + System.getenv("TRAVIS_BUILD_DIR")
        } else {
            jvmArgs "-Xss2m", "-Dfile.encoding=UTF-8"
        }
        testLogging {
            events "passed"
        }
        afterTest afterTestClosure
        if (isFirstTry) {
            afterSuite checkTestNgFailureClosure
        }
        finalizedBy "killFirefox${id}", "killChromedriver${id}"
        onlyIf {
            isFirstTry || file("${buildDir}/reports/e2e-test-try-${id - 1}/testng-failed.xml").exists()
        }
    }
    e2eTests.dependsOn "e2eTestTry${id}"

    task "killFirefox${id}"(type: Exec) {
        doFirst {
            if (isWindows) {
                commandLine "taskkill", "/f", "/im", "firefox.exe"
                commandLine "taskkill", "/f", "/im", "geckodriver.exe"
            } else {
                commandLine "pkill", "firefox"
                commandLine "pkill", "geckodriver"
            }
            // Silence output for this task
            standardOutput = new ByteArrayOutputStream()
            errorOutput = standardOutput
        }
        ignoreExitValue = true
        outputs.upToDateWhen { false }
    }

    task "killChromedriver${id}"(type: Exec) {
        doFirst {
            if (isWindows) {
                commandLine "taskkill", "/f", "/im", "chromedriver.exe"
            } else {
                commandLine "pkill", "chromedriver"
            }
            // Silence output for this task
            standardOutput = new ByteArrayOutputStream()
            errorOutput = standardOutput
        }
        ignoreExitValue = true
        outputs.upToDateWhen { false }
    }
}

// COVERAGE TASKS

jacoco {
    toolVersion = jacocoVersion
}

task jacocoReport(type: JacocoReport) {
    description "Runs coverage session from available test run data."
    group "Test"
    sourceDirectories.from files(sourceSets.main.java.srcDirs)
    classDirectories.from files(sourceSets.main.output)
    executionData fileTree("${buildDir}/jacoco").files
    reports {
        xml.enabled true
        html.enabled true
    }
    afterEvaluate {
        classDirectories.from files(classDirectories.files.collect {
            fileTree(dir: it, exclude: ["**/*.jar"])
        })
    }
}

// Helper methods
import groovy.xml.StreamingMarkupBuilder
import java.nio.charset.StandardCharsets

void writeXmlToPath(Node xml, String pathToWrite) {
    new File(pathToWrite).withWriter(StandardCharsets.UTF_8.name()) { out ->
        out << new StreamingMarkupBuilder().bind { mkp.xmlDeclaration() }
        def xmlNodePrinter = new XmlNodePrinter(new PrintWriter(out))
        xmlNodePrinter.preserveWhitespace = true
        xmlNodePrinter.print(xml)
    }
}