back.gradle

//  Copyright (c) 2018 Gonzalo Müller Bravo.
//  Licensed under the MIT License (MIT), see LICENSE.txt

buildscript {
  dependencies {
    classpath 'org.gradle:gradle-tooling-api:+'
 }
}

plugins {
  id 'all.shared.gradle.code-common-tasks' version '1.0.1'
  id 'checkstyle'
  id 'java'
  id 'jacoco'
  id 'org.springframework.boot' version '2.1.0.RELEASE'
  id 'pmd'
}
final FRONT = ':front'

description 'Backend code'
group 'Code'
evaluationDependsOn(FRONT)

configurations {
  monitorClasspath
}

dependencies {
  compile 'org.springframework.boot:spring-boot-starter-web:+'
  monitorClasspath 'org.springframework.boot:spring-boot-devtools:+'
  testCompile 'org.springframework.boot:spring-boot-starter-test:+'
  testCompile 'org.junit.jupiter:junit-jupiter-api:+'
  testRuntime 'org.junit.jupiter:junit-jupiter-engine:+'
  testCompile 'org.mockito:mockito-core:+'
}

apply from: 'local_gradle/coverage.gradle'
apply from: 'local_gradle/hotrun.gradle'

// CONSTANTS
////////////

final INTEGRATION_TEST_FILE_NAME = 'IntegrationTest'
final INTEGRATION_TEST_FILE_PATTERN = "**/*$INTEGRATION_TEST_FILE_NAME.*"

final TEST_COMMON_SOURCE = sourceSets.test.allJava.findAll {
  it.name.matches('.*(?<!Test)\\..*')
}
final CHECK_UNIT_TEST_COMMON_CONFIGURATION = {
  source = (TEST_COMMON_SOURCE + sourceSets.test.allJava.findAll {
    it.name.matches(".*(?<!$INTEGRATION_TEST_FILE_NAME)\\..*")
  })
  .unique()
  classpath = sourceSets.test.output.classesDirs
}
final CHECK_INTEGRATION_TEST_COMMON_CONFIGURATION = {
  source = TEST_COMMON_SOURCE + sourceSets.test.allJava.findAll {
    it.name.matches(".*$INTEGRATION_TEST_FILE_NAME\\..*")
  }
  classpath = sourceSets.test.output.classesDirs
}

// Plugin settings
//////////////////

baseStyleConfig.back.complement(checkstyle)

pmd {
  toolVersion = BACK$PMD_VERSION
  consoleOutput = true
}
baseStyleConfig.back.complement(pmd)

// TASKS
////////

// Assess Unit Test code
////////////////////////

task checkstyleUnitTest(type: Checkstyle) {
  description = 'Run Checkstyle analysis for Unit test code.'
  group = codeCommonTasks.groupForAssessTasks
  shouldRunAfter checkstyleMain
}
checkstyleUnitTest CHECK_UNIT_TEST_COMMON_CONFIGURATION

task pmdUnitTest(type: Pmd) {
  description = 'Run PMD analysis for Unit test code.'
  group = codeCommonTasks.groupForAssessTasks
  shouldRunAfter 'pmdMain', checkstyleUnitTest
}
pmdUnitTest CHECK_UNIT_TEST_COMMON_CONFIGURATION

task assessUnitTest {
  dependsOn 'checkstyleUnitTest', 'pmdUnitTest'
}

// Assess Integration Test code
///////////////////////////////

task checkstyleIntegrationTest(type: Checkstyle) {
  description = 'Run Checkstyle analysis for Integration test code.'
  group = codeCommonTasks.groupForAssessTasks
  shouldRunAfter checkstyleMain
}
checkstyleIntegrationTest CHECK_INTEGRATION_TEST_COMMON_CONFIGURATION

task pmdIntegrationTest(type: Pmd) {
  description = 'Run PMD analysis for Integration test code.'
  group = codeCommonTasks.groupForAssessTasks
  shouldRunAfter 'pmdMain', 'checkstyleIntegrationTest'
}
pmdIntegrationTest CHECK_INTEGRATION_TEST_COMMON_CONFIGURATION

task assessIntegrationTest {
  dependsOn 'checkstyleIntegrationTest', 'pmdIntegrationTest'
}

// Test code
////////////

final TEST_COMMON_CONFIGURATION = {
  testLogging {
    events 'failed', 'skipped'
  }
}

task unitTest(type: Test) {
  // Test task settings
  useJUnitPlatform()
  // gradle task settings
  include '**/*Test.*'
  exclude INTEGRATION_TEST_FILE_PATTERN
}
unitTest TEST_COMMON_CONFIGURATION

task integrationTest(type: Test) {
  // Test task settings
  useJUnitPlatform()
  // gradle task settings
  include INTEGRATION_TEST_FILE_PATTERN
}
integrationTest TEST_COMMON_CONFIGURATION

// Build
////////

