build.gradle

ext {
    grailsSDKsDir = project.hasProperty('grailsSDKsDir') ? project.property('grailsSDKsDir') : System.properties['user.home'] + '/sdk/grails'
    workspace = project.hasProperty('workspace') ? project.property('workspace') : System.properties['java.io.tmpdir']
    isTravisBuild = System.getenv().get("TRAVIS") == 'true'
    isWindows = System.properties['os.name'].toLowerCase().contains('windows')
}

task acceptanceTest(dependsOn: ":spring-security-oauth2-provider:install") {

    description = 'Tests the plugin against a specific version or versions of Grails'
    group = 'Verification'

    doLast {
        List<String> grailsVersions = []

        if (project.hasProperty('grailsVersions')) {
            grailsVersions = project.property('grailsVersions').tokenize(',')
        }
        else {
            println "Specify versions of Grails to test in a CSV list:\n" +
                    "gradle acceptanceTest -P grailsVersions=3.0.9,3.0.10"
        }

        grailsVersions.each { String version ->
            println "Starting acceptance tests for Grails ${version}"
            String grailsHome = grailsHome(version)

            String testProjectName = 'grails_' + version.replaceAll('\\.', '_') + '_spring_security_oauth2_provider_test'
            createApp(grailsHome, testProjectName)

            String testProjectDir = testProjectDir(testProjectName)
            updateBuildScript(testProjectDir)

            runQuickstart(grailsHome, testProjectDir)
            copyTestResources(grailsHome, testProjectDir, testProjectName)

            runTests(grailsHome, testProjectDir)
        }
    }
}

private void createApp(String grailsHome, String appName) {

    File dir = new File(testProjectDir(appName))
    GFileUtils.deleteDirectory(dir)

    callGrails(grailsHome, workspace, 'create-app', [appName])
}

private void updateBuildScript(String testProjectDir) {
    println "Updating build.gradle in ${testProjectDir}"

    Project plugin = project(":spring-security-oauth2-provider")

    File buildGradle = new File(testProjectDir, 'build.gradle')
    String contents = buildGradle.text

    contents = contents.replace('compile "org.grails.plugins:scaffolding"', """
    compile "org.grails.plugins:scaffolding"

    compile '${plugin.group}:${plugin.name}:${plugin.version}'
    """)

    contents = contents.replace('testCompile "org.grails.plugins:geb"', """
    testCompile "org.grails.plugins:geb"

    testCompile "org.seleniumhq.selenium:selenium-chrome-driver:2.53.0"
    testCompile 'com.codeborne:phantomjsdriver:1.2.1'

    testCompile 'org.codehaus.groovy.modules.http-builder:http-builder:0.7.1', {
        ["commons-logging", "xml-apis", "groovy"].each { exclude module: it }
    }

    testRuntime "org.apache.httpcomponents:httpclient:4.3.2"
""")

    contents = contents + """
tasks.withType(Test) {
    testLogging {
        events "passed", "skipped", "failed"
    }
"""
    if (isTravisBuild) {
        contents = contents + """
    jvmArgs "-XX:MaxPermSize=256m"
    maxParallelForks = 2
    maxHeapSize = '768m'
    forkEvery = 100   // helps when tests leak memory
    afterSuite {
        System.out.print('.')
        System.out.flush()
    }
"""
    }
    contents = contents + """
}
"""

    buildGradle.withWriter { it.writeLine contents }
}

private void runQuickstart(String grailsHome, String testProjectDir) {
    callGrails(grailsHome, testProjectDir, 's2-quickstart', ['test.oauth2', 'User', 'Role'])

    callGrails(grailsHome, testProjectDir, 's2-init-oauth2-provider', ['test.oauth2', 'Client', 'AuthorizationCode', 'AccessToken', 'RefreshToken'])
    callGrails(grailsHome, testProjectDir, 's2-init-oauth2-approval', ['test.oauth2', 'UserApproval'])

    File applicationGroovy = new File(testProjectDir, 'grails-app/conf/application.groovy')
    String contents = applicationGroovy.text

    contents = contents.replace('grails.plugin.springsecurity.controllerAnnotations.staticRules = [', """
grails.plugin.springsecurity.controllerAnnotations.staticRules = [
        [pattern: '/oauth/authorize',           access: "isFullyAuthenticated() and (request.getMethod().equals('GET') or request.getMethod().equals('POST'))"],
        [pattern: '/oauth/token',               access: "isFullyAuthenticated() and request.getMethod().equals('POST')"],
""")

    applicationGroovy.withWriter { it.writeLine contents }

    applicationGroovy.withWriterAppend { it.writeLine '''grails.plugin.springsecurity.filterChain.chainMap = [
        [pattern: '/oauth/token',               filters: 'JOINED_FILTERS,-oauth2ProviderFilter,-securityContextPersistenceFilter,-logoutFilter,-authenticationProcessingFilter,-rememberMeAuthenticationFilter,-exceptionTranslationFilter'],
        [pattern: '/securedOAuth2Resources/**', filters: 'JOINED_FILTERS,-securityContextPersistenceFilter,-logoutFilter,-authenticationProcessingFilter,-rememberMeAuthenticationFilter,-oauth2BasicAuthenticationFilter,-exceptionTranslationFilter'],
        [pattern: '/**',                        filters: 'JOINED_FILTERS,-statelessSecurityContextPersistenceFilter,-oauth2ProviderFilter,-clientCredentialsTokenEndpointFilter,-oauth2BasicAuthenticationFilter,-oauth2ExceptionTranslationFilter']
]'''}
}

