atlan-java/build.gradle.kts at main · atlanhq/atlan-java · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
/* SPDX-License-Identifier: Apache-2.0 */
plugins {
    id("com.atlan.java")
    id("io.github.gradle-nexus.publish-plugin") version "2.0.0"
    id("org.owasp.dependencycheck") version "12.2.1"
}

group = providers.gradleProperty("GROUP").get()
version = providers.gradleProperty("VERSION_NAME").get()

nexusPublishing {
    repositories {
        sonatype {
            nexusUrl.set(uri("https://ossrh-staging-api.central.sonatype.com/service/local/"))
            snapshotRepositoryUrl.set(uri("https://central.sonatype.com/repository/maven-snapshots/"))
        }
    }
}

dependencyCheck {
    nvd {
        apiKey = System.getenv("NVD_API_KEY") ?: ""
    }
    failBuildOnCVSS = 7.0F
}

val wireMockService = gradle.sharedServices.registerIfAbsent("wireMock", WireMockService::class) {
    parameters {
        wireMockResourcesDir.set(layout.buildDirectory.dir("wiremock").get())
        port.set(8765)
    }
}

val prepareWireMockResources = tasks.register("prepareWireMockResources") {
    group = "test setup"
    description = "Copies shared WireMock resources and allows module overrides"

    doLast {
        val wireMockDir = layout.buildDirectory.dir("wiremock").get().asFile
        wireMockDir.mkdirs()

        val mappingsDir = File(wireMockDir, "mappings")
        val filesDir = File(wireMockDir, "__files")
        mappingsDir.mkdirs()
        filesDir.mkdirs()

        // Copy shared WireMock files from mock module
        val mockModuleDir = project(":mocks").projectDir
        val sharedMappings = File(mockModuleDir, "src/main/resources/wiremock/mappings")
        val sharedFiles = File(mockModuleDir, "src/main/resources/wiremock/__files")

        if (sharedMappings.exists()) {
            sharedMappings.copyRecursively(mappingsDir, overwrite = true)
            println("Copied shared mappings from mock module")
        }

        if (sharedFiles.exists()) {
            sharedFiles.copyRecursively(filesDir, overwrite = true)
            println("Copied shared response files from mock module")
        }

        // Allow individual modules to override/extend
        allprojects.forEach { subproject ->
            if (subproject != rootProject && subproject.name != "mocks") {
                val moduleMappings = File(subproject.projectDir, "src/test/resources/wiremock/mappings")
                val moduleFiles = File(subproject.projectDir, "src/test/resources/wiremock/__files")

                if (moduleMappings.exists()) {
                    moduleMappings.copyRecursively(mappingsDir, overwrite = true)
                    println("Applied ${subproject.name} module mapping overrides")
                }

                if (moduleFiles.exists()) {
                    moduleFiles.copyRecursively(filesDir, overwrite = true)
                    println("Applied ${subproject.name} module file overrides")
                }
            }
        }

        println("WireMock resources prepared in ${wireMockDir.absolutePath}")
    }
}

val startWireMock = tasks.register("startWireMock") {
    group = "test setup"
    description = "Starts WireMock server for all tests"
    usesService(wireMockService)
    dependsOn(prepareWireMockResources)

    doLast {
        wireMockService.get().startServer()
    }
}

val stopWireMock = tasks.register("stopWireMock") {
    group = "test setup"
    description = "Stops WireMock server after all tests"
    usesService(wireMockService)

    doLast {
        wireMockService.get().stopServer()
    }
}

allprojects {
    tasks.withType<JavaCompile> {
        options.isFork = true
        options.forkOptions.jvmArgs = listOf(
            "-Xmx4g",
            "-Xms2g"
        )
    }
    tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
        compilerOptions.freeCompilerArgs.add("-Xannotation-default-target=param-property")
    }
    tasks.withType<Test> {
        dependsOn(startWireMock)
        finalizedBy(stopWireMock)
    }
    configurations.all {
        resolutionStrategy {
            // Note: force a safe version of all of these libraries, even if transitive, to avoid potential CVEs
            force(
                libs.parsson,
                libs.json.path,
                libs.json.smart,
                libs.guava,
                libs.commons.compress,
                libs.commons.io,
                libs.jetty.http,
                libs.jetty.server,
                libs.jetty.http2.common,
                libs.jetty.http2.hpack,
                libs.jetty.http2.server,
                libs.netty.common,
                libs.netty.codec.http2,
                libs.rhino,
                libs.commons.lang,
                libs.nimbus,
            )
        }
    }
}