build.gradle

plugins {
  id 'application'
  id 'java'
  id 'io.spring.dependency-management' version '1.1.7'
  id 'org.springframework.boot' version '3.5.7'
  id 'jacoco'
  id 'maven-publish'
  id "com.github.ben-manes.versions" version "0.53.0"
  id "org.cyclonedx.bom" version "3.0.1"
  id "au.com.dius.pact" version "4.6.17"
}

group = 'uk.gov.hmcts.cp'
version = System.getProperty('ARTEFACT_VERSION') ?: '0.0.999'

def githubActor = project.findProperty("github.actor") ?: System.getenv("GITHUB_ACTOR")
def githubToken = project.findProperty("github.token") ?: System.getenv("GITHUB_TOKEN")
def githubRepo = System.getenv("GITHUB_REPOSITORY")

def azureADOArtifactRepository = 'https://pkgs.dev.azure.com/hmcts/Artifacts/_packaging/hmcts-lib/maven/v1'
def azureADOArtifactActor = System.getenv("AZURE_DEVOPS_ARTIFACT_USERNAME")
def azureADOArtifactToken = System.getenv("AZURE_DEVOPS_ARTIFACT_TOKEN")

java {
  sourceCompatibility = JavaVersion.VERSION_21
  targetCompatibility = JavaVersion.VERSION_21
}

sourceSets {
  integrationTest {
    java {
      compileClasspath += sourceSets.main.output
      runtimeClasspath += sourceSets.main.output
    }
    resources.srcDir file('src/integrationTest/resources')
  }
  pactVerificationTest {
    java {
      compileClasspath += sourceSets.main.output
      runtimeClasspath += sourceSets.main.output
    }
    resources.srcDir file('src/pactVerificationTest/resources')
  }
}

configurations {
  integrationTestImplementation.extendsFrom testImplementation
  integrationTestRuntimeOnly.extendsFrom runtimeOnly

  pactVerificationTestImplementation.extendsFrom testImplementation
  pactVerificationTestRuntimeOnly.extendsFrom runtimeOnly

  // Ensure testRuntimeClasspath can be resolved for agent injection
  testRuntimeClasspath {
    canBeResolved = true
  }
}


tasks.withType(JavaCompile) {
  options.compilerArgs << "-Xlint:unchecked" << "-Werror"
}

// https://github.com/gradle/gradle/issues/16791
tasks.withType(JavaExec).configureEach {
  javaLauncher.set(javaToolchains.launcherFor(java.toolchain))
}

tasks.named('test') {
  useJUnitPlatform{
    excludeTags 'pact'
  }
  systemProperty 'API_SPEC_VERSION', project.version
  failFast = true
  // Mockito must be added as an agent, see:
  // https://javadoc.io/doc/org.mockito/mockito-core/latest/org.mockito/org/mockito/Mockito.html#0.3
  jvmArgs += [
    "-javaagent:${configurations.testRuntimeClasspath.find { it.name.contains('mockito-core') }}", '-Xshare:off'
  ]
  testLogging {
    events "passed", "skipped", "failed"
    exceptionFormat = 'full'
    showStandardStreams = true
  }
  reports {
    junitXml.required.set(true)
    html.required.set(true)
  }
}

tasks.register('integration', Test) {
  description = "Runs integration tests"
  group = "Verification"
  testClassesDirs = sourceSets.integrationTest.output.classesDirs
  classpath = sourceSets.integrationTest.runtimeClasspath
  useJUnitPlatform()
  failFast = true
  testLogging {
    events "passed", "skipped", "failed"
    exceptionFormat = 'full'
    showStandardStreams = true
  }
  reports {
    junitXml.required.set(true)
    html.required.set(true)
  }
}

tasks.register('pactVerificationTest', Test) {
  description = "Runs Pact provider verification tests"
  group = "Verification"
  testClassesDirs = sourceSets.pactVerificationTest.output.classesDirs
  classpath = sourceSets.pactVerificationTest.runtimeClasspath
  useJUnitPlatform {
    includeTags 'pact'
  }
  failFast = true

  def sysOrEnv = { String key ->
    System.getProperty(key) ?: System.getenv(key.toUpperCase().replace('.', '_'))
  }
  systemProperty 'pact.broker.url', sysOrEnv('pact.broker.url')
  systemProperty 'pact.broker.token', sysOrEnv('pact.broker.token')
  systemProperty 'pact.provider.version', sysOrEnv('pact.provider.version')
  systemProperty 'pact.provider.branch', sysOrEnv('pact.provider.branch')
  systemProperty 'pact.verifier.publishResults', sysOrEnv('pact.verifier.publishResults')
  systemProperty 'pact.env', sysOrEnv( 'pact.env') ?: 'local'
  reports {
    junitXml.required.set(true)
    html.required.set(true)
  }
}

tasks.named('build') {
  dependsOn tasks.named('test')
  dependsOn tasks.named('integration')
}

