Page History
Table of Contents |
---|
...
We use a configuration file to define the REST API specifics (the Xray API key, i.e., the client id and client secret pair Jira server/DC URL along with a Jira username and password) and some parameters to identify, for example, the target project and version/release of the SUT.
...
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
apply plugin: 'java'
repositories {
mavenCentral()
}
jar {
archiveBaseName = 'tutorial-gradle-junit4-basic'
archiveVersion = '0.1.0'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8
tasks.withType(JavaCompile) {
options.compilerArgs += '-Xlint:deprecation'
}
test {
useJUnit()
reports {
// destination = file('build/test-results/folder')
junitXml.required = true
html.required = false
}
ignoreFailures = true
}
dependencies {
testImplementation 'junit:junit:4.13.2'
testImplementation 'org.hamcrest:hamcrest-library:2.2'
}
configurations.all {
resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
resolutionStrategy.cacheDynamicVersionsFor 0, 'seconds'
}
|
...
task |
...
importJUnitResultsToXrayDC(type: Exec) {
description 'Imports Junit test results to Xray Test Management for Jira DC.'
dependsOn 'test'
// the following variables can be defined locally or in gradle.properties
// - jiraBaseUrl, jiraUsername, jiraPassword
// - reportFormat, projectKey version, revision, testPlanKey, testExecKey, testEnvironment
def reportFile = "build/test-results/test/TEST-app.getxray.java.CalcTest.xml"
def url = "${jiraBaseUrl}/rest/raven/2.0/import/execution/${reportFormat}?"
if (projectKey?.trim()) {
url += "&projectKey=${projectKey}"
}
if (version?.trim()) {
url += "&fixVersion=${version}"
}
if (revision?.trim()) {
url += "&revision=${revision}"
}
if (testPlanKey?.trim()) {
url += "&testPlanKey=${testPlanKey}"
}
if (testExecKey?.trim()) {
url += "&testExecKey=${testExecKey}"
}
if (testEnvironment?.trim()) {
url += "&testEnvironments=${testEnvironment}"
}
commandLine 'curl', '--fail-with-body', '-H','Content-Type: multipart/form-data', '-u', "${jiraUsername}:${jiraPassword}", '-F', "file=@${reportFile}", url
//store the output instead of printing to the console:
standardOutput = new ByteArrayOutputStream()
ignoreExitValue = false //true
doLast {
if (execResult.getExitValue() != 0) {
println "ERROR: problem importing results to Xray"
} else {
println "Results imported to Xray!"
}
println standardOutput.toString()
}
}
|
To run the tests and import them to Xray we can run gradle as usual and add the name of the task we created earlier.
Code Block | ||
---|---|---|
| ||
gradle clean compileJava test importJUnitResultsToXrayDC |
In Xray, a Test Execution will be created accordingly.
JUnit5
In this example the tests are
Code Block | ||
---|---|---|
| ||
gradle clean compileJava test importJUnitResultsToXrayDC |
In Xray, a Test Execution will be created accordingly.
JUnit5
In this example the tests are implemented using Java + JUnit 5.8.x.
We use a configuration file to define the REST API specifics (the Xray API key, i.e., the client id and client secret pair) and some parameters to identify, for example, the target project and version/release of the SUT.
In this case, we're using the standard JUnit endpoint (more info on the endpoint and the supported parameters is available in Import Execution Results - REST).
Code Block | ||||
---|---|---|---|---|
| ||||
# Jira server/DC specifics
jiraBaseUrl=https://jiraserver.local
jiraUsername=someuser
jiraPassword=somepass
reportFormat=junit
projectKey=CALC
version=v1.0
revision=123
testPlanKey=CALC-726
testExecKey=
testEnvironment= |
We then generate a "standard" JUnit XML report and use a custom task to perform the REST API request that submits the results to Xray.
The following example shows a build.gradle
file with a custom task named importJUnitResultsToXrayDC where we implement the logic to push the results to Xray.
The test
task uses the JUnit5 platform runner by declaring useJUnitPlatform().
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
apply plugin: 'java'
repositories {
mavenCentral()
}
jar {
archiveBaseName = 'tutorial-gradle-junit5-basic'
archiveVersion = '0.1.0'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8
test {
useJUnitPlatform()
reports {
// destination = file('build/test-results/folder')
junitXml.required = true
html.required = false
}
ignoreFailures = true
}
dependencies {
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
testImplementation 'org.hamcrest:hamcrest-library:2.2'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
}
configurations.all {
resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
resolutionStrategy.cacheDynamicVersionsFor 0, 'seconds'
}
|
To run the tests and import them to Xray we can run gradle as usual and add the name of the task we created earlier.
Code Block | ||
---|---|---|
| ||
gradle clean compileJava test importJUnitResultsToXrayDC |
In Xray, a Test Execution will be created accordingly.
JUnit5 with additional information
In this example the tests are implemented using Java + JUnit 5.8.x.
Info |
---|
In this case, we'll use the enhanced capabilities that Xray provides for JUnit allowing you to provide additional information during the execution of the tests, including screenshots and other; to do so, we'll use the xray-junit-extensions package. |
We use a configuration file to define the REST API specifics (the Xray API key, We use a configuration file to define the REST API specifics (i.e., the client id and client secret pair) and Jira server/DC URL along with a Jira username and password) and some parameters to identify, for example, the target project and version/release of the SUT.
...
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
apply plugin: 'java' repositories { mavenCentral() } jar { archiveBaseName = 'tutorial-gradle-junit5-enhancedbasic' archiveVersion = '0.1.0' } sourceCompatibility = 1.8 targetCompatibility = 1.8 test { useJUnitPlatform() reports { // destination = file('build/test-results/folder') junitXml.required = true html.required = false } ignoreFailures = true } dependencies { testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' testImplementation 'org.hamcrest:hamcrest-library:2.2' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1' testImplementation 'app.getxray:xray-junit-extensions:0.6.1' } configurations.all { resolutionStrategy.cacheChangingModulesFor 0, 'seconds' resolutionStrategy.cacheDynamicVersionsFor 0, 'seconds' } |
...
task |
...
importJUnitResultsToXrayDC(type: Exec) {
description 'Imports Junit test results to Xray Test Management for Jira DC.'
dependsOn 'test'
// the following variables can be defined locally or in gradle.properties
// - jiraBaseUrl, jiraUsername, jiraPassword
// - reportFormat, projectKey version, revision, testPlanKey, testExecKey, testEnvironment
def reportFile = "build/test-results/test/TEST-app.getxray.java.CalcTest.xml"
def url = "${jiraBaseUrl}/rest/raven/2.0/import/execution/${reportFormat}?"
if (projectKey?.trim()) {
url += "&projectKey=${projectKey}"
}
if (version?.trim()) {
url += "&fixVersion=${version}"
}
if (revision?.trim()) {
url += "&revision=${revision}"
}
if (testPlanKey?.trim()) {
url += "&testPlanKey=${testPlanKey}"
}
if (testExecKey?.trim()) {
url += "&testExecKey=${testExecKey}"
}
if (testEnvironment?.trim()) {
url += "&testEnvironments=${testEnvironment}"
}
commandLine 'curl', '--fail-with-body', '-H','Content-Type: multipart/form-data', '-u', "${jiraUsername}:${jiraPassword}", '-F', "file=@${reportFile}", url
//store the output instead of printing to the console:
standardOutput = new ByteArrayOutputStream()
ignoreExitValue = false //true
doLast {
if (execResult.getExitValue() != 0) {
println "ERROR: problem importing results to Xray"
} else {
println "Results imported to Xray!"
}
println standardOutput.toString()
}
}
|
To run the tests and import them to Xray we can run gradle as usual and add the name of the task we created earlier.
Code Block | ||
---|---|---|
| ||
gradle clean compileJava test importJUnitResultsToXrayDC |
In Xray, a Test Execution will be created accordingly.
JUnit5 with additional information
In this example the tests are implemented using Java + JUnit 5.8.x.
Info |
---|
In this case, we'll use the enhanced capabilities that Xray provides for JUnit allowing you to provide additional information during the execution of the tests, including screenshots and other; to do so, we'll use the xray-junit-extensions package. |
We use a configuration file to define the REST API specifics (i.e., Jira server/DC URL along with a Jira username and password) and some parameters to identify, for example, the target project and version/release of the SUT.
In this case, we're using the standard JUnit endpoint (more info on the endpoint and the supported parameters is available in Import Execution Results - REST).
Code Block | ||||
---|---|---|---|---|
| ||||
# Jira server/DC specifics
jiraBaseUrl=https://jiraserver.local
jiraUsername=someuser
jiraPassword=somepass
reportFormat=junit
projectKey=CALC
version=v1.0
revision=123
testPlanKey=CALC-726
testExecKey=
testEnvironment= |
We then generate a "standard" JUnit XML report and use a custom task to perform the REST API request that submits the results to Xray.
The following example shows a build.gradle
file with a custom task named importJUnitResultsToXrayDC where we implement the logic to push the results to Xray.
The test
task uses the JUnit5 platform runner by declaring useJUnitPlatform().
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
apply plugin: 'java'
repositories {
mavenCentral()
}
jar {
archiveBaseName = 'tutorial-gradle-junit5-enhanced'
archiveVersion = '0.1.0'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8
test {
useJUnitPlatform()
reports {
// destination = file('build/test-results/folder')
junitXml.required = true
html.required = false
}
ignoreFailures = true
}
dependencies {
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
testImplementation 'org.hamcrest:hamcrest-library:2.2'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
testImplementation 'app.getxray:xray-junit-extensions:0.6.1'
}
configurations.all {
resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
resolutionStrategy.cacheDynamicVersionsFor 0, 'seconds'
}
task importJUnitResultsToXrayDC(type: Exec) {
description 'Imports Junit test results to Xray Test Management for Jira DC.'
dependsOn 'test'
// the following variables can be defined locally or in gradle.properties
// - jiraBaseUrl, jiraUsername, jiraPassword
// - reportFormat, projectKey version, revision, testPlanKey, testExecKey, testEnvironment
def reportFile = "reports/TEST-junit-jupiter.xml"
def url = "${jiraBaseUrl}/rest/raven/2.0/import/execution/${reportFormat}?"
if (projectKey?.trim()) {
url += "&projectKey=${projectKey}"
}
if (version?.trim()) {
url += "&fixVersion=${version}"
}
if (revision?.trim()) {
url += "&revision=${revision}"
}
if (testPlanKey?.trim()) {
url += "&testPlanKey=${testPlanKey}"
}
if (testExecKey?.trim()) {
url += "&testExecKey=${testExecKey}"
}
if (testEnvironment?.trim()) {
url += "&testEnvironments=${testEnvironment}"
}
commandLine 'curl', '--fail-with-body', '-H','Content-Type: multipart/form-data', '-u', "${jiraUsername}:${jiraPassword}", '-F', "file=@${reportFile}", url
//store the output instead of printing to the console:
standardOutput = new ByteArrayOutputStream()
ignoreExitValue = false //true
doLast {
if (execResult.getExitValue() != 0) {
println "ERROR: problem importing results to Xray"
} else {
println "Results imported to Xray!"
}
println standardOutput.toString()
}
}
|
To run the tests and import them to Xray we can run gradle as usual and add the name of the task we created earlier.
Code Block | ||
---|---|---|
| ||
gradle clean compileJava test importJUnitResultsToXrayDC |
In Xray, a Test Execution will be created accordingly.
TestNG
In this example the tests are implemented using Java + TestNG 7.6.x.
We use a configuration file to define the REST API specifics (i.e., Jira server/DC URL along with a Jira username and password) and some parameters to identify, for example, the target project and version/release of the SUT.
In this case, we're using the standard TestNG endpoint (more info on the endpoint and the supported parameters is available in Import Execution Results - REST).
Code Block | ||||
---|---|---|---|---|
| ||||
# Jira server/DC specifics
jiraBaseUrl=https://jiraserver.local
jiraUsername=someuser
jiraPassword=somepass
reportFormat=testng
projectKey=CALC
version=v1.0
revision=123
testPlanKey=CALC-726
testExecKey=
testEnvironment= |
We then generate a "standard" TestNG XML report and use a custom task to perform the REST API request that submits the results to Xray.
The following example shows a build.gradle
file with a custom task named importTestNGResultsToXrayDC where we implement the logic to push the results to Xray.
The test
task uses the TestNG runner by declaring useTestNG().
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
apply plugin: 'java'
repositories {
mavenCentral()
}
jar {
archiveBaseName = 'tutorial-gradle-testng-basic'
archiveVersion = '0.1.0'
}
sourceCompatibility = 11
targetCompatibility = 11
test {
useTestNG() {
// report generation delegated to TestNG library:
useDefaultListeners = true
}
reports {
junitXml.required = false
html.required = false
}
ignoreFailures = true
}
dependencies {
testImplementation 'org.testng:testng:7.6.1'
}
configurations.all {
resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
resolutionStrategy.cacheDynamicVersionsFor 0, 'seconds'
}
task importTestNGResultsToXrayDC(type: Exec) {
description 'Imports TestNG test results to Xray Test Management for Jira DC.'
dependsOn 'test'
// the following variables can be defined locally or in gradle.properties
// - jiraBaseUrl, jiraUsername, jiraPassword
// - reportFormat, projectKey version, revision, testPlanKey, testExecKey, testEnvironment
def reportFile = "build/reports/tests/test/testng-results.xml"
def url = "${jiraBaseUrl}/rest/raven/2.0/import/execution/${reportFormat}?"
if (projectKey?.trim()) {
url += "&projectKey=${projectKey}"
}
if (version?.trim()) {
url += "&fixVersion=${version}"
}
if (revision?.trim()) {
url += "&revision=${revision}"
}
if (testPlanKey?.trim()) {
url += "&testPlanKey=${testPlanKey}"
}
if (testExecKey?.trim()) {
url += "&testExecKey=${testExecKey}"
}
if (testEnvironment?.trim()) {
url += "&testEnvironments=${testEnvironment}"
}
commandLine 'curl', '--fail-with-body', '-H','Content-Type: multipart/form-data', '-u', "${jiraUsername}:${jiraPassword}", '-F', "file=@${reportFile}", url
//store the output instead of printing to the console:
standardOutput = new ByteArrayOutputStream()
ignoreExitValue = false //true
doLast {
if (execResult.getExitValue() != 0) {
|
Code Block | ||
---|---|---|
| ||
gradle clean compileJava test importJUnitResultsToXrayDC |
In Xray, a Test Execution will be created accordingly.
TestNG
In this example the tests are implemented using Java + TestNG 7.6.x.
We use a configuration file to define the REST API specifics (the Xray API key, i.e., the client id and client secret pair) and some parameters to identify, for example, the target project and version/release of the SUT.
In this case, we're using the standard TestNG endpoint (more info on the endpoint and the supported parameters is available in Import Execution Results - REST).
Code Block | ||||
---|---|---|---|---|
| ||||
# Jira server/DC specifics
jiraBaseUrl=https://jiraserver.local
jiraUsername=someuser
jiraPassword=somepass
reportFormat=testng
projectKey=CALC
version=v1.0
revision=123
testPlanKey=CALC-726
testExecKey=
testEnvironment= |
We then generate a "standard" TestNG XML report and use a custom task to perform the REST API request that submits the results to Xray.
The following example shows a build.gradle
file with a custom task named importTestNGResultsToXrayDC where we implement the logic to push the results to Xray.
The test
task uses the TestNG runner by declaring useTestNG().
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
apply plugin: 'java' repositories { mavenCentral() } jar { archiveBaseName = 'tutorial-gradle-testng-basic' archiveVersion = '0.1.0' } sourceCompatibility = 11 targetCompatibility = 11 test { useTestNG() { // report generation delegated to TestNGprintln library"ERROR: problem importing results to Xray" useDefaultListeners = true } } else reports { junitXml.required = false println "Results html.requiredimported =to falseXray!" } ignoreFailures = true } dependencies { testImplementation 'org.testng:testng:7.6.1' } configurations.all { resolutionStrategy.cacheChangingModulesFor 0, 'seconds' println standardOutput.toString() resolutionStrategy.cacheDynamicVersionsFor 0, 'seconds'} } |
To run the tests and import them to Xray we can run gradle as usual and add the name of the task we created earlier.
...
In Xray, a Test Execution will be created accordingly.
TestNG with additional information
...
We use a configuration file to define the REST API specifics (the Xray API key, i.e., the client id and client secret pair) and Jira server/DC URL along with a Jira username and password) and some parameters to identify, for example, the target project and version/release of the SUT.
...
In Xray, a Test Execution will be created accordingly.
Tips
- To debug existing tasks, run your gradle command with "–stacktrace"
- On the custom tasks that execute a command using exec, set
ignoreExitValue = false
...