task bootRunDependenciesJar(type: Jar) {
  // Jar task settings
  final SPRING_BOOT_DEPENDENCIES = configurations.runtime.join(' ')
  baseName = "$jar.baseName-dependencies"
  version = jar.version
  manifest {
    attributes 'Class-Path': SPRING_BOOT_DEPENDENCIES
  }
  // gradle task settings
  description 'Sets the classpath into a JAR for using on bootRun.'
  group = codeCommonTasks.groupForBuildTasks
  inputs.files configurations.runtime.files
  inputs.property('springBootDependencies', SPRING_BOOT_DEPENDENCIES)
  shouldRunAfter codeCommonTasks.assessMainTask
}

final COMMON_JAR_CONFIGURATION = {
  // Jar task settings
  baseName = BACK$ARCHIVE_NAME
  manifest {
    attributes 'Main-Class': BACK$MAIN_CLASS
  }
  // gradle task settings
  doLast  {
    logger.info "JAR Manifest:$manifest.attributes"
  }
}

final PROJECT_FRONT = project(FRONT)

task fixedJar(type: Jar) {
  // Jar task settings
  classifier = 'fix'
  from jar.source
  manifest {
    attributes 'Class-Path': "$PROJECT_FRONT.assemble.archivePath $bootRunDependenciesJar.archivePath"
  }
  // gradle task settings
  description 'Assembles a fixed JAR archive containing the main classes and fixed classpath for all dependencies.'
  group = codeCommonTasks.groupForBuildTasks
  dependsOn PROJECT_FRONT.assemble, 'bootRunDependenciesJar'
}
fixedJar COMMON_JAR_CONFIGURATION

// Documentation
////////////////

task monitorClasspath {
  description = 'Enables classpath monitoring.'
  group = GLOBAL$GROUP_RUN
  ext.monitor = false
  doLast {
    ext.monitor = true
  }
}

task monitorRun {
  description = 'Runs the project with support for monitoring classpath changes and reloading classes.'
  group = GLOBAL$GROUP_RUN
  dependsOn = ['monitorClasspath', 'bootRun']
}

task run {
  description = bootRun.description
  group = GLOBAL$GROUP_RUN
  dependsOn = ['bootRun']
}

// Plugin tasks
///////////////

checkstyleMain {
  group = codeCommonTasks.groupForAssessTasks
}

checkstyleTest {
  group = codeCommonTasks.groupForAssessTasks
}

pmdMain {
  group = codeCommonTasks.groupForAssessTasks
  shouldRunAfter checkstyleMain
}

pmdTest {
  group = codeCommonTasks.groupForAssessTasks
  shouldRunAfter 'checkstyleTest'
}

test {
  description = ''
  exclude '**/*'
}

assemble {
  shouldRunAfter check
}

final JACOCO_EXEC_FILE = files("$buildDir/jacoco/unitTest.exec")

jacocoTestReport {
  // jacocoTestReport task settings
  executionData = JACOCO_EXEC_FILE
  afterEvaluate {
    classDirectories = files(classDirectories.files.collect {
      fileTree(dir: it, exclude: 'fit/your/needs/Main.class')
    })
  }
  reports {
    xml.enabled true
  }
  // gradle task settings
  shouldRunAfter = []
  doLast {
    showRatios jacocoTestReport.reports.xml.destination
  }
}

jacocoTestCoverageVerification {
  // jacocoTestCoverageVerification task settings
  final elementToCheck = 'SOURCEFILE'
  final valueToCheck = 'COVEREDRATIO'
  final toExclude = ['**/Main.java']
  executionData = JACOCO_EXEC_FILE
  violationRules {
    rule {
      element = elementToCheck
      excludes = toExclude
      limit {
        counter = 'BRANCH'
        value = valueToCheck
        minimum = 0.975
      }
    }
    rule {
      element = elementToCheck
      excludes = toExclude
      limit {
        counter = 'INSTRUCTION'
        value = valueToCheck
        minimum = 0.925
      }
    }
  }
  // gradle task settings
  shouldRunAfter = [jacocoTestReport]
}

bootRun {
  // bootRun task settings
  classpath = sourceSets.main.output + files(bootRunDependenciesJar.archivePath) +
      files(PROJECT_FRONT.webDir)
  jvmArgs "-Dspring.profiles.active=$runningEnvironment"
  // gradle task settings
  group = GLOBAL$GROUP_RUN
  dependsOn += [PROJECT_FRONT.assemble, 'bootRunDependenciesJar']
  shouldRunAfter check
  mustRunAfter monitorClasspath
  doFirst {
    if (monitorClasspath.monitor) {
      logger.quiet 'Monitor Classpath enabled'
      classpath += configurations.monitorClasspath
    }
    logger.debug "BootRun Classpath:$classpath.files"
  }
}

jar {
  // Jar task settings
  version = BACK$VERSION
  // gradle task settings
  shouldRunAfter codeCommonTasks.assessMainTask
}
jar COMMON_JAR_CONFIGURATION

tasks.withType(Checkstyle) {
  reports {
    xml.enabled = false
  }
}