---
title: "Integration with Travis CI"
canonical: "https://docs.getxray.app/space/XRAY/301502184/Integration%20with%20Travis%20CI"
format: markdown
---
> ℹ️ **What you'll learn**
> ℹ️
> ℹ️ - How to integrate with Travis CI
> ℹ️ - Run the Travis CI pipeline push the test report to Xray
> ℹ️ - Validate that the test results are available in Jira
> ⚠️ **Source-code for this tutorial**
> ⚠️
> ⚠️ - code is available in [GitHub](https://github.com/Xray-App/tutorial-java-junit-travisci)
# Overview
Travis CI is a continuous integration service used to build and test projects hosted in GitHub, Bitbucket, GitLab and Assembla.
The tool will automatically detect when a commit has been made and pushed to a repository that is configured with Travis CI, and each time this happens, it will try to execute what is defined in the Travis CI yaml file (build, pack, tests, etc).
# Prerequisites
Example
For this example we will use a simple calculator application that is part of the code available and tests defined in JUnit. We will use that repository to start a pipeline in Travis CI, where we will execute the compilation and tests, and report back to Xray.
What you'll need:
- Java and Maven installed
- Travis CI account linked to GitHub (in this case, you can also use Assembla, Bitbucket or GitLab)
# Implementing tests
In the repository you will find a calculator application and also tests that are validating those abilities.
The test consists of validating the supported operations (addition, subtraction, division and multiplication) of calculator application.
./test/java/com/xpand/java
```java
package com.xpand.java;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
public class CalcTest {
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public void CanAddNumbers()
{
assertThat(Calculator.Add(1, 1), is(2));
assertThat(Calculator.Add(-1, 1), is(0));
}
@Test
public void CanSubtract()
{
assertThat(Calculator.Subtract(1, 1), is(0));
assertThat(Calculator.Subtract(-1, -1), is(0));
assertThat(Calculator.Subtract(100, 5), is(95));
}
@Test
public void CanMultiply()
{
assertThat(Calculator.Multiply(1, 1), is(1));
assertThat(Calculator.Multiply(-1, -1), is(1));
assertThat(Calculator.Multiply(100, 5), is(500));
}
public void CanDivide()
{
assertThat(Calculator.Divide(1, 1), is(1));
assertThat(Calculator.Divide(-1, -1), is(1));
assertThat(Calculator.Divide(100, 5), is(20));
}
@Test
public void CanDoStuff()
{
assertThat(true, is(true));
}
}
```
Once the code is implemented, we can compile and execute the tests with the following command:
```shell
mvn clean compile test --file pom.xml
```
The results are immediately available in the terminal.
In this example, all test have succeed, the output generated in the terminal is the above one and the corresponding JUnit report is below:
Junit Report
```
```
Notes:
- For more information regarding the execution and integration of JUnit tests with Xray please check [this](https://getxraydocs.atlassian.net/wiki/spaces/X710/pages/45187852) article.
---
# Integrating with Travis CI
As we saw in the previous example, we produced a JUnit report locally with the test results; it is now a matter of executing those tests in Travis CI and importing their results to your Jira instance. You can do this by simply submitting automation results to Xray through the REST API or using the Jira interface to do so. In this case, we will show you how to integrate with Travis CI using API calls.
> Macro (ui-tabs)
>
> Please follow the Travis CI [documentation](https://docs.travis-ci.com/user/tutorial/#to-get-started-with-travis-ci-using-github) to configure your GitHub repo.
>
> In order to integrate Travis CI with Xray, we define the *CLIENT_ID* and *CLIENT_SECRET* as environment variables so they can later be used in the Xray API calls mentioned in the *.travis.yml* file.
>
> For that please go to the configuration of your repo in Travis CI and proceed as follows.
>
> 
>
> We have also added the necessary *.travis.yml* file to our project in GitHub in order to configure our pipeline.
>
> ##### **.travis.yml**
>
> ```yml
> sudo: false
> language: java
> jdk:
> - openjdk8
> cache:
> directories:
> - "$HOME/.cache"
>
> jobs:
> include:
> - stage: test and report to Xray
> script:
> - |
> echo "building repo..."
> mvn clean compile test --file pom.xml
> curl -H "Content-Type: multipart/form-data" -X POST -u USERNAME:PASSWORD -F "file=@target/surefire-reports/TEST-com.xpand.java.CalcTest.xml" "https://YOUR_JIRA_SERVER/rest/raven/2.0/import/execution/junit?projectKey=$PROJECTKEY_SERVER&testPlanKey=$TESTPLAN_SERVER"
> echo "done"
> ```
>
>
> On the file we can see one job definition that is compiling the code (like we did locally):
>
> ```shell
> mvn clean compile test --file pom.xml
> ```
>
>
> We can also see one API call to submit the results.
>
> #### Submit results
>
> ```shell
> curl -H "Content-Type: multipart/form-data" -X POST -u USERNAME:PASSWORD -F "file=@target/surefire-reports/TEST-com.xpand.java.CalcTest.xml" "https://YOUR_JIRA_SERVER/rest/raven/2.0/import/execution/junit?projectKey=$PROJECTKEY_SERVER&testPlanKey=$TESTPLAN_SERVER"
> ```
>
> With this command, you can create a new Test Execution for your tests, linked to the referred Test Plan "*COM-109.*" Tests will be auto-provisioned at the moment of the first import of results and will be reused afterward.
>
>
> Once everything is configured you can start the pipeline by committing to your code repository (in our case pushing code in GitHub).
>
> On the side of Travis CI, it will look like this:
>
> 
>
> The log that will appear in the bottom of the page in Travis CI will output all of the steps we are taking:
>
> 
This is how it looks in Xray once the test report is ingested back in, namely on the TestPlan "*COM-109*":
As we can see the Test Plan has 4 Tests, all currently marked as being passed.
If we drill down to the latest Test Run, we can see the details of that specific execution:
---
# Triggering automation from Xray side
Please have a look at [Integration with Automation for Jira](https://getxraydocs.atlassian.net/wiki/spaces/XRAY/pages/301695466) to see some examples of how automation can be triggered from Xray side.
---
# References
- [https://github.com/Xray-App/tutorial-java-junit-Travis CI](https://github.com/Xray-App/tutorial-java-junit-travisci)
- [https://docs.travis-ci.com/user/tutorial/](https://docs.travis-ci.com/user/tutorial/)
- [Taking advantage of Jira Cloud built-in automation capabilities](https://getxraydocs.atlassian.net/wiki/spaces/XRAYCLOUDDRAFT/pages/44837449)