diff --git a/src/main/java/de/stklcode/jvault/connector/model/AuthBackend.java b/src/main/java/de/stklcode/jvault/connector/model/AuthBackend.java index afd6318..2050e53 100644 --- a/src/main/java/de/stklcode/jvault/connector/model/AuthBackend.java +++ b/src/main/java/de/stklcode/jvault/connector/model/AuthBackend.java @@ -27,6 +27,7 @@ public enum AuthBackend { APPID("app-id"), APPROLE("approle"), USERPASS("userpass"), + GITHUB("github"), // Not supported yet. UNKNOWN(""); private final String type; diff --git a/src/main/java/de/stklcode/jvault/connector/model/response/AuthMethodsResponse.java b/src/main/java/de/stklcode/jvault/connector/model/response/AuthMethodsResponse.java index 3c4684c..a7d8cf3 100644 --- a/src/main/java/de/stklcode/jvault/connector/model/response/AuthMethodsResponse.java +++ b/src/main/java/de/stklcode/jvault/connector/model/response/AuthMethodsResponse.java @@ -45,11 +45,10 @@ public final class AuthMethodsResponse extends VaultDataResponse { @Override public void setData(final Map data) throws InvalidResponseException { ObjectMapper mapper = new ObjectMapper(); - for (String path : data.keySet()) { + for (Map.Entry entry : data.entrySet()) { try { - this.supportedMethods.put( - path, mapper.readValue(mapper.writeValueAsString(data.get(path)), - AuthMethod.class)); + this.supportedMethods.put(entry.getKey(), + mapper.readValue(mapper.writeValueAsString(entry.getValue()), AuthMethod.class)); } catch (IOException e) { throw new InvalidResponseException(); } diff --git a/src/test/java/de/stklcode/jvault/connector/model/AuthBackendTest.java b/src/test/java/de/stklcode/jvault/connector/model/AuthBackendTest.java index 0917cbf..b1ef34d 100644 --- a/src/test/java/de/stklcode/jvault/connector/model/AuthBackendTest.java +++ b/src/test/java/de/stklcode/jvault/connector/model/AuthBackendTest.java @@ -37,6 +37,7 @@ public class AuthBackendTest { assertThat(AuthBackend.forType("token"), is(AuthBackend.TOKEN)); assertThat(AuthBackend.forType("app-id"), is(AuthBackend.APPID)); assertThat(AuthBackend.forType("userpass"), is(AuthBackend.USERPASS)); + assertThat(AuthBackend.forType("github"), is(AuthBackend.GITHUB)); assertThat(AuthBackend.forType(""), is(AuthBackend.UNKNOWN)); assertThat(AuthBackend.forType("foobar"), is(AuthBackend.UNKNOWN)); } diff --git a/src/test/java/de/stklcode/jvault/connector/model/response/AuthMethodsResponseTest.java b/src/test/java/de/stklcode/jvault/connector/model/response/AuthMethodsResponseTest.java new file mode 100644 index 0000000..8a55c04 --- /dev/null +++ b/src/test/java/de/stklcode/jvault/connector/model/response/AuthMethodsResponseTest.java @@ -0,0 +1,114 @@ +package de.stklcode.jvault.connector.model.response; + +import com.fasterxml.jackson.databind.ObjectMapper; +import de.stklcode.jvault.connector.exception.InvalidResponseException; +import de.stklcode.jvault.connector.model.AuthBackend; +import de.stklcode.jvault.connector.model.response.embedded.AuthData; +import de.stklcode.jvault.connector.model.response.embedded.AuthMethod; +import org.junit.Test; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.hamcrest.Matchers.*; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.fail; + +/** + * JUnit Test for {@link AuthMethodsResponse} model. + * + * @author Stefan Kalscheuer + * @since 0.6.2 + */ +public class AuthMethodsResponseTest { + private static final String GH_PATH = "github/"; + private static final String GH_TYPE = "github"; + private static final String GH_DESCR = "GitHub auth"; + private static final String TK_PATH = "token/"; + private static final String TK_TYPE = "token"; + private static final String TK_DESCR = "token based credentials"; + private static final Integer TK_LEASE_TTL = 0; + private static final Integer TK_MAX_LEASE_TTL = 0; + + private static final String RES_JSON = "{\n" + + " \"data\": {" + + " \"" + GH_PATH + "\": {\n" + + " \"type\": \"" + GH_TYPE + "\",\n" + + " \"description\": \"" + GH_DESCR + "\"\n" + + " },\n" + + " \"" + TK_PATH + "\": {\n" + + " \"config\": {\n" + + " \"default_lease_ttl\": " + TK_LEASE_TTL + ",\n" + + " \"max_lease_ttl\": " + TK_MAX_LEASE_TTL + "\n" + + " },\n" + + " \"description\": \"" + TK_DESCR + "\",\n" + + " \"type\": \"" + TK_TYPE + "\"\n" + + " }\n" + + " }\n" + + "}"; + + private static final Map INVALID_DATA = new HashMap<>(); + + static { + INVALID_DATA.put("dummy/", new Dummy()); + } + + /** + * Test getter, setter and get-methods for response data. + */ + @Test + public void getDataRoundtrip() { + // Create empty Object. + AuthMethodsResponse res = new AuthMethodsResponse(); + assertThat("Initial method map should be empty", res.getSupportedMethods(), is(anEmptyMap())); + + // Parsing invalid data map should fail. + try { + res.setData(INVALID_DATA); + fail("Parsing invalid data succeeded"); + } catch (Exception e) { + assertThat(e, is(instanceOf(InvalidResponseException.class))); + } + } + + /** + * Test creation from JSON value as returned by Vault (JSON example copied from Vault documentation). + */ + @Test + public void jsonRoundtrip() { + try { + AuthMethodsResponse res = new ObjectMapper().readValue(RES_JSON, AuthMethodsResponse.class); + assertThat("Parsed response is NULL", res, is(notNullValue())); + // Extract auth data. + Map supported = res.getSupportedMethods(); + assertThat("Auth data is NULL", supported, is(notNullValue())); + assertThat("Incorrect number of supported methods", supported.entrySet(), hasSize(2)); + assertThat("Incorrect method paths", supported.keySet(), containsInAnyOrder(GH_PATH, TK_PATH)); + + // Verify first method. + AuthMethod method = supported.get(GH_PATH); + assertThat("Incorrect raw type for GitHub", method.getRawType(), is(GH_TYPE)); + assertThat("Incorrect parsed type for GitHub", method.getType(), is(AuthBackend.GITHUB)); + assertThat("Incorrect description for GitHub", method.getDescription(), is(GH_DESCR)); + assertThat("Unexpected config for GitHub", method.getConfig(), is(nullValue())); + + // Verify first method. + method = supported.get(TK_PATH); + assertThat("Incorrect raw type for Token", method.getRawType(), is(TK_TYPE)); + assertThat("Incorrect parsed type for Token", method.getType(), is(AuthBackend.TOKEN)); + assertThat("Incorrect description for Token", method.getDescription(), is(TK_DESCR)); + assertThat("Missing config for Token", method.getConfig(), is(notNullValue())); + assertThat("Unexpected config size for Token", method.getConfig().keySet(), hasSize(2)); + assertThat("Incorrect lease TTL config", method.getConfig().get("default_lease_ttl"), is(TK_LEASE_TTL.toString())); + assertThat("Incorrect max lease TTL config", method.getConfig().get("max_lease_ttl"), is(TK_MAX_LEASE_TTL.toString())); + } catch (IOException e) { + fail("AuthResponse deserialization failed: " + e.getMessage()); + } + } + + private static class Dummy { + + } +}