To create a distribution without running the tests, simply run the following:

Running Elasticsearch from a checkout

gradle run

Test case filtering.

gradle test -Dtests.class=org.elasticsearch.package.ClassName
gradle test "-Dtests.class=*.ClassName"

gradle test "-Dtests.class=org.elasticsearch.package.*"

gradle test "-Dtests.method=*esi*"

gradle test -Dtests.filter="@nightly and not @backwards"

gradle test -Dtests.filter="@nightly and not(@badapple or @backwards)"

Seed and repetitions.

gradle test -Dtests.seed=DEADBEEF

Repeats all tests of ClassName N times.

gradle test -Dtests.iters=N -Dtests.class=*.ClassName

Repeats all tests of ClassName N times.

gradle test -Dtests.iters=N -Dtests.class=*.ClassName -Dtests.seed=DEAD:BEEF

Repeats a given test N times

gradle test -Dtests.iters=N -Dtests.class=*.ClassName -Dtests.method=mytest*

gradle test -Dtests.iters=N -Dtests.failfast=true -Dtestcase=...
gradle test -Dtests.iters=N -Dtests.maxfailures=M -Dtestcase=...

Test groups.

gradle test -Dtests.nightly=[false]   - nightly test group (@Nightly)
gradle test -Dtests.weekly=[false]    - weekly tests (@Weekly)
gradle test -Dtests.awaitsfix=[false] - known issue (@AwaitsFix)

Load balancing and caches.

gradle test -Dtests.jvms=8

systemProp.tests.jvms=8

Test compatibility.

gradle test -Dtests.compatibility=1.0.0

Miscellaneous.

gradle test -Dtests.haltonfailure=false

gradle test -verbose

gradle test -Dtests.timeoutSuite=5000! ...

gradle test -Dtests.es.logger.level=DEBUG

gradle test -Dtests.output=always

gradle test -Dtests.heap.size=512m

# specify heap dump path
gradle test -Dtests.jvm.argline="-XX:HeapDumpPath=/path/to/heapdumps"
# enable gc logging
gradle test -Dtests.jvm.argline="-verbose:gc"
# enable security debugging
gradle test -Dtests.jvm.argline="-Djava.security.debug=access,failure"

Running backwards compatibility tests is disabled by default since it requires a release version of elasticsearch to be present on the test system. To run backwards compatibilty tests untar or unzip a release and run the tests with the following command:

Note that backwards tests must be run with security manager disabled. If the elasticsearch release is placed under ./backwards/elasticsearch-x.y.z the path can be omitted:

To setup the bwc test environment execute the following steps (provided you are already in your elasticsearch clone):

To run all verification tasks, including static checks, unit tests, and integration tests:

Note that this will also run the unit tests and precommit tasks first. If you want to just run the integration tests (because you are debugging them):

If you want to just run the precommit checks:

The available integration tests make use of the java API to communicate with the elasticsearch nodes, using the internal binary transport (port 9300 by default). The REST layer is tested through specific tests that are shared between all the elasticsearch official clients and consist of YAML files that describe the operations to be executed and the obtained results that need to be tested.

The REST tests are run automatically when executing the "gradle check" command. To run only the REST tests use the following command:

A specific test case can be run with

*Yaml*IT are the executable test classes that runs all the yaml suites available within the rest-api-spec folder.

The REST tests support all the options provided by the randomized runner, plus the following:

• tests.rest[true|false]: determines whether the REST tests need to be run (default) or not.

• tests.rest.suite: comma separated paths of the test suites to be run (by default loaded from /rest-api-spec/test). It is possible to run only a subset of the tests providing a sub-folder or even a single yaml file (the default /rest-api-spec/test prefix is optional when files are loaded from classpath) e.g. -Dtests.rest.suite=index,get,create/10_with_id

• tests.rest.blacklist: comma separated globs that identify tests that are blacklisted and need to be skipped e.g. -Dtests.rest.blacklist=index//Index document,get/10_basic/

• tests.rest.spec: REST spec path (default /rest-api-spec/api)

Note that the REST tests, like all the integration tests, can be run against an external cluster by specifying the tests.cluster property, which if present needs to contain a comma separated list of nodes to connect to (e.g. localhost:9300). A transport client will be created based on that and used for all the before|after test operations, and to extract the http addresses of the nodes so that REST requests can be sent to them.

The simplest way to test scripts and the packaged distributions is to use Vagrant. You can get started by following there five easy steps:

1. Install Virtual Box and Vagrant.

2. (Optional) Install vagrant-cachier to squeeze a bit more performance out of the process:

1. Validate your installed dependencies:

1. Download and smoke test the VMs with gradle vagrantSmokeTest or gradle -Pvagrant.boxes=all vagrantSmokeTest. The first time you run this it will download the base images and provision the boxes and immediately quit. If you you this again it’ll skip the download step.

