build.gradle

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath 'org.sonatype.plexus:plexus-sec-dispatcher:1.4'
    classpath 'org.codehaus.plexus:plexus-container-default:2.1.1'
    classpath 'org.sonatype.plexus:plexus-cipher:1.7'
  }
}

import org.gradle.internal.os.OperatingSystem
import org.apache.tools.ant.filters.ReplaceTokens
import groovy.xml.XmlParser
import org.sonatype.plexus.components.sec.dispatcher.DefaultSecDispatcher
import org.sonatype.plexus.components.cipher.DefaultPlexusCipher

plugins {
  id 'java-library'
  id 'eclipse'
  id 'maven-publish'
  id 'jacoco'
  id 'signing'

  id 'io.github.gradle-nexus.publish-plugin' version '2.0.0'
  id 'pl.allegro.tech.build.axion-release' version '1.21.1'
}

group = 'com.nordstrom.ui-tools'
description = 'Selenium Foundation'

ext.profile = project.findProperty('profile') ?: 'selenium4'
assert ['selenium3', 'selenium4'].contains(profile)

/* Repositories */
repositories {
    mavenLocal()
    mavenCentral()
    maven { url "${projectDir}/repo" }
}

def getMavenServer(String serverId) {
  def settingsFile = new File(System.getProperty("user.home"), ".m2/settings.xml")
  if (!settingsFile.exists()) return null

  def settings = new XmlParser().parse(settingsFile)
  def server = settings.servers.server.find { it.id.text() == serverId }

  if (server) {
    def dispatcher = new DefaultSecDispatcher()
    dispatcher._cipher = new DefaultPlexusCipher()

    def securityFile = new File(System.getProperty("user.home"), ".m2/settings-security.xml")
    System.setProperty("settings.security", securityFile.absolutePath)

    def decrypt = { String val ->
      if (val == null) return null
      return dispatcher._cipher.isEncryptedString(val) ? dispatcher.decrypt(val) : val
    }

    return [
      username: server.username?.text(),
      password: decrypt(server.password?.text()),
      passphrase: decrypt(server.passphrase?.text())
    ]
  }
  
  return null
}

scmVersion {
  branchVersionCreator.putAll([
    '.*': { version, position -> version }
  ])
  repository {
    def githubNode = getMavenServer('github')

    if (githubNode) {
      customUsername.set(githubNode.username)
      customPassword.set(githubNode.password)
    }
  }
}

/* Version logic */
def resolvedVersion = project.hasProperty('artifactVersion')
        ? project.property('artifactVersion').toString()
        : scmVersion.version
def verBits = resolvedVersion.split('-')
def seleniumApi = "s${profile.charAt(8)}"
ext.baseVersion = verBits[0]
ext.isSnapshot = !resolvedVersion.matches('\\d+\\.\\d+\\.\\d+')
ext.archiveVer = "${baseVersion}-${seleniumApi}" + (isSnapshot ? '-SNAPSHOT' : '')
ext.archiveBase = "${rootProject.name}-${archiveVer}"

version = archiveVer

task updateReadme {
  def base = project.ext.baseVersion
  doLast {
    def version = resolvedVersion
    if (version.endsWith('-SNAPSHOT')) return
    ant.replaceregexp(file: 'README.md',
      match: /\d+\.\d+\.\d+-s3/,
      replace: "${base}-s3",
      flags: 'g')
    ant.replaceregexp(file: 'README.md',
      match: /\d+\.\d+\.\d+-s4/,
      replace: "${base}-s4",
      flags: 'g')
  }
}


task checkSincePlaceholders {
  description = 'Fails non-SNAPSHOT release builds if any [next-major] placeholders remain unreplaced in source.'
  doLast {
    def version = project.version.toString()
    if (version.endsWith('-SNAPSHOT')) return
    def violations = []
    def sourceRoots = ['src/main/java', 'src/selenium3/java', 'src/selenium4/java']
      .collect { project.file(it) }
      .findAll { it.exists() }
    sourceRoots.each { root ->
      fileTree(root).matching {
        include '**/*.java'
      }.each { file ->
        file.readLines().eachWithIndex { line, idx ->
          if (line.contains('[next-major]')) {
            violations << "${file.path}:${idx + 1}"
          }
        }
      }
    }
    if (violations) {
      throw new GradleException(
        "\n*** RELEASE BUILD FAILED ***\n"
        + "Unreplaced [next-major] placeholders found in release ${ext.baseVersion}:\n"
        + violations.join('\n')
        + "\nEnsure all placeholders were replaced before publishing.\n")
    }
  }
}

