Xray enables easy integration with Jenkins through the "Xray for JIRA Jenkins Plugin", providing the means for successful Continuous Integration by allowing users to report automated testing results.
The installation is made manually. For more information on how to install add-ons, please refer to how to install add-ons.
The Jenkins baseline for this app is v2.60.3 and it may not work properly with previous versions. |
You may download the latest version of the Jenkins plugin from the latest Release Notes. |
If you have the actual xray-for-jira-connector.hpi
file,
xray-for-jira-connector.hpi
file.Xray for Jenkins is configured in the global settings configuration page Manage Jenkins > Configure System > Xray for Jira configuration.
The Jira servers configuration defines connections with Jira instances.
To add a new Jira instance connection, you need to specify some properties:
note: the Configuration ID is not editable. This value can be used in the pipelines scripts.
The user present in this configuration must exist in the JIRA instance and have permission to Create Test and Test Execution Issues |
The project is where the work that should be performed by Jenkins is configured.
For this app, you can configure:
. In the home page, clicking for example New Item > Freestyle project, provide a name, and then click OK.
Build steps are the building blocks of the build process. These need to be defined in the project configuration.
The app provides
The fields of the tasks may take advantage of the Jenkins Environment variables, which can be used to populate fields such as the "Revision" for specifying the source code's revision. For more information, please see Jenkins set environment variables. |
This build step will export the Cucumber Tests (i.e., Scenario/Scenario Outlines) in .feature or bundled in a .zip file. The rules for exporting are defined here.
It invokes Xray's Export Cucumber Tests REST API endpoint (see more information here).
Some fields need to be configured in order to export the Cucumber Tests. As input, you can either specify issue keys (see the endpoint documention here) or the ID of the saved filter in Jira.
field | description |
---|---|
Jira instance | The Jira instance where Xray is running |
Issue keys | Set of issue keys separated by ";" |
Filter ID | A number that indicates the filter ID |
File path | The relative path of the directory where the features should be exported to; normally, this corresponds to the "features" folder of the Cucumber project that has the implementation steps. Note: The directory will be created if it does not exist. |
This build step will import existing cucumber Tests from existing Cucumber feature files into Xray issues. This Task will import from .feature files and also from .zip files.
It invokes Xray's Import Cumcumber Tests REST API endpoint (see more information here)
field | decription |
---|---|
JIRA instance | The Jira instance where Xray is running. |
Project Key | This is the project where the Tests and Pre-Conditions will be created/updated. |
Cucumber feature files directory | This is the directory containing your feature files. All the files in this directory and sub directories will be imported. |
Modified in the last hours | By entering an integer n here, only files that where modified in the last n hours will be imported. Leave empty if you do not want to use this parameter. |
The app provides easy access to Xray's Import Execution Results REST API endpoints (see more information here). Therefore, it mimics the endpoints input parameters.
It supports importing results in Xray's own JSON format, Cucumber, Behave, JUnit, and NUnit, among others.
Using a glob expression, you can import multiple results files in the following formats:
For those formats, the file path needs to be relative to the workspace.
field | description |
---|---|
Jira instance | The Jira instance where Xray is running |
Format | A list of test result formats and its specific endpoint |
Execution Report File | The results relative file path Note: glob expressions are supported for
|
Depending on the chose test result format and endpoint, some additional fields may need to be configured.
format and specific endpoint | field | description | |
---|---|---|---|
Behave JSON multipart Cucumber JSON multipart NUnit XML multipart JUnit XML multipart Robot XML multipart TestNG XML multipart | Test execution fields | An object (JSON) specifying the fields for the issue. You may specify the object either directly in the field or in the file path.
| |
NUnit XML JUnit XML Robot XML TestNG XML | Import to Same Test Execution | When this option is check, if you are importing multiple execution report files using a glob expression, the results will be imported to the same Test Execution | |
Project key | Key of the project where the Test Execution (if the Test Execution Key field wasn't provided) and the Tests (if they aren't created yet) are going to be created | ||
Test execution key | Key of the Test Execution | ||
Test plan key | Key of the Test Plan | ||
Test environments | List of Test Environments separated by ";" | ||
Revision | Source code's revision being target by the Test Execution | ||
Fix version | The Fix Version associated with the test execution (it supports only one value) |
In a typical Cucumber Workflow, after having created a Cucumber project and the Cucumber tests specified in Jira, you may want to have a project that exports the features from Jira, executes the automated tests on a CI environment and then imports back its results.
For this scenario, the Jenkins project would be configured with a set of tasks responsible for:
To start the configuration, add the build step Xray: Cucumber Features Export Task.
After that, configure it.
In this example, we configured the task to extract the features from a set of issues (PROJ-78 and PROJ-79) to the folder that holds the Cucumber project.
To start the configuration, add the build step Xray: Cucumber Features Import Task.
After that, configure it.
In this example, we configured the task to import to the Project IF of the Xray instance all the .features and .zip files that are contained in \Cucumber directory and sub directories, which were modified in the last 3 hours.
To start the configuration, add the post-build action Xray: Results Import Task.
After that, configure it.
In this example, we configured the task to import the Cucumber JSON results back to Jira.
Once all configurations are done, click Save at the bottom of the page.
After running the job, the expected result is a new Test Execution issue created in the Jira instance.
For Cucumber, Behave, JUnit, Nunit and Robot, Xray for Jenkins allows you to create new Test Executions and have control over newly-created Test Execution fields. You can send two files, the normal execution result file and a JSON file similar to the one Jira uses to create new issues. More details regarding how Jira creates new issues here.
For this scenario and example, the import task needs to be configured with the Cucumber JSON Multipart format. When selecting this option, you can additionally configure the Test Execution fields in one of two ways:
In this example, we configured the following object:
{ "fields": { "project": { "key": "PROJ" }, "summary": "Test Execution for Cucumber results (Generated by job: ${BUILD_TAG})", "issuetype": { "id": "10102" } } } |
And configured the task to import the Cucumber JSON Multipart results back to Jira.
Once all configurations are done, click Save at the bottom of the page.
After running the job, the expected result is a new Test Execution issue created in the Jira instance, with the Test Execution fields as specified in the Jenkins build step configuration.
Apart from supporting Cucumber natively, Xray enables you to take advantage of many other testing frameworks like JUnit. In this sense, Xray for Jenkins lets you import results in other formats besides Cucumber JSON.
If you want to import JUnit XML reports, a typical Job outline would be:
To start the configuration, add the post-build action Xray: Results Import Task.
After that, configure it.
In this example, we have a configuration where the JUnit XML format is chosen.
After running the plan, the expected result is a new Test Execution issue created in the JIRA instance.
You can also import multiple results using a glob expression, like in the following example
Xray for Jenkins provides support for pipelines projects, allowing you to use Xray specific tasks.
Here is a simple example of a pipeline script using the Xray: Cucumber Features Export Task
pipeline { agent any stages { stage('Export Cucumber') { steps { step([$class: 'XrayExportBuilder', filePath: '\\features', issues: 'IF-1', serverInstance: '2ffc3a3e-9e2f-4279-abcd-e9301fe47bed']) } } } } |
For Pipeline specific documentation, you may want to give a look at: |
This is a declarative example, for JUnit based tests.
pipeline { agent any stages { stage('Compile'){ steps { checkout([$class: 'GitSCM', branches: [[name: '*/master']], doGenerateSubmoduleConfigurations: false, extensions: [[$class: 'SparseCheckoutPaths', sparseCheckoutPaths: [[path: 'java-junit-calc/']]]], submoduleCfg: [], userRemoteConfigs: [[credentialsId: 'a3285253-a867-4ea7-a843-da349fd36490', url: 'ssh://git@localhost/home/git/repos/automation-samples.git']]]) sh "mvn clean compile -f java-junit-calc/pom.xml" } } stage('Test'){ steps{ sh "mvn test -f java-junit-calc/pom.xml" } } stage('Import results to Xray') { steps { step([$class: 'XrayImportBuilder', endpointName: '/junit', fixVersion: 'v3.0', importFilePath: 'java-junit-calc/target/surefire-reports/*.xml', importToSameExecution: 'true', projectKey: 'CALC', serverInstance: '552d0cb6-6f8d-48ba-bbad-50e94f39b722']) } } } } |
This is a declarative example, for Cucumber tests using the "standard" workflow (see Testing in BDD with Gherkin based frameworks (e.g. Cucumber)).
pipeline { agent any stages { stage('Export features from Xray'){ steps { checkout([$class: 'GitSCM', branches: [[name: '*/master']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: 'a3285253-a867-4ea7-a843-da349fd36490', url: 'ssh://git@localhost/home/git/repos/automation-samples.git']]]) step([$class: 'XrayExportBuilder', filePath: 'cucumber_xray_tests/features', filter: '11400', serverInstance: '552d0cb6-6f8d-48ba-bbad-50e94f39b722']) } } stage('Test'){ steps{ sh "cd cucumber_xray_tests && cucumber -x -f json -o data.json" } } stage('Import results to Xray') { steps { step([$class: 'XrayImportBuilder', endpointName: '/cucumber', importFilePath: 'cucumber_xray_tests/data.json', serverInstance: '552d0cb6-6f8d-48ba-bbad-50e94f39b722']) } } } } |
This is a declarative example, for Cucumber tests using the "VCS/Git based" workflow (see Testing in BDD with Gherkin based frameworks (e.g. Cucumber)).
pipeline { agent any stages { stage('Synch (update) recent tests to Xray'){ steps { checkout([$class: 'GitSCM', branches: [[name: '*/master']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: 'a3285253-a867-4ea7-a843-da349fd36490', url: 'ssh://git@localhost/home/git/repos/automation-samples.git']]]) step([$class: 'XrayImportFeatureBuilder', folderPath: 'cucumber_xray_tests/features', lastModified: '10', projectKey: 'CALC', serverInstance: '552d0cb6-6f8d-48ba-bbad-50e94f39b722']) } } stage('Export features from Xray'){ steps { checkout([$class: 'GitSCM', branches: [[name: '*/master']], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: 'a3285253-a867-4ea7-a843-da349fd36490', url: 'ssh://git@localhost/home/git/repos/automation-samples.git']]]) sh "rm -rf cucumber_xray_tests/features" step([$class: 'XrayExportBuilder', filePath: 'cucumber_xray_tests/features', filter: '11400', serverInstance: '552d0cb6-6f8d-48ba-bbad-50e94f39b722']) } } stage('Test'){ steps{ sh "cd cucumber_xray_tests && cucumber -x -f json -o data.json" } } stage('Import results to Xray') { steps { step([$class: 'XrayImportBuilder', endpointName: '/cucumber', importFilePath: 'cucumber_xray_tests/data.json', serverInstance: '552d0cb6-6f8d-48ba-bbad-50e94f39b722']) } } } } |
You can ask for human input in your pipeline builds by passing parameters
pipeline{ agent any parameters { string(defaultValue: "NTP", description: '', name: 'projectKey') string(defaultValue: "Android", description: '', name: 'env') } stages { stage ('Import Results') { steps { step([$class: 'XrayImportBuilder', endpointName: '/junit', importFilePath: 'java-junit-calc/target/surefire-reports/*.xml', importToSameExecution: 'true', projectKey: params.projectKey, revision: params.projectKey + env.BUILD_NUMBER, serverInstance: '552d0cb6-6f8d-48ba-bbad-50e94f39b722', testEnvironments: params.env]) } } } } |
You can automatically generate your step scripts using the Jenkins Snippet Generator.
This is the simplest way to generate your step script, and we strongly recommend the use of this snippet due to the complexity of some task related parameters.
When you check the log, it has the following:
By default, when you successively try to log into Jira with the wrong credentials, the Jira instance will prompt you to provide a CAPTCHA the next time you try to log in. It is not possible to provide this information via the build process, so it will fail with status code 403 Forbidden.
You will need to log into Jira via the browser and provide the CAPTCHA.
If you are a Jira administrator, you can go to Jira administration > User Management and reset the failed login.