tasks.named('jacocoTestReport') {
  dependsOn tasks.named('test')
  reports {
    xml.required.set(true)
    csv.required.set(false)
    html.required.set(true)
  }
}

tasks.named('check') {
  dependsOn tasks.named('integration')
}

// check dependencies upon release ONLY
tasks.named("dependencyUpdates").configure {
  def isNonStable = { String version ->
    def stableKeyword = ['RELEASE', 'FINAL', 'GA'].any { qualifier -> version.toUpperCase().contains(qualifier) }
    def regex = /^[0-9,.v-]+$/
    return !stableKeyword && !(version ==~ regex)
  }
  rejectVersionIf {
    isNonStable(it.candidate.version) && !isNonStable(it.currentVersion)
  }
}

repositories {
  mavenLocal()
  mavenCentral()
  maven {
    url = azureADOArtifactRepository
  }
}

publishing {
  publications {
    mavenJava(MavenPublication) {
      artifact(tasks.named('bootJar'))
      artifact(tasks.named('jar'))
    }
  }
  repositories {
    maven {
      name = "GitHubPackages"
      url = uri("https://maven.pkg.github.com/$githubRepo")
      credentials {
        username = githubActor
        password = githubToken
      }
    }
    maven {
      name = "AzureArtifacts"
      url = uri(azureADOArtifactRepository)
      credentials {
        username = azureADOArtifactActor
        password = azureADOArtifactToken
      }
    }
  }
}

//Creation of Software Bill of Materials
//https://github.com/CycloneDX/cyclonedx-gradle-plugin
cyclonedxBom {
  includeConfigs = ["runtimeClasspath"]
  skipConfigs = ["compileClasspath", "testImplementation"]
  schemaVersion = "1.6"
  componentVersion = providers.provider { project.version.toString() }
  destination = file("$buildDir/reports")
}

jar {
  enabled = true
  archiveClassifier.set('plain')
  if (file("CHANGELOG.md").exists()) {
    from('CHANGELOG.md') {
      into 'META-INF'
    }
  } else {
    println "⚠️  CHANGELOG.md not found, skipping inclusion in JAR"
  }
}

bootJar {
  archiveFileName = "${rootProject.name}-${project.version}.jar"

  manifest {
    attributes('Implementation-Version': project.version.toString())
  }
}

application {
  mainClass = 'uk.gov.hmcts.cp.Application'
}

ext {
  apiCasesVersion="0.6.0"
  log4JVersion = "2.24.3"
  logbackVersion = "1.5.18"
  lombokVersion = "1.18.38"
}

tasks.named('processPactVerificationTestResources') {
  duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}


dependencies {
  implementation "uk.gov.hmcts.cp:api-cp-crime-courthearing-cases:$apiCasesVersion"
  implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.14'
  implementation 'io.swagger.core.v3:swagger-core:2.2.40'
  implementation 'javax.xml.bind:jaxb-api:2.3.1'

  implementation 'org.springframework.boot:spring-boot-starter-web'
  implementation 'org.springframework.boot:spring-boot-starter-actuator'
  implementation 'org.springframework.boot:spring-boot-starter-aop'
  implementation 'org.springframework.boot:spring-boot-starter-json'

  implementation platform('io.micrometer:micrometer-tracing-bom:latest.release')
  implementation 'io.micrometer:micrometer-tracing'
  implementation 'io.micrometer:micrometer-tracing-bridge-otel'
  implementation 'io.micrometer:micrometer-registry-azure-monitor'
  implementation 'com.azure:azure-monitor-opentelemetry-autoconfigure:1.4.0'

  implementation 'net.logstash.logback:logstash-logback-encoder:9.0'
  implementation group: 'org.apache.logging.log4j', name: 'log4j-to-slf4j', version: log4JVersion
  implementation group: 'ch.qos.logback', name: 'logback-classic', version: logbackVersion
  implementation group: 'ch.qos.logback', name: 'logback-core', version: logbackVersion

  implementation group: 'io.rest-assured', name: 'rest-assured', version: '5.5.6'
  implementation 'org.hibernate.validator:hibernate-validator:9.1.0.Final'
  implementation 'org.apache.commons:commons-text:1.14.0'

  implementation 'com.fasterxml.jackson.core:jackson-databind:2.20.1'

  compileOnly group: 'org.projectlombok', name: 'lombok', version: lombokVersion
  annotationProcessor group: 'org.projectlombok', name: 'lombok', version: lombokVersion

  testImplementation(platform('org.junit:junit-bom:6.0.1'))
  testImplementation 'org.mockito:mockito-core:5.20.0'
  testRuntimeOnly 'org.mockito:mockito-inline:5.2.0'
  testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
  testImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '3.5.7', {
    exclude group: 'junit', module: 'junit'
    exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
  }

  testImplementation 'au.com.dius.pact.provider:junit5:4.6.18'
  testImplementation 'au.com.dius.pact.provider:spring6:4.6.18'
}