task updateSinceAnnotations {
  description = 'Replaces [next-major] placeholders in source with the current project version.'
  def base = project.ext.baseVersion
  doLast {
    def version = project.version.toString()
    if (version.endsWith('-SNAPSHOT')) return
    def sinceVersion = base
    def sourceRoots = ['src/main/java', 'src/selenium3/java', 'src/selenium4/java']
      .collect { project.file(it) }
      .findAll { it.exists() }
    sourceRoots.each { root ->
      fileTree(root).matching {
        include '**/*.java'
      }.each { file ->
        ant.replaceregexp(
          file: file,
          match: '\\[next-major\\]',
          replace: sinceVersion,
          flags: 'g'
        )
      }
    }
  }
}

checkSincePlaceholders.mustRunAfter(updateSinceAnnotations)
checkSincePlaceholders.mustRunAfter(updateReadme)
publish.dependsOn(checkSincePlaceholders)
compileJava.dependsOn(updateSinceAnnotations, updateReadme, checkSincePlaceholders)

apply from: "${profile}Deps.gradle"

if (project.hasProperty('browsers')) {
  project.browsers.split(',').each { browser ->
    browser = browser.trim()
    if (browser) {
      apply from: "${browser}Deps.gradle"
    }
  }
}

/* personality injection */
if (project.hasProperty('personality')) {
  System.setProperty('injected.selenium.browser.name', personality)

  if ([".chrome", ".safari"].any { personality.endsWith(it) }) {
    System.setProperty('injected.selenium.context.platform', 'web-app')
    System.setProperty('injected.selenium.grid.examples', 'true')
  }
}

java {
  withJavadocJar()
  withSourcesJar()
}

/* Clean */
tasks.named('clean') {
  delete 'logs', 'target', buildRoot
  delete fileTree('.') {
    include 'hubConfig*.json'
    include 'nodeConfig*.json'
  }
}

/* JaCoCo */
jacoco {
  toolVersion = '0.8.13'
  reportsDirectory = layout.buildDirectory.dir("jacoco")
}

jacocoTestReport {
  reports {
    xml.required  = false
    csv.required  = false
    html.outputLocation = layout.buildDirectory.dir('jacocoHtml')
  }
}

/* Shared libs dir */
def libsDirProvider = layout.buildDirectory.dir("libs")

/* Main JAR */
tasks.named('jar', Jar) {
  group = 'Build'
  description = "Assembles a jar archive containing the '${profile}' classes, POM and Maven properties."

  def destPath = "META-INF/maven/${project.group}/${rootProject.name}"
  def timestamp = System.currentTimeMillis().toString()

  from('.') {
    include 'pom.xml'
    into destPath
    filter ReplaceTokens, tokens: [
      projectVersion : archiveVer,
      projectTimestamp: timestamp,
      seleniumApi    : seleniumApi
    ]
  }

  from('.') {
    include 'pom.properties'
    into destPath
    filter ReplaceTokens, tokens: [
      projectVersion   : archiveVer,
      projectGroupId   : project.group,
      projectArtifactId: rootProject.name
    ]
  }

  archiveFileName.set("${archiveBase}.jar")
  destinationDirectory.set(libsDirProvider)
}

/* Sources JAR */
tasks.named('sourcesJar', Jar) {
  group = 'Build'
  archiveClassifier.set('sources')
  archiveFileName.set("${archiveBase}-sources.jar")
  destinationDirectory.set(libsDirProvider)
}

/* Javadoc JAR */
tasks.named('javadocJar', Jar) {
  group = 'Build'
  archiveClassifier.set('javadoc')
  archiveFileName.set("${archiveBase}-javadoc.jar")
  destinationDirectory.set(libsDirProvider)
}

/* Test system property propagation */
tasks.withType(Test).configureEach {
  systemProperties.putAll(
    System.properties.findAll { k, _ ->
      k.endsWith('.binary.path') ||
      ['injected.', 'selenium.', 'appium.', 'testng.', 'junit.']
        .any { k.startsWith(it) }
    }.collectEntries { k, v ->
      if (OperatingSystem.current().isWindows() && k.endsWith('selenium.browser.caps')) {
        [(k): v.replace('"', '\\\"')]
      } else {
        [(k): v]
      }
    }
  )

  reports.html.outputLocation.set(
    layout.buildDirectory.dir("reports/${name}")
  )
}