private void copyTestResources(String grailsHome, String destinationDir, String appName) {
    String sourceDir = project(":test-app").projectDir

    /* Configuration for HTTP Basic Authentication */
    passHttpBasicToIntegrationTestTask(destinationDir)

    /* Bootstrap (Client Registration) */
    ant.copy file: "$sourceDir/grails-app/init/BootStrap.groovy",
             tofile: "$destinationDir/grails-app/init/BootStrap.groovy",
             overwrite: true

    /* Change the redirect uri to use for registration */
    changeRedirectUriConstant(destinationDir, 'grails-app/init/BootStrap.groovy', appName)

    /* Controllers */
    ant.copydir src: "$sourceDir/grails-app/controllers",
                dest: "$destinationDir/grails-app/controllers",
                forceoverwrite: true

    /* Views */
    ['logout', 'redirect', 'securedOAuth2Resources'].each { name ->
        ant.mkdir dir: "$destinationDir/grails-app/views/$name"

        ant.copy file: "$sourceDir/grails-app/views/$name/index.gsp",
                 tofile: "$destinationDir/grails-app/views/$name/index.gsp",
                 overwrite: true
    }

    ant.copy file: "$sourceDir/grails-app/views/index.gsp",
             tofile: "$destinationDir/grails-app/views/index.gsp",
             overwrite: true

    /* Tests */
    ant.copydir src: "$sourceDir/src/integration-test",
                dest: "$destinationDir/src/integration-test",
                forceoverwrite: true

    ant.copydir src: "$sourceDir/src/test/groovy/helper",
                dest: "$destinationDir/src/test/groovy/helper",
                forceoverwrite: true

    /* Change redirect uri referenced in tests */
    changeRedirectUriConstant(destinationDir, 'src/integration-test/groovy/test/oauth2/AbstractAuthorizationEndpointFunctionalSpec.groovy', appName)

    /* Custom TokenEnhancer */
    ant.copy file: "$sourceDir/grails-app/conf/spring/resources.groovy",
             tofile: "$destinationDir/grails-app/conf/spring/resources.groovy",
             overwrite: true

    ant.copy file: "$sourceDir/src/main/groovy/test/FooBarTokenEnhancer.groovy",
             tofile: "$destinationDir/src/main/groovy/test/FooBarTokenEnhancer.groovy",
             overwrite: true
}

private void changeRedirectUriConstant(String projectDir, String path, String appName) {
    File file = new File(projectDir, path)
    String contents = file.text

    String original = "REDIRECT_URI = 'http://localhost:8080/grails-spring-security-oauth2-provider/redirect'"
    String replacement = "REDIRECT_URI = 'http://localhost:8080/${appName}/redirect'"

    contents = contents.replace(original, replacement)

    file.withWriter { it.writeLine contents }
}

private void passHttpBasicToIntegrationTestTask(String projectDir) {
    File build = new File(projectDir, "build.gradle")
    build.append('\nintegrationTest { systemProperties = ["http.basic": System.getProperty("http.basic")] }\n')
}

private void runTests(String grailsHome, String projectDir) {
    callGrails(grailsHome, projectDir, 'test-app')
    callGrails(grailsHome, projectDir, 'test-app', ['-Dhttp.basic="true"'])
}

private String grailsHome(String version) {
    return grailsSDKsDir + '/' + version
}

private String testProjectDir(String name) {
    return workspace + '/' + name
}

// From http://stackoverflow.com/questions/14165517/processbuilder-forwarding-stdout-and-stderr-of-started-processes-without-blocki
//  For some reason gradle swallows output even when you use inheritIO on the process builder
private void inheritIO(final InputStream src, final PrintStream dest) {
    new Thread(new Runnable() {
        public void run() {
            Scanner sc = new Scanner(src);
            while (sc.hasNextLine()) {
                def line = sc.nextLine()
                logger.quiet(line)
                dest.println(line);
            }
        }
    }).start();
}

private void callGrails(String grailsHome, String projectDir, String action,
                        List extraArgs = null, boolean ignoreFailure = false) {

    StringBuilder commandBuilder = new StringBuilder("${grailsHome}/bin/grails${isWindows?'.bat':''} ${action}")

    extraArgs.each { arg ->
        commandBuilder.append(" ")
        commandBuilder.append(arg)
    }

    commandBuilder.append(" ")
    commandBuilder.append("--stacktrace ")
    commandBuilder.append("--debug ")

    String command = commandBuilder.toString()

    println "Running '$command'"

    ProcessBuilder processBuilder = new ProcessBuilder(command.tokenize())

    File workingDir = new File(projectDir)
    processBuilder.directory(workingDir)

    Map<String,String> environment = processBuilder.environment()
    environment.put("GRAILS_HOME", grailsHome)

    Process process = processBuilder.start()
    inheritIO(process.getInputStream(), System.out)
    inheritIO(process.getErrorStream(), System.err)

    int exitCode = process.waitFor()
    if (exitCode && !ignoreFailure) {
        throw new GradleException("Received Grails exit code: ${exitCode}")
    }
}