2. Run the tests with gradle packagingTest. This will cause gradle to build the tar, zip, and deb packages and all the plugins. It will then run the tests on ubuntu-1404 and centos-7. We chose those two distributions as the default because they cover deb and rpm packaging and SyvVinit and systemd.

You can run on all the VMs by running gradle -Pvagrant.boxes=all packagingTest. You can run a particular VM with a command like gradle -Pvagrant.boxes=oel-7 packagingTest. See gradle tasks for a complete list of available vagrant boxes for testing. It’s important to know that if you ctrl-c any of these gradle commands then the boxes will remain running and you’ll have to terminate them with 'gradle stop'.

All the regular vagrant commands should just work so you can get a shell in a VM running trusty by running vagrant up ubuntu-1404 --provider virtualbox && vagrant ssh ubuntu-1404.

These are the linux flavors the Vagrantfile currently supports:

• ubuntu-1404 aka trusty

• ubuntu-1604 aka xenial

• debian-8 aka jessie

• debian-9 aka stretch, the current debian stable distribution

• centos-6

• centos-7

• fedora-26

• fedora-27

• oel-6 aka Oracle Enterprise Linux 6

• oel-7 aka Oracle Enterprise Linux 7

• sles-12

• opensuse-42 aka Leap

We’re missing the following from the support matrix because there aren’t high quality boxes available in vagrant atlas:

• sles-11

We’re missing the following because our tests are very linux/bash centric:

• Windows Server 2012

It’s important to think of VMs like cattle. If they become lame you just shoot them and let vagrant reprovision them. Say you’ve hosed your precise VM:

All you’ve got to do to get another one is

The whole process takes a minute and a half on a modern laptop, two and a half without vagrant-cachier.

Its possible that some downloads will fail and it’ll be impossible to restart them. This is a bug in vagrant. See the instructions here for how to work around it: https://github.com/mitchellh/vagrant/issues/4479

Some vagrant commands will work on all VMs at once:

vagrant up would normally start all the VMs but we’ve prevented that because that’d consume a ton of ram.

In general its best to stick to testing in vagrant because the bats scripts are destructive. When working with a single package it’s generally faster to run its tests in a tighter loop than gradle provides. In one window:

and in another window:

If you wanted to retest all the release artifacts on a single VM you could:

You can also use Gradle to prepare the test environment and then starts a single VM:

Or any of vagrantCentos6#up, vagrantCentos7#up, vagrantDebian8#up, vagrantDebian9#up, vagrantFedora26#up, vagrantFedora27#up, vagrantOel6#up, vagrantOel7#up, vagrantOpensuse42#up,vagrantSles12#up, vagrantUbuntu1404#up, vagrantUbuntu1604#up.

Once up, you can then connect to the VM using SSH from the elasticsearch directory:

Or from another directory:

Note: Starting vagrant VM outside of the elasticsearch folder requires to indicates the folder that contains the Vagrantfile using the VAGRANT_CWD environment variable.

Backwards compatibility tests exist to test upgrading from each supported version to the current version. To run all backcompat tests use:

A specific version can be tested as well. For example, to test backcompat with version 5.3.2 run:

When running gradle check, some minimal backcompat checks are run. Which version is tested depends on the branch. On master, this will test against the current stable branch. On the stable branch, it will test against the latest release branch. Finally, on a release branch, it will test against the most recent release.

BWC Testing against a specific remote/branch

gradle check -Dtests.bwc.remote=${remote} -Dtests.bwc.refspec=index_req_bwc_5.x

Tests can be run instrumented with jacoco to produce a coverage report in target/site/jacoco/.

Unit test coverage:

Integration test coverage:

Combined (Unit+Integration) coverage:

If you want to run elasticsearch from your IDE, the gradle run task supports a remote debugging option:

If you want to run Elasticsearch and be able to remotely attach the process for debugging purposes from your IDE, can start Elasticsearch using ES_JAVA_OPTS:

Read your IDE documentation for how to attach a debugger to a JVM process.

Additional plugins may be built alongside elasticsearch, where their dependency on elasticsearch will be substituted with the local elasticsearch build. To add your plugin, create a directory called elasticsearch-extra as a sibling of elasticsearch. Checkout your plugin underneath elasticsearch-extra and the build will automatically pick it up. You can verify the plugin is included as part of the build by checking the projects of the build.

There is a known issue with macOS localhost resolve strategy that can cause some integration tests to fail. This is because integration tests have timings for cluster formation, discovery, etc. that can be exceeded if name resolution takes a long time. To fix this, make sure you have your computer name (as returned by hostname) inside /etc/hosts, e.g.: