Java Tests

Compatibility

Supported test frameworks:

If your test framework is not supported, you can try instrumenting your tests using Manual Testing API.

Supported build systems:

Other build systems, such as Ant, Bazel, or SBT are supported with the following limitations:

• Automatic coverage configuration and reporting is not supported.
• When building a multi-module project, every module is reported in a separate trace.

Setup

You may follow interactive setup steps on the Datadog site or the instructions below.

Configuring the Datadog Java Tracer varies depending on your CI provider.

Downloading SDK

You only need to download the SDK once for each server.

If the SDK is already available locally on the server, you can proceed directly to running the tests.

Declare DD_TRACER_FOLDER variable with the path to the folder where you want to store the downloaded tracer JAR:

export DD_TRACER_FOLDER=... // e.g. ~/.datadog

Run the command below to download the SDK JAR to the specified folder:

wget -O $DD_TRACER_FOLDER/dd-java-agent.jar 'https://dtdg.co/latest-java-tracer'

You can run the java -jar $DD_TRACER_FOLDER/dd-java-agent.jar command to check the version of the SDK.

Running your tests

Configuration

Default configuration values work well in most cases.

However, to customize the SDK’s behavior, Datadog SDK configuration options can be used.

Collecting Git metadata

Datadog uses Git information for visualizing your test results and grouping them by repository, branch, and commit. Git metadata is automatically collected by the test instrumentation from CI provider environment variables and the local .git folder in the project path, if available.

If you are running tests in non-supported CI providers or with no .git folder, you can set the Git information manually using environment variables. These environment variables take precedence over any auto-detected information. Set the following environment variables to provide Git information:

DD_GIT_REPOSITORY_URL

URL of the repository where the code is stored. Both HTTP and SSH URLs are supported.
Example: git@github.com:MyCompany/MyApp.git, https://github.com/MyCompany/MyApp.git

DD_GIT_BRANCH

Git branch being tested. Leave empty if providing tag information instead.
Example: develop

DD_GIT_TAG

Git tag being tested (if applicable). Leave empty if providing branch information instead.
Example: 1.0.1

DD_GIT_COMMIT_SHA

Full commit hash.
Example: a18ebf361cc831f5535e58ec4fae04ffd98d8152

DD_GIT_COMMIT_MESSAGE

Commit message.
Example: Set release number

DD_GIT_COMMIT_AUTHOR_NAME

Commit author name.
Example: John Smith

DD_GIT_COMMIT_AUTHOR_EMAIL

Commit author email.
Example: john@example.com

DD_GIT_COMMIT_AUTHOR_DATE

Commit author date in ISO 8601 format.
Example: 2021-03-12T16:00:28Z

DD_GIT_COMMIT_COMMITTER_NAME

Commit committer name.
Example: Jane Smith

DD_GIT_COMMIT_COMMITTER_EMAIL

Commit committer email.
Example: jane@example.com

DD_GIT_COMMIT_COMMITTER_DATE

Commit committer date in ISO 8601 format.
Example: 2021-03-12T16:00:28Z

Extensions

The SDK exposes a set of APIs that can be used to extend its functionality programmatically.

Adding custom tags to tests

importio.opentelemetry.api.trace.Span;// ...// inside your testSpanspan=Span.current();span.setAttribute("test_owner","my_team");// test continues normally// ...

importio.opentracing.Span;importio.opentracing.util.GlobalTracer;// ...// inside your testfinalSpanspan=GlobalTracer.get().activeSpan();if(span!=null){span.setTag("test_owner","my_team");}// test continues normally// ...

Adding custom measures to tests

Just like tags, you can add custom measures to your tests by using the current active span:

importio.opentelemetry.api.trace.Span;// ...// inside your testSpanspan=Span.current();span.setAttribute("test.memory.usage",1e8);// test continues normally// ...

importio.opentracing.Span;importio.opentracing.util.GlobalTracer;// ...// inside your testfinalSpanspan=GlobalTracer.get().activeSpan();if(span!=null){span.setTag("test.memory.usage",1e8);}// test continues normally// ...

For more information about custom measures, see the Add Custom Measures guide.

Using manual testing API

If you use one of the supported testing frameworks, the Java Tracer automatically instruments your tests and sends the results to the Datadog backend.

If you are using a framework that is not supported, or an ad-hoc testing solution, you can harness the manual testing API, which also reports test results to the backend.

To use the manual testing API, add the dd-trace-api library as a compile-time dependency to your project.

Domain model

The API is based around four concepts: test session, test module, test suite, and test.

Test session

A test session represents a project build, which typically corresponds to execution of a test command issued by a user or by a CI script.

To start a test session, call datadog.trace.api.civisibility.CIVisibility#startSession and pass the name of the project and the name of the testing framework you used.

When all your tests have finished, call datadog.trace.api.civisibility.DDTestSession#end, which forces the library to send all remaining test results to the backend.

Test module

A test module represents a smaller unit of work within a project build, typically corresponding to a project module. For example, a Maven submodule or Gradle subproject.

To start a test mode, call datadog.trace.api.civisibility.DDTestSession#testModuleStart and pass the name of the module.

When the module has finished building and testing, call datadog.trace.api.civisibility.DDTestModule#end.

Test Suite

A test suite comprises a set of tests that share common functionality. They can share a common initialization and teardown, and can also share some variables. A single suite usually corresponds to a Java class that contains test cases.

Create test suites in a test module by calling datadog.trace.api.civisibility.DDTestModule#testSuiteStart and passing the name of the test suite.

Call datadog.trace.api.civisibility.DDTestSuite#end when all the related tests in the suite have finished their execution.

Test

A test represents a single test case that is executed as part of a test suite. Usually it corresponds to a method that contains testing logic.

Create tests in a suite by calling datadog.trace.api.civisibility.DDTestSuite#testStart and passing the name of the test.

Call datadog.trace.api.civisibility.DDTest#end when a test has finished execution.

Code Example

The following code represents a simple usage of the API:

packagecom.datadog.civisibility.example;importdatadog.trace.api.civisibility.CIVisibility;importdatadog.trace.api.civisibility.DDTest;importdatadog.trace.api.civisibility.DDTestModule;importdatadog.trace.api.civisibility.DDTestSession;importdatadog.trace.api.civisibility.DDTestSuite;importjava.lang.reflect.Method;// the null arguments in the calls below are optional startTime/endTime values:// when they are not specified, current time is usedpublicclass ManualTest{publicstaticvoidmain(String[]args)throwsException{DDTestSessiontestSession=CIVisibility.startSession("my-project-name","my-test-framework",null);testSession.setTag("my-tag","additional-session-metadata");try{runTestModule(testSession);}finally{testSession.end(null);}}privatestaticvoidrunTestModule(DDTestSessiontestSession)throwsException{DDTestModuletestModule=testSession.testModuleStart("my-module",null);testModule.setTag("my-module-tag","additional-module-metadata");try{runFirstTestSuite(testModule);runSecondTestSuite(testModule);}finally{testModule.end(null);}}privatestaticvoidrunFirstTestSuite(DDTestModuletestModule)throwsException{DDTestSuitetestSuite=testModule.testSuiteStart("my-suite",ManualTest.class,null);testSuite.setTag("my-suite-tag","additional-suite-metadata");try{runTestCase(testSuite);}finally{testSuite.end(null);}}privatestaticvoidrunTestCase(DDTestSuitetestSuite)throwsException{MethodmyTestCaseMethod=ManualTest.class.getDeclaredMethod("myTestCase");DDTestddTest=testSuite.testStart("myTestCase",myTestCaseMethod,null);ddTest.setTag("my-test-case-tag","additional-test-case-metadata");ddTest.setTag("my-test-case-tag","more-test-case-metadata");try{myTestCase();}catch(Exceptione){ddTest.setErrorInfo(e);// pass error info to mark test case as failed}finally{ddTest.end(null);}}privatestaticvoidmyTestCase()throwsException{// run some test logic}privatestaticvoidrunSecondTestSuite(DDTestModuletestModule){DDTestSuitesecondTestSuite=testModule.testSuiteStart("my-second-suite",ManualTest.class,null);secondTestSuite.setSkipReason("this test suite is skipped");// pass skip reason to mark test suite as skippedsecondTestSuite.end(null);}}

Always call datadog.trace.api.civisibility.DDTestSession#end at the end so that all the test info is flushed to Datadog.

Best practices

Deterministic test parameters representation

Test Optimization works best when the test parameters are deterministic and stay the same between test runs. If a test case has a parameter that varies between test executions (such as a current date, a random number, or an instance of a class whose toString() method is not overridden), some of the product features may not work as expected. For example, the history of executions may not be available, or the test case may not be classified as flaky even if it exhibits flakiness.

The best way to fix this is to make sure that the test parameters are the same between test runs.

In JUnit 5, this can also be addressed by customizing the string representation of the test parameters without changing their values. To do so, use org.junit.jupiter.api.Named interface or change the name parameter of the org.junit.jupiter.params.ParameterizedTest annotation:

@ParameterizedTest@MethodSource("namedArguments")voidparameterizedTest(Strings,Dated){// The second parameter in this test case is non-deterministic.// In the argument provider method it is wrapped with Named to ensure it has a deterministic name.}staticStream<Arguments>namedArguments(){returnStream.of(Arguments.of("a string",Named.of("current date",newDate())),Arguments.of("another string",Named.of("a date in the future",newDate(System.currentTimeMillis()+TimeUnit.DAYS.toMillis(1)))));}

@ParameterizedTest(name="[{index}] {0}, a random number from one to ten")@MethodSource("randomArguments")voidanotherParameterizedTest(Strings,inti){// The second parameter in this test case is non-deterministic.// The name of the parameterized test is customized to ensure it has a deterministic name.}staticStream<Arguments>randomArguments(){returnStream.of(Arguments.of("a string",ThreadLocalRandom.current().nextInt(10)+1),Arguments.of("another string",ThreadLocalRandom.current().nextInt(10)+1));}

Test session name DD_TEST_SESSION_NAME

Use DD_TEST_SESSION_NAME to define the name of the test session and the related group of tests. Examples of values for this tag would be:

• unit-tests
• integration-tests
• smoke-tests
• flaky-tests
• ui-tests
• backend-tests

If DD_TEST_SESSION_NAME is not specified, the default value used is a combination of the:

• CI job name
• Command used to run the tests (such as mvn test)

The test session name needs to be unique within a repository to help you distinguish different groups of tests.

When to use DD_TEST_SESSION_NAME

There’s a set of parameters that Datadog checks to establish correspondence between test sessions. The test command used to execute the tests is one of them. If the test command contains a string that changes for every execution, such as a temporary folder, Datadog considers the sessions to be unrelated to each other. For example:

• mvn test --temp-dir=/var/folders/t1/rs2htfh55mz9px2j4prmpg_c0000gq/T

Datadog recommends using DD_TEST_SESSION_NAME if your test commands vary between executions.

Troubleshooting

The tests are not appearing in Datadog after enabling Test Optimization in the SDK

Verify that the SDK is injected into your build process by examining your build’s logs. If the injection is successful, you can see a line containing DATADOG TRACER CONFIGURATION. If the line is not there, make sure that the environment variables used to inject and configure the SDK are available to the build process. A common mistake is to set the variables in a build step and run the tests in another build step. This approach may not work if the variables are not propagated between build steps.

Ensure that you are using the latest version of the SDK.

Verify that your build system and testing framework are supported by Test Optimization. See the list of supported build systems and test frameworks.

Ensure that the dd.civisibility.enabled property (or DD_CIVISIBILITY_ENABLED environment variable) is set to true in the SDK arguments.

Try running your build with tracer debug logging enabled by setting the DD_TRACE_DEBUG environment variable to true. Check the build output for any errors that indicate tracer misconfiguration, such as an unset DD_API_KEY environment variable.

Tests or source code compilation fails when building a project with the SDK attached

By default, Test Optimization runs Java code compilation with a compiler plugin attached.

The plugin is optional, as it only serves to reduce the performance overhead.

Depending on the build configuration, adding the plugin can sometimes disrupt the compilation process.

If the plugin interferes with the build, disable it by adding dd.civisibility.compiler.plugin.auto.configuration.enabled=false to the list of -javaagent arguments (or by setting DD_CIVISIBILITY_COMPILER_PLUGIN_AUTO_CONFIGURATION_ENABLED=false environment variable).

Builds fails because dd-javac-plugin-client artifact cannot be found

It is possible that the Java compiler plugin injected into the build is not available if the build uses a custom artifactory storage or if it is run in offline mode.

If this is the case, you can disable plugin injection by adding dd.civisibility.compiler.plugin.auto.configuration.enabled=false to the list of -javaagent arguments (or by setting the DD_CIVISIBILITY_COMPILER_PLUGIN_AUTO_CONFIGURATION_ENABLED environment variable to false).

The plugin is optional, as it only serves to reduce the performance overhead.

Tests fail when building a project with the SDK attached

In some cases attaching the SDK can break tests, especially if they run asserts on the internal state of the JVM or instances of third-party libraries’ classes.

While the best approach is such cases is to update the tests, there is also a quicker option of disabling the SDK’s third-party library integrations.

The integrations provide additional insights into what happens in the tested code and are especially useful in integration tests, to monitor things like HTTP requests or database calls. They are enabled by default.

To disable a specific integration, refer to the Datadog Tracer Compatibility table for the relevant configuration property names. For example, to disable OkHttp3 client request integration, add dd.integration.okhttp-3.enabled=false to the list of -javaagent arguments.

To disable all integrations, augment the list of -javaagent arguments with dd.trace.enabled=false (or set DD_TRACE_ENABLED=false environment variable).

Further reading

Request a personalized demo