blob: 1151f1c81bc4609997b8542384acc904deae59c2 [file] [log] [blame]
= Gerrit Code Review - End to end tests
This document provides descriptions of Gerrit end-to-end (`e2e`) test scenarios implemented using
the link:[Gatling,role=external,window=_blank] framework.
Similar scenarios have been successfully used to compare performance of different Gerrit versions
or study the Gerrit response under different load profiles. Although mostly for load, scenarios can
either be for link:[load or functional,role=external,window=_blank]
(e2e) testing purposes. Functional scenarios may then reuse this framework and Gatling's usability
features such as its protocols (more below) and
That cross test-scope reusability applies to both Gerrit core scenarios and non-core ones, such as
for Gerrit plugins or other potential extensions. End-to-end testing may then include scopes like
feature integration, deployment, smoke (and load) testing. These load and functional test scopes
should remain orthogonal to the unit and component (aka Gerrit `IT`-suffixed or `acceptance`) ones.
The term `acceptance` though may still be coined by organizations to target e2e functional testing.
== What is Gatling?
Gatling is mostly a load testing tool which provides out of the box support for the HTTP protocol.
Documentation on how to write an HTTP load test can be found
However, in the scenarios that were initially proposed, the
link:[Gatling Git extension,role=external,window=_blank] was
leveraged to run tests at the Git protocol level.
Gatling is written in Scala, but the abstraction provided by the Gatling DSL makes the scenarios
implementation easy even without any Scala knowledge. The online `End-to-end tests`
links posted on the homepage have more introductory information.
== IDE: IntelliJ
Examples of scenarios can be found in the `e2e-tests` directory. The files in that directory should
be formatted using the mainstream
link:[Scala plugin for IntelliJ,role=external,window=_blank].
The latter is not mandatory but preferred for `sbt` and Scala IDE purposes in this project.
So, Eclipse can also be used alongside as a development IDE; this is described below.
=== Eclipse
1. Install the link:[Scala plugin for Eclipse,role=external,window=_blank].
2. Run `sbt eclipse` from the `e2e-tests` root directory.
3. Import the resulting `e2e-tests` eclipse file inside the Gerrit project, in Eclipse.
4. You should see errors in Eclipse telling you there are missing packages.
5. This is due to the sbt-eclipse plugin not properly linking the Gerrit Gatling e2e tests with
Gatling Git plugin.
6. You then have to right-click on the root directory and choose the build path->link source option.
7. Then you have to browse to `.sbt/1.0/staging`, find the folder where gatling-git is contained,
and choose that.
8. That last step should link the gatling-git plugin to the project; e2e tests should not show
errors anymore.
9. You may get errors in the gatling-git directory; these should not affect Gerrit Gatling
development and can be ignored.
== How to build the tests
An link:[sbt-based installation,role=external,window=_blank]
of link:[Scala,role=external,window=_blank] is required.
The `scalaVersion` used by `sbt` once installed is defined in the `build.sbt` file. That specific
version of Scala is automatically used by `sbt` while building:
sbt compile
The following warning, if present when executing `sbt` commands, can be removed by creating the
link:[related credentials file,role=external,window=_blank]
locally. Dummy values for `user` and `password` in that file can be used initially.
[warn] Credentials file ~/.sbt/sonatype_credentials does not exist
The other warning below can be safely ignored, so far. Running the proposed `sbt evicted` command
should only list `scala-java8-compat_2.12` as `[warn]`. The other dependency conflicts should show
as `[info]`. All of the listed conflicts get usually resolved seamlessly or so.
[warn] There may be incompatibilities among your library dependencies; run 'evicted' to see detailed eviction warnings.
Every `sbt` command can include an optional log level
Below, `[info]` logs are no longer shown:
sbt --warn compile
=== How to build using Docker
docker build . -t e2e-tests
== How to set-up
=== SSH keys
If you are running SSH commands, the private keys of the users used for testing need to go in
`/tmp/ssh-keys`. The keys need to be generated this way and won't be validated.
mkdir /tmp/ssh-keys
ssh-keygen -m PEM -t rsa -C "" -f /tmp/ssh-keys/id_rsa
The public key in `/tmp/ssh-keys/` has to be added to the test user(s) `SSH Keys` in
Gerrit. Now, the host from which the latter runs may need public key scanning to become known.
This applies to the local user that runs the forthcoming `sbt` testing commands. An example
assuming `localhost` follows:
ssh-keyscan -t rsa -p 29418 localhost > ~/.ssh/known_hosts
=== Input file
The `CloneUsingBothProtocols` scenario is fed with the data coming from the
`src/test/resources/data/com/google/gerrit/scenarios/CloneUsingBothProtocols.json` file. Such a
file contains the commands and repository used during the e2e test. That file currently looks like
below. This scenario serves as a simple example with no actual load in it. It can be used to test
or validate the local setup. More complex scenarios can be further developed, under the
`` package. The uppercase keywords are set through
link:#_environment_properties[environment properties,role=external,window=_blank].
"url": "ssh://admin@HOSTNAME:SSH_PORT/_PROJECT",
"cmd": "clone"
"cmd": "clone"
Valid commands are:
* `clone`
* `fetch`
* `pull`
* `push`
=== Project and HTTP credentials
The example above assumes that the `loadtest-repo` project exists in the Gerrit under test. The
`CloneUsingBothProtocols` scenario already includes creating that project and deleting it once done
with it. That scenario class can be used as an example of how a scenario can compose itself
alongside other scenarios (here, `CreateProject` and `DeleteProject`).
The `HTTP Credentials` or password obtained from test user's `Settings` (in Gerrit) may be
required, in `src/test/resources/application.conf`, depending on the above commands used. That
file's `http` section shows which shell environment variables can be used to set those credentials.
Executing the `CloneUsingBothProtocols` scenario, as is, does require setting the http credentials.
That is because of the aforementioned create/delete project (http) scenarios composed within it.
=== Environment properties
The `JAVA_OPTS` environment variable
link:[can optionally be used,role=external,window=_blank]
to define non-default values for keys found in scenario `json` data files. That variable can
currently be set with either one or many of these supported properties, from the core framework:
* ``
* ``
* ``
* ``
* ``
* ``
* ``
Above, the properties can be set with values matching specific deployment topologies under test.
The name of the property corresponds to the uppercase keyword found in the json file. For example,
`hostname` above will set the value of `HOSTNAME` in the
link:#_input_file[aforementioned example,role=external,window=_blank].
The example values shown above are the currently coded default ones. For example, the `http` scheme
above could be replaced with `https`. The framework may support differing or more properties over time.
==== Replication delay
The `replication_delay` property allows test scenario steps to wait for that many seconds, prior to
expecting a done replication. Its default is `15` seconds and can be set using another value:
* ``
There is a short time buffer added to this property. Now, the replication starts after replication
plugin's own `replicationDelay`, in seconds, and typically takes some more seconds to complete.
That whole replication time depends on the system under test. Therefore, this property here should
be set to a value high enough, so that the test checks for a done replication at the right time.
==== Context path
The `context_path` property allows test scenarios to send Gerrit REST requests to Gerrit instances
that use a context path in the URL. Its default is no context path and can be set using another value:
* ``
==== Authentication
The `authenticated` property allows test scenarios to use authenticated HTTP clones. Its default is
no authentication:
* ``
==== Automatic properties
The link:#_input_file[example keywords,role=external,window=_blank] also include `_PROJECT`,
prefixed with an underscore, which means that its value gets automatically generated by the
scenario. Any property setting for it is therefore not applicable. Its usage differs from the
non-prefixed `PROJECT` keyword, in that sense. Using the latter instead in json files requires
setting this `JAVA_OPTS` property:
* ``
Other automatic keys may be used and implemented, always prefixed with an underscore that tells so.
==== Plugin scenarios
Plugin or otherwise non-core scenarios can also use such properties. The core java package
`` from the example above has to be replaced with the one under which
those scenario classes are. Such extending scenarios can also add extension-specific properties.
Examples of this can be found in these Gerrit plugins test code:
* `link:[gc-conductor,role=external,window=_blank]`
* `link:[high-availability,role=external,window=_blank]`
* `link:[multi-site,role=external,window=_blank]`
* `link:[rename-project,role=external,window=_blank]`
==== Power factor
The following core property can be optionally set depending on the runtime environment. The test
environments used as reference for scenarios development assume its default value, `1.0`. For
slower or more complex execution environments, the value can be increased this way for example:
* ``
This will make the scenario steps take half more time to expect proper completion. A value smaller
than the default, say `0.8`, will make scenarios wait somewhat less than how they were developed.
Scenario development is often done using locally running Gerrit systems under test, which are
sometimes dockerized.
==== Number of users
The `number_of_users` property can be used to scale scenario steps to run with the specified number
of concurrent users. The value of this property remains `1` by default. For example, this sets the
number of concurrent users to 10:
* ``
This will make scenarios that support the `number_of_users` property to inject that many users
concurrently for load testing.
== How to run tests
Run all tests:
sbt "gatling:test"
Run a single test:
sbt "gatling:testOnly"
Generate the last report:
sbt "gatling:lastReport"
The `src/test/resources/logback.xml` file
Gatling's logging level. To quickly enable
link:[detailed logging,role=external,window=_blank]
of `http` requests and responses, the `root level` can be set to `trace` in that file.
=== How to run using Docker
docker run -it e2e-tests -s
=== How to run non-core scenarios
Locally adding non-core scenarios, for example from Gerrit plugins, is as simple as copying such
files in. Copying is necessary over linking, unless running using Docker (above) is not required.
Docker does not support links for files it has to copy over through the Dockerfile (here, the
scenario files). Here is how to proceed for adding such external (e.g., plugin) scenario files in:
pushd e2e-tests/src/test/scala
cp -r (or, ln -s) scalaPackageStructure .
pushd e2e-tests/src/test/resources/data
cp -r (or, ln -s) jsonFilesPackageStructure .
The destination folders above readily git-ignore every non-core scenario file added under them. If
running using Docker, `e2e-tests/Dockerfile` may require another `COPY` line for the hereby added
scenarios. Aforementioned `sbt` or `docker` commands can then be used to run the added tests.
Part of link:index.html[Gerrit Code Review]