corda/core-tests/build.gradle

apply plugin: 'org.jetbrains.kotlin.jvm'
apply plugin: 'org.jetbrains.kotlin.plugin.jpa'
apply plugin: 'net.corda.plugins.quasar-utils'
apply plugin: 'idea'

description 'Corda core tests'

configurations {
    integrationTestImplementation.extendsFrom testImplementation
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly

    smokeTestImplementation.extendsFrom implementation
    smokeTestRuntimeOnly.extendsFrom runtimeOnly

    testArtifacts.extendsFrom testRuntimeOnlyClasspath

    corda4_11
}

sourceSets {
    integrationTest {
        kotlin {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/integration-test/kotlin')
        }
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/integration-test/java')
        }
    }
    smokeTest {
        kotlin {
            // We must NOT have any Node code on the classpath, so do NOT
            // include the test or integrationTest dependencies here.
            srcDir file('src/smoke-test/kotlin')
        }
        java {
            srcDir file('src/smoke-test/java')
        }
    }
}

processSmokeTestResources {
    // Bring in the fully built corda.jar for use by NodeFactory in the smoke tests
    from(tasks.getByPath(":node:capsule:buildCordaJAR")) {
        rename 'corda-(.*)', 'corda.jar'
    }
    from(tasks.getByPath(":finance:workflows:jar")) {
        rename 'corda-finance-workflows-.*.jar', 'corda-finance-workflows.jar'
    }
    from(tasks.getByPath(":finance:contracts:jar")) {
        rename 'corda-finance-contracts-.*.jar', 'corda-finance-contracts.jar'
    }
    from(tasks.getByPath(":testing:cordapps:4.11-workflows:jar"))
    from(configurations.corda4_11)
}

dependencies {
    testImplementation "org.junit.jupiter:junit-jupiter-api:${junit_jupiter_version}"
    testImplementation "junit:junit:$junit_version"
    testRuntimeOnly "org.junit.vintage:junit-vintage-engine:${junit_vintage_version}"
    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junit_jupiter_version}"
    testRuntimeOnly "org.junit.platform:junit-platform-launcher:${junit_platform_version}"

    testImplementation "commons-fileupload:commons-fileupload:$fileupload_version"
    testImplementation project(":core")
    testImplementation project(path: ':core', configuration: 'testArtifacts')

    testImplementation project(":node")
    testImplementation project(":node-api")
    testImplementation project(":client:rpc")
    testImplementation project(":serialization")
    testImplementation project(":common-configuration-parsing")
    testImplementation project(":finance:contracts")
    testImplementation project(":finance:workflows")
    testImplementation project(":core-test-utils")
    testImplementation project(":test-utils")
    testImplementation project(path: ':core', configuration: 'testArtifacts')

    // Guava: Google test library (collections test suite)
    testImplementation "com.google.guava:guava-testlib:$guava_version"
    testImplementation "com.google.jimfs:jimfs:1.1"
    testImplementation group: "com.typesafe", name: "config", version: typesafe_config_version

    // Bring in the MockNode infrastructure for writing protocol unit tests.
    testImplementation project(":node-driver")

    implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
    testImplementation "org.jetbrains.kotlin:kotlin-test:$kotlin_version"

    // Hamkrest, for fluent, composable matchers
    testImplementation "com.natpryce:hamkrest:$hamkrest_version"

    // SLF4J: commons-logging bindings for a SLF4J back end
    implementation "org.slf4j:jcl-over-slf4j:$slf4j_version"
    implementation "org.slf4j:slf4j-api:$slf4j_version"

    // AssertJ: for fluent assertions for testing
    testImplementation "org.assertj:assertj-core:${assertj_version}"

    // Guava: Google utilities library.
    testImplementation "com.google.guava:guava:$guava_version"

    // Smoke tests do NOT have any Node code on the classpath!
    smokeTestImplementation project(":core")
    smokeTestImplementation project(":node-api")
    smokeTestImplementation project(":client:rpc")
    smokeTestImplementation project(':smoke-test-utils')
    smokeTestImplementation project(':core-test-utils')
    smokeTestImplementation project(":finance:contracts")
    smokeTestImplementation project(":finance:workflows")
    smokeTestImplementation project(":testing:cordapps:4.11-workflows")
    smokeTestImplementation "org.assertj:assertj-core:${assertj_version}"
    smokeTestImplementation "org.bouncycastle:bcprov-jdk18on:${bouncycastle_version}"
    smokeTestImplementation "co.paralleluniverse:quasar-core:$quasar_version"
    smokeTestImplementation "org.junit.jupiter:junit-jupiter-api:${junit_jupiter_version}"
    smokeTestImplementation "junit:junit:$junit_version"

    smokeTestRuntimeOnly "org.junit.vintage:junit-vintage-engine:${junit_vintage_version}"
    smokeTestRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junit_jupiter_version}"
    smokeTestRuntimeOnly "org.junit.platform:junit-platform-launcher:${junit_platform_version}"
    smokeTestRuntimeOnly "org.slf4j:slf4j-simple:$slf4j_version"

    // used by FinalityFlowTests
    testImplementation project(':testing:cordapps:cashobservers')

    corda4_11 "net.corda:corda-finance-contracts:4.11"
    corda4_11 "net.corda:corda-finance-workflows:4.11"
    corda4_11 "net.corda:corda:4.11"
}

tasks.withType(Test).configureEach {
    // fork a new test process for every test class
    forkEvery = 10
}

tasks.register('testJar', Jar) {
    classifier "tests"
    from sourceSets.test.output
}

tasks.register('integrationTest', Test) {
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
}

tasks.register('smokeTestJar', Jar) {
    classifier 'smokeTests'
    from(sourceSets.smokeTest.output) {
        exclude("*.jar")
    }
}

tasks.register('smokeTest', Test) {
    dependsOn smokeTestJar
    testClassesDirs = sourceSets.smokeTest.output.classesDirs
    classpath = sourceSets.smokeTest.runtimeClasspath
}

idea {
    module {
        downloadJavadoc = true
        downloadSources = true
    }
}

// quasar exclusions upon agent code instrumentation at run-time
quasar {
    excludePackages.addAll(
            "antlr**",
            "com.codahale**",
            "com.fasterxml.**",
            "com.github.benmanes.caffeine.**",
            "com.google.**",
            "com.lmax.**",
            "com.zaxxer.**",
            "net.bytebuddy**",
            "io.github.classgraph**",
            "io.netty*",
            "liquibase**",
            "net.i2p.crypto.**",
            "nonapi.io.github.classgraph.**",
            "org.apiguardian.**",
            "org.bouncycastle**",
            "org.codehaus.**",
            "org.h2**",
            "org.hibernate**",
            "org.jboss.**",
            "org.objenesis**",
            "org.w3c.**",
            "org.xml**",
            "org.yaml**",
            "rx**")
}

artifacts {
    testArtifacts testJar
}