/* TestNG */
tasks.register('testNG', Test) {
  dependsOn tasks.named('jar')
  useTestNG()
  testLogging.showStandardStreams = true
  
  testClassesDirs = sourceSets.test.output.classesDirs
  classpath = sourceSets.test.runtimeClasspath

  if (project.findProperty('debugTestNG') == 'true') {
    jvmArgs '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005'
    maxParallelForks = 1
    forkEvery = 0
  }
}

/* JUnit */
tasks.named('test', Test) {
  dependsOn tasks.named('testNG')
  testLogging.showStandardStreams = true

  if (project.findProperty('debugJUnit') == 'true') {
    jvmArgs '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5006'
    maxParallelForks = 1
    forkEvery = 0
  }

  doFirst {
    jvmArgs "-javaagent:${classpath.find { it.name.contains('junit-foundation') }}"
  }
}

/* Publishing */
publishing {
  publications {
    mavenJava(MavenPublication) {
      from components.java
      pom {
        name = 'Selenium Foundation'
        groupId = project.group
        artifactId = rootProject.name
        version = archiveVer
        packaging = 'jar'
        description = 'Selenium Foundation is an automation framework designed to extend and enhance the capabilities provided by Selenium (WebDriver).'
        url = 'https://github.com/sbabcoc/Selenium-Foundation'

        scm {
          connection = 'scm:git:https://github.com/sbabcoc/Selenium-Foundation.git'
          developerConnection = 'scm:git:https://github.com/sbabcoc/Selenium-Foundation.git'
          url = 'https://github.com/sbabcoc/Selenium-Foundation/tree/master'
          tag = 'HEAD'
        }

        licenses {
          license {
            name = 'The Apache License, Version 2.0'
            url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
          }
        }

        developers {
          developer {
            id = 'scoba'
            name = 'Scott Babcock'
            email = 'scoba@hotmail.com'
            organization = 'Nordstrom'
            organizationUrl = 'https://shop.nordstrom.com'
          }
        }
      }
      versionMapping {
        usage('java-api') {
          fromResolutionOf('runtimeClasspath')
        }
        usage('java-runtime') {
          fromResolutionResult()
        }
      }
    }
  }
}

/* Signing */
signing {
  if (project.hasProperty('signing.keyId')) {
    def keyId = project.getProperty('signing.keyId')
    def gpgNode = getMavenServer(keyId)
    def secret = gpgNode?.passphrase

    if (secret) {
      useGpgCmd()
      project.ext.set("signing.gnupg.passphrase", secret)
      project.ext.set("signing.gnupg.arguments", "--batch,--pinentry-mode,loopback")
    }
  }
  sign publishing.publications.mavenJava
}

/* Install alias */
tasks.register('install') {
  dependsOn tasks.named('publishToMavenLocal')
  group = tasks.named('publishToMavenLocal').get().group
  description = "[alias] publish to Maven Local"
}

/* Nexus publishing */
nexusPublishing {
  packageGroup = 'com.nordstrom'
  repositories {
    ossrh {
      def ossrhNode = getMavenServer('ossrh')
      username = ossrhNode?.username
      password = ossrhNode?.password
      nexusUrl.set(uri("https://ossrh-staging-api.central.sonatype.com/service/local/"))
      snapshotRepositoryUrl.set(uri("https://ossrh-staging-api.central.sonatype.com/content/repositories/snapshots/"))
      if (project.hasProperty('ossrhStagingProfileId')) {
        stagingProfileId = ossrhStagingProfileId
      }
    }
  }
}

/* Dependencies */
dependencies {
  api platform("com.nordstrom.ui-tools:selenium-bom-${seleniumApi}:${baseVersion}${isSnapshot ? '-SNAPSHOT' : ''}")

  api 'com.nordstrom.tools:java-utils'
  api 'com.nordstrom.tools:settings'
  api 'com.nordstrom.tools:junit-foundation'
  api('com.github.sbabcoc:logback-testng') {
    exclude group: 'org.testng', module: 'testng'
  }
  api 'org.hamcrest:hamcrest-core'
  api 'org.yaml:snakeyaml'
}