diff --git a/src/main/java/com/bunq/sdk/http/ApiClient.java b/src/main/java/com/bunq/sdk/http/ApiClient.java index dc1b0727..7ed201b9 100644 --- a/src/main/java/com/bunq/sdk/http/ApiClient.java +++ b/src/main/java/com/bunq/sdk/http/ApiClient.java @@ -47,7 +47,6 @@ public class ApiClient { * Error constants. */ private static final String ERROR_AMI_ENVIRONMENT_NOT_EXPECTED = "ApiEnvironment type \"%s\" is unexpected"; - private static final String ERROR_COULD_NOT_DETERMINE_RESPONSE_ID = "Could not determine response id."; /** * Endpoints not requiring active session for the request to succeed. @@ -61,40 +60,12 @@ public class ApiClient { SESSION_SERVER_URL ); - /** - * Header constants. - */ - public static final String HEADER_ATTACHMENT_DESCRIPTION = "X-Bunq-Attachment-Description"; - public static final String HEADER_CONTENT_TYPE = "Content-Type"; - public static final String HEADER_USER_AGENT = "User-Agent"; - public static final String HEADER_CACHE_CONTROL = "Cache-Control"; - public static final String HEADER_LANGUAGE = "X-Bunq-Language"; - public static final String HEADER_REGION = "X-Bunq-Region"; - public static final String HEADER_REQUEST_ID = "X-Bunq-Client-Request-Id"; - public static final String HEADER_GEOLOCATION = "X-Bunq-Geolocation"; - private static final String HEADER_SIGNATURE = "X-Bunq-Client-Signature"; - private static final String HEADER_AUTHENTICATION = "X-Bunq-Client-Authentication"; - private static final String HEADER_RESPONSE_ID_LOWER_CASE = "x-bunq-client-response-id"; - private static final String HEADER_RESPONSE_ID_UPPER_CASE = "X-Bunq-Client-Response-Id"; - /** * Field constants. */ private static final String FIELD_ERROR = "Error"; private static final String FIELD_ERROR_DESCRIPTION = "error_description"; - /** - * Header value to disable the cache control. - */ - public static final String CACHE_CONTROL_NONE = "no-cache"; - - /** - * Prefix for bunq's own headers. - */ - private static final String USER_AGENT_BUNQ = "bunq-sdk-java/0.13.1"; - public static final String LANGUAGE_EN_US = "en_US"; - public static final String REGION_NL_NL = "nl_NL"; - public static final String GEOLOCATION_ZERO = "0 0 0 0 000"; private static final String SCHEME_HTTPS = "https"; /** @@ -193,9 +164,9 @@ public BunqResponseRaw post( BunqRequestBody bunqRequestBody = BunqRequestBody.create(ContentType.JSON.getMediaType(), requestBodyBytes); - if (customHeaders.containsKey(HEADER_CONTENT_TYPE)) { + if (customHeaders.containsKey(BunqHeader.contentType.getHeader())) { bunqRequestBody = BunqRequestBody.create( - MediaType.parse(customHeaders.get(HEADER_CONTENT_TYPE)), + MediaType.parse(customHeaders.get(BunqHeader.contentType.getHeader())), requestBodyBytes ); } @@ -262,13 +233,13 @@ private void setHeaders(BunqRequestBuilder requestBuilder, Map c /** */ - private void setDefaultHeaders(Request.Builder httpEntity) { - httpEntity.addHeader(HEADER_CACHE_CONTROL, CACHE_CONTROL_NONE); - httpEntity.addHeader(HEADER_USER_AGENT, getVersion()); - httpEntity.addHeader(HEADER_LANGUAGE, LANGUAGE_EN_US); - httpEntity.addHeader(HEADER_REGION, REGION_NL_NL); - httpEntity.addHeader(HEADER_REQUEST_ID, UUID.randomUUID().toString()); - httpEntity.addHeader(HEADER_GEOLOCATION, GEOLOCATION_ZERO); + private void setDefaultHeaders(BunqRequestBuilder httpEntity) { + BunqHeader.cacheControl.addTo(httpEntity); + BunqHeader.userAgent.addTo(httpEntity); + BunqHeader.language.addTo(httpEntity); + BunqHeader.region.addTo(httpEntity); + BunqHeader.clientRequestId.addTo(httpEntity, UUID.randomUUID().toString()); + BunqHeader.geolocation.addTo(httpEntity); } /** @@ -285,8 +256,8 @@ private void setSessionHeaders(BunqRequestBuilder requestBuilder) { String sessionToken = apiContext.getSessionToken(); if (sessionToken != null) { - requestBuilder.addHeader(HEADER_AUTHENTICATION, sessionToken); - requestBuilder.addHeader(HEADER_SIGNATURE, generateSignature(requestBuilder)); + BunqHeader.clientAuthentication.addTo(requestBuilder, sessionToken); + BunqHeader.clientSignature.addTo(requestBuilder, generateSignature(requestBuilder)); } } @@ -297,12 +268,6 @@ private String generateSignature(BunqRequestBuilder requestBuilder) { apiContext.getInstallationContext().getKeyPairClient()); } - /** - */ - private String getVersion() { - return USER_AGENT_BUNQ; - } - /** */ private BunqResponseRaw createBunqResponseRaw(Response response) @@ -321,9 +286,7 @@ private BunqResponseRaw createBunqResponseRaw(Response response) private static String getResponseId(Response response) { Map headerMap = getHeadersMap(response); - if (headerMap.containsKey(HEADER_RESPONSE_ID_LOWER_CASE)) { - return headerMap.get(HEADER_RESPONSE_ID_LOWER_CASE); - } else return headerMap.getOrDefault(HEADER_RESPONSE_ID_UPPER_CASE, ERROR_COULD_NOT_DETERMINE_RESPONSE_ID); + return BunqHeader.clientResponseId.getOrDefault(headerMap); } /** diff --git a/src/main/java/com/bunq/sdk/http/BunqBasicHeader.java b/src/main/java/com/bunq/sdk/http/BunqBasicHeader.java index dc089ae8..b2672c7c 100644 --- a/src/main/java/com/bunq/sdk/http/BunqBasicHeader.java +++ b/src/main/java/com/bunq/sdk/http/BunqBasicHeader.java @@ -1,26 +1,70 @@ package com.bunq.sdk.http; -public class BunqBasicHeader { - private String name; - private String value; +import okhttp3.Response; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +public class BunqBasicHeader { /** + * String format constants for signing data */ - public BunqBasicHeader(String name, String value) { + private static final String DELIMITER_HEADER_NAME_AND_VALUE = ": "; + private static final String NEWLINE = "\n"; + + private final BunqHeader name; + private final String value; + + public static BunqBasicHeader get(BunqHeader header, Response response) { + return new BunqBasicHeader(header, response.header(header.getHeader())); + } + + public BunqBasicHeader(BunqHeader name, String value) { this.name = name; this.value = value; } - /** - */ - public String getName() { + public BunqHeader getName() { return name; } - /** - */ public String getValue() { return value; } + private String forSigning() { + return getName().getHeader() + DELIMITER_HEADER_NAME_AND_VALUE + getValue(); + } + + public static String collectForSigning( + Collection headers, + BunqHeader exclude, + Collection includes) { + List headersForSigning = new ArrayList(); + + for (BunqBasicHeader header:headers) { + if (!header.getName().isBunq() && !includes.contains(header.getName())) { + continue; + } + + if (exclude != null && exclude.equals(header.getName())) { + continue; + } + + headersForSigning.add(header.forSigning()); + } + + Collections.sort(headersForSigning); + + StringBuffer stringBuffer = new StringBuffer(); + + for (String header:headersForSigning) { + stringBuffer.append(header); + stringBuffer.append(NEWLINE); + } + + return stringBuffer.toString(); + } } diff --git a/src/main/java/com/bunq/sdk/http/BunqHeader.java b/src/main/java/com/bunq/sdk/http/BunqHeader.java new file mode 100644 index 00000000..519df850 --- /dev/null +++ b/src/main/java/com/bunq/sdk/http/BunqHeader.java @@ -0,0 +1,100 @@ +package com.bunq.sdk.http; + +import java.util.Collection; +import java.util.Map; + +public enum BunqHeader { + attachmentDescription("X-Bunq-Attachment-Description"), + cacheControl("Cache-Control", "no-cache"), + contentType("Content-Type"), + clientAuthentication("X-Bunq-Client-Authentication"), + clientEncryptionHMAC("X-Bunq-Client-Encryption-Hmac"), + clientEncryptionIV("X-Bunq-Client-Encryption-Iv"), + clientEncryptionKey("X-Bunq-Client-Encryption-Key"), + clientRequestId("X-Bunq-Client-Request-Id"), + clientSignature("X-Bunq-Client-Signature"), + clientResponseId("X-Bunq-Client-Response-Id", "Could not determine response id."), + geolocation("X-Bunq-Geolocation", "0 0 0 0 000"), + language("X-Bunq-Language", "en_US"), + region("X-Bunq-Region", "nl_NL"), + serverSignature("X-Bunq-Server-Signature"), + userAgent("User-Agent", "bunq-sdk-java/0.13.1"); + + private static final String PREFIX = "X-Bunq-"; + + private final String header; + private final String defaultValue; + + BunqHeader(String header) { + this(header, null); + } + + BunqHeader(String header, String defaultValue) { + this.header = header; + this.defaultValue = defaultValue; + } + + public static BunqHeader parse(String value) { + for (BunqHeader header:values()) { + if (header.equals(value)) { + return header; + } + } + + return null; + } + + public String getHeader() { + return header; + } + + public String getDefaultValue() { + return defaultValue; + } + + private String getOrDefault(String value) { + if (value != null) { + return value; + } + + return getDefaultValue(); + } + + public void addTo(Map headers, String value) { + headers.put(getHeader(), getOrDefault(value)); + } + + public void addTo(BunqRequestBuilder requestBuilder) { + addTo(requestBuilder, null); + } + + public void addTo(BunqRequestBuilder requestBuilder, String value) { + requestBuilder.addHeader(getHeader(), getOrDefault(value)); + } + + public boolean equals(String header) { + return getHeader().equalsIgnoreCase(header); + } + + public boolean isBunq() { + return getHeader().startsWith(PREFIX); + } + + private String findKey(Collection keys) { + for (String key:keys) { + if (this.equals(key)) { + return key; + } + } + + return null; + } + + public String getOrDefault(Map headers) { + String key = findKey(headers.keySet()); + if (key != null && headers.get(key) != null) { + return headers.get(key); + } + return getDefaultValue(); + } +} diff --git a/src/main/java/com/bunq/sdk/http/BunqRequestBuilder.java b/src/main/java/com/bunq/sdk/http/BunqRequestBuilder.java index 5aa2c3b1..a52dd82c 100644 --- a/src/main/java/com/bunq/sdk/http/BunqRequestBuilder.java +++ b/src/main/java/com/bunq/sdk/http/BunqRequestBuilder.java @@ -75,12 +75,20 @@ public BunqRequestBuilder url(URL url) { return (BunqRequestBuilder) super.url(url); } + private void addToAllHeader(String name, String value) { + BunqHeader header = BunqHeader.parse(name); + + if (header != null) { + this.allHeader.add(new BunqBasicHeader(header, value)); + } + } + /** * {@inheritDoc} */ @Override public BunqRequestBuilder header(String name, String value) { - this.allHeader.add(new BunqBasicHeader(name, value)); + addToAllHeader(name, value); return (BunqRequestBuilder) super.header(name, value); } @@ -90,7 +98,7 @@ public BunqRequestBuilder header(String name, String value) { */ @Override public BunqRequestBuilder addHeader(String name, String value) { - this.allHeader.add(new BunqBasicHeader(name, value)); + addToAllHeader(name, value); return (BunqRequestBuilder) super.addHeader(name, value); } @@ -205,13 +213,7 @@ public BunqRequestBody getBody() { /** */ - public List getAllHeaderAsList() { + public List getAllHeader() { return this.allHeader; } - - /** - */ - public BunqBasicHeader[] getAllHeaderAsArray() { - return this.allHeader.toArray(new BunqBasicHeader[this.allHeader.size()]); - } } diff --git a/src/main/java/com/bunq/sdk/security/SecurityUtils.java b/src/main/java/com/bunq/sdk/security/SecurityUtils.java index 4ac676ee..484ce31d 100644 --- a/src/main/java/com/bunq/sdk/security/SecurityUtils.java +++ b/src/main/java/com/bunq/sdk/security/SecurityUtils.java @@ -3,8 +3,8 @@ import com.bunq.sdk.context.ApiContext; import com.bunq.sdk.exception.BunqException; import com.bunq.sdk.exception.UncaughtExceptionError; -import com.bunq.sdk.http.ApiClient; import com.bunq.sdk.http.BunqBasicHeader; +import com.bunq.sdk.http.BunqHeader; import com.bunq.sdk.http.BunqRequestBuilder; import com.bunq.sdk.http.HttpMethod; import okhttp3.Headers; @@ -36,11 +36,9 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Base64; +import java.util.Collections; import java.util.List; import java.util.Map; -import java.util.regex.Matcher; -import java.util.regex.Pattern; -import java.util.stream.Collectors; /** * Static lib containing methods for handling encryption. @@ -72,14 +70,6 @@ public final class SecurityUtils { private static final String SIGNATURE_ALGORITHM = "SHA256withRSA"; private static final int KEY_PAIR_GENERATOR_KEY_SIZE = 2048; - /** - * Encryption-specific headers. - */ - private static final String HEADER_CLIENT_ENCRYPTION_HMAC = "X-Bunq-Client-Encryption-Hmac"; - private static final String HEADER_CLIENT_ENCRYPTION_IV = "X-Bunq-Client-Encryption-Iv"; - private static final String HEADER_CLIENT_ENCRYPTION_KEY = "X-Bunq-Client-Encryption-Key"; - private static final String HEADER_SERVER_SIGNATURE = "X-Bunq-Server-Signature"; - /** * The MAC algorithm to use for calculating and verifying the HMAC. */ @@ -139,26 +129,13 @@ public final class SecurityUtils { /** * Delimiter constants for building the data to sign. */ - private static final String HEADER_NAME_PREFIX_X_BUNQ = "X-Bunq-"; private static final String DELIMITER_METHOD_PATH = " "; - private static final String DELIMITER_HEADER_NAME_AND_VALUE = ": "; - - /** - * Regex constants. - */ - private static final String REGEX_FOR_LOWERCASE_HEADERS = "(-[a-z])"; /** * The index of the first item in an array. */ private static final int INDEX_FIRST = 0; - /** - * Substring constants. - */ - private static final int SUBSTRING_BEGIN_INDEX_FIRST_CHAR = 0; - private static final int SUBSTRING_END_INDEX_FIRST_CHAR = 1; - /** */ private SecurityUtils() { @@ -315,7 +292,7 @@ private static void addHeaderClientEncryptionKey(ApiContext apiContext, SecretKe cipher.init(Cipher.ENCRYPT_MODE, apiContext.getInstallationContext().getPublicKeyServer()); byte[] keyEncrypted = cipher.doFinal(key.getEncoded()); String keyEncryptedEncoded = Base64.getEncoder().encodeToString(keyEncrypted); - customHeaders.put(HEADER_CLIENT_ENCRYPTION_KEY, keyEncryptedEncoded); + BunqHeader.clientEncryptionKey.addTo(customHeaders, keyEncryptedEncoded); } catch (GeneralSecurityException exception) { throw new BunqException(exception.getMessage()); } @@ -324,8 +301,7 @@ private static void addHeaderClientEncryptionKey(ApiContext apiContext, SecretKe private static void addHeaderClientEncryptionIv(byte[] initializationVector, Map customHeaders) { String initializationVectorEncoded = Base64.getEncoder().encodeToString(initializationVector); - - customHeaders.put(HEADER_CLIENT_ENCRYPTION_IV, initializationVectorEncoded); + BunqHeader.clientEncryptionIV.addTo(customHeaders, initializationVectorEncoded); } private static byte[] encryptRequestBytes(byte[] requestBytes, SecretKey key, @@ -358,7 +334,7 @@ private static void addHeaderClientEncryptionHmac(byte[] requestBytes, bufferedSink.close(); byte[] hmac = mac.doFinal(); String hmacEncoded = Base64.getEncoder().encodeToString(hmac); - customHeaders.put(HEADER_CLIENT_ENCRYPTION_HMAC, hmacEncoded); + BunqHeader.clientEncryptionHMAC.addTo(customHeaders, hmacEncoded); } catch (GeneralSecurityException | IOException exception) { throw new BunqException(exception.getMessage()); } @@ -412,16 +388,11 @@ private static byte[] getEntityBodyBytes(BunqRequestBuilder requestBuilder) thro } private static String generateRequestHeadersSortedString(BunqRequestBuilder bunqRequestBuilder) { - return Arrays.stream(bunqRequestBuilder.getAllHeaderAsArray()) - .filter( - header -> - header.getName().startsWith(HEADER_NAME_PREFIX_X_BUNQ) || - header.getName().equals(ApiClient.HEADER_CACHE_CONTROL) || - header.getName().equals(ApiClient.HEADER_USER_AGENT) - ) - .map(header -> header.getName() + DELIMITER_HEADER_NAME_AND_VALUE + header.getValue()) - .sorted() - .collect(Collectors.joining(NEWLINE)); + return BunqBasicHeader.collectForSigning( + bunqRequestBuilder.getAllHeader(), + null, + Arrays.asList(BunqHeader.cacheControl, BunqHeader.userAgent) + ); } /** @@ -496,11 +467,9 @@ public static void validateResponseSignature( response.headers() ); Signature signature = getSignatureInstance(); - BunqBasicHeader headerServerSignature = new BunqBasicHeader( - HEADER_SERVER_SIGNATURE, - response.header(HEADER_SERVER_SIGNATURE) - ); - byte[] serverSignatureBase64Bytes = headerServerSignature.getValue().getBytes(); + BunqBasicHeader serverSignature = BunqBasicHeader.get(BunqHeader.serverSignature, response); + + byte[] serverSignatureBase64Bytes = serverSignature.getValue().getBytes(); byte[] serverSignatureDecoded = Base64.getDecoder().decode(serverSignatureBase64Bytes); verifyDataSigned(signature, keyPublicServer, responseBytes, serverSignatureDecoded); } @@ -514,23 +483,15 @@ private static byte[] getResponseBytes( List allResponseHeader = new ArrayList<>(); for (int i = INDEX_FIRST; i < allHeader.names().size(); i++) { - if (allHeader.name(i).equals(HEADER_SERVER_SIGNATURE)) { - continue; - } + BunqHeader header = BunqHeader.parse(allHeader.name(i)); - allResponseHeader.add(new BunqBasicHeader( - getHeaderNameCorrectlyCased(allHeader.name(i)), - allHeader.get(allHeader.name(i)) - )); + if (header != null && !BunqHeader.serverSignature.equals(header)) { + allResponseHeader.add(new BunqBasicHeader(header, allHeader.get(allHeader.name(i)))); + } } try { - outputStream.write( - getResponseHeadBytes( - responseCode, - allResponseHeader.toArray(new BunqBasicHeader[allResponseHeader.size()]) - ) - ); + outputStream.write(getResponseHeadBytes(responseCode, allResponseHeader)); outputStream.write(responseBodyBytes); } catch (IOException exception) { throw new UncaughtExceptionError(exception); @@ -539,38 +500,18 @@ private static byte[] getResponseBytes( return outputStream.toByteArray(); } - private static String getHeaderNameCorrectlyCased(String headerName) { - headerName = headerName.toLowerCase(); - headerName = headerName.substring(SUBSTRING_BEGIN_INDEX_FIRST_CHAR, SUBSTRING_END_INDEX_FIRST_CHAR).toUpperCase() - + headerName.substring(SUBSTRING_END_INDEX_FIRST_CHAR); - Pattern pattern = Pattern.compile(REGEX_FOR_LOWERCASE_HEADERS); - Matcher matcher = pattern.matcher(headerName); - - while (matcher.find()) { - String result = matcher.group(); - headerName = headerName.replace(result, result.toUpperCase()); - } - - return headerName; - } - - private static byte[] getResponseHeadBytes(int responseCode, BunqBasicHeader[] responseHeaders) { - String requestHeadString = responseCode + NEWLINE + - generateResponseHeadersSortedString(responseHeaders) + NEWLINE + NEWLINE; + private static byte[] getResponseHeadBytes(int code, List headers) { + String requestHeadString = code + NEWLINE + + generateResponseHeadersSortedString(headers) + NEWLINE + NEWLINE; return requestHeadString.getBytes(); } - private static String generateResponseHeadersSortedString(BunqBasicHeader[] responseHeaders) { - return Arrays.stream(responseHeaders) - .filter( - header -> - header.getName().startsWith(HEADER_NAME_PREFIX_X_BUNQ) && - !header.getName().equals(HEADER_SERVER_SIGNATURE) - ) - .map(header -> header.getName() + DELIMITER_HEADER_NAME_AND_VALUE + header.getValue()) - .sorted() - .collect(Collectors.joining(NEWLINE)); + private static String generateResponseHeadersSortedString(List headers) { + return BunqBasicHeader.collectForSigning( + headers, + BunqHeader.serverSignature, + Collections.emptyList() + ); } - } diff --git a/src/test/java/com/bunq/sdk/BunqSdkTestBase.java b/src/test/java/com/bunq/sdk/BunqSdkTestBase.java index 96b199f5..825bf36d 100644 --- a/src/test/java/com/bunq/sdk/BunqSdkTestBase.java +++ b/src/test/java/com/bunq/sdk/BunqSdkTestBase.java @@ -4,7 +4,7 @@ import com.bunq.sdk.context.ApiEnvironmentType; import com.bunq.sdk.context.BunqContext; import com.bunq.sdk.exception.BunqException; -import com.bunq.sdk.http.ApiClient; +import com.bunq.sdk.http.BunqHeader; import com.bunq.sdk.http.BunqResponse; import com.bunq.sdk.model.generated.endpoint.CashRegister; import com.bunq.sdk.model.generated.endpoint.MonetaryAccountBank; @@ -121,11 +121,11 @@ private static SandboxUser generateNewSandboxUser() { URL_PATH_SANDBOX_USER ) .post(RequestBody.create(null, new byte[INDEX_FIRST])) - .addHeader(ApiClient.HEADER_REQUEST_ID, UUID.randomUUID().toString()) - .addHeader(ApiClient.HEADER_CACHE_CONTROL, ApiClient.CACHE_CONTROL_NONE) - .addHeader(ApiClient.HEADER_GEOLOCATION, ApiClient.GEOLOCATION_ZERO) - .addHeader(ApiClient.HEADER_LANGUAGE, ApiClient.LANGUAGE_EN_US) - .addHeader(ApiClient.HEADER_REGION, ApiClient.REGION_NL_NL) + .addHeader(BunqHeader.clientRequestId.getHeader(), UUID.randomUUID().toString()) + .addHeader(BunqHeader.cacheControl.getHeader(), BunqHeader.cacheControl.getDefaultValue()) + .addHeader(BunqHeader.geolocation.getHeader(), BunqHeader.geolocation.getDefaultValue()) + .addHeader(BunqHeader.language.getHeader(), BunqHeader.language.getDefaultValue()) + .addHeader(BunqHeader.region.getHeader(), BunqHeader.region.getDefaultValue()) .build(); try { diff --git a/src/test/java/com/bunq/sdk/http/BunqHeaderTest.java b/src/test/java/com/bunq/sdk/http/BunqHeaderTest.java new file mode 100644 index 00000000..ddaf0c78 --- /dev/null +++ b/src/test/java/com/bunq/sdk/http/BunqHeaderTest.java @@ -0,0 +1,69 @@ +package com.bunq.sdk.http; + +import java.util.Collections; +import java.util.Map; +import java.util.HashMap; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public class BunqHeaderTest { + @Test + public void parse() { + // parse works case-insensitive + assertEquals(BunqHeader.clientResponseId, BunqHeader.parse("X-Bunq-Client-Response-Id")); + assertEquals(BunqHeader.clientResponseId, BunqHeader.parse("x-bunq-client-response-id")); + } + + @Test + public void isBunq() { + assertFalse(BunqHeader.cacheControl.isBunq()); + assertFalse(BunqHeader.contentType.isBunq()); + assertFalse(BunqHeader.userAgent.isBunq()); + + assertTrue(BunqHeader.attachmentDescription.isBunq()); + assertTrue(BunqHeader.clientAuthentication.isBunq()); + assertTrue(BunqHeader.clientEncryptionHMAC.isBunq()); + assertTrue(BunqHeader.clientEncryptionIV.isBunq()); + assertTrue(BunqHeader.clientEncryptionIV.isBunq()); + assertTrue(BunqHeader.clientEncryptionKey.isBunq()); + assertTrue(BunqHeader.clientRequestId.isBunq()); + assertTrue(BunqHeader.clientSignature.isBunq()); + assertTrue(BunqHeader.clientResponseId.isBunq()); + assertTrue(BunqHeader.geolocation.isBunq()); + assertTrue(BunqHeader.region.isBunq()); + assertTrue(BunqHeader.serverSignature.isBunq()); + assertTrue(BunqHeader.clientEncryptionKey.isBunq()); + assertTrue(BunqHeader.clientRequestId.isBunq()); + } + + @Test + public void getOrDefault() { + BunqHeader h = BunqHeader.clientResponseId; + + assertEquals("test-id", + h.getOrDefault(Collections.singletonMap("x-bunq-client-response-id", "test-id"))); + assertEquals("Could not determine response id.", + h.getOrDefault(Collections.singletonMap("x-bunq-some-other-header", "test-id"))); + assertEquals("Could not determine response id.", + h.getOrDefault(Collections.emptyMap())); + } + + @Test + public void addToMap() { + Map headers = new HashMap<>(); + + //sut + BunqHeader.language.addTo(headers, null); + BunqHeader.geolocation.addTo(headers, null); + BunqHeader.userAgent.addTo(headers, "test-agent"); + + // verify + assertEquals("en_US", headers.get("X-Bunq-Language")); + assertEquals("0 0 0 0 000", headers.get("X-Bunq-Geolocation")); + assertEquals("test-agent", headers.get("User-Agent")); + } +} diff --git a/src/test/java/com/bunq/sdk/model/generated/endpoint/AttachmentPublicTest.java b/src/test/java/com/bunq/sdk/model/generated/endpoint/AttachmentPublicTest.java index f45e791d..866d34d2 100644 --- a/src/test/java/com/bunq/sdk/model/generated/endpoint/AttachmentPublicTest.java +++ b/src/test/java/com/bunq/sdk/model/generated/endpoint/AttachmentPublicTest.java @@ -3,12 +3,14 @@ import com.bunq.sdk.BunqSdkTestBase; import com.bunq.sdk.exception.BunqException; import com.bunq.sdk.http.ApiClient; +import com.bunq.sdk.http.BunqHeader; import org.apache.commons.io.FileUtils; import org.junit.Test; import java.io.File; import java.io.IOException; import java.util.HashMap; +import java.util.Map; import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; @@ -36,13 +38,12 @@ private static byte[] getRequestBytes() { } private static String uploadFileAndGetUuid() { - HashMap customHeaders = new HashMap<>(); - customHeaders.put(ApiClient.HEADER_CONTENT_TYPE, CONTENT_TYPE); - customHeaders.put(ApiClient.HEADER_ATTACHMENT_DESCRIPTION, ATTACHMENT_DESCRIPTION); + Map customHeaders = new HashMap<>(); - byte[] RequestBytes = getRequestBytes(); + BunqHeader.contentType.addTo(customHeaders, CONTENT_TYPE); + BunqHeader.attachmentDescription.addTo(customHeaders, ATTACHMENT_DESCRIPTION); - return AttachmentPublic.create(customHeaders, RequestBytes).getValue(); + return AttachmentPublic.create(customHeaders, getRequestBytes()).getValue(); } /** diff --git a/src/test/java/com/bunq/sdk/model/generated/endpoint/AvatarTest.java b/src/test/java/com/bunq/sdk/model/generated/endpoint/AvatarTest.java index bb5066b1..65284c1b 100644 --- a/src/test/java/com/bunq/sdk/model/generated/endpoint/AvatarTest.java +++ b/src/test/java/com/bunq/sdk/model/generated/endpoint/AvatarTest.java @@ -4,6 +4,7 @@ import com.bunq.sdk.context.ApiContext; import com.bunq.sdk.exception.BunqException; import com.bunq.sdk.http.ApiClient; +import com.bunq.sdk.http.BunqHeader; import org.apache.commons.io.FileUtils; import org.junit.Test; @@ -53,11 +54,9 @@ public void createAvatarTest() { } private String uploadAvatar(byte[] file_contents) { - HashMap customHeaders = new HashMap<>(); - customHeaders.put(ApiClient.HEADER_ATTACHMENT_DESCRIPTION, ATTACHMENT_PATH_IN); - customHeaders.put(ApiClient.HEADER_CONTENT_TYPE, CONTENT_TYPE); - - return AttachmentPublic.create(customHeaders, file_contents).getValue(); + HashMap allCustomHeader = new HashMap<>(); + BunqHeader.attachmentDescription.addTo(allCustomHeader, ATTACHMENT_PATH_IN); + BunqHeader.contentType.addTo(allCustomHeader, CONTENT_TYPE); + return AttachmentPublic.create(allCustomHeader, file_contents).getValue(); } - }