Modifies the integration test suite to use TestContainers

Author: steve-perkins

README.md

@@ -145,6 +145,9 @@ should represent non-breaking changes.  The third number represents any very min
   * Includes the REST response body in `VaultException` messages for basic read and write operations.
   * Implements the `/v1/auth/token/lookup-self` endpoint.
   * Makes numerous classes implement `Serializable`.
+  * Re-works the integration test suite, so that you no longer have to manually configure and run a Vault server 
+    instance.  The tests now use the [TestContainers](https://www.testcontainers.org/) to setup and launch a 
+    Vault server instance from within a Docker container, in a completely automated manner.
 * **2.0.0**: This is breaking-change release, with numerous deprecated items cleaned up.
   * Adds support for authentication via the AppRole auth backend.  
   * Adds support for renewing secret leases.

build.gradle

@@ -7,17 +7,27 @@ archivesBaseName = 'vault-java-driver'
 version '3.0.0-SNAPSHOT'
 ext.isReleaseVersion = !version.endsWith('SNAPSHOT')
 
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+compileJava {
+    sourceCompatibility = 1.7
+    targetCompatibility = 1.7
+}
+
+compileTestJava {
+    sourceCompatibility = 1.8
+    targetCompatibility = 1.8
+}
 
 repositories {
     mavenCentral()
 }
 
 dependencies {
+    testCompile('org.testcontainers:testcontainers:1.3.0')
     testCompile('junit:junit:4.11')
     testCompile('org.mockito:mockito-core:1.10.19')
     testCompile('org.eclipse.jetty:jetty-server:9.3.7.v20160115')
+    testCompile('org.slf4j:slf4j-api:1.7.25')
+    testRuntime('org.slf4j:slf4j-simple:1.7.25')
 }
 
 task wrapper(type: Wrapper) {
@@ -73,13 +83,6 @@ task integrationTest(type: Test) {
     testLogging {
         events "passed", "skipped", "failed"
     }
-    systemProperties = [
-        VAULT_ADDR: System.getProperty("VAULT_ADDR"),
-        VAULT_TOKEN: System.getProperty("VAULT_TOKEN"),
-        VAULT_APP_ID: System.getProperty("VAULT_APP_ID"),
-        VAULT_USER_ID: System.getProperty("VAULT_USER_ID"),
-        VAULT_PASSWORD: System.getProperty("VAULT_PASSWORD")
-    ]
 }
 
 //

src/main/java/com/bettercloud/vault/api/Auth.java

@@ -10,8 +10,6 @@
 import com.bettercloud.vault.rest.Rest;
 
 import java.io.Serializable;
-import java.io.UnsupportedEncodingException;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
@@ -78,71 +76,71 @@ public static class TokenRequest implements Serializable {
         /**
          * {@link #id}
          */
-        public TokenRequest withId(final UUID id) {
+        public TokenRequest id(final UUID id) {
             this.id = id;
             return this;
         }
 
         /**
          * {@link #polices}
          */
-        public TokenRequest withPolices(final List<String> polices) {
+        public TokenRequest polices(final List<String> polices) {
             this.polices = polices;
             return this;
         }
 
         /**
          * {@link #meta}
          */
-        public TokenRequest withMeta(final Map<String, String> meta) {
+        public TokenRequest meta(final Map<String, String> meta) {
             this.meta = meta;
             return this;
         }
 
         /**
          * {@link #noParent}
          */
-        public TokenRequest withNoParent(final Boolean noParent) {
+        public TokenRequest noParent(final Boolean noParent) {
             this.noParent = noParent;
             return this;
         }
 
         /**
          * {@link #noDefaultPolicy}
          */
-        public TokenRequest withNoDefaultPolicy(final Boolean noDefaultPolicy) {
+        public TokenRequest noDefaultPolicy(final Boolean noDefaultPolicy) {
             this.noDefaultPolicy = noDefaultPolicy;
             return this;
         }
 
         /**
          * {@link #ttl}
          */
-        public TokenRequest withTtl(final String ttl) {
+        public TokenRequest ttl(final String ttl) {
             this.ttl = ttl;
             return this;
         }
 
         /**
          * {@link #displayName}
          */
-        public TokenRequest withDisplayName(final String displayName) {
+        public TokenRequest displayName(final String displayName) {
             this.displayName = displayName;
             return this;
         }
 
         /**
          * {@link #numUses}
          */
-        public TokenRequest withNumUses(final Long numUses) {
+        public TokenRequest numUses(final Long numUses) {
             this.numUses = numUses;
             return this;
         }
 
         /**
          * {@link #role}
          */
-        public TokenRequest withRole(final String role) {
+        public TokenRequest role(final String role) {
             this.role = role;
             return this;
         }
@@ -259,14 +257,14 @@ public AuthResponse createToken(
     ) throws VaultException {
         return createToken(
                 new TokenRequest()
-                        .withId(id)
-                        .withPolices(policies)
-                        .withMeta(meta)
-                        .withNoParent(noParent)
-                        .withNoDefaultPolicy(noDefaultPolicy)
-                        .withTtl(ttl)
-                        .withDisplayName(displayName)
-                        .withNumUses(numUses));
+                        .id(id)
+                        .polices(policies)
+                        .meta(meta)
+                        .noParent(noParent)
+                        .noDefaultPolicy(noDefaultPolicy)
+                        .ttl(ttl)
+                        .displayName(displayName)
+                        .numUses(numUses));
     }
 
 

src/test-integration/README.md

@@ -3,78 +3,21 @@ Intro
 Unit tests, which do not rely on a Vault server being available, are separated from
 these integration tests, which do require a Vault instance.
 
-Configuring a Vault Server
-==========================
-It's not necessary to have a production-grade Vault server.  To run these tests, you
-can simply run a [Dev Server](https://www.vaultproject.io/intro/getting-started/dev-server.html)
-process:
+Running the Integration Tests
+=============================
+Originally this test suite required a decent amount of manual setup.  You had to run and configure a Vault server 
+instance on your machine, and populate several environment variables with values that would be picked up by the 
+tests.
 
-```
-$ vault server -dev`
+Since then, the tests have been modified to work with [TestContainers](https://www.testcontainers.org/), a Java 
+library that efficiently manages Docker containers and makes them available to JUnit tests.  So now, setup of the 
+Vault server instance is entirely automated, and dealt with by the test suite itself.
 
-==> WARNING: Dev mode is enabled!
+However, to run these tests you do need to have a current version of Docker installed on your machine.  This is 
+supported for Linux, OS X, and Windows, although the details vary significantly between those operating systems.
+See the [Docker website](https://www.docker.com/) for information on installing Docker on your OS, after checking 
+also with the TestContainers website for OS-specific caveats (Windows in particular).
 
-In this mode, Vault is completely in-memory and unsealed.
-Vault is configured to only have a single unseal key. The root
-token has already been authenticated with the CLI, so you can
-immediately begin using the Vault CLI.
+With Docker installed on your machine, you can run this test suite using the `integrationTest` Gradle task:
 
-The only step you need to take is to set the following
-environment variables:
-
-    set VAULT_ADDR=http://127.0.0.1:8200
-
-The unseal key and root token are reproduced below in case you
-want to seal/unseal the Vault or play with authentication.
-
-Unseal Key: 642e33b1c397c292743df56da6129a25df6a6349934931f55a2baac34a6e2c80
-Root Token: 764cf317-d3b9-3d52-dc7d-e4f0198f6a8c
-
-...
-```
-
-Some of the integration tests verify that an authentication  token can be retrieved
-from various auth backends (e.g. [App Id](https://www.vaultproject.io/docs/auth/app-id.html),
-[Username & Password](https://www.vaultproject.io/docs/auth/userpass.html), etc).
-So prior to running these tests, you will need to run some Vault CLI commands to
-enable auth backends and populate user and app data:
-
-```
-vault auth-enable app-id
-vault write auth/app-id/map/app-id/fake_app display_name=fake_app
-vault write auth/app-id/map/user-id/fake_user value=fake_app
-
-vault auth-enable userpass
-vault write auth/userpass/users/fake_user password=fake_password
-
-vault mount -path=pki pki
-vault mount -path=other-pki pki
-vault write pki/root/generate/internal common_name=myvault.com ttl=99h
-
-vault auth-enable approle
-vault write auth/approle/role/testrole secret_id_ttl=10m token_ttl=20m token_max_ttl=30m secret_id_num_uses=40
-```
-
-Configuring and Running the Integration Tests
-=============================================
-The Gradle `integrationTest` task is used to execute the integration test suite.
-When running this Gradle task, you need to pass several JVM options so that Gradle
-will make them available to the tests:
-
-* `VAULT_ADDR`: The connection URL for the Vault server.  The Dev Server displays
-  this when the server starts up (e.g. `http://127.0.0.1:8200`) in the example above.
-* `VAULT_TOKEN`: The root token, to enable Vault API calls.  The Dev Server also
-  displays this at startup (e.g. `764cf317-d3b9-3d52-dc7d-e4f0198f6a8c` in the
-  example above).
-* `VAULT_APP_ID`: An application ID that has been created in the Vault server,
-  for testing the App Id auth backend.  This can be whatever you populate (e.g.
-  `fake_app` in the example CLI command above).
-* `VAULT_USER_ID`: A user ID that has been created in the Vault server, for testing
-  the Username and Password auth backend.  This can be whatever you populate (e.g.
-  `fake_user` in the example CLI command above).
-* `VAULT_PASSWORD`: The password corresponding to the above user (e.g. `fake_password`
-  in the CLI command above).
-
-Example Gradle invocation:
-
-`$ gradle integrationTest -DVAULT_ADDR=http://127.0.0.1:8200 -DVAULT_TOKEN=764cf317-d3b9-3d52-dc7d-e4f0198f6a8c -DVAULT_APP_ID=fake_app -DVAULT_USER_ID=fake_user -DVAULT_PASSWORD=fake_password`
+`$ ./gradlew integrationTest`