From d441a2872ade357b096e67bd866a909e04d97192 Mon Sep 17 00:00:00 2001 From: skyflow-shravan Date: Tue, 15 Oct 2024 14:15:53 +0530 Subject: [PATCH 01/18] SK-1666 implement invoke connection public interface --- .../java/com/skyflow/ConnectionClient.java | 65 +++++++ v2/src/main/java/com/skyflow/Skyflow.java | 4 + .../com/skyflow/config/ConnectionConfig.java | 9 + .../java/com/skyflow/utils/HttpUtility.java | 180 ++++++++++++++++++ v2/src/main/java/com/skyflow/utils/Utils.java | 39 ++++ .../connection/InvokeConnectionRequest.java | 91 ++++++++- .../connection/InvokeConnectionResponse.java | 14 +- .../controller/ConnectionController.java | 79 +++++++- 8 files changed, 470 insertions(+), 11 deletions(-) create mode 100644 v2/src/main/java/com/skyflow/ConnectionClient.java create mode 100644 v2/src/main/java/com/skyflow/utils/HttpUtility.java diff --git a/v2/src/main/java/com/skyflow/ConnectionClient.java b/v2/src/main/java/com/skyflow/ConnectionClient.java new file mode 100644 index 00000000..a42d3aa6 --- /dev/null +++ b/v2/src/main/java/com/skyflow/ConnectionClient.java @@ -0,0 +1,65 @@ +package com.skyflow; + +import com.skyflow.config.ConnectionConfig; +import com.skyflow.config.Credentials; +import com.skyflow.config.VaultConfig; +import com.skyflow.generated.rest.ApiClient; +import com.skyflow.generated.rest.api.RecordsApi; +import com.skyflow.generated.rest.api.TokensApi; +import io.github.cdimascio.dotenv.Dotenv; + +public class ConnectionClient { + + private final ConnectionConfig connectionConfig; + private Credentials commonCredentials; + private Credentials finalCredentials; + private final ApiClient apiClient; + + + protected ConnectionClient(ConnectionConfig connectionConfig, Credentials credentials) { + super(); + this.connectionConfig = connectionConfig; + this.commonCredentials = credentials; + this.apiClient = new ApiClient(); + prioritiseCredentials(); + } + + protected Credentials getFinalCredentials() { + return finalCredentials; + } + + protected ConnectionConfig getConnectionConfig() { + return connectionConfig; + } + + protected void setCommonCredentials(Credentials commonCredentials) { + this.commonCredentials = commonCredentials; + prioritiseCredentials(); + } + + protected ApiClient getApiClient() { + return apiClient; + } + + private void prioritiseCredentials() { + try { + if (this.connectionConfig.getCredentials() != null) { + this.finalCredentials = this.connectionConfig.getCredentials(); + } else if (this.commonCredentials != null) { + this.finalCredentials = this.commonCredentials; + } else { + Dotenv dotenv = Dotenv.load(); + String sysCredentials = dotenv.get("SKYFLOW_CREDENTIALS"); + if (sysCredentials == null) { + // throw error for not passing any credentials + } else { + this.finalCredentials = new Credentials(); + this.finalCredentials.setCredentialsString(sysCredentials); + } + } + } catch (Exception e) { + throw new RuntimeException(e); + } + } + +} diff --git a/v2/src/main/java/com/skyflow/Skyflow.java b/v2/src/main/java/com/skyflow/Skyflow.java index 6c08644e..c8bae6cc 100644 --- a/v2/src/main/java/com/skyflow/Skyflow.java +++ b/v2/src/main/java/com/skyflow/Skyflow.java @@ -100,6 +100,7 @@ public static final class SkyflowClientBuilder { private final LinkedHashMap connectionsMap; private final LinkedHashMap vaultClientsMap; private final LinkedHashMap vaultConfigMap; + private final LinkedHashMap connectionConfigMap; private Credentials skyflowCredentials; private LogLevel logLevel; @@ -107,6 +108,7 @@ public SkyflowClientBuilder() { this.vaultClientsMap = new LinkedHashMap<>(); this.vaultConfigMap = new LinkedHashMap<>(); this.connectionsMap = new LinkedHashMap<>(); + this.connectionConfigMap = new LinkedHashMap<>(); this.skyflowCredentials = null; this.logLevel = LogLevel.ERROR; } @@ -147,6 +149,7 @@ public SkyflowClientBuilder addConnectionConfig(ConnectionConfig connectionConfi if (this.connectionsMap.containsKey(connectionConfig.getConnectionId())) { // display error log, throw error, or both } else { + this.connectionConfigMap.put(connectionConfig.getConnectionId(), connectionConfig); ConnectionController controller = new ConnectionController(connectionConfig, this.skyflowCredentials); this.connectionsMap.put(connectionConfig.getConnectionId(), controller); } @@ -166,6 +169,7 @@ public SkyflowClientBuilder updateConnectionConfig(ConnectionConfig connectionCo public SkyflowClientBuilder removeConnectionConfig(String connectionId) { if (this.connectionsMap.containsKey(connectionId)) { this.connectionsMap.remove(connectionId); + this.connectionConfigMap.remove(connectionId); } else { // display error log, throw error, or both } diff --git a/v2/src/main/java/com/skyflow/config/ConnectionConfig.java b/v2/src/main/java/com/skyflow/config/ConnectionConfig.java index 0c2c4320..3d431565 100644 --- a/v2/src/main/java/com/skyflow/config/ConnectionConfig.java +++ b/v2/src/main/java/com/skyflow/config/ConnectionConfig.java @@ -26,4 +26,13 @@ public void setConnectionUrl(String connectionUrl) { public void setCredentials(Credentials credentials) { this.credentials = credentials; } + + public String getConnectionUrl() { + return connectionUrl; + } + + public Credentials getCredentials() { + return credentials; + } + } diff --git a/v2/src/main/java/com/skyflow/utils/HttpUtility.java b/v2/src/main/java/com/skyflow/utils/HttpUtility.java new file mode 100644 index 00000000..93cbdd31 --- /dev/null +++ b/v2/src/main/java/com/skyflow/utils/HttpUtility.java @@ -0,0 +1,180 @@ +package com.skyflow.utils; + +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.skyflow.errors.SkyflowException; + +import java.io.*; +import java.net.HttpURLConnection; +import java.net.URL; +import java.nio.charset.StandardCharsets; +import java.util.HashMap; +import java.util.Map; + +public final class HttpUtility { + + private static String requestID; + + public static String getRequestID() { + return requestID; + } + + private static final String LINE_FEED = "\r\n"; + + public static String sendRequest(String method, URL url, JsonObject params, Map headers) throws IOException, SkyflowException { + + HttpURLConnection connection = null; + BufferedReader in = null; + StringBuffer response = null; + String boundary = String.valueOf(System.currentTimeMillis()); + + try { + connection = (HttpURLConnection) url.openConnection(); + connection.setRequestMethod(method); + connection.setRequestProperty("content-type", "application/json"); + connection.setRequestProperty("Accept", "*/*"); + + if (headers != null && headers.size() > 0) { + for (Map.Entry entry : headers.entrySet()) + connection.setRequestProperty(entry.getKey(), entry.getValue()); + + // append dynamic boundary if content-type is multipart/form-data + if (headers.containsKey("content-type")) { + if (headers.get("content-type") == "multipart/form-data") { + connection.setRequestProperty("content-type", "multipart/form-data; boundary=" + boundary); + } + } + } + if (params != null && params.size() > 0) { + connection.setDoOutput(true); + try (DataOutputStream wr = new DataOutputStream(connection.getOutputStream())) { + byte[] input = null; + String requestContentType = connection.getRequestProperty("content-type"); + + if (requestContentType.contains("application/x-www-form-urlencoded")) { + input = formatJsonToFormEncodedString(params).getBytes(StandardCharsets.UTF_8); + } else if (requestContentType.contains("multipart/form-data")) { + input = formatJsonToMultiPartFormDataString(params, boundary).getBytes(StandardCharsets.UTF_8); + }else { + input = params.toString().getBytes(StandardCharsets.UTF_8); + } + + wr.write(input, 0, input.length); + wr.flush(); + } + } + + int status = connection.getResponseCode(); + String requestID = connection.getHeaderField("x-request-id"); + HttpUtility.requestID = requestID; + + Reader streamReader; + if (status > 299) { + if (connection.getErrorStream() != null) + streamReader = new InputStreamReader(connection.getErrorStream()); + else { + String description = appendRequestId("replace with description", requestID); + throw new SkyflowException(description); + } + } else { + streamReader = new InputStreamReader(connection.getInputStream()); + } + + response = new StringBuffer(); + in = new BufferedReader(streamReader); + String inputLine; + while ((inputLine = in.readLine()) != null) { + response.append(inputLine); + } + + if (status > 299) { + String errorMsg = appendRequestIdToErrorObj(status, response.toString(), requestID); + throw new SkyflowException(errorMsg); + } + } finally { + if (in != null) { + in.close(); + } + if (connection != null) { + connection.disconnect(); + } + } + return response.toString(); + + } + + public static String formatJsonToFormEncodedString(JsonObject requestBody) { + StringBuilder formEncodeString = new StringBuilder(); + HashMap jsonMap = convertJsonToMap(requestBody, ""); + + for (Map.Entry currentEntry : jsonMap.entrySet()) + formEncodeString.append(makeFormEncodeKeyValuePair(currentEntry.getKey(), currentEntry.getValue())); + + return formEncodeString.substring(0, formEncodeString.length() - 1); + } + + public static String formatJsonToMultiPartFormDataString(JsonObject requestBody, String boundary) { + StringBuilder formEncodeString = new StringBuilder(); + HashMap jsonMap = convertJsonToMap(requestBody, ""); + + for (Map.Entry currentEntry : jsonMap.entrySet()) + formEncodeString.append(makeFormDataKeyValuePair(currentEntry.getKey(), currentEntry.getValue(), boundary)); + + formEncodeString.append(LINE_FEED); + formEncodeString.append("--").append(boundary).append("--").append(LINE_FEED); + + return formEncodeString.toString(); + } + + private static HashMap convertJsonToMap(JsonObject json, String rootKey) { + HashMap currentMap = new HashMap<>(); + for (Object key : json.keySet()) { + Object currentValue = json.get((String) key); + String currentKey = rootKey.length() != 0 ? rootKey + '[' + key.toString() + ']' : rootKey + key.toString(); + if (currentValue instanceof JsonObject) { + currentMap.putAll(convertJsonToMap((JsonObject) currentValue, currentKey)); + } else { + currentMap.put(currentKey, currentValue.toString()); + } + } + return currentMap; + } + + private static String makeFormDataKeyValuePair(String key, String value, String boundary) { + StringBuilder formDataTextField = new StringBuilder(); + formDataTextField.append("--").append(boundary).append(LINE_FEED); + formDataTextField.append("Content-Disposition: form-data; name=\"").append(key).append("\"").append(LINE_FEED); + formDataTextField.append(LINE_FEED); + formDataTextField.append(value).append(LINE_FEED); + + return formDataTextField.toString(); + } + + public static String appendRequestId(String message, String requestId) { + if (requestId != null && !requestId.isEmpty()) { + message = message + " - requestId: " + requestId; + } + return message; + } + + public static String appendRequestIdToErrorObj(int status, String error, String requestId) throws SkyflowException { + if (requestId != null && !requestId.isEmpty()) { + JsonObject errorObject = (JsonObject) new JsonParser().parse(error); + JsonObject tempError = (JsonObject) errorObject.get("error"); + if (tempError != null) { + String message = String.valueOf(tempError.get("message")); + message = message + " - requestId: " + requestId; + + tempError.addProperty("message", message); + errorObject.add("error", tempError); + } + error = errorObject.toString(); + } + return error; + } + + private static String makeFormEncodeKeyValuePair(String key, String value) { + return key + "=" + value + "&"; + } + +} diff --git a/v2/src/main/java/com/skyflow/utils/Utils.java b/v2/src/main/java/com/skyflow/utils/Utils.java index 51115bb0..0937083f 100644 --- a/v2/src/main/java/com/skyflow/utils/Utils.java +++ b/v2/src/main/java/com/skyflow/utils/Utils.java @@ -1,9 +1,11 @@ package com.skyflow.utils; +import com.skyflow.config.ConnectionConfig; import com.skyflow.config.Credentials; import com.skyflow.enums.Env; import com.skyflow.errors.SkyflowException; import com.skyflow.serviceaccount.util.BearerToken; +import com.skyflow.vault.connection.InvokeConnectionRequest; import org.apache.commons.codec.binary.Base64; import java.io.File; @@ -14,6 +16,8 @@ import java.security.PrivateKey; import java.security.spec.InvalidKeySpecException; import java.security.spec.PKCS8EncodedKeySpec; +import java.util.HashMap; +import java.util.Map; public final class Utils { public static String getVaultURL(String clusterId, Env env) { @@ -97,4 +101,39 @@ private static PrivateKey parsePkcs8PrivateKey(byte[] pkcs8Bytes) throws Skyflow } return privateKey; } + + public static String constructConnectionURL(ConnectionConfig config, InvokeConnectionRequest invokeConnectionRequest) { + StringBuilder filledURL = new StringBuilder((String) config.getConnectionUrl()); + + if (invokeConnectionRequest.getPathParams() != null && !invokeConnectionRequest.getPathParams().isEmpty()) { + for (Map.Entry entry : invokeConnectionRequest.getPathParams().entrySet()) { + String key = entry.getKey(); + String value = entry.getValue(); + filledURL = new StringBuilder(filledURL.toString().replace(String.format("{%s}", key), value)); + } + } + + if(invokeConnectionRequest.getQueryParams() != null && !invokeConnectionRequest.getQueryParams().isEmpty()) { + filledURL.append("?"); + for (Map.Entry entry : invokeConnectionRequest.getQueryParams().entrySet()) { + String key = entry.getKey(); + String value = entry.getValue(); + filledURL.append(key).append("=").append(value).append("&"); + } + filledURL = new StringBuilder(filledURL.substring(0, filledURL.length() - 1)); + } + + return filledURL.toString(); + } + + public static Map constructConnectionHeadersMap(Map requestHeaders) { + Map headersMap = new HashMap<>(); + for (Map.Entry entry : requestHeaders.entrySet()) { + String key = entry.getKey(); + String value = entry.getValue(); + headersMap.put(key.toLowerCase(), value); + } + return headersMap; + } + } diff --git a/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java b/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java index 886e2166..a74b9adb 100644 --- a/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java +++ b/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java @@ -1,10 +1,95 @@ package com.skyflow.vault.connection; +import com.google.gson.JsonObject; +import com.skyflow.enums.RedactionType; +import com.skyflow.vault.tokens.DetokenizeRequest; +import com.skyflow.vault.tokens.TokenizeRequest; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + public class InvokeConnectionRequest { - // members - public InvokeConnectionRequest() { + private final InvokeConnectionRequestBuilder builder; + + private InvokeConnectionRequest(InvokeConnectionRequestBuilder builder) { + this.builder = builder; + } + + public static InvokeConnectionRequestBuilder builder() { + return new InvokeConnectionRequestBuilder(); + } + + public InvokeConnectionRequest getConnectionRequest() { + return new InvokeConnectionRequest(builder); + } + + public String getMethodName() { + return builder.methodName; + } + + public Map getPathParams() { + return builder.pathParams; + } + + public Map getQueryParams() { + return builder.queryParams; + } + + public Map getRequestHeaders() { + return builder.requestHeaders; + } + + public Object getRequestBody() { + return builder.requestBody; + } + + public static final class InvokeConnectionRequestBuilder{ + + private String methodName; + private Map pathParams; + private Map queryParams; + private Map requestHeaders; + private Object requestBody; + + public InvokeConnectionRequestBuilder() { + this.methodName = ""; + this.pathParams = new HashMap<>(); + this.queryParams = new HashMap<>(); + this.requestHeaders = new HashMap<>(); + this.requestBody = new Object(); + } + + public InvokeConnectionRequestBuilder methodName(String methodName) { + this.methodName = methodName; + return this; + } + + public InvokeConnectionRequestBuilder pathParams(Map pathParams) { + this.pathParams = pathParams; + return this; + } + + public InvokeConnectionRequestBuilder queryParams(Map queryParams) { + this.queryParams = queryParams; + return this; + } + + public InvokeConnectionRequestBuilder requestHeaders(Map requestHeaders) { + this.requestHeaders = requestHeaders; + return this; + } + + public InvokeConnectionRequestBuilder requestBody(Object requestBody) { + this.requestBody = requestBody; + return this; + } + + public InvokeConnectionRequest build() { + return new InvokeConnectionRequest(this); + } + } - // getters ans setters } diff --git a/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionResponse.java b/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionResponse.java index 4876cffd..d6c8fa17 100644 --- a/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionResponse.java +++ b/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionResponse.java @@ -1,10 +1,18 @@ package com.skyflow.vault.connection; +import com.google.gson.JsonObject; + public class InvokeConnectionResponse { - // members + private JsonObject response; - public InvokeConnectionResponse() { + public InvokeConnectionResponse(JsonObject response) { + this.response = response; } - // getters ans setters + @Override + public String toString() { + return "InvokeConnectionResponse{" + + "response=" + response + + '}'; + } } diff --git a/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java b/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java index 3061ca3c..74e91d29 100644 --- a/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java +++ b/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java @@ -1,15 +1,35 @@ package com.skyflow.vault.controller; +import com.google.gson.Gson; +import com.google.gson.JsonParser; +import com.skyflow.ConnectionClient; import com.skyflow.config.ConnectionConfig; import com.skyflow.config.Credentials; +import com.skyflow.errors.SkyflowException; +import com.skyflow.generated.rest.auth.HttpBearerAuth; +import com.skyflow.serviceaccount.util.Token; +import com.skyflow.utils.HttpUtility; +import com.skyflow.utils.Utils; +import com.skyflow.utils.validations.Validations; import com.skyflow.vault.connection.InvokeConnectionRequest; import com.skyflow.vault.connection.InvokeConnectionResponse; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; -public class ConnectionController { +import java.net.URL; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; + +public class ConnectionController extends ConnectionClient { private ConnectionConfig connectionConfig; private Credentials commonCredentials; + private String token; + public ConnectionController(ConnectionConfig connectionConfig, Credentials credentials) { + super(connectionConfig, credentials); this.connectionConfig = connectionConfig; this.commonCredentials = credentials; } @@ -26,9 +46,58 @@ public void setConnectionConfig(ConnectionConfig connectionConfig) { this.connectionConfig = connectionConfig; } - // check in python interfaces - public InvokeConnectionResponse invoke(InvokeConnectionRequest invokeConnectionRequest) { - // invoke the connection - return null; + public InvokeConnectionResponse invoke(InvokeConnectionRequest invokeConnectionRequest) throws SkyflowException, IOException { + + InvokeConnectionResponse connectionResponse; + setBearerToken(); + String filledURL = Utils.constructConnectionURL(connectionConfig, invokeConnectionRequest); + Map headers = new HashMap<>(); + + if (invokeConnectionRequest.getRequestHeaders().containsKey("requestHeader")) { + headers = Utils.constructConnectionHeadersMap(invokeConnectionRequest.getRequestHeaders()); + } + if (!headers.containsKey("x-skyflow-authorization")) { + headers.put("x-skyflow-authorization", token); + } + + String requestMethod = invokeConnectionRequest.getMethodName(); + JsonObject requestBody = null; + Object requestBodyObject = invokeConnectionRequest.getRequestBody(); + + if(requestBodyObject!=null) { + try { + requestBody = (JsonObject) convertObjectToJson(requestBodyObject); + System.out.println("Converted requestBody to JsonObject: " + requestBody.toString()); + } catch (Exception e) { + System.out.println("Error while converting requestBody to JsonObject: " + e.getMessage()); + } + } + + String response = HttpUtility.sendRequest(requestMethod, new URL(filledURL), requestBody, headers); +// connectionResponse = (JsonObject) new JsonParser().parse(response); + connectionResponse = new InvokeConnectionResponse((JsonObject) new JsonParser().parse(response)); + return connectionResponse; + } + + private void setBearerToken() throws SkyflowException { + Validations.validateCredentials(super.getFinalCredentials()); + if (token == null || Token.isExpired(token)) { + token = Utils.generateBearerToken(super.getFinalCredentials()); + } + HttpBearerAuth Bearer = (HttpBearerAuth) super.getApiClient().getAuthentication("Bearer"); + Bearer.setBearerToken(token); + } + + private JsonObject convertObjectToJson(Object object) { + Gson gson = new Gson(); + JsonElement jsonElement = gson.toJsonTree(object); + + if (jsonElement.isJsonObject()) { + return jsonElement.getAsJsonObject(); + } else { + JsonObject wrapper = new JsonObject(); + wrapper.add("value", jsonElement); + return wrapper; + } } } From c4ad6c5ca8571ddfab5b07b6b37f56628a2f76b4 Mon Sep 17 00:00:00 2001 From: skyflow-shravan Date: Fri, 18 Oct 2024 15:04:56 +0530 Subject: [PATCH 02/18] SK-1666 validations for invoke connection request --- .../java/com/skyflow/enums/RequestMethod.java | 22 ++++++++ v2/src/main/java/com/skyflow/utils/Utils.java | 2 +- .../utils/validations/Validations.java | 36 +++++++++++++ .../controller/ConnectionController.java | 50 ++++++++++--------- .../skyflow/vault/tokens/TokenizeRequest.java | 2 +- 5 files changed, 87 insertions(+), 25 deletions(-) create mode 100644 v2/src/main/java/com/skyflow/enums/RequestMethod.java diff --git a/v2/src/main/java/com/skyflow/enums/RequestMethod.java b/v2/src/main/java/com/skyflow/enums/RequestMethod.java new file mode 100644 index 00000000..ffa3d949 --- /dev/null +++ b/v2/src/main/java/com/skyflow/enums/RequestMethod.java @@ -0,0 +1,22 @@ +package com.skyflow.enums; + +public enum RequestMethod { + GET("GET"), + POST("POST"), + PUT("PUT"), + PATCH("PATCH"), + DELETE("DELETE"), + ; + + private final String requestMethod; + + + RequestMethod(String requestMethod) { + this.requestMethod = requestMethod; + } + + @Override + public String toString() { + return requestMethod; + } +} diff --git a/v2/src/main/java/com/skyflow/utils/Utils.java b/v2/src/main/java/com/skyflow/utils/Utils.java index 0937083f..048f3c38 100644 --- a/v2/src/main/java/com/skyflow/utils/Utils.java +++ b/v2/src/main/java/com/skyflow/utils/Utils.java @@ -103,7 +103,7 @@ private static PrivateKey parsePkcs8PrivateKey(byte[] pkcs8Bytes) throws Skyflow } public static String constructConnectionURL(ConnectionConfig config, InvokeConnectionRequest invokeConnectionRequest) { - StringBuilder filledURL = new StringBuilder((String) config.getConnectionUrl()); + StringBuilder filledURL = new StringBuilder(config.getConnectionUrl()); if (invokeConnectionRequest.getPathParams() != null && !invokeConnectionRequest.getPathParams().isEmpty()) { for (Map.Entry entry : invokeConnectionRequest.getPathParams().entrySet()) { diff --git a/v2/src/main/java/com/skyflow/utils/validations/Validations.java b/v2/src/main/java/com/skyflow/utils/validations/Validations.java index 556e36f2..696deb27 100644 --- a/v2/src/main/java/com/skyflow/utils/validations/Validations.java +++ b/v2/src/main/java/com/skyflow/utils/validations/Validations.java @@ -3,11 +3,16 @@ import com.skyflow.config.ConnectionConfig; import com.skyflow.config.Credentials; import com.skyflow.config.VaultConfig; +import com.skyflow.enums.RequestMethod; +import com.skyflow.errors.ErrorCode; import com.skyflow.errors.SkyflowException; +import com.skyflow.vault.connection.InvokeConnectionRequest; import com.skyflow.vault.data.*; import com.skyflow.vault.tokens.DetokenizeRequest; import com.skyflow.vault.tokens.TokenizeRequest; +import java.net.URL; + // Add config and request validations public class Validations { @@ -19,6 +24,37 @@ public static void validateConnectionConfig(ConnectionConfig connectionConfig) t } + public static void validateInvokeConnectionRequest(InvokeConnectionRequest invokeConnectionRequest) throws SkyflowException { + if (invokeConnectionRequest.getRequestHeaders().containsKey("connectionURL")) { + String connectionURL = invokeConnectionRequest.getRequestHeaders().get("connectionURL"); + if (isInvalidURL(connectionURL)) { + throw new SkyflowException(); + } + } else { + throw new SkyflowException(); + } + + if (invokeConnectionRequest.getMethodName()!=null) { + try { + RequestMethod requestMethod = RequestMethod.valueOf(invokeConnectionRequest.getMethodName()); + } catch (Exception e) { + throw new SkyflowException(); + } + } else { + throw new SkyflowException(); + } + } + + private static boolean isInvalidURL(String configURL) { + try { + URL url = new URL(configURL); + if (!url.getProtocol().equals("https")) throw new Exception(); + } catch (Exception e) { + return true; + } + return false; + } + public static void validateCredentials(Credentials credentials) throws SkyflowException { int nonNullMembers = 0; if (credentials.getPath() != null) nonNullMembers++; diff --git a/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java b/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java index 74e91d29..d2e08977 100644 --- a/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java +++ b/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java @@ -19,6 +19,7 @@ import java.net.URL; import java.io.IOException; +import java.text.ParseException; import java.util.HashMap; import java.util.Map; @@ -49,33 +50,36 @@ public void setConnectionConfig(ConnectionConfig connectionConfig) { public InvokeConnectionResponse invoke(InvokeConnectionRequest invokeConnectionRequest) throws SkyflowException, IOException { InvokeConnectionResponse connectionResponse; - setBearerToken(); - String filledURL = Utils.constructConnectionURL(connectionConfig, invokeConnectionRequest); - Map headers = new HashMap<>(); - - if (invokeConnectionRequest.getRequestHeaders().containsKey("requestHeader")) { - headers = Utils.constructConnectionHeadersMap(invokeConnectionRequest.getRequestHeaders()); - } - if (!headers.containsKey("x-skyflow-authorization")) { - headers.put("x-skyflow-authorization", token); - } + try { + Validations.validateInvokeConnectionRequest(invokeConnectionRequest); + setBearerToken(); + String filledURL = Utils.constructConnectionURL(connectionConfig, invokeConnectionRequest); + Map headers = new HashMap<>(); + + if (invokeConnectionRequest.getRequestHeaders().containsKey("requestHeader")) { + headers = Utils.constructConnectionHeadersMap(invokeConnectionRequest.getRequestHeaders()); + } + if (!headers.containsKey("x-skyflow-authorization")) { + headers.put("x-skyflow-authorization", token); + } - String requestMethod = invokeConnectionRequest.getMethodName(); - JsonObject requestBody = null; - Object requestBodyObject = invokeConnectionRequest.getRequestBody(); + String requestMethod = invokeConnectionRequest.getMethodName(); + JsonObject requestBody = null; + Object requestBodyObject = invokeConnectionRequest.getRequestBody(); - if(requestBodyObject!=null) { - try { - requestBody = (JsonObject) convertObjectToJson(requestBodyObject); - System.out.println("Converted requestBody to JsonObject: " + requestBody.toString()); - } catch (Exception e) { - System.out.println("Error while converting requestBody to JsonObject: " + e.getMessage()); + if(requestBodyObject!=null) { + try { + requestBody = convertObjectToJson(requestBodyObject); + } catch (Exception e) { + throw new SkyflowException(); + } } - } - String response = HttpUtility.sendRequest(requestMethod, new URL(filledURL), requestBody, headers); -// connectionResponse = (JsonObject) new JsonParser().parse(response); - connectionResponse = new InvokeConnectionResponse((JsonObject) new JsonParser().parse(response)); + String response = HttpUtility.sendRequest(requestMethod, new URL(filledURL), requestBody, headers); + connectionResponse = new InvokeConnectionResponse((JsonObject) new JsonParser().parse(response)); + } catch (IOException e) { + throw new SkyflowException(); + } return connectionResponse; } diff --git a/v2/src/main/java/com/skyflow/vault/tokens/TokenizeRequest.java b/v2/src/main/java/com/skyflow/vault/tokens/TokenizeRequest.java index 7bfd8de0..f0540933 100644 --- a/v2/src/main/java/com/skyflow/vault/tokens/TokenizeRequest.java +++ b/v2/src/main/java/com/skyflow/vault/tokens/TokenizeRequest.java @@ -23,7 +23,7 @@ public List getColumnValues() { public static final class TokenizeRequestBuilder { private List columnValues; - public TokenizeRequestBuilder() { + private TokenizeRequestBuilder() { this.columnValues = new ArrayList<>(); } From 4e61b527216a9bbc561f273809e90c5997a2339c Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Fri, 1 Nov 2024 21:09:32 +0530 Subject: [PATCH 03/18] =?UTF-8?q?SK-1684=20Add=20unit=20tests=20-=20Added?= =?UTF-8?q?=20unit=20tests=20for=20Detokenize=20request=20validations=20-?= =?UTF-8?q?=20Added=20unit=20tests=20for=20Insert=20request=20validations?= =?UTF-8?q?=E2=80=8B=20=E2=80=8B-=20Added=20unit=20tests=20for=20Get=20req?= =?UTF-8?q?uest=20validations=E2=80=8B=20=E2=80=8B-=20Added=20unit=20tests?= =?UTF-8?q?=20for=20Update=20request=20validations=E2=80=8B=20-=20Added=20?= =?UTF-8?q?unit=20tests=20for=20Delete=20request=20validations=E2=80=8B=20?= =?UTF-8?q?=E2=80=8B=E2=80=8B-=20Added=20unit=20tests=20for=20Query=20requ?= =?UTF-8?q?est=20validations=E2=80=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- v2/pom.xml | 15 + v2/src/main/java/com/skyflow/Skyflow.java | 3 +- .../com/skyflow/vault/data/GetRequest.java | 7 +- .../com/skyflow/vault/data/DeleteTests.java | 155 ++++++ .../java/com/skyflow/vault/data/GetTests.java | 471 ++++++++++++++++++ .../com/skyflow/vault/data/InsertTests.java | 375 ++++++++++++++ .../com/skyflow/vault/data/QueryTests.java | 95 ++++ .../com/skyflow/vault/data/UpdateTests.java | 372 ++++++++++++++ .../skyflow/vault/tokens/DetokenizeTests.java | 213 ++++++++ 9 files changed, 1701 insertions(+), 5 deletions(-) create mode 100644 v2/src/test/java/com/skyflow/vault/data/DeleteTests.java create mode 100644 v2/src/test/java/com/skyflow/vault/data/GetTests.java create mode 100644 v2/src/test/java/com/skyflow/vault/data/InsertTests.java create mode 100644 v2/src/test/java/com/skyflow/vault/data/QueryTests.java create mode 100644 v2/src/test/java/com/skyflow/vault/data/UpdateTests.java create mode 100644 v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java diff --git a/v2/pom.xml b/v2/pom.xml index 4e314ed9..bddf1ae2 100644 --- a/v2/pom.xml +++ b/v2/pom.xml @@ -18,6 +18,8 @@ 4.12.0 2.10.1 1.9.0 + 5.10.3 + 1.10.0 @@ -51,5 +53,18 @@ logging-interceptor ${okhttp-version} + + + org.junit.jupiter + junit-jupiter-engine + ${junit-version} + test + + + org.junit.platform + junit-platform-runner + ${junit-platform-runner.version} + test + \ No newline at end of file diff --git a/v2/src/main/java/com/skyflow/Skyflow.java b/v2/src/main/java/com/skyflow/Skyflow.java index abc1eea2..cafa32ca 100644 --- a/v2/src/main/java/com/skyflow/Skyflow.java +++ b/v2/src/main/java/com/skyflow/Skyflow.java @@ -128,7 +128,8 @@ public SkyflowClientBuilder addVaultConfig(VaultConfig vaultConfig) throws Skyfl } else { this.vaultConfigMap.put(vaultConfig.getVaultId(), vaultConfig); this.vaultClientsMap.put(vaultConfig.getVaultId(), new VaultController(vaultConfig, this.skyflowCredentials)); - LogUtil.printInfoLog(InfoLogs.VAULT_CONTROLLER_INITIALIZED.getLog()); + LogUtil.printInfoLog(Utils.parameterizedString( + InfoLogs.VAULT_CONTROLLER_INITIALIZED.getLog(), vaultConfig.getVaultId())); } return this; } diff --git a/v2/src/main/java/com/skyflow/vault/data/GetRequest.java b/v2/src/main/java/com/skyflow/vault/data/GetRequest.java index 0a123e33..04626e35 100644 --- a/v2/src/main/java/com/skyflow/vault/data/GetRequest.java +++ b/v2/src/main/java/com/skyflow/vault/data/GetRequest.java @@ -4,7 +4,6 @@ import com.skyflow.utils.Constants; import java.util.ArrayList; -import java.util.List; public class GetRequest { private final GetRequestBuilder builder; @@ -33,7 +32,7 @@ public Boolean getReturnTokens() { return this.builder.returnTokens; } - public List getFields() { + public ArrayList getFields() { return this.builder.fields; } @@ -66,7 +65,7 @@ public static final class GetRequestBuilder { private ArrayList ids; private RedactionType redactionType; private Boolean returnTokens; - private List fields; + private ArrayList fields; private String offset; private String limit; private Boolean downloadURL; @@ -99,7 +98,7 @@ public GetRequestBuilder returnTokens(Boolean returnTokens) { return this; } - public GetRequestBuilder fields(List fields) { + public GetRequestBuilder fields(ArrayList fields) { this.fields = fields; return this; } diff --git a/v2/src/test/java/com/skyflow/vault/data/DeleteTests.java b/v2/src/test/java/com/skyflow/vault/data/DeleteTests.java new file mode 100644 index 00000000..5660522e --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/data/DeleteTests.java @@ -0,0 +1,155 @@ +package com.skyflow.vault.data; + +import com.skyflow.Skyflow; +import com.skyflow.config.Credentials; +import com.skyflow.config.VaultConfig; +import com.skyflow.enums.Env; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.serviceaccount.util.Token; +import com.skyflow.utils.Constants; +import com.skyflow.utils.Utils; +import com.skyflow.utils.validations.Validations; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import java.util.ArrayList; + +@RunWith(PowerMockRunner.class) +@PrepareForTest(fullyQualifiedNames = "com.skyflow.serviceaccount.util.Token") +public class DeleteTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String vaultID = null; + private static String clusterID = null; + private static String skyflowID = null; + private static String table = null; + private static ArrayList ids = null; + private static Skyflow skyflowClient = null; + + @BeforeClass + public static void setup() throws SkyflowException { + PowerMockito.mockStatic(Token.class); + PowerMockito.when(Token.isExpired("valid_token")).thenReturn(true); + PowerMockito.when(Token.isExpired("not_a_valid_token")).thenReturn(false); + + vaultID = "vault123"; + clusterID = "cluster123"; + + Credentials credentials = new Credentials(); + credentials.setToken("valid-token"); + + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + vaultConfig.setEnv(Env.DEV); +// vaultConfig.setCredentials(credentials); + +// skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + + skyflowID = "test_delete_id_1"; + ids = new ArrayList<>(); + table = "test_table"; + } + + @Test + public void testValidInputInDeleteRequestValidations() { + try { + ids.add(skyflowID); + DeleteRequest request = DeleteRequest.builder().ids(ids).table(table).build(); + Validations.validateDeleteRequest(request); + Assert.assertEquals(1, ids.size()); + Assert.assertEquals(table, request.getTable()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testNoIdsInDeleteRequestValidations() { + DeleteRequest request = DeleteRequest.builder().table(table).build(); + try { + Validations.validateDeleteRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.IdsKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyIdsInDeleteRequestValidations() { + ids.clear(); + DeleteRequest request = DeleteRequest.builder().ids(ids).table(table).build(); + try { + Validations.validateDeleteRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyIds.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyIdInIdsInDeleteRequestValidations() { + ids.add(skyflowID); + ids.add(""); + DeleteRequest request = DeleteRequest.builder().ids(ids).table(table).build(); + try { + Validations.validateDeleteRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyIdInIds.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testNoTableInDeleteRequestValidations() { + ids.clear(); + ids.add(skyflowID); + DeleteRequest request = DeleteRequest.builder().ids(ids).build(); + try { + Validations.validateDeleteRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyTableInDeleteRequestValidations() { + ids.clear(); + ids.add(skyflowID); + DeleteRequest request = DeleteRequest.builder().ids(ids).table("").build(); + try { + Validations.validateDeleteRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyTable.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } +} diff --git a/v2/src/test/java/com/skyflow/vault/data/GetTests.java b/v2/src/test/java/com/skyflow/vault/data/GetTests.java new file mode 100644 index 00000000..66e5cddb --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/data/GetTests.java @@ -0,0 +1,471 @@ +package com.skyflow.vault.data; + +import com.skyflow.Skyflow; +import com.skyflow.config.Credentials; +import com.skyflow.config.VaultConfig; +import com.skyflow.enums.Env; +import com.skyflow.enums.RedactionType; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.serviceaccount.util.Token; +import com.skyflow.utils.Constants; +import com.skyflow.utils.Utils; +import com.skyflow.utils.validations.Validations; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import java.util.ArrayList; + +@RunWith(PowerMockRunner.class) +@PrepareForTest(fullyQualifiedNames = "com.skyflow.serviceaccount.util.Token") +public class GetTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String vaultID = null; + private static String clusterID = null; + private static String skyflowID = null; + private static String field = null; + private static String table = null; + private static ArrayList ids = null; + private static ArrayList fields = null; + private static String columnName = null; + private static String columnValue = null; + private static ArrayList columnValues = null; + private static Skyflow skyflowClient = null; + + @BeforeClass + public static void setup() throws SkyflowException { + PowerMockito.mockStatic(Token.class); + PowerMockito.when(Token.isExpired("valid_token")).thenReturn(true); + PowerMockito.when(Token.isExpired("not_a_valid_token")).thenReturn(false); + + vaultID = "vault123"; + clusterID = "cluster123"; + + Credentials credentials = new Credentials(); + credentials.setToken("valid-token"); + + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + vaultConfig.setEnv(Env.DEV); + vaultConfig.setCredentials(credentials); + +// skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + + skyflowID = "test_get_id_1"; + ids = new ArrayList<>(); + field = "test_get_field"; + fields = new ArrayList<>(); + columnName = "test_column_name"; + columnValue = "test_column_value"; + columnValues = new ArrayList<>(); + table = "test_table"; + } + + @Test + public void testValidGetByIdInputInGetRequestValidations() { + try { + ids.add(skyflowID); + fields.add(field); + GetRequest request = GetRequest.builder() + .ids(ids) + .table(table) + .returnTokens(true) + .downloadURL(true) + .offset("2") + .limit("1") + .fields(fields) + .orderBy(Constants.ORDER_ASCENDING) + .build(); + Validations.validateGetRequest(request); + Assert.assertEquals(table, request.getTable()); + Assert.assertEquals(1, request.getIds().size()); + Assert.assertEquals(1, request.getFields().size()); + Assert.assertEquals("2", request.getOffset()); + Assert.assertEquals("1", request.getLimit()); + Assert.assertEquals(Constants.ORDER_ASCENDING, request.getOrderBy()); + Assert.assertTrue(request.getDownloadURL()); + Assert.assertTrue(request.getReturnTokens()); + Assert.assertNull(request.getRedactionType()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testValidGetByColumnValuesInputInGetRequestValidations() { + try { + columnValues.add(columnValue); + GetRequest request = GetRequest.builder() + .table(table) + .columnName(columnName) + .columnValues(columnValues) + .redactionType(RedactionType.PLAIN_TEXT) + .downloadURL(true) + .offset("2") + .limit("1") + .fields(fields) + .orderBy(Constants.ORDER_ASCENDING) + .build(); + Validations.validateGetRequest(request); + Assert.assertEquals(table, request.getTable()); + Assert.assertEquals(columnName, request.getColumnName()); + Assert.assertEquals(1, request.getColumnValues().size()); + Assert.assertEquals(1, request.getFields().size()); + Assert.assertEquals(RedactionType.PLAIN_TEXT, request.getRedactionType()); + Assert.assertEquals("2", request.getOffset()); + Assert.assertEquals("1", request.getLimit()); + Assert.assertEquals(Constants.ORDER_ASCENDING, request.getOrderBy()); + Assert.assertTrue(request.getDownloadURL()); + Assert.assertNull(request.getReturnTokens()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testNoTableInGetRequestValidations() { + ids.clear(); + ids.add(skyflowID); + GetRequest request = GetRequest.builder().ids(ids).build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyTableInGetRequestValidations() { + ids.clear(); + ids.add(skyflowID); + GetRequest request = GetRequest.builder().ids(ids).table("").build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyTable.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyIdsInGetRequestValidations() { + ids.clear(); + GetRequest request = GetRequest.builder().ids(ids).table(table).build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyIds.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyIdInIdsInGetRequestValidations() { + ids.add(skyflowID); + ids.add(""); + GetRequest request = GetRequest.builder().ids(ids).table(table).build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyIdInIds.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyFieldsInGetRequestValidations() { + ids.clear(); + ids.add(skyflowID); + fields.clear(); + GetRequest request = GetRequest.builder().ids(ids).table(table).fields(fields).build(); + try { + System.out.println(ids); + System.out.println(fields); + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyFields.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyFieldInFieldsInGetRequestValidations() { + fields.add(field); + fields.add(""); + GetRequest request = GetRequest.builder().ids(ids).table(table).fields(fields).build(); + try { + System.out.println(ids); + System.out.println(fields); + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyFieldInFields.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testNoRedactionInGetRequestValidations() { + GetRequest request = GetRequest.builder().table(table).build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.RedactionKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testReturnTokensWithRedactionInGetRequestValidations() { + GetRequest request = GetRequest.builder() + .table(table).redactionType(RedactionType.PLAIN_TEXT).returnTokens(true) + .build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.RedactionWithTokensNotSupported.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testReturnTokensWithColumnNameInGetRequestValidations() { + GetRequest request = GetRequest.builder().table(table).returnTokens(true).columnName(columnName).build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.TokensGetColumnNotSupported.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testReturnTokensWithColumnValuesInGetRequestValidations() { + GetRequest request = GetRequest.builder().table(table).returnTokens(true).columnValues(columnValues).build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.TokensGetColumnNotSupported.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyOffsetInGetRequestValidations() { + GetRequest request = GetRequest.builder() + .table(table).redactionType(RedactionType.PLAIN_TEXT).offset("") + .build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyOffset.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyLimitInGetRequestValidations() { + GetRequest request = GetRequest.builder() + .table(table).redactionType(RedactionType.PLAIN_TEXT).limit("") + .build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyLimit.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testNoIdsOrColumnNameInGetRequestValidations() { + GetRequest request = GetRequest.builder().table(table).redactionType(RedactionType.PLAIN_TEXT).build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.UniqueColumnOrIdsKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testBothIdsAndColumnNameInGetRequestValidations() { + GetRequest request = GetRequest.builder() + .table(table).redactionType(RedactionType.PLAIN_TEXT).ids(ids).columnName(columnName) + .build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.BothIdsAndColumnDetailsSpecified.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testBothIdsAndColumnValuesInGetRequestValidations() { + GetRequest request = GetRequest.builder() + .table(table).redactionType(RedactionType.PLAIN_TEXT).ids(ids).columnValues(columnValues) + .build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.BothIdsAndColumnDetailsSpecified.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testColumnNameWithoutColumnValuesInGetRequestValidations() { + GetRequest request = GetRequest.builder() + .table(table).redactionType(RedactionType.PLAIN_TEXT).columnName(columnName) + .build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.ColumnValuesKeyErrorGet.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testColumnValuesWithoutColumnNameInGetRequestValidations() { + GetRequest request = GetRequest.builder() + .table(table).redactionType(RedactionType.PLAIN_TEXT).columnValues(columnValues) + .build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.ColumnNameKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyColumnNameInGetRequestValidations() { + GetRequest request = GetRequest.builder() + .table(table).redactionType(RedactionType.PLAIN_TEXT).columnName("").columnValues(columnValues) + .build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyColumnName.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyColumnValuesInGetRequestValidations() { + columnValues.clear(); + GetRequest request = GetRequest.builder() + .table(table).redactionType(RedactionType.PLAIN_TEXT).columnName(columnName).columnValues(columnValues) + .build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyColumnValues.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyValueInColumnValuesInGetRequestValidations() { + columnValues.add(columnValue); + columnValues.add(""); + GetRequest request = GetRequest.builder() + .table(table).redactionType(RedactionType.PLAIN_TEXT).columnName(columnName).columnValues(columnValues) + .build(); + try { + Validations.validateGetRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyValueInColumnValues.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } +} diff --git a/v2/src/test/java/com/skyflow/vault/data/InsertTests.java b/v2/src/test/java/com/skyflow/vault/data/InsertTests.java new file mode 100644 index 00000000..2b1c8432 --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/data/InsertTests.java @@ -0,0 +1,375 @@ +package com.skyflow.vault.data; + +import com.skyflow.Skyflow; +import com.skyflow.config.Credentials; +import com.skyflow.config.VaultConfig; +import com.skyflow.enums.Byot; +import com.skyflow.enums.Env; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.serviceaccount.util.Token; +import com.skyflow.utils.Constants; +import com.skyflow.utils.Utils; +import com.skyflow.utils.validations.Validations; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import java.util.ArrayList; +import java.util.HashMap; + +@RunWith(PowerMockRunner.class) +@PrepareForTest(fullyQualifiedNames = "com.skyflow.serviceaccount.util.Token") +public class InsertTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String vaultID = null; + private static String clusterID = null; + private static String table = null; + private static ArrayList> values = null; + private static ArrayList> tokens = null; + private static HashMap valueMap = null; + private static HashMap tokenMap = null; + private static String upsert = null; + private static Skyflow skyflowClient = null; + + @BeforeClass + public static void setup() throws SkyflowException { + PowerMockito.mockStatic(Token.class); + PowerMockito.when(Token.isExpired("valid_token")).thenReturn(true); + PowerMockito.when(Token.isExpired("not_a_valid_token")).thenReturn(false); + + vaultID = "vault123"; + clusterID = "cluster123"; + + Credentials credentials = new Credentials(); + credentials.setToken("valid-token"); + + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + vaultConfig.setEnv(Env.DEV); + vaultConfig.setCredentials(credentials); + +// skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + + table = "test_table"; + values = new ArrayList<>(); + tokens = new ArrayList<>(); + valueMap = new HashMap<>(); + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); + tokenMap = new HashMap<>(); + tokenMap.put("test_column_1", "test_token_1"); + upsert = "upsert_column"; + } + + @Test + public void testValidInputInInsertRequestValidations() { + try { + values.add(valueMap); + tokens.add(tokenMap); + InsertRequest request = InsertRequest.builder() + .table(table) + .continueOnError(true) + .returnTokens(true) + .homogeneous(false) + .upsert(upsert) + .values(values) + .tokens(tokens) + .tokenMode(true) + .tokenStrict(Byot.ENABLE) + .build(); + Validations.validateInsertRequest(request); + + Assert.assertEquals(table, request.getTable()); + Assert.assertEquals(upsert, request.getUpsert()); + Assert.assertEquals(1, request.getValues().size()); + Assert.assertEquals(1, request.getTokens().size()); + Assert.assertEquals(Byot.ENABLE, request.getTokenStrict()); + Assert.assertTrue(request.getContinueOnError()); + Assert.assertFalse(request.getHomogeneous()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testNoTableInInsertRequestValidations() { + InsertRequest request = InsertRequest.builder().build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyTableInInsertRequestValidations() { + InsertRequest request = InsertRequest.builder().table("").build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyTable.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testNoValuesInInsertRequestValidations() { + InsertRequest request = InsertRequest.builder().table(table).build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.ValuesKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyValuesInInsertRequestValidations() { + values.clear(); + InsertRequest request = InsertRequest.builder().table(table).values(values).build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyValues.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyKeyInValuesInInsertRequestValidations() { + valueMap.put("", "test_value_3"); + values.add(valueMap); + InsertRequest request = InsertRequest.builder().table(table).values(values).build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyKeyInValues.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyValueInValuesInInsertRequestValidations() { + valueMap.remove(""); + valueMap.put("test_column_3", ""); + InsertRequest request = InsertRequest.builder().table(table).values(values).build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyValueInValues.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyUpsertInInsertRequestValidations() { + valueMap.remove("test_column_3"); + InsertRequest request = InsertRequest.builder().table(table).values(values).upsert("").build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyUpsert.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testUpsertWithHomogenousInInsertRequestValidations() { + InsertRequest request = InsertRequest.builder() + .table(table).values(values).upsert(upsert).homogeneous(true) + .build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.HomogenousNotSupportedWithUpsert.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testTokensWithTokenStrictDisableInInsertRequestValidations() { + InsertRequest request = InsertRequest.builder().table(table).values(values).tokens(tokens).build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.TokensPassedForByotDisable.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testNoTokensWithTokenStrictEnableInInsertRequestValidations() { + InsertRequest request = InsertRequest.builder() + .table(table).values(values).tokenStrict(Byot.ENABLE) + .build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.NoTokensWithByot.getMessage(), Byot.ENABLE.toString()), + e.getMessage() + ); + } + } + + @Test + public void testNoTokensWithTokenStrictEnableStrictInInsertRequestValidations() { + InsertRequest request = InsertRequest.builder() + .table(table).values(values).tokenStrict(Byot.ENABLE_STRICT) + .build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.NoTokensWithByot.getMessage(), Byot.ENABLE_STRICT.toString()), + e.getMessage() + ); + } + } + + @Test + public void testEmptyTokensWithTokenStrictEnableInInsertRequestValidations() { + tokens.clear(); + InsertRequest request = InsertRequest.builder() + .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE) + .build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyTokens.getMessage(), e.getMessage()); + } + } + + @Test + public void testInsufficientTokensWithTokenStrictEnableStrictInInsertRequestValidations1() { + tokens.add(tokenMap); + System.out.println(values); + System.out.println(tokens); + InsertRequest request = InsertRequest.builder() + .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE_STRICT) + .build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InsufficientTokensPassedForByotEnableStrict.getMessage(), e.getMessage()); + } + } + + @Test + public void testInsufficientTokensWithTokenStrictEnableStrictInInsertRequestValidations2() { + values.add(valueMap); + InsertRequest request = InsertRequest.builder() + .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE_STRICT) + .build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InsufficientTokensPassedForByotEnableStrict.getMessage(), e.getMessage()); + } + } + + @Test + public void testTokenValueMismatchInInsertRequestValidations() { + tokenMap.put("test_column_3", "test_token_3"); + values.remove(1); + InsertRequest request = InsertRequest.builder() + .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE_STRICT) + .build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.MismatchOfFieldsAndTokens.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyKeyInTokensInInsertRequestValidations() { + tokenMap.remove("test_column_2"); + tokenMap.remove("test_column_3"); + tokenMap.put("", "test_token_2"); + InsertRequest request = InsertRequest.builder() + .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE_STRICT) + .build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyKeyInTokens.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyValueInTokensInInsertRequestValidations() { + tokenMap.remove(""); + tokenMap.put("test_column_2", ""); + InsertRequest request = InsertRequest.builder() + .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE_STRICT) + .build(); + try { + Validations.validateInsertRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyValueInTokens.getMessage(), e.getMessage()); + } + } + +} diff --git a/v2/src/test/java/com/skyflow/vault/data/QueryTests.java b/v2/src/test/java/com/skyflow/vault/data/QueryTests.java new file mode 100644 index 00000000..141704a1 --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/data/QueryTests.java @@ -0,0 +1,95 @@ +package com.skyflow.vault.data; + +import com.skyflow.Skyflow; +import com.skyflow.config.Credentials; +import com.skyflow.config.VaultConfig; +import com.skyflow.enums.Env; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.serviceaccount.util.Token; +import com.skyflow.utils.Constants; +import com.skyflow.utils.Utils; +import com.skyflow.utils.validations.Validations; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +@RunWith(PowerMockRunner.class) +@PrepareForTest(fullyQualifiedNames = "com.skyflow.serviceaccount.util.Token") +public class QueryTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String vaultID = null; + private static String clusterID = null; + private static String query = null; + private static Skyflow skyflowClient = null; + + @BeforeClass + public static void setup() throws SkyflowException { + PowerMockito.mockStatic(Token.class); + PowerMockito.when(Token.isExpired("valid_token")).thenReturn(true); + PowerMockito.when(Token.isExpired("not_a_valid_token")).thenReturn(false); + + vaultID = "vault123"; + clusterID = "cluster123"; + + Credentials credentials = new Credentials(); + credentials.setToken("valid-token"); + + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + vaultConfig.setEnv(Env.DEV); + vaultConfig.setCredentials(credentials); + + query = "test_query"; + +// skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + } + + @Test + public void testValidInputInQueryRequestValidations() { + try { + QueryRequest request = QueryRequest.builder().query(query).build(); + Validations.validateQueryRequest(request); + Assert.assertEquals(query, request.getQuery()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testNoQueryInQueryRequestValidations() { + QueryRequest request = QueryRequest.builder().build(); + try { + Validations.validateQueryRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.QueryKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyQueryInQueryRequestValidations() { + QueryRequest request = QueryRequest.builder().query("").build(); + try { + Validations.validateQueryRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyQuery.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } +} diff --git a/v2/src/test/java/com/skyflow/vault/data/UpdateTests.java b/v2/src/test/java/com/skyflow/vault/data/UpdateTests.java new file mode 100644 index 00000000..5a72001c --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/data/UpdateTests.java @@ -0,0 +1,372 @@ +package com.skyflow.vault.data; + +import com.skyflow.Skyflow; +import com.skyflow.config.Credentials; +import com.skyflow.config.VaultConfig; +import com.skyflow.enums.Byot; +import com.skyflow.enums.Env; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.serviceaccount.util.Token; +import com.skyflow.utils.Constants; +import com.skyflow.utils.Utils; +import com.skyflow.utils.validations.Validations; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import java.util.HashMap; + +@RunWith(PowerMockRunner.class) +@PrepareForTest(fullyQualifiedNames = "com.skyflow.serviceaccount.util.Token") +public class UpdateTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String vaultID = null; + private static String clusterID = null; + private static String skyflowID = null; + private static String table = null; + private static HashMap valueMap = null; + private static HashMap tokenMap = null; + private static Skyflow skyflowClient = null; + + @BeforeClass + public static void setup() throws SkyflowException { + PowerMockito.mockStatic(Token.class); + PowerMockito.when(Token.isExpired("valid_token")).thenReturn(true); + PowerMockito.when(Token.isExpired("not_a_valid_token")).thenReturn(false); + + vaultID = "vault123"; + clusterID = "cluster123"; + + Credentials credentials = new Credentials(); + credentials.setToken("valid-token"); + + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + vaultConfig.setEnv(Env.DEV); + vaultConfig.setCredentials(credentials); + +// skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + + skyflowID = "test_update_id_1"; + table = "test_table"; + valueMap = new HashMap<>(); + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); + tokenMap = new HashMap<>(); + tokenMap.put("test_column_1", "test_token_1"); + } + + @Test + public void testValidInputInUpdateRequestValidations() { + try { + UpdateRequest request = UpdateRequest.builder() + .id(skyflowID) + .table(table) + .values(valueMap) + .tokens(tokenMap) + .returnTokens(true) + .tokenStrict(Byot.ENABLE) + .build(); + Validations.validateUpdateRequest(request); + Assert.assertEquals(table, request.getTable()); + Assert.assertEquals(skyflowID, request.getId()); + Assert.assertEquals(2, request.getValues().size()); + Assert.assertEquals(1, request.getTokens().size()); + Assert.assertTrue(request.getReturnTokens()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testNoSkyflowIdInUpdateRequestValidations() { + UpdateRequest request = UpdateRequest.builder().table(table).build(); + try { + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.SkyflowIdKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptySkyflowIdInUpdateRequestValidations() { + UpdateRequest request = UpdateRequest.builder().id("").table(table).build(); + try { + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptySkyflowId.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testNoTableInUpdateRequestValidations() { + UpdateRequest request = UpdateRequest.builder().id(skyflowID).build(); + try { + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyTableInUpdateRequestValidations() { + UpdateRequest request = UpdateRequest.builder().id(skyflowID).table("").build(); + try { + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyTable.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testNoValuesInUpdateRequestValidations() { + UpdateRequest request = UpdateRequest.builder().id(skyflowID).table(table).build(); + try { + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.ValuesKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyValuesInUpdateRequestValidations() { + HashMap emptyValueMap = new HashMap<>(); + UpdateRequest request = UpdateRequest.builder().id(skyflowID).table(table).values(emptyValueMap).build(); + try { + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyValues.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyKeyInValuesInUpdateRequestValidations() { + valueMap.put("", "test_value_3"); + UpdateRequest request = UpdateRequest.builder().id(skyflowID).table(table).values(valueMap).build(); + try { + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyKeyInValues.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testEmptyValueInValuesInUpdateRequestValidations() { + valueMap.remove(""); + valueMap.put("test_column_3", ""); + UpdateRequest request = UpdateRequest.builder().id(skyflowID).table(table).values(valueMap).build(); + try { + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyValueInValues.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testTokensWithTokenStrictDisableInUpdateRequestValidations() { + valueMap.remove("test_column_3"); + UpdateRequest request = UpdateRequest.builder() + .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.DISABLE) + .build(); + try { + System.out.println(valueMap); + System.out.println(tokenMap); + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.TokensPassedForByotDisable.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testNoTokensWithTokenStrictEnableInUpdateRequestValidations() { + UpdateRequest request = UpdateRequest.builder() + .id(skyflowID).table(table).values(valueMap).tokenStrict(Byot.ENABLE) + .build(); + try { + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.NoTokensWithByot.getMessage(), Byot.ENABLE.toString()), + e.getMessage() + ); + } + } + + @Test + public void testNoTokensWithTokenStrictEnableStrictInUpdateRequestValidations() { + UpdateRequest request = UpdateRequest.builder() + .id(skyflowID).table(table).values(valueMap).tokenStrict(Byot.ENABLE_STRICT) + .build(); + try { + System.out.println(valueMap); + System.out.println(tokenMap); + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.NoTokensWithByot.getMessage(), Byot.ENABLE_STRICT.toString()), + e.getMessage() + ); + } + } + + @Test + public void testEmptyTokensWithTokenStrictEnableInUpdateRequestValidations() { + HashMap emptyTokenMap = new HashMap<>(); + UpdateRequest request = UpdateRequest.builder() + .id(skyflowID).table(table).values(valueMap).tokens(emptyTokenMap).tokenStrict(Byot.ENABLE) + .build(); + try { + System.out.println(valueMap); + System.out.println(tokenMap); + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyTokens.getMessage(), e.getMessage()); + } + } + + @Test + public void testInsufficientTokensWithTokenStrictEnableStrictInUpdateRequestValidations1() { + UpdateRequest request = UpdateRequest.builder() + .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) + .build(); + try { + System.out.println(valueMap); + System.out.println(tokenMap); + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InsufficientTokensPassedForByotEnableStrict.getMessage(), e.getMessage()); + } + } + + @Test + public void testInsufficientTokensWithTokenStrictEnableStrictInUpdateRequestValidations2() { + UpdateRequest request = UpdateRequest.builder() + .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) + .build(); + try { + System.out.println(valueMap); + System.out.println(tokenMap); + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InsufficientTokensPassedForByotEnableStrict.getMessage(), e.getMessage()); + } + } + + @Test + public void testTokenValueMismatchInUpdateRequestValidations() { + tokenMap.put("test_column_3", "test_token_3"); + UpdateRequest request = UpdateRequest.builder() + .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) + .build(); + try { + System.out.println(valueMap); + System.out.println(tokenMap); + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.MismatchOfFieldsAndTokens.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyKeyInTokensInUpdateRequestValidations() { + tokenMap.remove("test_column_2"); + tokenMap.remove("test_column_3"); + tokenMap.put("", "test_token_2"); + UpdateRequest request = UpdateRequest.builder() + .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) + .build(); + try { + System.out.println(valueMap); + System.out.println(tokenMap); + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyKeyInTokens.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyValueInTokensInUpdateRequestValidations() { + tokenMap.remove(""); + tokenMap.put("test_column_2", ""); + UpdateRequest request = UpdateRequest.builder() + .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) + .build(); + try { + System.out.println(valueMap); + System.out.println(tokenMap); + Validations.validateUpdateRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyValueInTokens.getMessage(), e.getMessage()); + } + } + +} diff --git a/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java b/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java new file mode 100644 index 00000000..04dd406d --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java @@ -0,0 +1,213 @@ +package com.skyflow.vault.tokens; + +import com.skyflow.Skyflow; +import com.skyflow.config.Credentials; +import com.skyflow.config.VaultConfig; +import com.skyflow.enums.Env; +import com.skyflow.enums.LogLevel; +import com.skyflow.enums.RedactionType; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.generated.rest.ApiException; +import com.skyflow.generated.rest.api.TokensApi; +import com.skyflow.generated.rest.models.V1DetokenizeResponse; +import com.skyflow.utils.Constants; +import com.skyflow.utils.Utils; +import com.skyflow.utils.validations.Validations; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.mockito.ArgumentMatchers; +import org.powermock.api.mockito.PowerMockito; + +import java.util.ArrayList; + +//@RunWith(PowerMockRunner.class) +//@PrepareForTest(fullyQualifiedNames = { +// "com.skyflow.serviceaccount.util.Token", +// "com.skyflow.generated.rest.ApiClient", +// "com.skyflow.generated.rest.api.TokensApi", +//}) +public class DetokenizeTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String vaultID = null; + private static String clusterID = null; + private static VaultConfig vaultConfig = null; + private static String token = null; + private static ArrayList tokens = null; + private static Skyflow skyflowClient = null; + + @BeforeClass + public static void setup() throws SkyflowException, NoSuchMethodException { +// PowerMockito.mockStatic(Token.class); +// PowerMockito.when(Token.isExpired("valid_token")).thenReturn(true); +// PowerMockito.when(Token.isExpired("not_a_valid_token")).thenReturn(false); +// PowerMockito.mock(ApiClient.class); + + vaultID = "vault123"; + clusterID = "cluster123"; + + Credentials credentials = new Credentials(); + credentials.setToken("valid-token"); + + vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + vaultConfig.setEnv(Env.DEV); + vaultConfig.setCredentials(credentials); + + token = "test_token_1"; + tokens = new ArrayList<>(); + } + + @Test + public void testValidInputInDetokenizeRequestValidations() { + try { + tokens.add(token); + DetokenizeRequest request = DetokenizeRequest.builder(). + tokens(tokens).redactionType(RedactionType.MASKED).continueOnError(false).build(); + Validations.validateDetokenizeRequest(request); + Assert.assertEquals(1, tokens.size()); + Assert.assertEquals(RedactionType.MASKED, request.getRedactionType()); + Assert.assertFalse(request.getContinueOnError()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testNoTokensInDetokenizeRequestValidations() { + DetokenizeRequest request = DetokenizeRequest.builder().build(); + try { + Validations.validateDetokenizeRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.InvalidDataTokens.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + Assert.assertEquals(RedactionType.PLAIN_TEXT, request.getRedactionType()); + Assert.assertTrue(request.getContinueOnError()); + } + } + + @Test + public void testEmptyTokensInDetokenizeRequestValidations() { + tokens.clear(); + DetokenizeRequest request = DetokenizeRequest.builder().tokens(tokens).build(); + try { + Validations.validateDetokenizeRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyDataTokens.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + Assert.assertEquals(RedactionType.PLAIN_TEXT, request.getRedactionType()); + Assert.assertTrue(request.getContinueOnError()); + } + } + + @Test + public void testEmptyTokenInTokensInDetokenizeRequestValidations() { + tokens.add(token); + tokens.add(""); + DetokenizeRequest request = DetokenizeRequest.builder().tokens(tokens).build(); + try { + Validations.validateDetokenizeRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyTokenInDataTokens.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + Assert.assertEquals(RedactionType.PLAIN_TEXT, request.getRedactionType()); + Assert.assertTrue(request.getContinueOnError()); + } + } + + @Test + public void testRedactionAndContinueOnErrorInDetokenizeRequestValidations() { + tokens.clear(); + tokens.add(token); + DetokenizeRequest request = DetokenizeRequest.builder(). + tokens(tokens).redactionType(null).continueOnError(null).build(); + try { + Validations.validateDetokenizeRequest(request); + Assert.assertEquals(RedactionType.PLAIN_TEXT, request.getRedactionType()); + Assert.assertTrue(request.getContinueOnError()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testNoTokensInDetokenizeMethod() { + DetokenizeRequest request = DetokenizeRequest.builder().build(); + try { + V1DetokenizeResponse mockResponse = new V1DetokenizeResponse(); + TokensApi mockApi = PowerMockito.mock(TokensApi.class); + PowerMockito + .when(mockApi.recordServiceDetokenize(ArgumentMatchers.anyString(), ArgumentMatchers.any())) + .thenReturn(mockResponse); + + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + DetokenizeResponse response = skyflowClient.vault().detokenize(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.InvalidDataTokens.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + Assert.assertEquals(RedactionType.PLAIN_TEXT, request.getRedactionType()); + Assert.assertTrue(request.getContinueOnError()); + } catch (ApiException e) { + Assert.fail(); + } + } + + @Test + public void testEmptyTokensInDetokenizeMethod() { + tokens.clear(); + DetokenizeRequest request = DetokenizeRequest.builder().tokens(tokens).build(); + try { + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + DetokenizeResponse response = skyflowClient.vault().detokenize(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyDataTokens.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + Assert.assertEquals(RedactionType.PLAIN_TEXT, request.getRedactionType()); + Assert.assertTrue(request.getContinueOnError()); + } + } + + @Test + public void testEmptyTokenInTokensInDetokenizeMethod() { + tokens.add(token); + tokens.add(""); + DetokenizeRequest request = DetokenizeRequest.builder().tokens(tokens).build(); + try { + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + DetokenizeResponse response = skyflowClient.vault().detokenize(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.EmptyTokenInDataTokens.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + Assert.assertEquals(RedactionType.PLAIN_TEXT, request.getRedactionType()); + Assert.assertTrue(request.getContinueOnError()); + } + } +} From 184124b2a8ba70d917b9caa234e3a8193ce2607b Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Fri, 1 Nov 2024 21:11:44 +0530 Subject: [PATCH 04/18] SK-1680 Changed info logs to error logs in validation checks - SK-1681 Updated validation checks for Get request interface --- .../utils/validations/Validations.java | 155 ++++++++++-------- 1 file changed, 87 insertions(+), 68 deletions(-) diff --git a/v2/src/main/java/com/skyflow/utils/validations/Validations.java b/v2/src/main/java/com/skyflow/utils/validations/Validations.java index bd4a7cd6..266bb0aa 100644 --- a/v2/src/main/java/com/skyflow/utils/validations/Validations.java +++ b/v2/src/main/java/com/skyflow/utils/validations/Validations.java @@ -175,33 +175,33 @@ public static void validateInsertRequest(InsertRequest insertRequest) throws Sky Byot tokenStrict = insertRequest.getTokenStrict(); if (table == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.TABLE_IS_REQUIRED.getLog(), InterfaceName.INSERT.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.TableKeyError.getMessage()); } else if (table.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_TABLE_NAME.getLog(), InterfaceName.INSERT.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyTable.getMessage()); } else if (values == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.VALUES_IS_REQUIRED.getLog(), InterfaceName.INSERT.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.ValuesKeyError.getMessage()); } else if (values.isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_VALUES.getLog(), InterfaceName.INSERT.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyValues.getMessage()); } else if (upsert != null) { if (upsert.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_UPSERT.getLog(), InterfaceName.INSERT.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyUpsert.getMessage()); } else if (homogeneous != null && homogeneous) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.HOMOGENOUS_NOT_SUPPORTED_WITH_UPSERT.getLog(), InterfaceName.INSERT.getName() )); throw new SkyflowException( @@ -213,14 +213,14 @@ public static void validateInsertRequest(InsertRequest insertRequest) throws Sky for (HashMap valuesMap : values) { for (String key : valuesMap.keySet()) { if (key == null || key.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OR_NULL_KEY_IN_VALUES.getLog(), InterfaceName.INSERT.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyKeyInValues.getMessage()); } else { Object value = valuesMap.get(key); if (value == null || value.toString().trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OR_NULL_VALUE_IN_VALUES.getLog(), InterfaceName.INSERT.getName(), key )); @@ -233,7 +233,7 @@ public static void validateInsertRequest(InsertRequest insertRequest) throws Sky switch (tokenStrict) { case DISABLE: if (tokens != null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.TOKENS_NOT_ALLOWED_WITH_BYOT_DISABLE.getLog(), InterfaceName.INSERT.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.TokensPassedForByotDisable.getMessage()); @@ -241,7 +241,7 @@ public static void validateInsertRequest(InsertRequest insertRequest) throws Sky break; case ENABLE: if (tokens == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.TOKENS_REQUIRED_WITH_BYOT.getLog(), InterfaceName.INSERT.getName(), Byot.ENABLE.toString() )); @@ -249,11 +249,11 @@ public static void validateInsertRequest(InsertRequest insertRequest) throws Sky Utils.parameterizedString(ErrorMessage.NoTokensWithByot.getMessage(), Byot.ENABLE.toString()) ); } - validateTokensForInsertRequest(tokens, values); + validateTokensForInsertRequest(tokens, values, tokenStrict); break; case ENABLE_STRICT: if (tokens == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.TOKENS_REQUIRED_WITH_BYOT.getLog(), InterfaceName.INSERT.getName(), Byot.ENABLE_STRICT.toString() )); @@ -261,7 +261,7 @@ public static void validateInsertRequest(InsertRequest insertRequest) throws Sky Utils.parameterizedString(ErrorMessage.NoTokensWithByot.getMessage(), Byot.ENABLE_STRICT.toString()) ); } else if (tokens.size() != values.size()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.INSUFFICIENT_TOKENS_PASSED_FOR_BYOT_ENABLE_STRICT.getLog(), InterfaceName.INSERT.getName() )); @@ -269,7 +269,7 @@ public static void validateInsertRequest(InsertRequest insertRequest) throws Sky ErrorMessage.InsufficientTokensPassedForByotEnableStrict.getMessage() ); } - validateTokensForInsertRequest(tokens, values); + validateTokensForInsertRequest(tokens, values, tokenStrict); break; } } @@ -279,7 +279,7 @@ public static void validateGetRequest(GetRequest getRequest) throws SkyflowExcep ArrayList ids = getRequest.getIds(); RedactionType redactionType = getRequest.getRedactionType(); Boolean tokenization = getRequest.getReturnTokens(); - List fields = getRequest.getFields(); + ArrayList fields = getRequest.getFields(); String offset = getRequest.getOffset(); String limit = getRequest.getLimit(); String columnName = getRequest.getColumnName(); @@ -287,18 +287,18 @@ public static void validateGetRequest(GetRequest getRequest) throws SkyflowExcep String orderBy = getRequest.getOrderBy(); if (table == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.TABLE_IS_REQUIRED.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.TableKeyError.getMessage()); } else if (table.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_TABLE_NAME.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyTable.getMessage()); } else if (ids != null) { if (ids.isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_IDS.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyIds.getMessage()); @@ -306,7 +306,7 @@ public static void validateGetRequest(GetRequest getRequest) throws SkyflowExcep for (int index = 0; index < ids.size(); index++) { String id = ids.get(index); if (id == null || id.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OR_NULL_ID_IN_IDS.getLog(), InterfaceName.GET.getName(), Integer.toString(index) )); @@ -314,9 +314,10 @@ public static void validateGetRequest(GetRequest getRequest) throws SkyflowExcep } } } - } else if (fields != null) { + } + if (fields != null) { if (fields.isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_FIELDS.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyFields.getMessage()); @@ -324,7 +325,7 @@ public static void validateGetRequest(GetRequest getRequest) throws SkyflowExcep for (int index = 0; index < fields.size(); index++) { String field = fields.get(index); if (field == null || field.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OR_NULL_FIELD_IN_FIELDS.getLog(), InterfaceName.GET.getName(), Integer.toString(index) )); @@ -332,69 +333,72 @@ public static void validateGetRequest(GetRequest getRequest) throws SkyflowExcep } } } - } else if (redactionType == null && (tokenization == null || !tokenization)) { - LogUtil.printInfoLog(Utils.parameterizedString( + } + if (redactionType == null && (tokenization == null || !tokenization)) { + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.REDACTION_IS_REQUIRED.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.RedactionKeyError.getMessage()); - } else if (tokenization != null && tokenization) { + } + if (tokenization != null && tokenization) { if (redactionType != null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.TOKENIZATION_NOT_SUPPORTED_WITH_REDACTION.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.RedactionWithTokensNotSupported.getMessage() ); } else if (columnName != null || columnValues != null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.TOKENIZATION_SUPPORTED_ONLY_WITH_IDS.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.TokensGetColumnNotSupported.getMessage() ); } - } else if (offset != null && offset.isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + } + if (offset != null && offset.trim().isEmpty()) { + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OFFSET.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyOffset.getMessage()); - } else if (limit != null && limit.isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + } + if (limit != null && limit.trim().isEmpty()) { + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_LIMIT.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyLimit.getMessage()); } - if (ids == null && columnName == null && columnValues == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.NEITHER_IDS_NOR_COLUMN_NAME_PASSED.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.UniqueColumnOrIdsKeyError.getMessage()); } else if (ids != null && (columnName != null || columnValues != null)) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.BOTH_IDS_AND_COLUMN_NAME_PASSED.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.BothIdsAndColumnDetailsSpecified.getMessage()); } else if (columnName == null && columnValues != null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.COLUMN_NAME_IS_REQUIRED.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.ColumnNameKeyError.getMessage()); } else if (columnName != null && columnValues == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.COLUMN_VALUES_IS_REQUIRED_GET.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.ColumnValuesKeyErrorGet.getMessage()); } else if (columnName != null) { if (columnName.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_COLUMN_NAME.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyColumnName.getMessage()); } else if (columnValues.isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_COLUMN_VALUES.getLog(), InterfaceName.GET.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyColumnValues.getMessage()); @@ -402,7 +406,7 @@ public static void validateGetRequest(GetRequest getRequest) throws SkyflowExcep for (int index = 0; index < columnValues.size(); index++) { String columnValue = columnValues.get(index); if (columnValue == null || columnValue.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OR_NULL_COLUMN_VALUE_IN_COLUMN_VALUES.getLog(), InterfaceName.GET.getName(), Integer.toString(index) )); @@ -422,32 +426,37 @@ public static void validateUpdateRequest(UpdateRequest updateRequest) throws Sky Byot tokenStrict = updateRequest.getTokenStrict(); if (table == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.TABLE_IS_REQUIRED.getLog(), InterfaceName.UPDATE.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.TableKeyError.getMessage()); } else if (table.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_TABLE_NAME.getLog(), InterfaceName.UPDATE.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyTable.getMessage()); } else if (skyflowId == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.SKYFLOW_ID_IS_REQUIRED.getLog(), InterfaceName.UPDATE.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.SkyflowIdKeyError.getMessage()); } else if (skyflowId.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_SKYFLOW_ID.getLog(), InterfaceName.UPDATE.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptySkyflowId.getMessage()); - } else if (values == null || values.isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + } else if (values == null) { + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.VALUES_IS_REQUIRED.getLog(), InterfaceName.UPDATE.getName() + )); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.ValuesKeyError.getMessage()); + } else if (values.isEmpty()) { + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_VALUES.getLog(), InterfaceName.UPDATE.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyValues.getMessage()); } else if (tokens != null && tokens.isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_TOKENS.getLog(), InterfaceName.UPDATE.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyTokens.getMessage()); @@ -455,14 +464,14 @@ public static void validateUpdateRequest(UpdateRequest updateRequest) throws Sky for (String key : values.keySet()) { if (key == null || key.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OR_NULL_KEY_IN_VALUES.getLog(), InterfaceName.UPDATE.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyKeyInValues.getMessage()); } else { Object value = values.get(key); if (value == null || value.toString().trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OR_NULL_VALUE_IN_VALUES.getLog(), InterfaceName.UPDATE.getName(), key )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), @@ -474,7 +483,7 @@ public static void validateUpdateRequest(UpdateRequest updateRequest) throws Sky switch (tokenStrict) { case DISABLE: if (tokens != null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.TOKENS_NOT_ALLOWED_WITH_BYOT_DISABLE.getLog(), InterfaceName.INSERT.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), @@ -483,7 +492,7 @@ public static void validateUpdateRequest(UpdateRequest updateRequest) throws Sky break; case ENABLE: if (tokens == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.TOKENS_REQUIRED_WITH_BYOT.getLog(), InterfaceName.INSERT.getName(), Byot.ENABLE.toString() )); @@ -494,14 +503,14 @@ public static void validateUpdateRequest(UpdateRequest updateRequest) throws Sky break; case ENABLE_STRICT: if (tokens == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.TOKENS_REQUIRED_WITH_BYOT.getLog(), InterfaceName.INSERT.getName(), Byot.ENABLE_STRICT.toString() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), Utils.parameterizedString( ErrorMessage.NoTokensWithByot.getMessage(), Byot.ENABLE_STRICT.toString())); } else if (tokens.size() != values.size()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.INSUFFICIENT_TOKENS_PASSED_FOR_BYOT_ENABLE_STRICT.getLog(), InterfaceName.INSERT.getName() )); @@ -517,23 +526,23 @@ public static void validateDeleteRequest(DeleteRequest deleteRequest) throws Sky String table = deleteRequest.getTable(); ArrayList ids = deleteRequest.getIds(); if (table == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.TABLE_IS_REQUIRED.getLog(), InterfaceName.DELETE.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.TableKeyError.getMessage()); } else if (table.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_TABLE_NAME.getLog(), InterfaceName.DELETE.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyTable.getMessage()); } else if (ids == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.IDS_IS_REQUIRED.getLog(), InterfaceName.DELETE.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.IdsKeyError.getMessage()); } else if (ids.isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_IDS.getLog(), InterfaceName.DELETE.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyIds.getMessage()); @@ -541,7 +550,7 @@ public static void validateDeleteRequest(DeleteRequest deleteRequest) throws Sky for (int index = 0; index < ids.size(); index++) { String id = ids.get(index); if (id.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OR_NULL_ID_IN_IDS.getLog(), InterfaceName.DELETE.getName(), Integer.toString(index) )); @@ -554,12 +563,12 @@ public static void validateDeleteRequest(DeleteRequest deleteRequest) throws Sky public static void validateQueryRequest(QueryRequest queryRequest) throws SkyflowException { String query = queryRequest.getQuery(); if (query == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.QUERY_IS_REQUIRED.getLog(), InterfaceName.QUERY.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.QueryKeyError.getMessage()); } else if (query.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_QUERY.getLog(), InterfaceName.QUERY.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyQuery.getMessage()); @@ -571,12 +580,12 @@ public static void validateTokenizeRequest(TokenizeRequest tokenizeRequest) thro if (columnValues == null || columnValues.isEmpty()) { if (columnValues == null) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.COLUMN_VALUES_IS_REQUIRED_TOKENIZE.getLog(), InterfaceName.TOKENIZE.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.ColumnValuesKeyErrorTokenize.getMessage()); } else { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_COLUMN_VALUES.getLog(), InterfaceName.TOKENIZE.getName() )); } @@ -585,13 +594,13 @@ public static void validateTokenizeRequest(TokenizeRequest tokenizeRequest) thro for (int index = 0; index < columnValues.size(); index++) { ColumnValue value = columnValues.get(index); if (value.getValue() == null || value.getValue().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OR_NULL_COLUMN_VALUE_IN_COLUMN_VALUES.getLog(), InterfaceName.TOKENIZE.getName(), Integer.toString(index) )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyValueInColumnValues.getMessage()); } else if (value.getColumnGroup() == null || value.getColumnGroup().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OR_NULL_COLUMN_GROUP_IN_COLUMN_VALUES.getLog(), InterfaceName.TOKENIZE.getName(), Integer.toString(index) )); @@ -604,10 +613,11 @@ public static void validateTokenizeRequest(TokenizeRequest tokenizeRequest) thro private static void validateTokensForInsertRequest( ArrayList> tokens, - ArrayList> values + ArrayList> values, + Byot tokenStrict ) throws SkyflowException { if (tokens.isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_TOKENS.getLog(), InterfaceName.INSERT.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyTokens.getMessage()); @@ -616,6 +626,15 @@ private static void validateTokensForInsertRequest( for (int index = 0; index < tokens.size(); index++) { HashMap tokensMap = tokens.get(index); HashMap valuesMap = values.get(index); + if (tokensMap.size() != valuesMap.size() && tokenStrict == Byot.ENABLE_STRICT) { + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.INSUFFICIENT_TOKENS_PASSED_FOR_BYOT_ENABLE_STRICT.getLog(), + InterfaceName.INSERT.getName() + )); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), + ErrorMessage.InsufficientTokensPassedForByotEnableStrict.getMessage() + ); + } validateTokensMapWithTokenStrict(tokensMap, valuesMap); } } @@ -625,19 +644,19 @@ private static void validateTokensMapWithTokenStrict( ) throws SkyflowException { for (String key : tokensMap.keySet()) { if (key == null || key.trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OR_NULL_KEY_IN_TOKENS.getLog(), InterfaceName.INSERT.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyKeyInTokens.getMessage()); } else if (!valuesMap.containsKey(key)) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.MISMATCH_OF_FIELDS_AND_TOKENS.getLog(), InterfaceName.INSERT.getName() )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.MismatchOfFieldsAndTokens.getMessage()); } else { Object value = tokensMap.get(key); if (value == null || value.toString().trim().isEmpty()) { - LogUtil.printInfoLog(Utils.parameterizedString( + LogUtil.printErrorLog(Utils.parameterizedString( ErrorLogs.EMPTY_OR_NULL_VALUE_IN_TOKENS.getLog(), InterfaceName.INSERT.getName(), key )); From 8df4058d66aafd78d911e7d4227a453609462a42 Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Tue, 5 Nov 2024 20:32:14 +0530 Subject: [PATCH 05/18] SK-1684 Add unit tests - Add unit tests for configs i.e. vault, connection and credentials - Add unit tests for response pojo classes for few vault API interfaces --- .../com/skyflow/config/ConnectionConfig.java | 4 + .../java/com/skyflow/config/VaultConfig.java | 5 - .../utils/validations/Validations.java | 3 +- .../skyflow/vault/data/DeleteResponse.java | 2 +- .../com/skyflow/vault/data/QueryResponse.java | 2 +- .../skyflow/vault/data/UpdateResponse.java | 4 +- .../vault/config/ConnectionConfigTests.java | 144 ++++++++++ .../vault/config/CredentialsTests.java | 262 ++++++++++++++++++ .../vault/config/VaultConfigTests.java | 174 ++++++++++++ .../com/skyflow/vault/data/DeleteTests.java | 12 + .../java/com/skyflow/vault/data/GetTests.java | 22 +- .../com/skyflow/vault/data/InsertTests.java | 4 +- .../com/skyflow/vault/data/QueryTests.java | 23 ++ .../com/skyflow/vault/data/UpdateTests.java | 31 +-- .../vault/serviceaccount/util/TokenTests.java | 46 +++ 15 files changed, 700 insertions(+), 38 deletions(-) create mode 100644 v2/src/test/java/com/skyflow/vault/config/ConnectionConfigTests.java create mode 100644 v2/src/test/java/com/skyflow/vault/config/CredentialsTests.java create mode 100644 v2/src/test/java/com/skyflow/vault/config/VaultConfigTests.java create mode 100644 v2/src/test/java/com/skyflow/vault/serviceaccount/util/TokenTests.java diff --git a/v2/src/main/java/com/skyflow/config/ConnectionConfig.java b/v2/src/main/java/com/skyflow/config/ConnectionConfig.java index f0821de7..7661df0d 100644 --- a/v2/src/main/java/com/skyflow/config/ConnectionConfig.java +++ b/v2/src/main/java/com/skyflow/config/ConnectionConfig.java @@ -27,6 +27,10 @@ public void setConnectionUrl(String connectionUrl) { this.connectionUrl = connectionUrl; } + public Credentials getCredentials() { + return credentials; + } + public void setCredentials(Credentials credentials) { this.credentials = credentials; } diff --git a/v2/src/main/java/com/skyflow/config/VaultConfig.java b/v2/src/main/java/com/skyflow/config/VaultConfig.java index 2e757c7b..fd36d384 100644 --- a/v2/src/main/java/com/skyflow/config/VaultConfig.java +++ b/v2/src/main/java/com/skyflow/config/VaultConfig.java @@ -1,7 +1,6 @@ package com.skyflow.config; import com.skyflow.enums.Env; -import com.skyflow.utils.Utils; public class VaultConfig { private String vaultId; @@ -48,10 +47,6 @@ public void setCredentials(Credentials credentials) { this.credentials = credentials; } - public String getVaultURL() { - return Utils.getVaultURL(this.clusterId, this.env); - } - @Override public String toString() { return "VaultConfig {" + diff --git a/v2/src/main/java/com/skyflow/utils/validations/Validations.java b/v2/src/main/java/com/skyflow/utils/validations/Validations.java index 266bb0aa..f0c44956 100644 --- a/v2/src/main/java/com/skyflow/utils/validations/Validations.java +++ b/v2/src/main/java/com/skyflow/utils/validations/Validations.java @@ -134,7 +134,8 @@ public static void validateCredentials(Credentials credentials) throws SkyflowEx } } } - } else if (context != null && context.trim().isEmpty()) { + } + if (context != null && context.trim().isEmpty()) { LogUtil.printErrorLog(ErrorLogs.EMPTY_OR_NULL_CONTEXT.getLog()); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyContext.getMessage()); } diff --git a/v2/src/main/java/com/skyflow/vault/data/DeleteResponse.java b/v2/src/main/java/com/skyflow/vault/data/DeleteResponse.java index 0024c68a..21adc788 100644 --- a/v2/src/main/java/com/skyflow/vault/data/DeleteResponse.java +++ b/v2/src/main/java/com/skyflow/vault/data/DeleteResponse.java @@ -3,7 +3,7 @@ import java.util.ArrayList; public class DeleteResponse { - private ArrayList deletedIds; + private final ArrayList deletedIds; public DeleteResponse(ArrayList deletedIds) { this.deletedIds = deletedIds; diff --git a/v2/src/main/java/com/skyflow/vault/data/QueryResponse.java b/v2/src/main/java/com/skyflow/vault/data/QueryResponse.java index 72d1e316..e8103506 100644 --- a/v2/src/main/java/com/skyflow/vault/data/QueryResponse.java +++ b/v2/src/main/java/com/skyflow/vault/data/QueryResponse.java @@ -4,7 +4,7 @@ import java.util.HashMap; public class QueryResponse { - private ArrayList> fields; + private final ArrayList> fields; private ArrayList> tokenizedData; public QueryResponse(ArrayList> fields) { diff --git a/v2/src/main/java/com/skyflow/vault/data/UpdateResponse.java b/v2/src/main/java/com/skyflow/vault/data/UpdateResponse.java index 05ae30bd..0f860b22 100644 --- a/v2/src/main/java/com/skyflow/vault/data/UpdateResponse.java +++ b/v2/src/main/java/com/skyflow/vault/data/UpdateResponse.java @@ -3,8 +3,8 @@ import java.util.HashMap; public class UpdateResponse { - private String skyflowId; - private HashMap tokens; + private final String skyflowId; + private final HashMap tokens; public UpdateResponse(String skyflowId, HashMap tokens) { this.skyflowId = skyflowId; diff --git a/v2/src/test/java/com/skyflow/vault/config/ConnectionConfigTests.java b/v2/src/test/java/com/skyflow/vault/config/ConnectionConfigTests.java new file mode 100644 index 00000000..648ad98d --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/config/ConnectionConfigTests.java @@ -0,0 +1,144 @@ +package com.skyflow.vault.config; + +import com.skyflow.config.ConnectionConfig; +import com.skyflow.config.Credentials; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.generated.rest.ApiClient; +import com.skyflow.serviceaccount.util.Token; +import com.skyflow.utils.validations.Validations; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +@RunWith(PowerMockRunner.class) +@PrepareForTest(fullyQualifiedNames = "com.skyflow.serviceaccount.util.Token") +public class ConnectionConfigTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String connectionID = null; + private static String connectionURL = null; + private static String invalidConnectionURL = null; + private static Credentials credentials = null; + + @BeforeClass + public static void setup() throws SkyflowException, NoSuchMethodException { + PowerMockito.mockStatic(Token.class); + PowerMockito.when(Token.isExpired("valid_token")).thenReturn(true); + PowerMockito.when(Token.isExpired("not_a_valid_token")).thenReturn(false); + PowerMockito.mock(ApiClient.class); + + connectionID = "connection123"; + connectionURL = "https://connection.url.com"; + invalidConnectionURL = "invalid.connection.url.com"; + + credentials = new Credentials(); + credentials.setToken("valid-token"); + } + + @Test + public void testValidConnectionConfigWithCredentials() { + try { + ConnectionConfig connectionConfig = new ConnectionConfig(); + connectionConfig.setConnectionId(connectionID); + connectionConfig.setConnectionUrl(connectionURL); + connectionConfig.setCredentials(credentials); + Validations.validateConnectionConfig(connectionConfig); + + Assert.assertEquals(connectionID, connectionConfig.getConnectionId()); + Assert.assertEquals(connectionURL, connectionConfig.getConnectionUrl()); + Assert.assertNotNull(connectionConfig.getCredentials()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testValidConnectionConfigWithoutCredentials() { + try { + ConnectionConfig connectionConfig = new ConnectionConfig(); + connectionConfig.setConnectionId(connectionID); + connectionConfig.setConnectionUrl(connectionURL); + Validations.validateConnectionConfig(connectionConfig); + + Assert.assertEquals(connectionID, connectionConfig.getConnectionId()); + Assert.assertEquals(connectionURL, connectionConfig.getConnectionUrl()); + Assert.assertNull(connectionConfig.getCredentials()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testNoConnectionIdInConnectionConfig() { + ConnectionConfig connectionConfig = new ConnectionConfig(); + try { + connectionConfig.setConnectionUrl(connectionURL); + Validations.validateConnectionConfig(connectionConfig); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidConnectionId.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyConnectionIdInConnectionConfig() { + try { + ConnectionConfig connectionConfig = new ConnectionConfig(); + connectionConfig.setConnectionId(""); + connectionConfig.setConnectionUrl(connectionURL); + Validations.validateConnectionConfig(connectionConfig); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyConnectionId.getMessage(), e.getMessage()); + } + } + + @Test + public void testNoConnectionURLInConnectionConfig() { + try { + ConnectionConfig connectionConfig = new ConnectionConfig(); + connectionConfig.setConnectionId(connectionID); + Validations.validateConnectionConfig(connectionConfig); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidConnectionUrl.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyConnectionURLInConnectionConfig() { + try { + ConnectionConfig connectionConfig = new ConnectionConfig(); + connectionConfig.setConnectionId(connectionID); + connectionConfig.setConnectionUrl(""); + Validations.validateConnectionConfig(connectionConfig); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyConnectionUrl.getMessage(), e.getMessage()); + } + } + + @Test + public void testInvalidConnectionURLInConnectionConfig() { + try { + ConnectionConfig connectionConfig = new ConnectionConfig(); + connectionConfig.setConnectionId(connectionID); + connectionConfig.setConnectionUrl(invalidConnectionURL); + Validations.validateConnectionConfig(connectionConfig); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidConnectionUrlFormat.getMessage(), e.getMessage()); + } + } +} diff --git a/v2/src/test/java/com/skyflow/vault/config/CredentialsTests.java b/v2/src/test/java/com/skyflow/vault/config/CredentialsTests.java new file mode 100644 index 00000000..554f7f0d --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/config/CredentialsTests.java @@ -0,0 +1,262 @@ +package com.skyflow.vault.config; + +import com.skyflow.config.Credentials; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.generated.rest.ApiClient; +import com.skyflow.serviceaccount.util.Token; +import com.skyflow.utils.validations.Validations; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import java.util.ArrayList; + +@RunWith(PowerMockRunner.class) +@PrepareForTest(fullyQualifiedNames = "com.skyflow.serviceaccount.util.Token") +public class CredentialsTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String path = null; + private static String credentialsString = null; + private static String token = null; + private static String validApiKey = null; + private static String invalidApiKey = null; + private static ArrayList roles = null; + private static String role = null; + private static String context = null; + + @BeforeClass + public static void setup() throws SkyflowException, NoSuchMethodException { + PowerMockito.mockStatic(Token.class); + PowerMockito.when(Token.isExpired("valid_token")).thenReturn(true); + PowerMockito.when(Token.isExpired("not_a_valid_token")).thenReturn(false); + PowerMockito.mock(ApiClient.class); + + path = "valid-path-to-credentials-file"; + credentialsString = "valid-credentials-string"; + token = "valid-token"; + validApiKey = "sky-ab123-abcd1234cdef1234abcd4321cdef4321"; + invalidApiKey = "invalid-api-key"; + roles = new ArrayList<>(); + role = "test_credentials_role"; + context = "test_context_value"; + } + + @Test + public void testValidCredentialsWithPath() { + try { + Credentials credentials = new Credentials(); + credentials.setPath(path); + Validations.validateCredentials(credentials); + Assert.assertNull(credentials.getCredentialsString()); + Assert.assertNull(credentials.getToken()); + Assert.assertNull(credentials.getApiKey()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testValidCredentialsWithCredentialsString() { + try { + Credentials credentials = new Credentials(); + credentials.setCredentialsString(credentialsString); + Validations.validateCredentials(credentials); + Assert.assertNull(credentials.getPath()); + Assert.assertNull(credentials.getToken()); + Assert.assertNull(credentials.getApiKey()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testValidCredentialsWithToken() { + try { + Credentials credentials = new Credentials(); + credentials.setToken(token); + Validations.validateCredentials(credentials); + Assert.assertNull(credentials.getPath()); + Assert.assertNull(credentials.getCredentialsString()); + Assert.assertNull(credentials.getApiKey()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testValidCredentialsWithApikey() { + try { + Credentials credentials = new Credentials(); + credentials.setApiKey(validApiKey); + Validations.validateCredentials(credentials); + Assert.assertNull(credentials.getPath()); + Assert.assertNull(credentials.getCredentialsString()); + Assert.assertNull(credentials.getToken()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testValidCredentialsWithRolesAndContext() { + try { + roles.add(role); + Credentials credentials = new Credentials(); + credentials.setApiKey(validApiKey); + credentials.setRoles(roles); + credentials.setContext(context); + Validations.validateCredentials(credentials); + Assert.assertNull(credentials.getPath()); + Assert.assertNull(credentials.getCredentialsString()); + Assert.assertNull(credentials.getToken()); + Assert.assertEquals(context, credentials.getContext()); + Assert.assertEquals(1, credentials.getRoles().size()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testEmptyPathInCredentials() { + try { + Credentials credentials = new Credentials(); + credentials.setPath(""); + Validations.validateCredentials(credentials); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyCredentialFilePath.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyCredentialsStringInCredentials() { + try { + Credentials credentials = new Credentials(); + credentials.setCredentialsString(""); + Validations.validateCredentials(credentials); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyCredentialsString.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyTokenInCredentials() { + try { + Credentials credentials = new Credentials(); + credentials.setToken(""); + Validations.validateCredentials(credentials); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyToken.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyApikeyInCredentials() { + try { + Credentials credentials = new Credentials(); + credentials.setApiKey(""); + Validations.validateCredentials(credentials); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyApikey.getMessage(), e.getMessage()); + } + } + + @Test + public void testInvalidApikeyInCredentials() { + try { + Credentials credentials = new Credentials(); + credentials.setApiKey(invalidApiKey); + Validations.validateCredentials(credentials); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidApikey.getMessage(), e.getMessage()); + } + } + + @Test + public void testBothTokenAndPathInCredentials() { + try { + Credentials credentials = new Credentials(); + credentials.setPath(path); + credentials.setToken(token); + Validations.validateCredentials(credentials); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.MultipleTokenGenerationMeansPassed.getMessage(), e.getMessage()); + } + } + + @Test + public void testNothingPassedInCredentials() { + try { + Credentials credentials = new Credentials(); + Validations.validateCredentials(credentials); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.NoTokenGenerationMeansPassed.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyRolesInCredentials() { + try { + roles.clear(); + Credentials credentials = new Credentials(); + credentials.setPath(path); + credentials.setRoles(roles); + Validations.validateCredentials(credentials); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyRoles.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyRoleInRolesInCredentials() { + try { + Credentials credentials = new Credentials(); + credentials.setPath(path); + roles.add(role); + roles.add(""); + credentials.setRoles(roles); + Validations.validateCredentials(credentials); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyRoleInRoles.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyContextInCredentials() { + try { + Credentials credentials = new Credentials(); + credentials.setPath(path); + credentials.setContext(""); + Validations.validateCredentials(credentials); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyContext.getMessage(), e.getMessage()); + } + } + +} diff --git a/v2/src/test/java/com/skyflow/vault/config/VaultConfigTests.java b/v2/src/test/java/com/skyflow/vault/config/VaultConfigTests.java new file mode 100644 index 00000000..011f2990 --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/config/VaultConfigTests.java @@ -0,0 +1,174 @@ +package com.skyflow.vault.config; + +import com.skyflow.config.Credentials; +import com.skyflow.config.VaultConfig; +import com.skyflow.enums.Env; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.generated.rest.ApiClient; +import com.skyflow.serviceaccount.util.Token; +import com.skyflow.utils.validations.Validations; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +@RunWith(PowerMockRunner.class) +@PrepareForTest(fullyQualifiedNames = "com.skyflow.serviceaccount.util.Token") +public class VaultConfigTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String vaultID = null; + private static String clusterID = null; + private static Credentials credentials = null; + + + @BeforeClass + public static void setup() throws SkyflowException, NoSuchMethodException { + PowerMockito.mockStatic(Token.class); + PowerMockito.when(Token.isExpired("valid_token")).thenReturn(true); + PowerMockito.when(Token.isExpired("not_a_valid_token")).thenReturn(false); + PowerMockito.mock(ApiClient.class); + + vaultID = "vault123"; + clusterID = "cluster123"; + + credentials = new Credentials(); + credentials.setToken("valid-token"); + + } + + @Test + public void testValidVaultConfigWithCredentials() { + try { + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + vaultConfig.setEnv(Env.SANDBOX); + vaultConfig.setCredentials(credentials); + Validations.validateVaultConfig(vaultConfig); + + Assert.assertEquals(vaultID, vaultConfig.getVaultId()); + Assert.assertEquals(clusterID, vaultConfig.getClusterId()); + Assert.assertEquals(Env.SANDBOX, vaultConfig.getEnv()); + Assert.assertNotNull(vaultConfig.getCredentials()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testValidVaultConfigWithoutCredentials() { + try { + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + vaultConfig.setEnv(Env.SANDBOX); + Validations.validateVaultConfig(vaultConfig); + + Assert.assertEquals(vaultID, vaultConfig.getVaultId()); + Assert.assertEquals(clusterID, vaultConfig.getClusterId()); + Assert.assertEquals(Env.SANDBOX, vaultConfig.getEnv()); + Assert.assertNull(vaultConfig.getCredentials()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testDefaultEnvInVaultConfigWithCredentials() { + try { + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + vaultConfig.setCredentials(credentials); + Validations.validateVaultConfig(vaultConfig); + + Assert.assertEquals(vaultID, vaultConfig.getVaultId()); + Assert.assertEquals(clusterID, vaultConfig.getClusterId()); + Assert.assertEquals(Env.PROD, vaultConfig.getEnv()); + Assert.assertNotNull(vaultConfig.getCredentials()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testDefaultEnvInVaultConfigWithoutCredentials() { + try { + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + Validations.validateVaultConfig(vaultConfig); + + Assert.assertEquals(vaultID, vaultConfig.getVaultId()); + Assert.assertEquals(clusterID, vaultConfig.getClusterId()); + Assert.assertEquals(Env.PROD, vaultConfig.getEnv()); + Assert.assertNull(vaultConfig.getCredentials()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testNoVaultIdInVaultConfig() { + VaultConfig vaultConfig = new VaultConfig(); + try { + vaultConfig.setClusterId(clusterID); + vaultConfig.setEnv(Env.SANDBOX); + Validations.validateVaultConfig(vaultConfig); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidVaultId.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyVaultIdInVaultConfig() { + try { + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(""); + vaultConfig.setClusterId(clusterID); + vaultConfig.setEnv(Env.SANDBOX); + Validations.validateVaultConfig(vaultConfig); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyVaultId.getMessage(), e.getMessage()); + } + } + + @Test + public void testNoClusterIdInVaultConfig() { + try { + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setEnv(Env.SANDBOX); + Validations.validateVaultConfig(vaultConfig); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidClusterId.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyClusterIdInVaultConfig() { + try { + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(""); + vaultConfig.setEnv(Env.SANDBOX); + Validations.validateVaultConfig(vaultConfig); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyClusterId.getMessage(), e.getMessage()); + } + } +} diff --git a/v2/src/test/java/com/skyflow/vault/data/DeleteTests.java b/v2/src/test/java/com/skyflow/vault/data/DeleteTests.java index 5660522e..9ab78af6 100644 --- a/v2/src/test/java/com/skyflow/vault/data/DeleteTests.java +++ b/v2/src/test/java/com/skyflow/vault/data/DeleteTests.java @@ -152,4 +152,16 @@ public void testEmptyTableInDeleteRequestValidations() { ); } } + + @Test + public void testDeleteResponse() { + try { + DeleteResponse response = new DeleteResponse(ids); + String responseString = "{\n\t\"deletedIds\": [\n\t\t\"" + skyflowID + "\"]\n}"; + Assert.assertEquals(1, response.getDeletedIds().size()); + Assert.assertEquals(responseString, response.toString()); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } } diff --git a/v2/src/test/java/com/skyflow/vault/data/GetTests.java b/v2/src/test/java/com/skyflow/vault/data/GetTests.java index 66e5cddb..ac6625fe 100644 --- a/v2/src/test/java/com/skyflow/vault/data/GetTests.java +++ b/v2/src/test/java/com/skyflow/vault/data/GetTests.java @@ -13,6 +13,7 @@ import com.skyflow.utils.Utils; import com.skyflow.utils.validations.Validations; import org.junit.Assert; +import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; @@ -69,6 +70,13 @@ public static void setup() throws SkyflowException { table = "test_table"; } + @Before + public void setupTest() { + ids.clear(); + fields.clear(); + columnValues.clear(); + } + @Test public void testValidGetByIdInputInGetRequestValidations() { try { @@ -103,6 +111,7 @@ public void testValidGetByIdInputInGetRequestValidations() { public void testValidGetByColumnValuesInputInGetRequestValidations() { try { columnValues.add(columnValue); + fields.add(field); GetRequest request = GetRequest.builder() .table(table) .columnName(columnName) @@ -132,7 +141,6 @@ public void testValidGetByColumnValuesInputInGetRequestValidations() { @Test public void testNoTableInGetRequestValidations() { - ids.clear(); ids.add(skyflowID); GetRequest request = GetRequest.builder().ids(ids).build(); try { @@ -149,7 +157,6 @@ public void testNoTableInGetRequestValidations() { @Test public void testEmptyTableInGetRequestValidations() { - ids.clear(); ids.add(skyflowID); GetRequest request = GetRequest.builder().ids(ids).table("").build(); try { @@ -166,7 +173,6 @@ public void testEmptyTableInGetRequestValidations() { @Test public void testEmptyIdsInGetRequestValidations() { - ids.clear(); GetRequest request = GetRequest.builder().ids(ids).table(table).build(); try { Validations.validateGetRequest(request); @@ -199,13 +205,9 @@ public void testEmptyIdInIdsInGetRequestValidations() { @Test public void testEmptyFieldsInGetRequestValidations() { - ids.clear(); ids.add(skyflowID); - fields.clear(); GetRequest request = GetRequest.builder().ids(ids).table(table).fields(fields).build(); try { - System.out.println(ids); - System.out.println(fields); Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { @@ -219,12 +221,11 @@ public void testEmptyFieldsInGetRequestValidations() { @Test public void testEmptyFieldInFieldsInGetRequestValidations() { + ids.add(skyflowID); fields.add(field); fields.add(""); GetRequest request = GetRequest.builder().ids(ids).table(table).fields(fields).build(); try { - System.out.println(ids); - System.out.println(fields); Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { @@ -349,6 +350,7 @@ public void testNoIdsOrColumnNameInGetRequestValidations() { @Test public void testBothIdsAndColumnNameInGetRequestValidations() { + ids.add(skyflowID); GetRequest request = GetRequest.builder() .table(table).redactionType(RedactionType.PLAIN_TEXT).ids(ids).columnName(columnName) .build(); @@ -366,6 +368,7 @@ public void testBothIdsAndColumnNameInGetRequestValidations() { @Test public void testBothIdsAndColumnValuesInGetRequestValidations() { + ids.add(skyflowID); GetRequest request = GetRequest.builder() .table(table).redactionType(RedactionType.PLAIN_TEXT).ids(ids).columnValues(columnValues) .build(); @@ -434,7 +437,6 @@ public void testEmptyColumnNameInGetRequestValidations() { @Test public void testEmptyColumnValuesInGetRequestValidations() { - columnValues.clear(); GetRequest request = GetRequest.builder() .table(table).redactionType(RedactionType.PLAIN_TEXT).columnName(columnName).columnValues(columnValues) .build(); diff --git a/v2/src/test/java/com/skyflow/vault/data/InsertTests.java b/v2/src/test/java/com/skyflow/vault/data/InsertTests.java index 2b1c8432..f49f9c20 100644 --- a/v2/src/test/java/com/skyflow/vault/data/InsertTests.java +++ b/v2/src/test/java/com/skyflow/vault/data/InsertTests.java @@ -93,6 +93,8 @@ public void testValidInputInInsertRequestValidations() { Assert.assertEquals(1, request.getTokens().size()); Assert.assertEquals(Byot.ENABLE, request.getTokenStrict()); Assert.assertTrue(request.getContinueOnError()); + Assert.assertTrue(request.getReturnTokens()); + Assert.assertTrue(request.getTokenMode()); Assert.assertFalse(request.getHomogeneous()); } catch (SkyflowException e) { Assert.fail(INVALID_EXCEPTION_THROWN); @@ -294,8 +296,6 @@ public void testEmptyTokensWithTokenStrictEnableInInsertRequestValidations() { @Test public void testInsufficientTokensWithTokenStrictEnableStrictInInsertRequestValidations1() { tokens.add(tokenMap); - System.out.println(values); - System.out.println(tokens); InsertRequest request = InsertRequest.builder() .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE_STRICT) .build(); diff --git a/v2/src/test/java/com/skyflow/vault/data/QueryTests.java b/v2/src/test/java/com/skyflow/vault/data/QueryTests.java index 141704a1..3197a83c 100644 --- a/v2/src/test/java/com/skyflow/vault/data/QueryTests.java +++ b/v2/src/test/java/com/skyflow/vault/data/QueryTests.java @@ -19,6 +19,9 @@ import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.modules.junit4.PowerMockRunner; +import java.util.ArrayList; +import java.util.HashMap; + @RunWith(PowerMockRunner.class) @PrepareForTest(fullyQualifiedNames = "com.skyflow.serviceaccount.util.Token") public class QueryTests { @@ -28,6 +31,7 @@ public class QueryTests { private static String clusterID = null; private static String query = null; private static Skyflow skyflowClient = null; + private static HashMap queryRecord = null; @BeforeClass public static void setup() throws SkyflowException { @@ -48,6 +52,9 @@ public static void setup() throws SkyflowException { vaultConfig.setCredentials(credentials); query = "test_query"; + queryRecord = new HashMap<>(); + queryRecord.put("name", "test_name"); + queryRecord.put("card_number", "test_card_number"); // skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); } @@ -92,4 +99,20 @@ public void testEmptyQueryInQueryRequestValidations() { ); } } + + @Test + public void testQueryResponse() { + try { + ArrayList> fields = new ArrayList<>(); + fields.add(queryRecord); + QueryResponse response = new QueryResponse(fields); + String responseString = "{\n\t\"fields\": " + + "[{\n\t\t\"card_number\": \"test_card_number\",\n\t\t\"name\": \"test_name\"," + + "\n\t\t\"tokenizedData\": " + null + "\n\t}]\n}"; + Assert.assertEquals(1, response.getFields().size()); + Assert.assertEquals(responseString, response.toString()); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } } diff --git a/v2/src/test/java/com/skyflow/vault/data/UpdateTests.java b/v2/src/test/java/com/skyflow/vault/data/UpdateTests.java index 5a72001c..3780a417 100644 --- a/v2/src/test/java/com/skyflow/vault/data/UpdateTests.java +++ b/v2/src/test/java/com/skyflow/vault/data/UpdateTests.java @@ -217,8 +217,6 @@ public void testTokensWithTokenStrictDisableInUpdateRequestValidations() { .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.DISABLE) .build(); try { - System.out.println(valueMap); - System.out.println(tokenMap); Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { @@ -253,8 +251,6 @@ public void testNoTokensWithTokenStrictEnableStrictInUpdateRequestValidations() .id(skyflowID).table(table).values(valueMap).tokenStrict(Byot.ENABLE_STRICT) .build(); try { - System.out.println(valueMap); - System.out.println(tokenMap); Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { @@ -273,8 +269,6 @@ public void testEmptyTokensWithTokenStrictEnableInUpdateRequestValidations() { .id(skyflowID).table(table).values(valueMap).tokens(emptyTokenMap).tokenStrict(Byot.ENABLE) .build(); try { - System.out.println(valueMap); - System.out.println(tokenMap); Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { @@ -289,8 +283,6 @@ public void testInsufficientTokensWithTokenStrictEnableStrictInUpdateRequestVali .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) .build(); try { - System.out.println(valueMap); - System.out.println(tokenMap); Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { @@ -305,8 +297,6 @@ public void testInsufficientTokensWithTokenStrictEnableStrictInUpdateRequestVali .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) .build(); try { - System.out.println(valueMap); - System.out.println(tokenMap); Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { @@ -322,8 +312,6 @@ public void testTokenValueMismatchInUpdateRequestValidations() { .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) .build(); try { - System.out.println(valueMap); - System.out.println(tokenMap); Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { @@ -341,8 +329,6 @@ public void testEmptyKeyInTokensInUpdateRequestValidations() { .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) .build(); try { - System.out.println(valueMap); - System.out.println(tokenMap); Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { @@ -359,8 +345,6 @@ public void testEmptyValueInTokensInUpdateRequestValidations() { .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) .build(); try { - System.out.println(valueMap); - System.out.println(tokenMap); Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { @@ -369,4 +353,19 @@ public void testEmptyValueInTokensInUpdateRequestValidations() { } } + @Test + public void testUpdateResponse() { + try { + tokenMap.put("test_column_2", "test_token_2"); + UpdateResponse response = new UpdateResponse(skyflowID, tokenMap); + String responseString = "{\n\t\"skyflowId\": " + skyflowID + "\n\t\"tokens\": " + + "{\n\t\t\"test_column_1\": \"test_token_1\"," + + "\n\t\t\"test_column_2\": \"test_token_2\",\n\t}\n}"; + Assert.assertEquals(skyflowID, response.getSkyflowId()); + Assert.assertEquals(2, response.getTokens().size()); + Assert.assertEquals(responseString, response.toString()); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } } diff --git a/v2/src/test/java/com/skyflow/vault/serviceaccount/util/TokenTests.java b/v2/src/test/java/com/skyflow/vault/serviceaccount/util/TokenTests.java new file mode 100644 index 00000000..3a3d8f6e --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/serviceaccount/util/TokenTests.java @@ -0,0 +1,46 @@ +package com.skyflow.vault.serviceaccount.util; + +import com.skyflow.serviceaccount.util.Token; +import org.junit.Assert; +import org.junit.Test; + +public class TokenTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + + @Test + public void testNoTokenForIsExpiredToken() { + try { + Assert.assertTrue(Token.isExpired(null)); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testEmptyTokenForIsExpiredToken() { + try { + Assert.assertTrue(Token.isExpired("")); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testInvalidTokenForIsExpiredToken() { + try { + Assert.assertTrue(Token.isExpired("invalid-token")); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testExpiredTokenForIsExpiredToken() { + try { + String token = System.getProperty("TEST_EXPIRED_TOKEN"); + Assert.assertTrue(Token.isExpired(token)); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } +} From be856d008b90ef36ace543b0e830798b98088a92 Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Wed, 6 Nov 2024 21:12:15 +0530 Subject: [PATCH 06/18] SK-1684 Add unit tests for bearer token utilities --- .../serviceaccount/util/BearerToken.java | 4 +- .../serviceaccount/util/SignedDataTokens.java | 4 +- .../config/ConnectionConfigTests.java | 2 +- .../{vault => }/config/CredentialsTests.java | 2 +- .../{vault => }/config/VaultConfigTests.java | 20 +- .../serviceaccount/util/BearerTokenTests.java | 220 ++++++++++++++++++ .../serviceaccount/util/TokenTests.java | 3 +- .../java/com/skyflow/utils/UtilsTests.java | 136 +++++++++++ .../skyflow/vault/tokens/DetokenizeTests.java | 23 +- .../invalidPrivateKeyCredentials.json | 1 + .../resources/invalidTokenURICredentials.json | 1 + .../test/resources/noClientIDCredentials.json | 1 + v2/src/test/resources/noKeyIDCredentials.json | 1 + .../resources/noPrivateKeyCredentials.json | 1 + .../test/resources/noTokenURICredentials.json | 1 + v2/src/test/resources/notJson.txt | 1 + 16 files changed, 401 insertions(+), 20 deletions(-) rename v2/src/test/java/com/skyflow/{vault => }/config/ConnectionConfigTests.java (99%) rename v2/src/test/java/com/skyflow/{vault => }/config/CredentialsTests.java (99%) rename v2/src/test/java/com/skyflow/{vault => }/config/VaultConfigTests.java (91%) create mode 100644 v2/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java rename v2/src/test/java/com/skyflow/{vault => }/serviceaccount/util/TokenTests.java (92%) create mode 100644 v2/src/test/java/com/skyflow/utils/UtilsTests.java create mode 100644 v2/src/test/resources/invalidPrivateKeyCredentials.json create mode 100644 v2/src/test/resources/invalidTokenURICredentials.json create mode 100644 v2/src/test/resources/noClientIDCredentials.json create mode 100644 v2/src/test/resources/noKeyIDCredentials.json create mode 100644 v2/src/test/resources/noPrivateKeyCredentials.json create mode 100644 v2/src/test/resources/noTokenURICredentials.json create mode 100644 v2/src/test/resources/notJson.txt diff --git a/v2/src/main/java/com/skyflow/serviceaccount/util/BearerToken.java b/v2/src/main/java/com/skyflow/serviceaccount/util/BearerToken.java index 2040cf16..f235da49 100644 --- a/v2/src/main/java/com/skyflow/serviceaccount/util/BearerToken.java +++ b/v2/src/main/java/com/skyflow/serviceaccount/util/BearerToken.java @@ -65,11 +65,11 @@ private static V1GetAuthTokenResponse generateBearerTokenFromCredentials( } catch (JsonSyntaxException e) { LogUtil.printErrorLog(ErrorLogs.INVALID_CREDENTIALS_FILE_FORMAT.getLog()); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), Utils.parameterizedString( - ErrorMessage.FileInvalidJson.getMessage(), credentialsFile.getAbsolutePath())); + ErrorMessage.FileInvalidJson.getMessage(), credentialsFile.getPath())); } catch (FileNotFoundException e) { LogUtil.printErrorLog(ErrorLogs.CREDENTIALS_FILE_NOT_FOUND.getLog()); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), Utils.parameterizedString( - ErrorMessage.FileNotFound.getMessage(), credentialsFile.getAbsolutePath())); + ErrorMessage.FileNotFound.getMessage(), credentialsFile.getPath())); } } diff --git a/v2/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java b/v2/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java index 47e50951..88312ff7 100644 --- a/v2/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java +++ b/v2/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java @@ -60,11 +60,11 @@ private static List generateSignedTokenFromCredentialsF } catch (JsonSyntaxException e) { LogUtil.printErrorLog(ErrorLogs.INVALID_CREDENTIALS_FILE_FORMAT.getLog()); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), Utils.parameterizedString( - ErrorMessage.FileInvalidJson.getMessage(), credentialsFile.getAbsolutePath())); + ErrorMessage.FileInvalidJson.getMessage(), credentialsFile.getPath())); } catch (FileNotFoundException e) { LogUtil.printErrorLog(ErrorLogs.CREDENTIALS_FILE_NOT_FOUND.getLog()); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), Utils.parameterizedString( - ErrorMessage.FileNotFound.getMessage(), credentialsFile.getAbsolutePath())); + ErrorMessage.FileNotFound.getMessage(), credentialsFile.getPath())); } return responseToken; } diff --git a/v2/src/test/java/com/skyflow/vault/config/ConnectionConfigTests.java b/v2/src/test/java/com/skyflow/config/ConnectionConfigTests.java similarity index 99% rename from v2/src/test/java/com/skyflow/vault/config/ConnectionConfigTests.java rename to v2/src/test/java/com/skyflow/config/ConnectionConfigTests.java index 648ad98d..03b1021e 100644 --- a/v2/src/test/java/com/skyflow/vault/config/ConnectionConfigTests.java +++ b/v2/src/test/java/com/skyflow/config/ConnectionConfigTests.java @@ -1,4 +1,4 @@ -package com.skyflow.vault.config; +package com.skyflow.config; import com.skyflow.config.ConnectionConfig; import com.skyflow.config.Credentials; diff --git a/v2/src/test/java/com/skyflow/vault/config/CredentialsTests.java b/v2/src/test/java/com/skyflow/config/CredentialsTests.java similarity index 99% rename from v2/src/test/java/com/skyflow/vault/config/CredentialsTests.java rename to v2/src/test/java/com/skyflow/config/CredentialsTests.java index 554f7f0d..64f34c94 100644 --- a/v2/src/test/java/com/skyflow/vault/config/CredentialsTests.java +++ b/v2/src/test/java/com/skyflow/config/CredentialsTests.java @@ -1,4 +1,4 @@ -package com.skyflow.vault.config; +package com.skyflow.config; import com.skyflow.config.Credentials; import com.skyflow.errors.ErrorCode; diff --git a/v2/src/test/java/com/skyflow/vault/config/VaultConfigTests.java b/v2/src/test/java/com/skyflow/config/VaultConfigTests.java similarity index 91% rename from v2/src/test/java/com/skyflow/vault/config/VaultConfigTests.java rename to v2/src/test/java/com/skyflow/config/VaultConfigTests.java index 011f2990..478f8cf0 100644 --- a/v2/src/test/java/com/skyflow/vault/config/VaultConfigTests.java +++ b/v2/src/test/java/com/skyflow/config/VaultConfigTests.java @@ -1,7 +1,5 @@ -package com.skyflow.vault.config; +package com.skyflow.config; -import com.skyflow.config.Credentials; -import com.skyflow.config.VaultConfig; import com.skyflow.enums.Env; import com.skyflow.errors.ErrorCode; import com.skyflow.errors.ErrorMessage; @@ -43,7 +41,7 @@ public static void setup() throws SkyflowException, NoSuchMethodException { } @Test - public void testValidVaultConfigWithCredentials() { + public void testValidVaultConfigWithCredentialsInValidations() { try { VaultConfig vaultConfig = new VaultConfig(); vaultConfig.setVaultId(vaultID); @@ -62,7 +60,7 @@ public void testValidVaultConfigWithCredentials() { } @Test - public void testValidVaultConfigWithoutCredentials() { + public void testValidVaultConfigWithoutCredentialsInValidations() { try { VaultConfig vaultConfig = new VaultConfig(); vaultConfig.setVaultId(vaultID); @@ -80,7 +78,7 @@ public void testValidVaultConfigWithoutCredentials() { } @Test - public void testDefaultEnvInVaultConfigWithCredentials() { + public void testDefaultEnvInVaultConfigWithCredentialsInValidations() { try { VaultConfig vaultConfig = new VaultConfig(); vaultConfig.setVaultId(vaultID); @@ -98,7 +96,7 @@ public void testDefaultEnvInVaultConfigWithCredentials() { } @Test - public void testDefaultEnvInVaultConfigWithoutCredentials() { + public void testDefaultEnvInVaultConfigWithoutCredentialsInValidations() { try { VaultConfig vaultConfig = new VaultConfig(); vaultConfig.setVaultId(vaultID); @@ -115,7 +113,7 @@ public void testDefaultEnvInVaultConfigWithoutCredentials() { } @Test - public void testNoVaultIdInVaultConfig() { + public void testNoVaultIdInVaultConfigInValidations() { VaultConfig vaultConfig = new VaultConfig(); try { vaultConfig.setClusterId(clusterID); @@ -129,7 +127,7 @@ public void testNoVaultIdInVaultConfig() { } @Test - public void testEmptyVaultIdInVaultConfig() { + public void testEmptyVaultIdInVaultConfigInValidations() { try { VaultConfig vaultConfig = new VaultConfig(); vaultConfig.setVaultId(""); @@ -144,7 +142,7 @@ public void testEmptyVaultIdInVaultConfig() { } @Test - public void testNoClusterIdInVaultConfig() { + public void testNoClusterIdInVaultConfigInValidations() { try { VaultConfig vaultConfig = new VaultConfig(); vaultConfig.setVaultId(vaultID); @@ -158,7 +156,7 @@ public void testNoClusterIdInVaultConfig() { } @Test - public void testEmptyClusterIdInVaultConfig() { + public void testEmptyClusterIdInVaultConfigInValidations() { try { VaultConfig vaultConfig = new VaultConfig(); vaultConfig.setVaultId(vaultID); diff --git a/v2/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java b/v2/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java new file mode 100644 index 00000000..3993e476 --- /dev/null +++ b/v2/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java @@ -0,0 +1,220 @@ +package com.skyflow.serviceaccount.util; + +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.utils.Utils; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; +import java.util.ArrayList; + +public class BearerTokenTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String invalidJsonFilePath = null; + private static String credentialsFilePath = null; + private static String invalidFilePath = null; + private static String credentialsString = null; + private static String context = null; + private static ArrayList roles = null; + private static String role = null; + + @BeforeClass + public static void setup() { + credentialsFilePath = "./credentials.json"; + invalidJsonFilePath = "./src/test/resources/notJson.txt"; + invalidFilePath = "./src/test/credentials.json"; + credentialsString = "{\"key\":\"value\"}"; + context = "test_context"; + roles = new ArrayList<>(); + role = "test_role"; + } + + @Test + public void testBearerTokenBuilderWithCredentialsFile() { + try { + roles.add(role); + File file = new File(credentialsFilePath); + BearerToken.builder().setCredentials(file).setCtx(context).setRoles(roles).build(); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testBearerTokenBuilderWithCredentialsString() { + try { + BearerToken.builder().setCredentials(credentialsString).setCtx(context).setRoles(roles).build(); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + + } + + @Test + public void testEmptyCredentialsFilePath() { + try { + File file = new File(""); + BearerToken bearerToken = BearerToken.builder().setCredentials(file).build(); + bearerToken.getBearerToken(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidCredentials.getMessage(), e.getMessage()); + } + } + + @Test + public void testInvalidFilePath() { + try { + File file = new File(invalidFilePath); + BearerToken bearerToken = BearerToken.builder().setCredentials(file).build(); + bearerToken.getBearerToken(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidCredentials.getMessage(), e.getMessage()); + } + } + + @Test + public void testInvalidCredentialsFile() { + try { + File file = new File(invalidJsonFilePath); + BearerToken bearerToken = BearerToken.builder().setCredentials(file).build(); + bearerToken.getBearerToken(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.FileInvalidJson.getMessage(), invalidJsonFilePath), + e.getMessage() + ); + } + } + + @Test + public void testEmptyCredentialsString() { + try { + BearerToken bearerToken = BearerToken.builder().setCredentials("").build(); + bearerToken.getBearerToken(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidCredentials.getMessage(), e.getMessage()); + } + } + + @Test + public void testInvalidCredentialsString() { + try { + BearerToken bearerToken = BearerToken.builder().setCredentials(invalidFilePath).build(); + bearerToken.getBearerToken(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.CredentialsStringInvalidJson.getMessage(), e.getMessage()); + } + } + + + @Test + public void testNoPrivateKeyInCredentialsForCredentials() { + String filePath = "./src/test/resources/noPrivateKeyCredentials.json"; + File file = new File(filePath); + try { + BearerToken bearerToken = BearerToken.builder().setCredentials(file).build(); + bearerToken.getBearerToken(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.MissingPrivateKey.getMessage(), e.getMessage()); + } + } + + @Test + public void testNoClientIDInCredentialsForCredentials() { + String filePath = "./src/test/resources/noClientIDCredentials.json"; + File file = new File(filePath); + try { + BearerToken bearerToken = BearerToken.builder().setCredentials(file).build(); + bearerToken.getBearerToken(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.MissingClientId.getMessage(), e.getMessage()); + } + } + + @Test + public void testNoKeyIDInCredentialsForCredentials() { + String filePath = "./src/test/resources/noKeyIDCredentials.json"; + File file = new File(filePath); + try { + BearerToken bearerToken = BearerToken.builder().setCredentials(file).build(); + bearerToken.getBearerToken(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.MissingKeyId.getMessage(), e.getMessage()); + } + } + + @Test + public void testNoTokenURIInCredentialsForCredentials() { + String filePath = "./src/test/resources/noTokenURICredentials.json"; + File file = new File(filePath); + try { + BearerToken bearerToken = BearerToken.builder().setCredentials(file).build(); + bearerToken.getBearerToken(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.MissingTokenUri.getMessage(), e.getMessage()); + } + } + + @Test + public void testInvalidPrivateKeyInCredentialsForCredentials() { + String filePath = "./src/test/resources/invalidPrivateKeyCredentials.json"; + File file = new File(filePath); + try { + BearerToken bearerToken = BearerToken.builder().setCredentials(file).build(); + bearerToken.getBearerToken(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.JwtInvalidFormat.getMessage(), e.getMessage()); + } + } + + @Test + public void testInvalidKeySpecInCredentialsForCredentials() { + String credentialsString = "{\"privateKey\": \"-----BEGIN PRIVATE KEY-----\\ncHJpdmF0ZV9rZXlfdmFsdWU=\\n-----END PRIVATE KEY-----\", \"clientID\": \"client_id_value\", \"keyID\": \"key_id_value\", \"tokenURI\": \"invalid_token_uri\"}"; + try { + BearerToken bearerToken = BearerToken.builder().setCredentials(credentialsString).build(); + bearerToken.getBearerToken(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidKeySpec.getMessage(), e.getMessage()); + } + } + + @Test + public void testInvalidTokenURIInCredentialsForCredentials() throws SkyflowException { + String filePath = "./src/test/resources/invalidTokenURICredentials.json"; + File file = new File(filePath); + try { + BearerToken bearerToken = BearerToken.builder().setCredentials(file).build(); + bearerToken.getBearerToken(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidTokenUri.getMessage(), e.getMessage()); + } + } +} diff --git a/v2/src/test/java/com/skyflow/vault/serviceaccount/util/TokenTests.java b/v2/src/test/java/com/skyflow/serviceaccount/util/TokenTests.java similarity index 92% rename from v2/src/test/java/com/skyflow/vault/serviceaccount/util/TokenTests.java rename to v2/src/test/java/com/skyflow/serviceaccount/util/TokenTests.java index 3a3d8f6e..d1ac044b 100644 --- a/v2/src/test/java/com/skyflow/vault/serviceaccount/util/TokenTests.java +++ b/v2/src/test/java/com/skyflow/serviceaccount/util/TokenTests.java @@ -1,6 +1,5 @@ -package com.skyflow.vault.serviceaccount.util; +package com.skyflow.serviceaccount.util; -import com.skyflow.serviceaccount.util.Token; import org.junit.Assert; import org.junit.Test; diff --git a/v2/src/test/java/com/skyflow/utils/UtilsTests.java b/v2/src/test/java/com/skyflow/utils/UtilsTests.java new file mode 100644 index 00000000..33a83f59 --- /dev/null +++ b/v2/src/test/java/com/skyflow/utils/UtilsTests.java @@ -0,0 +1,136 @@ +package com.skyflow.utils; + +import com.skyflow.config.Credentials; +import com.skyflow.enums.Env; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; + +import java.util.ArrayList; + +public class UtilsTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String clusterId = null; + private static String url = null; + private static String filePath = null; + private static String credentialsString = null; + private static String token = null; + private static String context = null; + private static ArrayList roles = null; + + @BeforeClass + public static void setup() { + clusterId = "test_cluster_id"; + url = "https://test-url.com/java/unit/tests"; + filePath = "invalid/file/path/credentials.json"; + credentialsString = "invalid credentials string"; + token = "invalid-token"; + context = "test_context"; + roles = new ArrayList<>(); + String role = "test_role"; + roles.add(role); + } + + @Test + public void testGetVaultURLForDev() { + try { + String vaultURL = Utils.getVaultURL(clusterId, Env.DEV); + String devUrl = "https://test_cluster_id.vault.skyflowapis.dev"; + Assert.assertEquals(devUrl, vaultURL); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testGetVaultURLForStage() { + try { + String vaultURL = Utils.getVaultURL(clusterId, Env.STAGE); + String stageUrl = "https://test_cluster_id.vault.skyflowapis.tech"; + Assert.assertEquals(stageUrl, vaultURL); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testGetVaultURLForSandbox() { + try { + String vaultURL = Utils.getVaultURL(clusterId, Env.SANDBOX); + String sandboxUrl = "https://test_cluster_id.vault.skyflowapis-preview.com"; + Assert.assertEquals(sandboxUrl, vaultURL); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testGetVaultURLForProd() { + try { + String vaultURL = Utils.getVaultURL(clusterId, Env.PROD); + String prodUrl = "https://test_cluster_id.vault.skyflowapis.com"; + Assert.assertEquals(prodUrl, vaultURL); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testGetBaseURL() { + try { + String baseURL = Utils.getBaseURL(url); + String url = "https://test-url.com"; + Assert.assertEquals(url, baseURL); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testGenerateBearerTokenWithCredentialsFile() { + try { + Credentials credentials = new Credentials(); + credentials.setPath(filePath); + credentials.setContext(context); + credentials.setRoles(roles); + Utils.generateBearerToken(credentials); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidCredentials.getMessage(), e.getMessage()); + } + } + + @Test + public void testGenerateBearerTokenWithCredentialsString() { + try { + Credentials credentials = new Credentials(); + credentials.setCredentialsString(credentialsString); + credentials.setContext(context); + credentials.setRoles(roles); + Utils.generateBearerToken(credentials); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.CredentialsStringInvalidJson.getMessage(), e.getMessage()); + } + } + + @Test + public void testGenerateBearerTokenWithToken() { + try { + Credentials credentials = new Credentials(); + credentials.setToken(token); + credentials.setContext(context); + credentials.setRoles(roles); + String bearerToken = Utils.generateBearerToken(credentials); + Assert.assertEquals(token, bearerToken); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } +} diff --git a/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java b/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java index 04dd406d..d7a7d7fc 100644 --- a/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java +++ b/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java @@ -9,17 +9,23 @@ import com.skyflow.errors.ErrorCode; import com.skyflow.errors.ErrorMessage; import com.skyflow.errors.SkyflowException; +import com.skyflow.generated.rest.ApiClient; import com.skyflow.generated.rest.ApiException; import com.skyflow.generated.rest.api.TokensApi; import com.skyflow.generated.rest.models.V1DetokenizeResponse; +import com.skyflow.serviceaccount.util.Token; import com.skyflow.utils.Constants; import com.skyflow.utils.Utils; import com.skyflow.utils.validations.Validations; import org.junit.Assert; +import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.ArgumentMatchers; import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; import java.util.ArrayList; @@ -38,13 +44,14 @@ public class DetokenizeTests { private static String token = null; private static ArrayList tokens = null; private static Skyflow skyflowClient = null; + private ApiClient mockApiClient; + private TokensApi mockTokensApi; @BeforeClass public static void setup() throws SkyflowException, NoSuchMethodException { // PowerMockito.mockStatic(Token.class); // PowerMockito.when(Token.isExpired("valid_token")).thenReturn(true); // PowerMockito.when(Token.isExpired("not_a_valid_token")).thenReturn(false); -// PowerMockito.mock(ApiClient.class); vaultID = "vault123"; clusterID = "cluster123"; @@ -60,8 +67,22 @@ public static void setup() throws SkyflowException, NoSuchMethodException { token = "test_token_1"; tokens = new ArrayList<>(); + +// System.setProperty("ssl.TrustManagerFactory.algorithm", "PKIX"); } +// @Before +// public void setupMock() throws ApiException { +// mockApiClient = PowerMockito.mock(ApiClient.class); +// mockTokensApi = PowerMockito.mock(TokensApi.class); +// +// V1DetokenizeResponse mockResponse = new V1DetokenizeResponse(); +// PowerMockito +// .when(mockTokensApi.recordServiceDetokenize(ArgumentMatchers.anyString(), ArgumentMatchers.any())) +// .thenReturn(mockResponse); +// +// } + @Test public void testValidInputInDetokenizeRequestValidations() { try { diff --git a/v2/src/test/resources/invalidPrivateKeyCredentials.json b/v2/src/test/resources/invalidPrivateKeyCredentials.json new file mode 100644 index 00000000..3615e623 --- /dev/null +++ b/v2/src/test/resources/invalidPrivateKeyCredentials.json @@ -0,0 +1 @@ +{"privateKey": "private_key_value", "clientID": "client_id_value", "keyID": "key_id_value", "tokenURI": "invalid_token_uri"} \ No newline at end of file diff --git a/v2/src/test/resources/invalidTokenURICredentials.json b/v2/src/test/resources/invalidTokenURICredentials.json new file mode 100644 index 00000000..ac9346aa --- /dev/null +++ b/v2/src/test/resources/invalidTokenURICredentials.json @@ -0,0 +1 @@ +{"privateKey":"-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCzLp0TVwidRMtZ\n4tGLHPDEF6ihmE4OHSR/r5rZGqE+PNtw/uwXzBrfz1Mktb0hddMZNwC2IKhHE0Yw\nvtBT0jsfy4OUQR13Mohn9znz+5TES/yXjkvZjhZKzs5rxNw/cO8lpKYUYdwbFzwl\n9e3joCsWBXBDCbXdLQGPyggJV+KBI0LBal+LngNLU/U680LRlybCKCTyyrF0SERD\npytcpnq41CS2Q0ZDfkK/zLrvsCkEBU8xYeAf/TphXMKeqvMGTqxxg6IPOKfYya7Q\nnH9eZ1pn1SCe6N5XBUpQpB4K+1IZKvadOYpYWzRgM+tT5k4UVsg6s7kUm8k9n85/\nNQMjMY2XAgMBAAECggEASlg05ClgcaBxn0H1H3tKipImbaX7/O8qjbAW162s6V3m\nzuN2ogkVvXcQUFL3vkJc7EFeEjNKnvLoVKFXXvADiBWw6np591MINdrmOM1R1ICS\ntW9dGU9TAIb+LsjneYsqLrw6DIruAG+LjVSU97UlK2XmRmppAvQBid+Rpg7I9Dsy\naJyGjDHeC3RyYYNfpei2dBPUYlUjOkBqgYGOOyjYxHzzgYtdVZku0JPtsAey3WKL\nSbu8ryugu7r23fxP50H3FtYz91TPlVu1zVEk9Viizp2c9642ZKEoA0bB/bSNMUnt\nZ/kemZENAzC7tnoYgwN09rI3h0+U5jaU1BhXbrLpAQKBgQDt8eaywv6j+Hdv8i7S\nyMnZE4CaM70Z319ctJPlt2QdCZp8dtac858qnnrrZSCWV3n3yMv//bf1WZB4Lssw\nuxBzSCFI/imG6eY9uQA6yXLl1TY9DA5IJ8s2LGzwmtA1q+vC+jzWs+0+S/evUewo\nTZGQuNjHMHoM22jeLErqQZkHUQKBgQDAxz1WY56ZHdC3Y4aXkDeb5Ag+ZJV8Uqwn\nootA2zHCaEx8gM9CzChCl4pQcghHFXv4eEKqezdWSK+SIRA1CtR+q8g5dP8YtAkR\n9Uav6/fEkM8iCUvhZg+1DPRShu15nQF0ZAleSJ9OiSW5pIfAbY79RHru8H31azhE\nDOWezXbcZwKBgB9LAAckg+62n6aWWDgadglZekFNaqI7cUQ073p3mvACslGKI4Fy\nvM0TGKFapGWBTaYbv1CEYqwewlQ7+zcGcwxmQRJjcryuiDw312Lj2XuGheKTclFl\nAmG2iAFAqv9UA+aZmGS4NwxJW2KwSHmocetxk/jmVDbaqDkH5DZYuDJxAoGBAJqn\n/PRujVEnk0dc6CB1ybcd9OMhTK/ln0lY5MDOWRgvFpWXvS9InE/4RTWOlkd42/EV\ngd5FZbqqK3hfYCI9owZQiBxYWUMXRGOM0/3Un/ypdBNJQ//7IkTMtMH0j1XOeNlI\nXB+wwWV/L63EakgdXOag5sMEWvjl4MjvU9PX4DCnAoGAR0c567DWbkTXvcNIjvNF\nNK8suq/fGt4dpbkkFOEHjgqFd5RsjFHKc98JVrudPweUR7YjpeKQaeNKXfVFd4+N\nDPOs0zWSsaHckh1g9djkZlidha9SD/V6cOpxi3g2okcn/LI7h8NyNlAwDSn2mPEi\nMd3mrgMCZwJsXLndGQSDVUw=\n-----END PRIVATE KEY-----\n", "clientID": "client_id_value", "keyID": "key_id_value", "tokenURI": "invalid_token_uri"} \ No newline at end of file diff --git a/v2/src/test/resources/noClientIDCredentials.json b/v2/src/test/resources/noClientIDCredentials.json new file mode 100644 index 00000000..6e7edd20 --- /dev/null +++ b/v2/src/test/resources/noClientIDCredentials.json @@ -0,0 +1 @@ +{"privateKey":"private_key_value"} \ No newline at end of file diff --git a/v2/src/test/resources/noKeyIDCredentials.json b/v2/src/test/resources/noKeyIDCredentials.json new file mode 100644 index 00000000..64ff438e --- /dev/null +++ b/v2/src/test/resources/noKeyIDCredentials.json @@ -0,0 +1 @@ +{"privateKey":"private_key_value","clientID":"client_id_value"} \ No newline at end of file diff --git a/v2/src/test/resources/noPrivateKeyCredentials.json b/v2/src/test/resources/noPrivateKeyCredentials.json new file mode 100644 index 00000000..9e26dfee --- /dev/null +++ b/v2/src/test/resources/noPrivateKeyCredentials.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/v2/src/test/resources/noTokenURICredentials.json b/v2/src/test/resources/noTokenURICredentials.json new file mode 100644 index 00000000..f88b0792 --- /dev/null +++ b/v2/src/test/resources/noTokenURICredentials.json @@ -0,0 +1 @@ +{"privateKey":"private_key_value","clientID":"client_id_value","keyID":"key_id_value"} \ No newline at end of file diff --git a/v2/src/test/resources/notJson.txt b/v2/src/test/resources/notJson.txt new file mode 100644 index 00000000..bdf08de0 --- /dev/null +++ b/v2/src/test/resources/notJson.txt @@ -0,0 +1 @@ +test file \ No newline at end of file From fc336f0a6b83b3d2f86eb1a353b3c5fb84fb1971 Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Thu, 7 Nov 2024 20:15:43 +0530 Subject: [PATCH 07/18] SK-1684 Add unit tests for signed data tokens SK-1684 Add unit tests for Tokenize request validations --- .../serviceaccount/util/SignedDataTokens.java | 12 +- .../utils/validations/Validations.java | 20 +- .../skyflow/vault/tokens/TokenizeRequest.java | 2 - .../util/SignedDataTokensTests.java | 209 ++++++++++++++++++ .../skyflow/vault/tokens/TokenizeTests.java | 109 +++++++++ 5 files changed, 331 insertions(+), 21 deletions(-) create mode 100644 v2/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java create mode 100644 v2/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java diff --git a/v2/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java b/v2/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java index 88312ff7..2f486c42 100644 --- a/v2/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java +++ b/v2/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java @@ -155,14 +155,10 @@ private static List getSignedToken( public synchronized List getSignedDataTokens() throws SkyflowException { LogUtil.printInfoLog(InfoLogs.GET_SIGNED_DATA_TOKENS_TRIGGERED.getLog()); List signedToken = new ArrayList<>(); - try { - if (this.credentialsFile != null && Objects.equals(this.credentialsType, "FILE")) { - signedToken = generateSignedTokenFromCredentialsFile(this.credentialsFile, this.dataTokens, this.timeToLive, this.ctx); - } else if (this.credentialsString != null && Objects.equals(this.credentialsType, "STRING")) { - signedToken = generateSignedTokensFromCredentialsString(this.credentialsString, this.dataTokens, this.timeToLive, this.ctx); - } - } catch (SkyflowException e) { - e.printStackTrace(); + if (this.credentialsFile != null && Objects.equals(this.credentialsType, "FILE")) { + signedToken = generateSignedTokenFromCredentialsFile(this.credentialsFile, this.dataTokens, this.timeToLive, this.ctx); + } else if (this.credentialsString != null && Objects.equals(this.credentialsType, "STRING")) { + signedToken = generateSignedTokensFromCredentialsString(this.credentialsString, this.dataTokens, this.timeToLive, this.ctx); } LogUtil.printInfoLog(InfoLogs.GET_SIGNED_DATA_TOKEN_SUCCESS.getLog()); return signedToken; diff --git a/v2/src/main/java/com/skyflow/utils/validations/Validations.java b/v2/src/main/java/com/skyflow/utils/validations/Validations.java index f0c44956..a35f3f64 100644 --- a/v2/src/main/java/com/skyflow/utils/validations/Validations.java +++ b/v2/src/main/java/com/skyflow/utils/validations/Validations.java @@ -579,17 +579,15 @@ public static void validateQueryRequest(QueryRequest queryRequest) throws Skyflo public static void validateTokenizeRequest(TokenizeRequest tokenizeRequest) throws SkyflowException { List columnValues = tokenizeRequest.getColumnValues(); - if (columnValues == null || columnValues.isEmpty()) { - if (columnValues == null) { - LogUtil.printErrorLog(Utils.parameterizedString( - ErrorLogs.COLUMN_VALUES_IS_REQUIRED_TOKENIZE.getLog(), InterfaceName.TOKENIZE.getName() - )); - throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.ColumnValuesKeyErrorTokenize.getMessage()); - } else { - LogUtil.printErrorLog(Utils.parameterizedString( - ErrorLogs.EMPTY_COLUMN_VALUES.getLog(), InterfaceName.TOKENIZE.getName() - )); - } + if (columnValues == null) { + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.COLUMN_VALUES_IS_REQUIRED_TOKENIZE.getLog(), InterfaceName.TOKENIZE.getName() + )); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.ColumnValuesKeyErrorTokenize.getMessage()); + } else if (columnValues.isEmpty()) { + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.EMPTY_COLUMN_VALUES.getLog(), InterfaceName.TOKENIZE.getName() + )); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyColumnValues.getMessage()); } else { for (int index = 0; index < columnValues.size(); index++) { diff --git a/v2/src/main/java/com/skyflow/vault/tokens/TokenizeRequest.java b/v2/src/main/java/com/skyflow/vault/tokens/TokenizeRequest.java index f7570714..a1a5ca33 100644 --- a/v2/src/main/java/com/skyflow/vault/tokens/TokenizeRequest.java +++ b/v2/src/main/java/com/skyflow/vault/tokens/TokenizeRequest.java @@ -1,6 +1,5 @@ package com.skyflow.vault.tokens; -import java.util.ArrayList; import java.util.List; public class TokenizeRequest { @@ -22,7 +21,6 @@ public static final class TokenizeRequestBuilder { private List columnValues; private TokenizeRequestBuilder() { - this.columnValues = new ArrayList<>(); } public TokenizeRequestBuilder values(List columnValues) { diff --git a/v2/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java b/v2/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java new file mode 100644 index 00000000..e5ce56b1 --- /dev/null +++ b/v2/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java @@ -0,0 +1,209 @@ +package com.skyflow.serviceaccount.util; + +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.utils.Utils; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; +import java.util.ArrayList; + +public class SignedDataTokensTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String invalidJsonFilePath = null; + private static String credentialsFilePath = null; + private static String invalidFilePath = null; + private static String credentialsString = null; + private static String context = null; + private static ArrayList dataTokens = null; + private static String dataToken = null; + private static Integer ttl = null; + + @BeforeClass + public static void setup() { + credentialsFilePath = "./credentials.json"; + invalidJsonFilePath = "./src/test/resources/notJson.txt"; + invalidFilePath = "./src/test/credentials.json"; + credentialsString = "{\"key\":\"value\"}"; + context = "test_context"; + dataTokens = new ArrayList<>(); + dataToken = "test_data_token"; + ttl = 60; + } + + @Test + public void testSignedDataTokensBuilderWithCredentialsFile() { + try { + File file = new File(credentialsFilePath); + dataTokens.add(dataToken); + SignedDataTokens.builder() + .setCredentials(file).setCtx(context).setDataTokens(dataTokens).setTimeToLive(ttl) + .build(); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testSignedDataTokensBuilderWithCredentialsString() { + try { + SignedDataTokens.builder() + .setCredentials(credentialsString).setCtx(context).setDataTokens(dataTokens).setTimeToLive(ttl) + .build(); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + + } + + @Test + public void testEmptyCredentialsFilePath() { + try { + File file = new File(""); + SignedDataTokens signedTokens = SignedDataTokens.builder().setCredentials(file).build(); + signedTokens.getSignedDataTokens(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidCredentials.getMessage(), e.getMessage()); + } + } + + @Test + public void testInvalidFilePath() { + try { + File file = new File(invalidFilePath); + SignedDataTokens signedTokens = SignedDataTokens.builder().setCredentials(file).build(); + signedTokens.getSignedDataTokens(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidCredentials.getMessage(), e.getMessage()); + } + } + + @Test + public void testInvalidCredentialsFile() { + try { + File file = new File(invalidJsonFilePath); + SignedDataTokens signedTokens = SignedDataTokens.builder().setCredentials(file).build(); + signedTokens.getSignedDataTokens(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.FileInvalidJson.getMessage(), invalidJsonFilePath), + e.getMessage() + ); + } + } + + @Test + public void testEmptyCredentialsString() { + try { + SignedDataTokens signedTokens = SignedDataTokens.builder().setCredentials("").build(); + signedTokens.getSignedDataTokens(); + System.out.println("in try block"); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + System.out.println("caught skyflow exception"); + System.out.println(e); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.InvalidCredentials.getMessage(), invalidJsonFilePath), + e.getMessage() + ); + } catch (Exception e) { + System.out.println("catching exception"); + System.out.println(e); + } + } + + @Test + public void testInvalidCredentialsString() { + try { + SignedDataTokens signedTokens = SignedDataTokens.builder().setCredentials(invalidFilePath).build(); + signedTokens.getSignedDataTokens(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.CredentialsStringInvalidJson.getMessage(), invalidJsonFilePath), + e.getMessage() + ); + } + } + + @Test + public void testNoPrivateKeyInCredentials() { + String filePath = "./src/test/resources/noPrivateKeyCredentials.json"; + File file = new File(filePath); + try { + SignedDataTokens signedTokens = SignedDataTokens.builder().setCredentials(file).build(); + signedTokens.getSignedDataTokens(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.MissingPrivateKey.getMessage(), e.getMessage()); + } + } + + @Test + public void testNoClientIDInCredentials() { + String filePath = "./src/test/resources/noClientIDCredentials.json"; + File file = new File(filePath); + try { + SignedDataTokens signedTokens = SignedDataTokens.builder().setCredentials(file).build(); + signedTokens.getSignedDataTokens(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.MissingClientId.getMessage(), e.getMessage()); + } + } + + @Test + public void testNoKeyIDInCredentials() { + String filePath = "./src/test/resources/noKeyIDCredentials.json"; + File file = new File(filePath); + try { + SignedDataTokens signedTokens = SignedDataTokens.builder().setCredentials(file).build(); + signedTokens.getSignedDataTokens(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.MissingKeyId.getMessage(), e.getMessage()); + } + } + + @Test + public void testInvalidPrivateKeyInCredentials() { + String filePath = "./src/test/resources/invalidPrivateKeyCredentials.json"; + File file = new File(filePath); + try { + SignedDataTokens signedTokens = SignedDataTokens.builder().setCredentials(file).build(); + signedTokens.getSignedDataTokens(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.JwtInvalidFormat.getMessage(), e.getMessage()); + } + } + + @Test + public void testInvalidKeySpecInCredentials() { + String credentialsString = "{\"privateKey\": \"-----BEGIN PRIVATE KEY-----\\ncHJpdmF0ZV9rZXlfdmFsdWU=\\n-----END PRIVATE KEY-----\", \"clientID\": \"client_id_value\", \"keyID\": \"key_id_value\", \"tokenURI\": \"invalid_token_uri\"}"; + try { + SignedDataTokens signedTokens = SignedDataTokens.builder().setCredentials(credentialsString).build(); + signedTokens.getSignedDataTokens(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidKeySpec.getMessage(), e.getMessage()); + } + } +} diff --git a/v2/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java b/v2/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java new file mode 100644 index 00000000..4f801a44 --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java @@ -0,0 +1,109 @@ +package com.skyflow.vault.tokens; + +import com.skyflow.Skyflow; +import com.skyflow.config.VaultConfig; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.utils.validations.Validations; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; + +public class TokenizeTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String vaultID = null; + private static String clusterID = null; + private static VaultConfig vaultConfig = null; + private static String token = null; + private static ArrayList tokens = null; + private static Skyflow skyflowClient = null; + private static List columnValues = null; + private static ColumnValue columnValue = null; + private static String value = null; + private static String group = null; + + @BeforeClass + public static void setup() { + columnValues = new ArrayList<>(); + value = "test_value"; + group = "test_group"; + } + + @Before + public void setupTest() { + columnValues.clear(); + } + + @Test + public void testValidInputInTokenizeRequestValidations() { + try { + columnValue = ColumnValue.builder().value(value).columnGroup(group).build(); + columnValues.add(columnValue); + TokenizeRequest request = TokenizeRequest.builder().values(columnValues).build(); + Validations.validateTokenizeRequest(request); + Assert.assertEquals(1, request.getColumnValues().size()); + Assert.assertEquals(value, request.getColumnValues().get(0).getValue()); + Assert.assertEquals(group, request.getColumnValues().get(0).getColumnGroup()); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testNoColumnValuesInTokenizeRequestValidations() { + try { + TokenizeRequest request = TokenizeRequest.builder().build(); + Validations.validateTokenizeRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.ColumnValuesKeyErrorTokenize.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyColumnValuesInTokenizeRequestValidations() { + try { + TokenizeRequest request = TokenizeRequest.builder().values(columnValues).build(); + Validations.validateTokenizeRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyColumnValues.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyColumnValueInColumnValuesInTokenizeRequestValidations() { + try { + columnValue = ColumnValue.builder().value("").columnGroup(group).build(); + columnValues.add(columnValue); + TokenizeRequest request = TokenizeRequest.builder().values(columnValues).build(); + Validations.validateTokenizeRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyValueInColumnValues.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyColumnGroupInColumnValuesInTokenizeRequestValidations() { + try { + columnValue = ColumnValue.builder().value(value).columnGroup("").build(); + columnValues.add(columnValue); + TokenizeRequest request = TokenizeRequest.builder().values(columnValues).build(); + Validations.validateTokenizeRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyColumnGroupInColumnValue.getMessage(), e.getMessage()); + } + } +} From 9f3bd92e854455b63fb09efb449c65bfbe434787 Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Fri, 8 Nov 2024 21:06:52 +0530 Subject: [PATCH 08/18] SK-1684 Add unit tests for Java SDK v2 --- .../vault/controller/VaultController.java | 2 - .../com/skyflow/vault/data/GetResponse.java | 2 +- .../skyflow/vault/data/InsertResponse.java | 2 +- .../test/java/com/skyflow/SkyflowTests.java | 281 ++++++++++++++++++ .../controller/VaultControllerTests.java | 192 ++++++++++++ .../java/com/skyflow/vault/data/GetTests.java | 27 ++ .../com/skyflow/vault/data/InsertTests.java | 58 +++- .../com/skyflow/vault/data/QueryTests.java | 5 +- .../skyflow/vault/tokens/DetokenizeTests.java | 72 ----- .../skyflow/vault/tokens/TokenizeTests.java | 14 + 10 files changed, 568 insertions(+), 87 deletions(-) create mode 100644 v2/src/test/java/com/skyflow/SkyflowTests.java create mode 100644 v2/src/test/java/com/skyflow/vault/controller/VaultControllerTests.java diff --git a/v2/src/main/java/com/skyflow/vault/controller/VaultController.java b/v2/src/main/java/com/skyflow/vault/controller/VaultController.java index 08204181..3a3bc03f 100644 --- a/v2/src/main/java/com/skyflow/vault/controller/VaultController.java +++ b/v2/src/main/java/com/skyflow/vault/controller/VaultController.java @@ -26,8 +26,6 @@ public final class VaultController extends VaultClient { private AuditController auditController; private BinLookupController binLookupController; - private String token; - public VaultController(VaultConfig vaultConfig, Credentials credentials) { super(vaultConfig, credentials); this.auditController = null; diff --git a/v2/src/main/java/com/skyflow/vault/data/GetResponse.java b/v2/src/main/java/com/skyflow/vault/data/GetResponse.java index 2d2a4b1d..bd882138 100644 --- a/v2/src/main/java/com/skyflow/vault/data/GetResponse.java +++ b/v2/src/main/java/com/skyflow/vault/data/GetResponse.java @@ -24,7 +24,7 @@ public ArrayList> getErrors() { public String toString() { StringBuilder response = new StringBuilder("{"); response.append("\n\t\"data\": ").append(formatRecords(data)); - response.append("\n\t\"errors\": ").append(formatRecords(errors)); + response.append(",\n\t\"errors\": ").append(formatRecords(errors)); response.append("\n}"); return response.toString(); } diff --git a/v2/src/main/java/com/skyflow/vault/data/InsertResponse.java b/v2/src/main/java/com/skyflow/vault/data/InsertResponse.java index e0eaf098..240c6940 100644 --- a/v2/src/main/java/com/skyflow/vault/data/InsertResponse.java +++ b/v2/src/main/java/com/skyflow/vault/data/InsertResponse.java @@ -24,7 +24,7 @@ public ArrayList> getErrorFields() { public String toString() { StringBuilder response = new StringBuilder("{"); response.append("\n\t\"insertedFields\": ").append(formatRecords(insertedFields)); - response.append("\n\t\"errors\": ").append(formatRecords(errorFields)); + response.append(",\n\t\"errors\": ").append(formatRecords(errorFields)); response.append("\n}"); return response.toString(); } diff --git a/v2/src/test/java/com/skyflow/SkyflowTests.java b/v2/src/test/java/com/skyflow/SkyflowTests.java new file mode 100644 index 00000000..cfdd7e5a --- /dev/null +++ b/v2/src/test/java/com/skyflow/SkyflowTests.java @@ -0,0 +1,281 @@ +package com.skyflow; + +import com.skyflow.config.ConnectionConfig; +import com.skyflow.config.Credentials; +import com.skyflow.config.VaultConfig; +import com.skyflow.enums.Env; +import com.skyflow.enums.LogLevel; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; + +public class SkyflowTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String vaultID = null; + private static String clusterID = null; + private static String newClusterID = null; + private static String connectionID = null; + private static String connectionURL = null; + private static String token = null; + + @BeforeClass + public static void setup() { + vaultID = "test_vault_id"; + clusterID = "test_cluster_id"; + newClusterID = "new_test_cluster_id"; + connectionID = "test_connection_id"; + connectionURL = "https://test.connection.url"; + token = "test_token"; + } + + @Test + public void testAddingInvalidVaultConfigInSkyflowBuilder() { + try { + VaultConfig config = new VaultConfig(); + config.setVaultId(""); + config.setClusterId(clusterID); + config.setEnv(Env.SANDBOX); + Skyflow.builder().addVaultConfig(config).build(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyVaultId.getMessage(), e.getMessage()); + } + } + + @Test + public void testAddingInvalidVaultConfigInSkyflowClient() { + try { + VaultConfig config = new VaultConfig(); + config.setVaultId(""); + config.setClusterId(clusterID); + config.setEnv(Env.SANDBOX); + Skyflow skyflowClient = Skyflow.builder().build(); + skyflowClient.addVaultConfig(config); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyVaultId.getMessage(), e.getMessage()); + } + } + + @Test + public void testAddingValidVaultConfigInSkyflowClient() { + try { + VaultConfig config = new VaultConfig(); + config.setVaultId(vaultID); + config.setClusterId(clusterID); + config.setEnv(Env.SANDBOX); + Skyflow skyflowClient = Skyflow.builder().build(); + skyflowClient.addVaultConfig(config); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testAddingExistingVaultConfigInSkyflowClient() { + try { + VaultConfig config = new VaultConfig(); + config.setVaultId(vaultID); + config.setClusterId(clusterID); + config.setEnv(Env.SANDBOX); + Skyflow skyflowClient = Skyflow.builder().build(); + skyflowClient.addVaultConfig(config).addVaultConfig(config); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.VaultIdAlreadyInConfigList.getMessage(), e.getMessage()); + } + } + + @Test + public void testUpdatingNonExistentVaultConfigInSkyflowBuilder() { + try { + VaultConfig config = new VaultConfig(); + config.setVaultId(vaultID); + config.setClusterId(clusterID); + config.setEnv(Env.SANDBOX); + Skyflow.builder().updateVaultConfig(config).build(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.VaultIdNotInConfigList.getMessage(), e.getMessage()); + } + } + + @Test + public void testUpdatingNonExistentVaultConfigInSkyflowClient() { + try { + VaultConfig config = new VaultConfig(); + config.setVaultId(vaultID); + config.setClusterId(clusterID); + config.setEnv(Env.SANDBOX); + Skyflow skyflowClient = Skyflow.builder().build(); + skyflowClient.updateVaultConfig(config); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.VaultIdNotInConfigList.getMessage(), e.getMessage()); + } catch (Exception e) { + Assert.assertEquals(ErrorMessage.VaultIdNotInConfigList.getMessage(), e.getMessage()); + } + } + + @Test + public void testUpdatingValidVaultConfigInSkyflowClient() { + try { + VaultConfig config = new VaultConfig(); + config.setVaultId(vaultID); + config.setClusterId(clusterID); + config.setEnv(Env.SANDBOX); + Skyflow skyflowClient = Skyflow.builder().addVaultConfig(config).build(); + + Credentials credentials = new Credentials(); + credentials.setToken(token); + + skyflowClient.updateVaultConfig(config); + + config.setClusterId(newClusterID); + config.setEnv(Env.PROD); + config.setCredentials(credentials); + + skyflowClient.updateVaultConfig(config); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testRemovingNonExistentVaultConfigInSkyflowBuilder() { + try { + Skyflow.builder().removeVaultConfig(vaultID).build(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.VaultIdNotInConfigList.getMessage(), e.getMessage()); + } + } + + @Test + public void testRemovingNonExistentVaultConfigInSkyflowClient() { + try { + VaultConfig config = new VaultConfig(); + config.setVaultId(vaultID); + config.setClusterId(clusterID); + config.setEnv(Env.SANDBOX); + Skyflow skyflowClient = Skyflow.builder().addVaultConfig(config).build(); + skyflowClient.removeVaultConfig(vaultID); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testRemovingValidVaultConfigInSkyflowClient() { + try { + Skyflow skyflowClient = Skyflow.builder().build(); + skyflowClient.removeVaultConfig(vaultID); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.VaultIdNotInConfigList.getMessage(), e.getMessage()); + } + } + + @Test + public void testGettingNonExistentVaultConfigInSkyflowClient() { + try { + Skyflow skyflowClient = Skyflow.builder().build(); + VaultConfig config = skyflowClient.getVaultConfig(vaultID); + Assert.assertNull(config); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + + @Test + public void testAddingInvalidConnectionConfigInSkyflowBuilder() { + try { + ConnectionConfig config = new ConnectionConfig(); + config.setConnectionId(""); + config.setConnectionUrl(connectionURL); + Skyflow.builder().addConnectionConfig(config).build(); +// Assert.fail(EXCEPTION_NOT_THROWN); + } catch (Exception e) { +// Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyVaultId.getMessage(), e.getMessage()); + } + } + + @Test + public void testAddingInvalidConnectionConfigInSkyflowClient() { + try { + ConnectionConfig config = new ConnectionConfig(); + config.setConnectionId(""); + config.setConnectionUrl(connectionURL); + Skyflow skyflowClient = Skyflow.builder().build(); + skyflowClient.addConnectionConfig(config); +// Assert.fail(EXCEPTION_NOT_THROWN); + } catch (Exception e) { +// Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyVaultId.getMessage(), e.getMessage()); + } + } + + @Test + public void testAddingInvalidSkyflowCredentialsInSkyflowBuilder() { + try { + Credentials credentials = new Credentials(); + Skyflow.builder().addSkyflowCredentials(credentials).build(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.NoTokenGenerationMeansPassed.getMessage(), e.getMessage()); + } + } + + @Test + public void testUpdatingValidSkyflowCredentialsInSkyflowClient() { + try { + Credentials credentials = new Credentials(); + credentials.setToken(token); + Skyflow skyflowClient = Skyflow.builder().build(); + skyflowClient.updateSkyflowCredentials(credentials); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testDefaultLogLevel() { + try { + Skyflow skyflowClient = Skyflow.builder().setLogLevel(null).build(); + Assert.assertEquals(LogLevel.ERROR, skyflowClient.getLogLevel()); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testUpdateLogLevel() { + try { + Skyflow skyflowClient = Skyflow.builder().setLogLevel(LogLevel.INFO).build(); + Assert.assertEquals(LogLevel.INFO, skyflowClient.getLogLevel()); + skyflowClient.updateLogLevel(LogLevel.WARN); + Assert.assertEquals(LogLevel.WARN, skyflowClient.getLogLevel()); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + +} diff --git a/v2/src/test/java/com/skyflow/vault/controller/VaultControllerTests.java b/v2/src/test/java/com/skyflow/vault/controller/VaultControllerTests.java new file mode 100644 index 00000000..ecfca480 --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/controller/VaultControllerTests.java @@ -0,0 +1,192 @@ +package com.skyflow.vault.controller; + +import com.skyflow.Skyflow; +import com.skyflow.config.Credentials; +import com.skyflow.config.VaultConfig; +import com.skyflow.enums.Env; +import com.skyflow.enums.LogLevel; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.generated.rest.ApiClient; +import com.skyflow.generated.rest.api.TokensApi; +import com.skyflow.utils.Constants; +import com.skyflow.utils.Utils; +import com.skyflow.vault.data.*; +import com.skyflow.vault.tokens.DetokenizeRequest; +import com.skyflow.vault.tokens.TokenizeRequest; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; + +public class VaultControllerTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String vaultID = null; + private static String clusterID = null; + private static VaultConfig vaultConfig = null; + private static Skyflow skyflowClient = null; + private ApiClient mockApiClient; + private TokensApi mockTokensApi; + + @BeforeClass + public static void setup() throws SkyflowException, NoSuchMethodException { + vaultID = "vault123"; + clusterID = "cluster123"; + + Credentials credentials = new Credentials(); + credentials.setToken("valid-token"); + + vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + vaultConfig.setEnv(Env.DEV); + vaultConfig.setCredentials(credentials); + } + + @Test + public void testInvalidRequestInInsertMethod() { + try { + InsertRequest request = InsertRequest.builder().build(); + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + skyflowClient.vault().insert(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testInvalidRequestInDetokenizeMethod() { + try { + DetokenizeRequest request = DetokenizeRequest.builder().build(); + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + skyflowClient.vault().detokenize(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.InvalidDataTokens.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testInvalidRequestInGetMethod() { + try { + GetRequest request = GetRequest.builder().build(); + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + skyflowClient.vault().get(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testInvalidRequestInUpdateMethod() { + try { + UpdateRequest request = UpdateRequest.builder().build(); + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + skyflowClient.vault().update(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testInvalidRequestInDeleteMethod() { + try { + DeleteRequest request = DeleteRequest.builder().build(); + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + skyflowClient.vault().delete(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testInvalidRequestInQueryMethod() { + try { + QueryRequest request = QueryRequest.builder().build(); + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + skyflowClient.vault().query(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.QueryKeyError.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testInvalidRequestInTokenizeMethod() { + try { + TokenizeRequest request = TokenizeRequest.builder().build(); + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + skyflowClient.vault().tokenize(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals( + Utils.parameterizedString(ErrorMessage.ColumnValuesKeyErrorTokenize.getMessage(), Constants.SDK_PREFIX), + e.getMessage() + ); + } + } + + @Test + public void testLookUpBin() { + try { + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + skyflowClient.vault().lookUpBin(); + skyflowClient.vault().lookUpBin(); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testAudit() { + try { + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + skyflowClient.vault().audit(); + skyflowClient.vault().audit(); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testDetect() { + try { + skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); + skyflowClient.vault().detect(); + skyflowClient.vault().detect(); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + +} diff --git a/v2/src/test/java/com/skyflow/vault/data/GetTests.java b/v2/src/test/java/com/skyflow/vault/data/GetTests.java index ac6625fe..140990a7 100644 --- a/v2/src/test/java/com/skyflow/vault/data/GetTests.java +++ b/v2/src/test/java/com/skyflow/vault/data/GetTests.java @@ -22,6 +22,7 @@ import org.powermock.modules.junit4.PowerMockRunner; import java.util.ArrayList; +import java.util.HashMap; @RunWith(PowerMockRunner.class) @PrepareForTest(fullyQualifiedNames = "com.skyflow.serviceaccount.util.Token") @@ -470,4 +471,30 @@ public void testEmptyValueInColumnValuesInGetRequestValidations() { ); } } + + @Test + public void testGetResponse() { + try { + ArrayList> data = new ArrayList<>(); + HashMap record = new HashMap<>(); + record.put("test_column_1", "test_value_1"); + record.put("test_column_2", "test_value_2"); + data.add(record); + data.add(record); + ArrayList> errors = new ArrayList<>(); + GetResponse response = new GetResponse(data, errors); + String responseString = "{\n\t\"data\": [" + + "{\n\t\t\"test_column_1\": \"test_value_1\"," + + "\n\t\t\"test_column_2\": \"test_value_2\",\n\t}, " + + "{\n\t\t\"test_column_1\": \"test_value_1\"," + + "\n\t\t\"test_column_2\": \"test_value_2\",\n\t}]" + + ",\n\t\"errors\": " + errors + "\n}"; + Assert.assertEquals(2, response.getData().size()); + Assert.assertTrue(response.getErrors().isEmpty()); + Assert.assertEquals(responseString, response.toString()); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + + } } diff --git a/v2/src/test/java/com/skyflow/vault/data/InsertTests.java b/v2/src/test/java/com/skyflow/vault/data/InsertTests.java index f49f9c20..50b1e5fc 100644 --- a/v2/src/test/java/com/skyflow/vault/data/InsertTests.java +++ b/v2/src/test/java/com/skyflow/vault/data/InsertTests.java @@ -13,6 +13,7 @@ import com.skyflow.utils.Utils; import com.skyflow.utils.validations.Validations; import org.junit.Assert; +import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; @@ -62,11 +63,19 @@ public static void setup() throws SkyflowException { values = new ArrayList<>(); tokens = new ArrayList<>(); valueMap = new HashMap<>(); + tokenMap = new HashMap<>(); + upsert = "upsert_column"; + } + + @Before + public void setupTest() { + values.clear(); + tokens.clear(); + valueMap.clear(); valueMap.put("test_column_1", "test_value_1"); valueMap.put("test_column_2", "test_value_2"); - tokenMap = new HashMap<>(); + tokenMap.clear(); tokenMap.put("test_column_1", "test_token_1"); - upsert = "upsert_column"; } @Test @@ -148,7 +157,6 @@ public void testNoValuesInInsertRequestValidations() { @Test public void testEmptyValuesInInsertRequestValidations() { - values.clear(); InsertRequest request = InsertRequest.builder().table(table).values(values).build(); try { Validations.validateInsertRequest(request); @@ -181,8 +189,8 @@ public void testEmptyKeyInValuesInInsertRequestValidations() { @Test public void testEmptyValueInValuesInInsertRequestValidations() { - valueMap.remove(""); valueMap.put("test_column_3", ""); + values.add(valueMap); InsertRequest request = InsertRequest.builder().table(table).values(values).build(); try { Validations.validateInsertRequest(request); @@ -198,7 +206,7 @@ public void testEmptyValueInValuesInInsertRequestValidations() { @Test public void testEmptyUpsertInInsertRequestValidations() { - valueMap.remove("test_column_3"); + values.add(valueMap); InsertRequest request = InsertRequest.builder().table(table).values(values).upsert("").build(); try { Validations.validateInsertRequest(request); @@ -214,6 +222,7 @@ public void testEmptyUpsertInInsertRequestValidations() { @Test public void testUpsertWithHomogenousInInsertRequestValidations() { + values.add(valueMap); InsertRequest request = InsertRequest.builder() .table(table).values(values).upsert(upsert).homogeneous(true) .build(); @@ -231,6 +240,7 @@ public void testUpsertWithHomogenousInInsertRequestValidations() { @Test public void testTokensWithTokenStrictDisableInInsertRequestValidations() { + values.add(valueMap); InsertRequest request = InsertRequest.builder().table(table).values(values).tokens(tokens).build(); try { Validations.validateInsertRequest(request); @@ -246,6 +256,7 @@ public void testTokensWithTokenStrictDisableInInsertRequestValidations() { @Test public void testNoTokensWithTokenStrictEnableInInsertRequestValidations() { + values.add(valueMap); InsertRequest request = InsertRequest.builder() .table(table).values(values).tokenStrict(Byot.ENABLE) .build(); @@ -263,6 +274,7 @@ public void testNoTokensWithTokenStrictEnableInInsertRequestValidations() { @Test public void testNoTokensWithTokenStrictEnableStrictInInsertRequestValidations() { + values.add(valueMap); InsertRequest request = InsertRequest.builder() .table(table).values(values).tokenStrict(Byot.ENABLE_STRICT) .build(); @@ -280,7 +292,7 @@ public void testNoTokensWithTokenStrictEnableStrictInInsertRequestValidations() @Test public void testEmptyTokensWithTokenStrictEnableInInsertRequestValidations() { - tokens.clear(); + values.add(valueMap); InsertRequest request = InsertRequest.builder() .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE) .build(); @@ -295,6 +307,7 @@ public void testEmptyTokensWithTokenStrictEnableInInsertRequestValidations() { @Test public void testInsufficientTokensWithTokenStrictEnableStrictInInsertRequestValidations1() { + values.add(valueMap); tokens.add(tokenMap); InsertRequest request = InsertRequest.builder() .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE_STRICT) @@ -311,6 +324,8 @@ public void testInsufficientTokensWithTokenStrictEnableStrictInInsertRequestVali @Test public void testInsufficientTokensWithTokenStrictEnableStrictInInsertRequestValidations2() { values.add(valueMap); + values.add(valueMap); + tokens.add(tokenMap); InsertRequest request = InsertRequest.builder() .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE_STRICT) .build(); @@ -325,8 +340,9 @@ public void testInsufficientTokensWithTokenStrictEnableStrictInInsertRequestVali @Test public void testTokenValueMismatchInInsertRequestValidations() { + values.add(valueMap); tokenMap.put("test_column_3", "test_token_3"); - values.remove(1); + tokens.add(tokenMap); InsertRequest request = InsertRequest.builder() .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE_STRICT) .build(); @@ -341,9 +357,9 @@ public void testTokenValueMismatchInInsertRequestValidations() { @Test public void testEmptyKeyInTokensInInsertRequestValidations() { - tokenMap.remove("test_column_2"); - tokenMap.remove("test_column_3"); tokenMap.put("", "test_token_2"); + values.add(valueMap); + tokens.add(tokenMap); InsertRequest request = InsertRequest.builder() .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE_STRICT) .build(); @@ -358,8 +374,9 @@ public void testEmptyKeyInTokensInInsertRequestValidations() { @Test public void testEmptyValueInTokensInInsertRequestValidations() { - tokenMap.remove(""); tokenMap.put("test_column_2", ""); + values.add(valueMap); + tokens.add(tokenMap); InsertRequest request = InsertRequest.builder() .table(table).values(values).tokens(tokens).tokenStrict(Byot.ENABLE_STRICT) .build(); @@ -372,4 +389,25 @@ public void testEmptyValueInTokensInInsertRequestValidations() { } } + @Test + public void testInsertResponse() { + try { + ArrayList> errorFields = new ArrayList<>(); + values.add(valueMap); + values.add(valueMap); + InsertResponse response = new InsertResponse(values, errorFields); + String responseString = "{\n\t\"insertedFields\": [" + + "{\n\t\t\"test_column_1\": \"test_value_1\"," + + "\n\t\t\"test_column_2\": \"test_value_2\",\n\t}, " + + "{\n\t\t\"test_column_1\": \"test_value_1\"," + + "\n\t\t\"test_column_2\": \"test_value_2\",\n\t}]" + + ",\n\t\"errors\": " + errorFields + "\n}"; + Assert.assertEquals(2, response.getInsertedFields().size()); + Assert.assertTrue(response.getErrorFields().isEmpty()); + Assert.assertEquals(responseString, response.toString()); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + } diff --git a/v2/src/test/java/com/skyflow/vault/data/QueryTests.java b/v2/src/test/java/com/skyflow/vault/data/QueryTests.java index 3197a83c..a84c9113 100644 --- a/v2/src/test/java/com/skyflow/vault/data/QueryTests.java +++ b/v2/src/test/java/com/skyflow/vault/data/QueryTests.java @@ -105,11 +105,14 @@ public void testQueryResponse() { try { ArrayList> fields = new ArrayList<>(); fields.add(queryRecord); + fields.add(queryRecord); QueryResponse response = new QueryResponse(fields); String responseString = "{\n\t\"fields\": " + "[{\n\t\t\"card_number\": \"test_card_number\",\n\t\t\"name\": \"test_name\"," + + "\n\t\t\"tokenizedData\": " + null + "\n\t}, " + + "{\n\t\t\"card_number\": \"test_card_number\",\n\t\t\"name\": \"test_name\"," + "\n\t\t\"tokenizedData\": " + null + "\n\t}]\n}"; - Assert.assertEquals(1, response.getFields().size()); + Assert.assertEquals(2, response.getFields().size()); Assert.assertEquals(responseString, response.toString()); } catch (Exception e) { Assert.fail(INVALID_EXCEPTION_THROWN); diff --git a/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java b/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java index d7a7d7fc..b4185260 100644 --- a/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java +++ b/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java @@ -13,19 +13,12 @@ import com.skyflow.generated.rest.ApiException; import com.skyflow.generated.rest.api.TokensApi; import com.skyflow.generated.rest.models.V1DetokenizeResponse; -import com.skyflow.serviceaccount.util.Token; import com.skyflow.utils.Constants; import com.skyflow.utils.Utils; import com.skyflow.utils.validations.Validations; import org.junit.Assert; -import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentMatchers; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; import java.util.ArrayList; @@ -166,69 +159,4 @@ public void testRedactionAndContinueOnErrorInDetokenizeRequestValidations() { Assert.fail(INVALID_EXCEPTION_THROWN); } } - - @Test - public void testNoTokensInDetokenizeMethod() { - DetokenizeRequest request = DetokenizeRequest.builder().build(); - try { - V1DetokenizeResponse mockResponse = new V1DetokenizeResponse(); - TokensApi mockApi = PowerMockito.mock(TokensApi.class); - PowerMockito - .when(mockApi.recordServiceDetokenize(ArgumentMatchers.anyString(), ArgumentMatchers.any())) - .thenReturn(mockResponse); - - skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); - DetokenizeResponse response = skyflowClient.vault().detokenize(request); - Assert.fail(EXCEPTION_NOT_THROWN); - } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); - Assert.assertEquals( - Utils.parameterizedString(ErrorMessage.InvalidDataTokens.getMessage(), Constants.SDK_PREFIX), - e.getMessage() - ); - Assert.assertEquals(RedactionType.PLAIN_TEXT, request.getRedactionType()); - Assert.assertTrue(request.getContinueOnError()); - } catch (ApiException e) { - Assert.fail(); - } - } - - @Test - public void testEmptyTokensInDetokenizeMethod() { - tokens.clear(); - DetokenizeRequest request = DetokenizeRequest.builder().tokens(tokens).build(); - try { - skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); - DetokenizeResponse response = skyflowClient.vault().detokenize(request); - Assert.fail(EXCEPTION_NOT_THROWN); - } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); - Assert.assertEquals( - Utils.parameterizedString(ErrorMessage.EmptyDataTokens.getMessage(), Constants.SDK_PREFIX), - e.getMessage() - ); - Assert.assertEquals(RedactionType.PLAIN_TEXT, request.getRedactionType()); - Assert.assertTrue(request.getContinueOnError()); - } - } - - @Test - public void testEmptyTokenInTokensInDetokenizeMethod() { - tokens.add(token); - tokens.add(""); - DetokenizeRequest request = DetokenizeRequest.builder().tokens(tokens).build(); - try { - skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); - DetokenizeResponse response = skyflowClient.vault().detokenize(request); - Assert.fail(EXCEPTION_NOT_THROWN); - } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); - Assert.assertEquals( - Utils.parameterizedString(ErrorMessage.EmptyTokenInDataTokens.getMessage(), Constants.SDK_PREFIX), - e.getMessage() - ); - Assert.assertEquals(RedactionType.PLAIN_TEXT, request.getRedactionType()); - Assert.assertTrue(request.getContinueOnError()); - } - } } diff --git a/v2/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java b/v2/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java index 4f801a44..1f4360b2 100644 --- a/v2/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java +++ b/v2/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java @@ -1,7 +1,9 @@ package com.skyflow.vault.tokens; import com.skyflow.Skyflow; +import com.skyflow.config.Credentials; import com.skyflow.config.VaultConfig; +import com.skyflow.enums.Env; import com.skyflow.errors.ErrorCode; import com.skyflow.errors.ErrorMessage; import com.skyflow.errors.SkyflowException; @@ -30,6 +32,18 @@ public class TokenizeTests { @BeforeClass public static void setup() { + vaultID = "vault123"; + clusterID = "cluster123"; + + Credentials credentials = new Credentials(); + credentials.setToken("valid-token"); + + vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + vaultConfig.setEnv(Env.DEV); + vaultConfig.setCredentials(credentials); + columnValues = new ArrayList<>(); value = "test_value"; group = "test_group"; From f1484693d41823b73968c27e2a62394dbbb05357 Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Fri, 8 Nov 2024 22:10:45 +0530 Subject: [PATCH 09/18] SK-1666 Fix conflicts and build issues after merge --- v2/src/main/java/com/skyflow/Skyflow.java | 23 +++++++------------ .../com/skyflow/config/ConnectionConfig.java | 8 ------- v2/src/main/java/com/skyflow/utils/Utils.java | 4 ++-- .../utils/validations/Validations.java | 12 +++------- 4 files changed, 13 insertions(+), 34 deletions(-) diff --git a/v2/src/main/java/com/skyflow/Skyflow.java b/v2/src/main/java/com/skyflow/Skyflow.java index b4223e32..eaf7a7a2 100644 --- a/v2/src/main/java/com/skyflow/Skyflow.java +++ b/v2/src/main/java/com/skyflow/Skyflow.java @@ -39,7 +39,7 @@ public VaultConfig getVaultConfig(String vaultId) { return this.builder.vaultConfigMap.get(vaultId); } - public Skyflow updateVaultConfig(VaultConfig vaultConfig) throws Exception { + public Skyflow updateVaultConfig(VaultConfig vaultConfig) throws SkyflowException { this.builder.updateVaultConfig(vaultConfig); return this; } @@ -206,7 +206,7 @@ public SkyflowClientBuilder addSkyflowCredentials(Credentials credentials) throw public SkyflowClientBuilder setLogLevel(LogLevel logLevel) { this.logLevel = logLevel == null ? LogLevel.ERROR : logLevel; - LogUtil.setupLogger(logLevel); + LogUtil.setupLogger(this.logLevel); LogUtil.printInfoLog(Utils.parameterizedString( InfoLogs.CURRENT_LOG_LEVEL.getLog(), String.valueOf(logLevel) )); @@ -219,19 +219,12 @@ public Skyflow build() { private VaultConfig findAndUpdateVaultConfig(VaultConfig vaultConfig) throws SkyflowException { VaultConfig previousConfig = this.vaultConfigMap.get(vaultConfig.getVaultId()); - if (previousConfig == null) { - LogUtil.printErrorLog(Utils.parameterizedString( - ErrorLogs.VAULT_CONFIG_DOES_NOT_EXIST.getLog(), vaultConfig.getVaultId() - )); - throw new SkyflowException(); - } else { - Env env = vaultConfig.getEnv() != null ? vaultConfig.getEnv() : previousConfig.getEnv(); - String clusterId = vaultConfig.getClusterId() != null ? vaultConfig.getClusterId() : previousConfig.getClusterId(); - Credentials credentials = vaultConfig.getCredentials() != null ? vaultConfig.getCredentials() : previousConfig.getCredentials(); - previousConfig.setEnv(env); - previousConfig.setClusterId(clusterId); - previousConfig.setCredentials(credentials); - } + Env env = vaultConfig.getEnv() != null ? vaultConfig.getEnv() : previousConfig.getEnv(); + String clusterId = vaultConfig.getClusterId() != null ? vaultConfig.getClusterId() : previousConfig.getClusterId(); + Credentials credentials = vaultConfig.getCredentials() != null ? vaultConfig.getCredentials() : previousConfig.getCredentials(); + previousConfig.setEnv(env); + previousConfig.setClusterId(clusterId); + previousConfig.setCredentials(credentials); return previousConfig; } } diff --git a/v2/src/main/java/com/skyflow/config/ConnectionConfig.java b/v2/src/main/java/com/skyflow/config/ConnectionConfig.java index acab67ad..c017b181 100644 --- a/v2/src/main/java/com/skyflow/config/ConnectionConfig.java +++ b/v2/src/main/java/com/skyflow/config/ConnectionConfig.java @@ -35,12 +35,4 @@ public void setCredentials(Credentials credentials) { this.credentials = credentials; } - public String getConnectionUrl() { - return connectionUrl; - } - - public Credentials getCredentials() { - return credentials; - } - } diff --git a/v2/src/main/java/com/skyflow/utils/Utils.java b/v2/src/main/java/com/skyflow/utils/Utils.java index 86eb17b8..66e50b5a 100644 --- a/v2/src/main/java/com/skyflow/utils/Utils.java +++ b/v2/src/main/java/com/skyflow/utils/Utils.java @@ -8,8 +8,8 @@ import com.skyflow.errors.SkyflowException; import com.skyflow.logs.ErrorLogs; import com.skyflow.serviceaccount.util.BearerToken; -import com.skyflow.vault.connection.InvokeConnectionRequest; import com.skyflow.utils.logger.LogUtil; +import com.skyflow.vault.connection.InvokeConnectionRequest; import org.apache.commons.codec.binary.Base64; import java.io.File; @@ -127,7 +127,7 @@ public static String constructConnectionURL(ConnectionConfig config, InvokeConne } } - if(invokeConnectionRequest.getQueryParams() != null && !invokeConnectionRequest.getQueryParams().isEmpty()) { + if (invokeConnectionRequest.getQueryParams() != null && !invokeConnectionRequest.getQueryParams().isEmpty()) { filledURL.append("?"); for (Map.Entry entry : invokeConnectionRequest.getQueryParams().entrySet()) { String key = entry.getKey(); diff --git a/v2/src/main/java/com/skyflow/utils/validations/Validations.java b/v2/src/main/java/com/skyflow/utils/validations/Validations.java index 42ef80ee..61c7ff80 100644 --- a/v2/src/main/java/com/skyflow/utils/validations/Validations.java +++ b/v2/src/main/java/com/skyflow/utils/validations/Validations.java @@ -3,14 +3,10 @@ import com.skyflow.config.ConnectionConfig; import com.skyflow.config.Credentials; import com.skyflow.config.VaultConfig; - -import com.skyflow.enums.RequestMethod; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.vault.connection.InvokeConnectionRequest; import com.skyflow.enums.Byot; import com.skyflow.enums.InterfaceName; import com.skyflow.enums.RedactionType; +import com.skyflow.enums.RequestMethod; import com.skyflow.errors.ErrorCode; import com.skyflow.errors.ErrorMessage; import com.skyflow.errors.SkyflowException; @@ -18,14 +14,12 @@ import com.skyflow.utils.Constants; import com.skyflow.utils.Utils; import com.skyflow.utils.logger.LogUtil; +import com.skyflow.vault.connection.InvokeConnectionRequest; import com.skyflow.vault.data.*; import com.skyflow.vault.tokens.ColumnValue; import com.skyflow.vault.tokens.DetokenizeRequest; import com.skyflow.vault.tokens.TokenizeRequest; -import java.net.URL; - -// Add config and request validations import java.net.MalformedURLException; import java.net.URL; import java.util.ArrayList; @@ -92,7 +86,7 @@ public static void validateInvokeConnectionRequest(InvokeConnectionRequest invok throw new SkyflowException(); } - if (invokeConnectionRequest.getMethodName()!=null) { + if (invokeConnectionRequest.getMethodName() != null) { try { RequestMethod requestMethod = RequestMethod.valueOf(invokeConnectionRequest.getMethodName()); } catch (Exception e) { From f529a234de0ef10f557ad53aafe6e883e1c76fa9 Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Fri, 15 Nov 2024 16:57:24 +0530 Subject: [PATCH 10/18] SK-1684 Add unit tests for invoke connection SK-1766 Add validations for invoke connection interface SK-1766 Refactor code for invoke connection, removed unnecessary components for code optimisation --- .../java/com/skyflow/ConnectionClient.java | 53 ++- v2/src/main/java/com/skyflow/Skyflow.java | 57 ++- v2/src/main/java/com/skyflow/VaultClient.java | 8 - .../java/com/skyflow/errors/ErrorMessage.java | 8 +- .../com/skyflow/errors/SkyflowException.java | 3 - .../main/java/com/skyflow/logs/ErrorLogs.java | 15 +- .../utils/validations/Validations.java | 96 +++-- .../connection/InvokeConnectionRequest.java | 25 +- .../controller/ConnectionController.java | 68 +-- .../test/java/com/skyflow/SkyflowTests.java | 154 ++++++- .../com/skyflow/config/CredentialsTests.java | 8 +- .../com/skyflow/utils/HttpUtilityTests.java | 123 ++++++ .../java/com/skyflow/utils/UtilsTests.java | 48 +++ .../connection/InvokeConnectionTests.java | 394 ++++++++++++++++++ .../controller/ConnectionControllerTests.java | 49 +++ .../skyflow/vault/tokens/DetokenizeTests.java | 59 +-- 16 files changed, 967 insertions(+), 201 deletions(-) create mode 100644 v2/src/test/java/com/skyflow/utils/HttpUtilityTests.java create mode 100644 v2/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java create mode 100644 v2/src/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java diff --git a/v2/src/main/java/com/skyflow/ConnectionClient.java b/v2/src/main/java/com/skyflow/ConnectionClient.java index a42d3aa6..40fd741a 100644 --- a/v2/src/main/java/com/skyflow/ConnectionClient.java +++ b/v2/src/main/java/com/skyflow/ConnectionClient.java @@ -2,32 +2,31 @@ import com.skyflow.config.ConnectionConfig; import com.skyflow.config.Credentials; -import com.skyflow.config.VaultConfig; -import com.skyflow.generated.rest.ApiClient; -import com.skyflow.generated.rest.api.RecordsApi; -import com.skyflow.generated.rest.api.TokensApi; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.logs.InfoLogs; +import com.skyflow.serviceaccount.util.Token; +import com.skyflow.utils.Constants; +import com.skyflow.utils.Utils; +import com.skyflow.utils.logger.LogUtil; +import com.skyflow.utils.validations.Validations; import io.github.cdimascio.dotenv.Dotenv; public class ConnectionClient { - private final ConnectionConfig connectionConfig; + protected String token; + protected String apiKey; private Credentials commonCredentials; private Credentials finalCredentials; - private final ApiClient apiClient; - protected ConnectionClient(ConnectionConfig connectionConfig, Credentials credentials) { super(); this.connectionConfig = connectionConfig; this.commonCredentials = credentials; - this.apiClient = new ApiClient(); prioritiseCredentials(); } - protected Credentials getFinalCredentials() { - return finalCredentials; - } - protected ConnectionConfig getConnectionConfig() { return connectionConfig; } @@ -37,8 +36,29 @@ protected void setCommonCredentials(Credentials commonCredentials) { prioritiseCredentials(); } - protected ApiClient getApiClient() { - return apiClient; + protected void updateConnectionConfig(ConnectionConfig connectionConfig) { + prioritiseCredentials(); + } + + protected void setBearerToken() throws SkyflowException { + Validations.validateCredentials(this.finalCredentials); + if (this.finalCredentials.getApiKey() != null) { + setApiKey(); + return; + } else if (token == null || Token.isExpired(token)) { + LogUtil.printInfoLog(InfoLogs.BEARER_TOKEN_EXPIRED.getLog()); + token = Utils.generateBearerToken(this.finalCredentials); + } else { + LogUtil.printInfoLog(InfoLogs.REUSE_BEARER_TOKEN.getLog()); + } + } + + private void setApiKey() { + if (apiKey == null) { + apiKey = this.finalCredentials.getApiKey(); + } else { + LogUtil.printInfoLog(InfoLogs.REUSE_API_KEY.getLog()); + } } private void prioritiseCredentials() { @@ -49,9 +69,10 @@ private void prioritiseCredentials() { this.finalCredentials = this.commonCredentials; } else { Dotenv dotenv = Dotenv.load(); - String sysCredentials = dotenv.get("SKYFLOW_CREDENTIALS"); + String sysCredentials = dotenv.get(Constants.ENV_CREDENTIALS_KEY_NAME); if (sysCredentials == null) { - // throw error for not passing any credentials + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), + ErrorMessage.EmptyCredentials.getMessage()); } else { this.finalCredentials = new Credentials(); this.finalCredentials.setCredentialsString(sysCredentials); diff --git a/v2/src/main/java/com/skyflow/Skyflow.java b/v2/src/main/java/com/skyflow/Skyflow.java index eaf7a7a2..2a2e42cc 100644 --- a/v2/src/main/java/com/skyflow/Skyflow.java +++ b/v2/src/main/java/com/skyflow/Skyflow.java @@ -49,21 +49,21 @@ public Skyflow removeVaultConfig(String vaultId) throws SkyflowException { return this; } - public Skyflow addConnectionConfig(ConnectionConfig connectionConfig) { + public Skyflow addConnectionConfig(ConnectionConfig connectionConfig) throws SkyflowException { this.builder.addConnectionConfig(connectionConfig); return this; } public ConnectionConfig getConnectionConfig(String connectionId) { - return this.builder.connectionsMap.get(connectionId).getConnectionConfig(); + return this.builder.connectionConfigMap.get(connectionId); } - public Skyflow updateConnectionConfig(ConnectionConfig connectionConfig) { + public Skyflow updateConnectionConfig(ConnectionConfig connectionConfig) throws SkyflowException { this.builder.updateConnectionConfig(connectionConfig); return this; } - public Skyflow removeConnectionConfig(String connectionId) { + public Skyflow removeConnectionConfig(String connectionId) throws SkyflowException { this.builder.removeConnectionConfig(connectionId); return this; } @@ -91,7 +91,6 @@ public VaultController vault(String vaultId) { return this.builder.vaultClientsMap.get(vaultId); } - // In case no id is passed, return first connection controller public ConnectionController connection() { String connectionId = (String) this.builder.connectionsMap.keySet().toArray()[0]; return this.connection(connectionId); @@ -137,6 +136,8 @@ public SkyflowClientBuilder addVaultConfig(VaultConfig vaultConfig) throws Skyfl } public SkyflowClientBuilder updateVaultConfig(VaultConfig vaultConfig) throws SkyflowException { + LogUtil.printInfoLog(InfoLogs.VALIDATING_VAULT_CONFIG.getLog()); + Validations.validateVaultConfig(vaultConfig); if (this.vaultClientsMap.containsKey(vaultConfig.getVaultId())) { VaultConfig updatedConfig = findAndUpdateVaultConfig(vaultConfig); this.vaultClientsMap.get(updatedConfig.getVaultId()).updateVaultConfig(); @@ -160,34 +161,51 @@ public SkyflowClientBuilder removeVaultConfig(String vaultId) throws SkyflowExce return this; } - public SkyflowClientBuilder addConnectionConfig(ConnectionConfig connectionConfig) { - // check if connectionConfig already exists + public SkyflowClientBuilder addConnectionConfig(ConnectionConfig connectionConfig) throws SkyflowException { + LogUtil.printInfoLog(InfoLogs.VALIDATING_CONNECTION_CONFIG.getLog()); + Validations.validateConnectionConfig(connectionConfig); if (this.connectionsMap.containsKey(connectionConfig.getConnectionId())) { - // display error log, throw error, or both + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.CONNECTION_CONFIG_EXISTS.getLog(), connectionConfig.getConnectionId() + )); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), + ErrorMessage.ConnectionIdAlreadyInConfigList.getMessage()); } else { this.connectionConfigMap.put(connectionConfig.getConnectionId(), connectionConfig); ConnectionController controller = new ConnectionController(connectionConfig, this.skyflowCredentials); this.connectionsMap.put(connectionConfig.getConnectionId(), controller); + LogUtil.printInfoLog(Utils.parameterizedString( + InfoLogs.CONNECTION_CONTROLLER_INITIALIZED.getLog(), connectionConfig.getConnectionId())); } return this; } - public SkyflowClientBuilder updateConnectionConfig(ConnectionConfig connectionConfig) { + public SkyflowClientBuilder updateConnectionConfig(ConnectionConfig connectionConfig) throws SkyflowException { + LogUtil.printInfoLog(InfoLogs.VALIDATING_CONNECTION_CONFIG.getLog()); + Validations.validateConnectionConfig(connectionConfig); if (this.connectionsMap.containsKey(connectionConfig.getConnectionId())) { - ConnectionController controller = this.connectionsMap.get(connectionConfig.getConnectionId()); - controller.setConnectionConfig(connectionConfig); + ConnectionConfig updatedConfig = findAndUpdateConnectionConfig(connectionConfig); + this.connectionsMap.get(updatedConfig.getConnectionId()).updateConnectionConfig(connectionConfig); } else { - // display error log, throw error, or both + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.CONNECTION_CONFIG_DOES_NOT_EXIST.getLog(), connectionConfig.getConnectionId() + )); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), + ErrorMessage.ConnectionIdNotInConfigList.getMessage()); } return this; } - public SkyflowClientBuilder removeConnectionConfig(String connectionId) { + public SkyflowClientBuilder removeConnectionConfig(String connectionId) throws SkyflowException { if (this.connectionsMap.containsKey(connectionId)) { this.connectionsMap.remove(connectionId); this.connectionConfigMap.remove(connectionId); } else { - // display error log, throw error, or both + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.CONNECTION_CONFIG_DOES_NOT_EXIST.getLog(), connectionId + )); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), + ErrorMessage.ConnectionIdNotInConfigList.getMessage()); } return this; } @@ -217,7 +235,7 @@ public Skyflow build() { return new Skyflow(this); } - private VaultConfig findAndUpdateVaultConfig(VaultConfig vaultConfig) throws SkyflowException { + private VaultConfig findAndUpdateVaultConfig(VaultConfig vaultConfig) { VaultConfig previousConfig = this.vaultConfigMap.get(vaultConfig.getVaultId()); Env env = vaultConfig.getEnv() != null ? vaultConfig.getEnv() : previousConfig.getEnv(); String clusterId = vaultConfig.getClusterId() != null ? vaultConfig.getClusterId() : previousConfig.getClusterId(); @@ -227,5 +245,14 @@ private VaultConfig findAndUpdateVaultConfig(VaultConfig vaultConfig) throws Sky previousConfig.setCredentials(credentials); return previousConfig; } + + private ConnectionConfig findAndUpdateConnectionConfig(ConnectionConfig connectionConfig) { + ConnectionConfig previousConfig = this.connectionConfigMap.get(connectionConfig.getConnectionId()); + String connectionURL = connectionConfig.getConnectionUrl() != null ? connectionConfig.getConnectionUrl() : previousConfig.getConnectionUrl(); + Credentials credentials = connectionConfig.getCredentials() != null ? connectionConfig.getCredentials() : previousConfig.getCredentials(); + previousConfig.setConnectionUrl(connectionURL); + previousConfig.setCredentials(credentials); + return previousConfig; + } } } diff --git a/v2/src/main/java/com/skyflow/VaultClient.java b/v2/src/main/java/com/skyflow/VaultClient.java index 1c2e81ea..b1acbdad 100644 --- a/v2/src/main/java/com/skyflow/VaultClient.java +++ b/v2/src/main/java/com/skyflow/VaultClient.java @@ -51,10 +51,6 @@ protected VaultClient(VaultConfig vaultConfig, Credentials credentials) { prioritiseCredentials(); } - protected Credentials getFinalCredentials() { - return finalCredentials; - } - protected RecordsApi getRecordsApi() { return recordsApi; } @@ -75,10 +71,6 @@ protected VaultConfig getVaultConfig() { return vaultConfig; } - protected String getToken() { - return token; - } - protected void setCommonCredentials(Credentials commonCredentials) { this.commonCredentials = commonCredentials; prioritiseCredentials(); diff --git a/v2/src/main/java/com/skyflow/errors/ErrorMessage.java b/v2/src/main/java/com/skyflow/errors/ErrorMessage.java index 5d9905a3..f44427fb 100644 --- a/v2/src/main/java/com/skyflow/errors/ErrorMessage.java +++ b/v2/src/main/java/com/skyflow/errors/ErrorMessage.java @@ -20,8 +20,8 @@ public enum ErrorMessage { // connection config InvalidConnectionId("%s1 Initialization failed. Invalid connection ID. Specify a valid connection ID."), EmptyConnectionId("%s1 Initialization failed. Invalid connection ID. Connection ID must not be empty."), - EmptyConnectionUrl("%s1 Initialization failed. Invalid connection URL. Connection URL must not be empty."), InvalidConnectionUrl("%s1 Initialization failed. Invalid connection URL. Specify a valid connection URL."), + EmptyConnectionUrl("%s1 Initialization failed. Invalid connection URL. Connection URL must not be empty."), InvalidConnectionUrlFormat("%s1 Initialization failed. Connection URL is not a valid URL. Specify a valid connection URL."), // credentials @@ -112,9 +112,13 @@ public enum ErrorMessage { ColumnValuesKeyErrorTokenize("%s1 Validation error. 'columnValues' key is missing from the payload. Specify a 'columnValues' key."), EmptyColumnGroupInColumnValue("%s1 Validation error. Invalid column group in column value. Specify a valid column group."), - //connection + // connection + InvalidRequestHeaders("%s1 Validation error. Request headers aren't valid. Specify valid request headers."), + EmptyRequestHeaders("%s1 Validation error. Request headers are empty. Specify valid ."), InvalidPathParams("%s1 Validation error. Path parameters aren't valid. Specify valid path parameters."), EmptyPathParams("%s1 Validation error. Path parameters are empty. Specify valid path parameters."), + InvalidQueryParams("%s1 Validation error. Query parameters aren't valid. Specify valid query parameters."), + EmptyQueryParams("%s1 Validation error. Query parameters are empty. Specify valid query parameters."), InvalidRequestBody("%s1 Validation error. Invalid request body. Specify the request body as an object."), EmptyRequestBody("%s1 Validation error. Request body can't be empty. Specify a valid request body."), diff --git a/v2/src/main/java/com/skyflow/errors/SkyflowException.java b/v2/src/main/java/com/skyflow/errors/SkyflowException.java index 1d0c81ff..625b0d2e 100644 --- a/v2/src/main/java/com/skyflow/errors/SkyflowException.java +++ b/v2/src/main/java/com/skyflow/errors/SkyflowException.java @@ -16,9 +16,6 @@ public class SkyflowException extends Exception { private JsonArray details; private JsonObject responseBody; - public SkyflowException() { - } - public SkyflowException(String message) { super(message); this.message = message; diff --git a/v2/src/main/java/com/skyflow/logs/ErrorLogs.java b/v2/src/main/java/com/skyflow/logs/ErrorLogs.java index fa1f945d..98bc3064 100644 --- a/v2/src/main/java/com/skyflow/logs/ErrorLogs.java +++ b/v2/src/main/java/com/skyflow/logs/ErrorLogs.java @@ -91,7 +91,20 @@ public enum ErrorLogs { COLUMN_VALUES_IS_REQUIRED_TOKENIZE("Invalid %s1 request. ColumnValues are required."), EMPTY_OR_NULL_COLUMN_GROUP_IN_COLUMN_VALUES("Invalid %s1 request. Column group can not be null or empty in column values at index %s2."), TOKENIZE_REQUEST_REJECTED("Tokenize request resulted in failure."), - DELETE_REQUEST_REJECTED("Delete request resulted in failure."); + DELETE_REQUEST_REJECTED("Delete request resulted in failure."), + + // invoke connection interface + INVOKE_CONNECTION_INVALID_CONNECTION_URL("Invalid %s1 request. Connection URL is not a valid URL."), + EMPTY_REQUEST_HEADERS("Invalid %s1 request. Request headers can not be empty."), + INVALID_REQUEST_HEADERS("Invalid %s1 request. Request header can not be null or empty in request headers."), + EMPTY_PATH_PARAMS("Invalid %s1 request. Path params can not be empty."), + INVALID_PATH_PARAM("Invalid %s1 request. Path parameter can not be null or empty in path params."), + EMPTY_QUERY_PARAMS("Invalid %s1 request. Query params can not be empty."), + INVALID_QUERY_PARAM("Invalid %s1 request. Query parameter can not be null or empty in query params."), + EMPTY_REQUEST_BODY("Invalid %s1 request. Request body can not be empty."), + INVALID_REQUEST_BODY("Invalid %s1 request. Request body can not be empty."), + INVOKE_CONNECTION_REQUEST_REJECTED("Invoke connection request resulted in failure."), + ; private final String log; diff --git a/v2/src/main/java/com/skyflow/utils/validations/Validations.java b/v2/src/main/java/com/skyflow/utils/validations/Validations.java index 61c7ff80..5e88ec1b 100644 --- a/v2/src/main/java/com/skyflow/utils/validations/Validations.java +++ b/v2/src/main/java/com/skyflow/utils/validations/Validations.java @@ -6,7 +6,6 @@ import com.skyflow.enums.Byot; import com.skyflow.enums.InterfaceName; import com.skyflow.enums.RedactionType; -import com.skyflow.enums.RequestMethod; import com.skyflow.errors.ErrorCode; import com.skyflow.errors.ErrorMessage; import com.skyflow.errors.SkyflowException; @@ -20,11 +19,11 @@ import com.skyflow.vault.tokens.DetokenizeRequest; import com.skyflow.vault.tokens.TokenizeRequest; -import java.net.MalformedURLException; import java.net.URL; import java.util.ArrayList; import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -67,44 +66,77 @@ public static void validateConnectionConfig(ConnectionConfig connectionConfig) t } else if (connectionUrl.trim().isEmpty()) { LogUtil.printErrorLog(ErrorLogs.EMPTY_CONNECTION_URL.getLog()); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyConnectionUrl.getMessage()); - } - try { - URL url = new URL(connectionUrl); - } catch (MalformedURLException e) { + } else if (isInvalidURL(connectionUrl)) { LogUtil.printErrorLog(ErrorLogs.INVALID_CONNECTION_URL.getLog()); throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.InvalidConnectionUrlFormat.getMessage()); } } public static void validateInvokeConnectionRequest(InvokeConnectionRequest invokeConnectionRequest) throws SkyflowException { - if (invokeConnectionRequest.getRequestHeaders().containsKey("connectionURL")) { - String connectionURL = invokeConnectionRequest.getRequestHeaders().get("connectionURL"); - if (isInvalidURL(connectionURL)) { - throw new SkyflowException(); + Map requestHeaders = invokeConnectionRequest.getRequestHeaders(); + Map pathParams = invokeConnectionRequest.getPathParams(); + Map queryParams = invokeConnectionRequest.getQueryParams(); + Object requestBody = invokeConnectionRequest.getRequestBody(); + + if (requestHeaders != null) { + if (requestHeaders.isEmpty()) { + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.EMPTY_REQUEST_HEADERS.getLog(), InterfaceName.INVOKE_CONNECTION.getName())); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyRequestHeaders.getMessage()); + } else { + for (String header : requestHeaders.keySet()) { + String headerValue = requestHeaders.get(header); + if (header == null || header.trim().isEmpty() || headerValue == null || headerValue.trim().isEmpty()) { + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.INVALID_REQUEST_HEADERS.getLog(), InterfaceName.INVOKE_CONNECTION.getName())); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.InvalidRequestHeaders.getMessage()); + } + } } - } else { - throw new SkyflowException(); } - if (invokeConnectionRequest.getMethodName() != null) { - try { - RequestMethod requestMethod = RequestMethod.valueOf(invokeConnectionRequest.getMethodName()); - } catch (Exception e) { - throw new SkyflowException(); + if (pathParams != null) { + if (pathParams.isEmpty()) { + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.EMPTY_PATH_PARAMS.getLog(), InterfaceName.INVOKE_CONNECTION.getName())); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyPathParams.getMessage()); + } else { + for (String param : pathParams.keySet()) { + String paramValue = pathParams.get(param); + if (param == null || param.trim().isEmpty() || paramValue == null || paramValue.trim().isEmpty()) { + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.INVALID_PATH_PARAM.getLog(), InterfaceName.INVOKE_CONNECTION.getName())); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.InvalidPathParams.getMessage()); + } + } } - } else { - throw new SkyflowException(); } - } - private static boolean isInvalidURL(String configURL) { - try { - URL url = new URL(configURL); - if (!url.getProtocol().equals("https")) throw new Exception(); - } catch (Exception e) { - return true; + if (queryParams != null) { + if (queryParams.isEmpty()) { + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.EMPTY_QUERY_PARAMS.getLog(), InterfaceName.INVOKE_CONNECTION.getName())); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyQueryParams.getMessage()); + } else { + for (String param : queryParams.keySet()) { + String paramValue = queryParams.get(param); + if (param == null || param.trim().isEmpty() || paramValue == null || paramValue.trim().isEmpty()) { + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.INVALID_QUERY_PARAM.getLog(), InterfaceName.INVOKE_CONNECTION.getName())); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.InvalidQueryParams.getMessage()); + } + } + } + } + + if (requestBody != null) { + Map requestBodyMap = (Map) requestBody; + if (requestBodyMap.isEmpty()) { + LogUtil.printErrorLog(Utils.parameterizedString( + ErrorLogs.EMPTY_REQUEST_BODY.getLog(), InterfaceName.INVOKE_CONNECTION.getName())); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.EmptyRequestBody.getMessage()); + } } - return false; } public static void validateCredentials(Credentials credentials) throws SkyflowException { @@ -643,6 +675,16 @@ public static void validateTokenizeRequest(TokenizeRequest tokenizeRequest) thro } } + private static boolean isInvalidURL(String configURL) { + try { + URL url = new URL(configURL); + if (!url.getProtocol().equals("https")) throw new Exception(); + } catch (Exception e) { + return true; + } + return false; + } + private static void validateTokensForInsertRequest( ArrayList> tokens, ArrayList> values, diff --git a/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java b/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java index a74b9adb..5edf4f4f 100644 --- a/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java +++ b/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java @@ -1,11 +1,7 @@ package com.skyflow.vault.connection; -import com.google.gson.JsonObject; -import com.skyflow.enums.RedactionType; -import com.skyflow.vault.tokens.DetokenizeRequest; -import com.skyflow.vault.tokens.TokenizeRequest; +import com.skyflow.enums.RequestMethod; -import java.util.ArrayList; import java.util.HashMap; import java.util.Map; @@ -21,11 +17,7 @@ public static InvokeConnectionRequestBuilder builder() { return new InvokeConnectionRequestBuilder(); } - public InvokeConnectionRequest getConnectionRequest() { - return new InvokeConnectionRequest(builder); - } - - public String getMethodName() { + public RequestMethod getMethodName() { return builder.methodName; } @@ -45,24 +37,23 @@ public Object getRequestBody() { return builder.requestBody; } - public static final class InvokeConnectionRequestBuilder{ - - private String methodName; + public static final class InvokeConnectionRequestBuilder { + private RequestMethod methodName; private Map pathParams; private Map queryParams; private Map requestHeaders; private Object requestBody; - public InvokeConnectionRequestBuilder() { - this.methodName = ""; + private InvokeConnectionRequestBuilder() { + this.methodName = RequestMethod.POST; this.pathParams = new HashMap<>(); this.queryParams = new HashMap<>(); this.requestHeaders = new HashMap<>(); this.requestBody = new Object(); } - public InvokeConnectionRequestBuilder methodName(String methodName) { - this.methodName = methodName; + public InvokeConnectionRequestBuilder methodName(RequestMethod methodName) { + this.methodName = methodName == null ? RequestMethod.POST : methodName; return this; } diff --git a/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java b/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java index d2e08977..7ae03a2a 100644 --- a/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java +++ b/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java @@ -1,97 +1,75 @@ package com.skyflow.vault.controller; import com.google.gson.Gson; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; import com.google.gson.JsonParser; import com.skyflow.ConnectionClient; import com.skyflow.config.ConnectionConfig; import com.skyflow.config.Credentials; +import com.skyflow.enums.RequestMethod; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; import com.skyflow.errors.SkyflowException; -import com.skyflow.generated.rest.auth.HttpBearerAuth; -import com.skyflow.serviceaccount.util.Token; +import com.skyflow.logs.ErrorLogs; +import com.skyflow.logs.InfoLogs; import com.skyflow.utils.HttpUtility; import com.skyflow.utils.Utils; +import com.skyflow.utils.logger.LogUtil; import com.skyflow.utils.validations.Validations; import com.skyflow.vault.connection.InvokeConnectionRequest; import com.skyflow.vault.connection.InvokeConnectionResponse; -import com.google.gson.JsonElement; -import com.google.gson.JsonObject; - -import java.net.URL; import java.io.IOException; -import java.text.ParseException; +import java.net.URL; import java.util.HashMap; import java.util.Map; public class ConnectionController extends ConnectionClient { - private ConnectionConfig connectionConfig; - private Credentials commonCredentials; - - private String token; - public ConnectionController(ConnectionConfig connectionConfig, Credentials credentials) { super(connectionConfig, credentials); - this.connectionConfig = connectionConfig; - this.commonCredentials = credentials; } - public void setCommonCredentials(Credentials commonCredentials) { - this.commonCredentials = commonCredentials; - } - - public ConnectionConfig getConnectionConfig() { - return connectionConfig; - } - - public void setConnectionConfig(ConnectionConfig connectionConfig) { - this.connectionConfig = connectionConfig; - } - - public InvokeConnectionResponse invoke(InvokeConnectionRequest invokeConnectionRequest) throws SkyflowException, IOException { - + public InvokeConnectionResponse invoke(InvokeConnectionRequest invokeConnectionRequest) throws SkyflowException { + LogUtil.printInfoLog(InfoLogs.INVOKE_CONNECTION_TRIGGERED.getLog()); InvokeConnectionResponse connectionResponse; try { + LogUtil.printInfoLog(InfoLogs.VALIDATING_INVOKE_CONNECTION_REQUEST.getLog()); Validations.validateInvokeConnectionRequest(invokeConnectionRequest); setBearerToken(); - String filledURL = Utils.constructConnectionURL(connectionConfig, invokeConnectionRequest); + String filledURL = Utils.constructConnectionURL(super.getConnectionConfig(), invokeConnectionRequest); Map headers = new HashMap<>(); if (invokeConnectionRequest.getRequestHeaders().containsKey("requestHeader")) { headers = Utils.constructConnectionHeadersMap(invokeConnectionRequest.getRequestHeaders()); } if (!headers.containsKey("x-skyflow-authorization")) { - headers.put("x-skyflow-authorization", token); + headers.put("x-skyflow-authorization", token == null ? apiKey : token); } - String requestMethod = invokeConnectionRequest.getMethodName(); + RequestMethod requestMethod = invokeConnectionRequest.getMethodName(); JsonObject requestBody = null; Object requestBodyObject = invokeConnectionRequest.getRequestBody(); - if(requestBodyObject!=null) { + if (requestBodyObject != null) { try { requestBody = convertObjectToJson(requestBodyObject); } catch (Exception e) { - throw new SkyflowException(); + LogUtil.printErrorLog(ErrorLogs.INVALID_REQUEST_HEADERS.getLog()); + throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.InvalidRequestBody.getMessage()); } } - String response = HttpUtility.sendRequest(requestMethod, new URL(filledURL), requestBody, headers); - connectionResponse = new InvokeConnectionResponse((JsonObject) new JsonParser().parse(response)); + String response = HttpUtility.sendRequest(requestMethod.name(), new URL(filledURL), requestBody, headers); + connectionResponse = new InvokeConnectionResponse((JsonObject) JsonParser.parseString(response)); + LogUtil.printInfoLog(InfoLogs.INVOKE_CONNECTION_REQUEST_RESOLVED.getLog()); } catch (IOException e) { - throw new SkyflowException(); + LogUtil.printErrorLog(ErrorLogs.INVOKE_CONNECTION_REQUEST_REJECTED.getLog()); + throw new SkyflowException(e.getMessage(), e); } return connectionResponse; } - private void setBearerToken() throws SkyflowException { - Validations.validateCredentials(super.getFinalCredentials()); - if (token == null || Token.isExpired(token)) { - token = Utils.generateBearerToken(super.getFinalCredentials()); - } - HttpBearerAuth Bearer = (HttpBearerAuth) super.getApiClient().getAuthentication("Bearer"); - Bearer.setBearerToken(token); - } - private JsonObject convertObjectToJson(Object object) { Gson gson = new Gson(); JsonElement jsonElement = gson.toJsonTree(object); diff --git a/v2/src/test/java/com/skyflow/SkyflowTests.java b/v2/src/test/java/com/skyflow/SkyflowTests.java index cfdd7e5a..efdc54dc 100644 --- a/v2/src/test/java/com/skyflow/SkyflowTests.java +++ b/v2/src/test/java/com/skyflow/SkyflowTests.java @@ -20,6 +20,7 @@ public class SkyflowTests { private static String newClusterID = null; private static String connectionID = null; private static String connectionURL = null; + private static String newConnectionURL = null; private static String token = null; @BeforeClass @@ -29,6 +30,7 @@ public static void setup() { newClusterID = "new_test_cluster_id"; connectionID = "test_connection_id"; connectionURL = "https://test.connection.url"; + newConnectionURL = "https://new.test.connection.url"; token = "test_token"; } @@ -147,8 +149,6 @@ public void testUpdatingValidVaultConfigInSkyflowClient() { skyflowClient.updateVaultConfig(config); } catch (SkyflowException e) { Assert.fail(INVALID_EXCEPTION_THROWN); - } catch (Exception e) { - Assert.fail(INVALID_EXCEPTION_THROWN); } } @@ -208,10 +208,10 @@ public void testAddingInvalidConnectionConfigInSkyflowBuilder() { config.setConnectionId(""); config.setConnectionUrl(connectionURL); Skyflow.builder().addConnectionConfig(config).build(); -// Assert.fail(EXCEPTION_NOT_THROWN); - } catch (Exception e) { -// Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); - Assert.assertEquals(ErrorMessage.EmptyVaultId.getMessage(), e.getMessage()); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyConnectionId.getMessage(), e.getMessage()); } } @@ -223,10 +223,134 @@ public void testAddingInvalidConnectionConfigInSkyflowClient() { config.setConnectionUrl(connectionURL); Skyflow skyflowClient = Skyflow.builder().build(); skyflowClient.addConnectionConfig(config); -// Assert.fail(EXCEPTION_NOT_THROWN); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyConnectionId.getMessage(), e.getMessage()); + } + } + + @Test + public void testAddingValidConnectionConfigInSkyflowClient() { + try { + ConnectionConfig config = new ConnectionConfig(); + config.setConnectionId(connectionID); + config.setConnectionUrl(connectionURL); + Skyflow skyflowClient = Skyflow.builder().build(); + skyflowClient.addConnectionConfig(config); } catch (Exception e) { -// Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); - Assert.assertEquals(ErrorMessage.EmptyVaultId.getMessage(), e.getMessage()); + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testAddingExistingConnectionConfigInSkyflowClient() { + try { + ConnectionConfig config = new ConnectionConfig(); + config.setConnectionId(connectionID); + config.setConnectionUrl(connectionURL); + Skyflow skyflowClient = Skyflow.builder().addConnectionConfig(config).build(); + skyflowClient.addConnectionConfig(config); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.ConnectionIdAlreadyInConfigList.getMessage(), e.getMessage()); + } + } + + @Test + public void testUpdatingNonExistentConnectionConfigInSkyflowBuilder() { + try { + ConnectionConfig config = new ConnectionConfig(); + config.setConnectionId(connectionID); + config.setConnectionUrl(connectionURL); + Skyflow.builder().updateConnectionConfig(config).build(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.ConnectionIdNotInConfigList.getMessage(), e.getMessage()); + } + } + + @Test + public void testUpdatingNonExistentConnectionConfigInSkyflowClient() { + try { + ConnectionConfig config = new ConnectionConfig(); + config.setConnectionId(connectionID); + config.setConnectionUrl(connectionURL); + Skyflow skyflowClient = Skyflow.builder().build(); + skyflowClient.updateConnectionConfig(config); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.ConnectionIdNotInConfigList.getMessage(), e.getMessage()); + } + } + + @Test + public void testUpdatingValidConnectionConfigInSkyflowClient() { + try { + ConnectionConfig config = new ConnectionConfig(); + config.setConnectionId(connectionID); + config.setConnectionUrl(connectionURL); + Skyflow skyflowClient = Skyflow.builder().addConnectionConfig(config).build(); + + Credentials credentials = new Credentials(); + credentials.setToken(token); + + config.setConnectionUrl(newConnectionURL); + config.setCredentials(credentials); + + skyflowClient.updateConnectionConfig(config); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testRemovingNonExistentConnectionConfigInSkyflowBuilder() { + try { + Skyflow.builder().removeConnectionConfig(connectionID).build(); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.ConnectionIdNotInConfigList.getMessage(), e.getMessage()); + } + } + + @Test + public void testRemovingNonExistentConnectionConfigInSkyflowClient() { + try { + Skyflow skyflowClient = Skyflow.builder().build(); + skyflowClient.removeConnectionConfig(connectionID); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.ConnectionIdNotInConfigList.getMessage(), e.getMessage()); + } + } + + @Test + public void testRemovingValidConnectionConfigInSkyflowClient() { + try { + ConnectionConfig config = new ConnectionConfig(); + config.setConnectionId(connectionID); + config.setConnectionUrl(connectionURL); + Skyflow skyflowClient = Skyflow.builder().addConnectionConfig(config).build(); + skyflowClient.removeConnectionConfig(connectionID); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testGettingNonExistentConnectionConfigInSkyflowClient() { + try { + Skyflow skyflowClient = Skyflow.builder().build(); + ConnectionConfig config = skyflowClient.getConnectionConfig(connectionID); + Assert.assertNull(config); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); } } @@ -245,9 +369,17 @@ public void testAddingInvalidSkyflowCredentialsInSkyflowBuilder() { @Test public void testUpdatingValidSkyflowCredentialsInSkyflowClient() { try { + VaultConfig vaultConfig = new VaultConfig(); + vaultConfig.setVaultId(vaultID); + vaultConfig.setClusterId(clusterID); + + ConnectionConfig connectionConfig = new ConnectionConfig(); + connectionConfig.setConnectionId(connectionID); + connectionConfig.setConnectionUrl(connectionURL); + Credentials credentials = new Credentials(); credentials.setToken(token); - Skyflow skyflowClient = Skyflow.builder().build(); + Skyflow skyflowClient = Skyflow.builder().addVaultConfig(vaultConfig).addConnectionConfig(connectionConfig).build(); skyflowClient.updateSkyflowCredentials(credentials); } catch (SkyflowException e) { Assert.fail(INVALID_EXCEPTION_THROWN); @@ -260,7 +392,6 @@ public void testDefaultLogLevel() { Skyflow skyflowClient = Skyflow.builder().setLogLevel(null).build(); Assert.assertEquals(LogLevel.ERROR, skyflowClient.getLogLevel()); } catch (Exception e) { - e.printStackTrace(); Assert.fail(INVALID_EXCEPTION_THROWN); } } @@ -277,5 +408,4 @@ public void testUpdateLogLevel() { } } - } diff --git a/v2/src/test/java/com/skyflow/config/CredentialsTests.java b/v2/src/test/java/com/skyflow/config/CredentialsTests.java index 64f34c94..1b7f6e64 100644 --- a/v2/src/test/java/com/skyflow/config/CredentialsTests.java +++ b/v2/src/test/java/com/skyflow/config/CredentialsTests.java @@ -1,6 +1,5 @@ package com.skyflow.config; -import com.skyflow.config.Credentials; import com.skyflow.errors.ErrorCode; import com.skyflow.errors.ErrorMessage; import com.skyflow.errors.SkyflowException; @@ -8,6 +7,7 @@ import com.skyflow.serviceaccount.util.Token; import com.skyflow.utils.validations.Validations; import org.junit.Assert; +import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; @@ -48,6 +48,11 @@ public static void setup() throws SkyflowException, NoSuchMethodException { context = "test_context_value"; } + @Before + public void setupTest() { + roles.clear(); + } + @Test public void testValidCredentialsWithPath() { try { @@ -217,7 +222,6 @@ public void testNothingPassedInCredentials() { @Test public void testEmptyRolesInCredentials() { try { - roles.clear(); Credentials credentials = new Credentials(); credentials.setPath(path); credentials.setRoles(roles); diff --git a/v2/src/test/java/com/skyflow/utils/HttpUtilityTests.java b/v2/src/test/java/com/skyflow/utils/HttpUtilityTests.java new file mode 100644 index 00000000..816f1504 --- /dev/null +++ b/v2/src/test/java/com/skyflow/utils/HttpUtilityTests.java @@ -0,0 +1,123 @@ +package com.skyflow.utils; + +import com.google.gson.JsonObject; +import com.skyflow.errors.SkyflowException; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.net.HttpURLConnection; +import java.net.URL; +import java.net.URLConnection; +import java.net.URLStreamHandler; +import java.util.HashMap; +import java.util.Map; + +import static org.junit.Assert.fail; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.BDDMockito.given; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({URL.class, HttpURLConnection.class}) +public class HttpUtilityTests { + + private static String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + @InjectMocks + HttpUtility httpUtility; + @Mock + OutputStream outputStream; + private String expected; + private String expectedError; + private URL url; + private HttpURLConnection mockConnection; + + @Before + public void setup() throws IOException { + expected = "{\"status\":\"success\"}"; + expectedError = "{\"status\":\"something went wrong\"}"; + mockConnection = Mockito.mock(HttpURLConnection.class); + given(mockConnection.getInputStream()).willReturn(new ByteArrayInputStream(expected.getBytes())); + given(mockConnection.getErrorStream()).willReturn(new ByteArrayInputStream(expectedError.getBytes())); + given(mockConnection.getOutputStream()).willReturn(outputStream); + given(mockConnection.getResponseCode()).willReturn(200); + given(mockConnection.getHeaderField(anyString())).willReturn("id"); + final URLStreamHandler handler = new URLStreamHandler() { + @Override + protected URLConnection openConnection(final URL arg0) throws IOException { + return mockConnection; + } + }; + url = new URL("https://google.com", "google.com", 80, "", handler); + } + + @Test + @PrepareForTest({URL.class, HttpURLConnection.class}) + public void testSendRequest() { + try { + given(mockConnection.getRequestProperty("content-type")).willReturn("application/json"); + Map headers = new HashMap<>(); + headers.put("content-type", "application/json"); + JsonObject params = new JsonObject(); + params.addProperty("key", "value"); + String response = httpUtility.sendRequest("GET", url, params, headers); + Assert.assertEquals(expected, response); + } catch (Exception e) { + fail(INVALID_EXCEPTION_THROWN); + } + } + + + @Test + @PrepareForTest({URL.class, HttpURLConnection.class}) + public void testSendRequestFormData() { + try { + given(mockConnection.getRequestProperty("content-type")).willReturn("multipart/form-data"); + Map headers = new HashMap<>(); + headers.put("content-type", "multipart/form-data"); + JsonObject params = new JsonObject(); + params.addProperty("key", "value"); + String response = httpUtility.sendRequest("GET", url, params, headers); + Assert.assertEquals(expected, response); + } catch (Exception e) { + fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + @PrepareForTest({URL.class, HttpURLConnection.class}) + public void testSendRequestFormURLEncoded() { + try { + given(mockConnection.getRequestProperty("content-type")).willReturn("application/x-www-form-urlencoded"); + Map headers = new HashMap<>(); + headers.put("content-type", "application/x-www-form-urlencoded"); + JsonObject params = new JsonObject(); + params.addProperty("key", "value"); + String response = httpUtility.sendRequest("GET", url, params, headers); + Assert.assertEquals(expected, response); + } catch (Exception e) { + fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + @PrepareForTest({URL.class, HttpURLConnection.class}) + public void testSendRequestError() { + try { + given(mockConnection.getResponseCode()).willReturn(500); + String response = httpUtility.sendRequest("GET", url, null, null); + } catch (SkyflowException e) { + Assert.assertEquals(expectedError, e.getMessage()); + } catch (Exception e) { + fail(INVALID_EXCEPTION_THROWN); + } + } +} diff --git a/v2/src/test/java/com/skyflow/utils/UtilsTests.java b/v2/src/test/java/com/skyflow/utils/UtilsTests.java index 33a83f59..5a1b9de7 100644 --- a/v2/src/test/java/com/skyflow/utils/UtilsTests.java +++ b/v2/src/test/java/com/skyflow/utils/UtilsTests.java @@ -1,15 +1,20 @@ package com.skyflow.utils; +import com.skyflow.config.ConnectionConfig; import com.skyflow.config.Credentials; import com.skyflow.enums.Env; +import com.skyflow.enums.RequestMethod; import com.skyflow.errors.ErrorCode; import com.skyflow.errors.ErrorMessage; import com.skyflow.errors.SkyflowException; +import com.skyflow.vault.connection.InvokeConnectionRequest; import org.junit.Assert; import org.junit.BeforeClass; import org.junit.Test; import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; public class UtilsTests { private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; @@ -21,6 +26,11 @@ public class UtilsTests { private static String token = null; private static String context = null; private static ArrayList roles = null; + private static String connectionId = null; + private static String connectionUrl = null; + private static Map queryParams; + private static Map pathParams; + private static Map requestHeaders; @BeforeClass public static void setup() { @@ -33,6 +43,11 @@ public static void setup() { roles = new ArrayList<>(); String role = "test_role"; roles.add(role); + connectionId = "test_connection_id"; + connectionUrl = "https://test.connection.url"; + pathParams = new HashMap<>(); + queryParams = new HashMap<>(); + requestHeaders = new HashMap<>(); } @Test @@ -133,4 +148,37 @@ public void testGenerateBearerTokenWithToken() { Assert.fail(INVALID_EXCEPTION_THROWN); } } + + @Test + public void testConstructConnectionURL() { + try { + queryParams.put("query_param", "value"); + pathParams.put("path_param", "value"); + + ConnectionConfig connectionConfig = new ConnectionConfig(); + connectionConfig.setConnectionId(connectionId); + connectionConfig.setConnectionUrl(connectionUrl); + + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST).pathParams(pathParams).queryParams(queryParams).build(); + String filledUrl = Utils.constructConnectionURL(connectionConfig, request); + Assert.assertEquals(connectionUrl + "?" + "query_param=value", filledUrl); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testConstructConnectionHeaderMap() { + try { + requestHeaders.put("HEADER", "value"); + Map headers = Utils.constructConnectionHeadersMap(requestHeaders); + Assert.assertEquals(1, headers.size()); + Assert.assertTrue(headers.containsKey("header")); + Assert.assertFalse(headers.containsKey("HEADER")); + Assert.assertEquals("value", headers.get("header")); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } } diff --git a/v2/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java b/v2/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java new file mode 100644 index 00000000..2294bdaa --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java @@ -0,0 +1,394 @@ +package com.skyflow.vault.connection; + +import com.skyflow.enums.RequestMethod; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.utils.validations.Validations; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; + +import java.util.HashMap; +import java.util.Map; + +public class InvokeConnectionTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static Map queryParams; + private static Map pathParams; + private static Map requestHeaders; + private static Map requestBody; + + @BeforeClass + public static void setup() { + queryParams = new HashMap<>(); + pathParams = new HashMap<>(); + requestHeaders = new HashMap<>(); + requestBody = new HashMap<>(); + } + + @Before + public void setupTest() { + queryParams.clear(); + pathParams.clear(); + requestHeaders.clear(); + requestBody.clear(); + } + + @Test + public void testValidInputInInvokeConnectionRequestValidations() { + queryParams.put("query_param", "value"); + pathParams.put("path_param", "value"); + requestHeaders.put("header", "value"); + requestBody.put("key", "value"); + try { + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.assertEquals(1, request.getQueryParams().size()); + Assert.assertEquals(1, request.getPathParams().size()); + Assert.assertEquals(1, request.getRequestHeaders().size()); + Assert.assertEquals(RequestMethod.POST, request.getMethodName()); + Assert.assertNotNull(request.getRequestBody()); + } catch (SkyflowException e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } + + @Test + public void testEmptyRequestHeadersInInvokeConnectionRequestValidations() { + try { + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyRequestHeaders.getMessage(), e.getMessage()); + } + } + + @Test + public void testNullRequestHeaderKeyInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value1"); + requestHeaders.put(null, "value2"); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidRequestHeaders.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyRequestHeaderKeyInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + requestHeaders.put("", "value"); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidRequestHeaders.getMessage(), e.getMessage()); + } + } + + @Test + public void testNullRequestHeaderValueInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + requestHeaders.put("header2", null); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidRequestHeaders.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyRequestHeaderValueInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + requestHeaders.put("header2", ""); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidRequestHeaders.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyPathParamsInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyPathParams.getMessage(), e.getMessage()); + } + } + + @Test + public void testNullPathParamKeyInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + pathParams.put("path_param", "value"); + pathParams.put(null, "value"); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidPathParams.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyPathParamKeyInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + pathParams.put("path_param", "value"); + pathParams.put("", "value"); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidPathParams.getMessage(), e.getMessage()); + } + } + + @Test + public void testNullPathParamValueInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + pathParams.put("path_param1", "value"); + pathParams.put("path_param2", null); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidPathParams.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyPathParamValueInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + pathParams.put("path_param1", "value"); + pathParams.put("path_param2", ""); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidPathParams.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyQueryParamsInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + pathParams.put("path_param", "value"); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyQueryParams.getMessage(), e.getMessage()); + } + } + + @Test + public void testNullQueryParamKeyInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + pathParams.put("path_param", "value"); + queryParams.put("query_param", "value"); + queryParams.put(null, "value"); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidQueryParams.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyQueryParamKeyInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + pathParams.put("path_param", "value"); + queryParams.put("query_param", "value"); + queryParams.put("", "value"); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidQueryParams.getMessage(), e.getMessage()); + } + } + + @Test + public void testNullQueryParamValueInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + pathParams.put("path_param", "value"); + queryParams.put("query_param1", "value"); + queryParams.put("query_param2", null); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidQueryParams.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyQueryParamValueInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header1", "value"); + pathParams.put("path_param", "value"); + queryParams.put("query_param1", "value"); + queryParams.put("query_param2", ""); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.InvalidQueryParams.getMessage(), e.getMessage()); + } + } + + @Test + public void testEmptyRequestBodyInInvokeConnectionRequestValidations() { + try { + requestHeaders.put("header", "value"); + pathParams.put("path_param", "value"); + queryParams.put("query_param", "value"); + InvokeConnectionRequest request = InvokeConnectionRequest.builder() + .methodName(RequestMethod.POST) + .requestHeaders(requestHeaders) + .pathParams(pathParams) + .queryParams(queryParams) + .requestBody(requestBody) + .build(); + Validations.validateInvokeConnectionRequest(request); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyRequestBody.getMessage(), e.getMessage()); + } + } +} diff --git a/v2/src/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java b/v2/src/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java new file mode 100644 index 00000000..0b933b4a --- /dev/null +++ b/v2/src/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java @@ -0,0 +1,49 @@ +package com.skyflow.vault.controller; + +import com.skyflow.Skyflow; +import com.skyflow.config.ConnectionConfig; +import com.skyflow.config.Credentials; +import com.skyflow.enums.LogLevel; +import com.skyflow.errors.ErrorCode; +import com.skyflow.errors.ErrorMessage; +import com.skyflow.errors.SkyflowException; +import com.skyflow.vault.connection.InvokeConnectionRequest; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; + +public class ConnectionControllerTests { + private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; + private static String connectionID = null; + private static String connectionURL = null; + private static ConnectionConfig connectionConfig = null; + private static Skyflow skyflowClient = null; + + @BeforeClass + public static void setup() { + connectionID = "vault123"; + connectionURL = "https://test.connection.url"; + + Credentials credentials = new Credentials(); + credentials.setToken("valid-token"); + + connectionConfig = new ConnectionConfig(); + connectionConfig.setConnectionId(connectionID); + connectionConfig.setConnectionUrl(connectionURL); + connectionConfig.setCredentials(credentials); + } + + @Test + public void testInvalidRequestInInvokeConnectionMethod() { + try { + InvokeConnectionRequest connectionRequest = InvokeConnectionRequest.builder().build(); + Skyflow skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addConnectionConfig(connectionConfig).build(); + skyflowClient.connection().invoke(connectionRequest); + Assert.fail(EXCEPTION_NOT_THROWN); + } catch (SkyflowException e) { + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorMessage.EmptyRequestHeaders.getMessage(), e.getMessage()); + } + } +} diff --git a/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java b/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java index b4185260..d569cbc9 100644 --- a/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java +++ b/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java @@ -1,80 +1,35 @@ package com.skyflow.vault.tokens; -import com.skyflow.Skyflow; -import com.skyflow.config.Credentials; -import com.skyflow.config.VaultConfig; -import com.skyflow.enums.Env; -import com.skyflow.enums.LogLevel; import com.skyflow.enums.RedactionType; import com.skyflow.errors.ErrorCode; import com.skyflow.errors.ErrorMessage; import com.skyflow.errors.SkyflowException; -import com.skyflow.generated.rest.ApiClient; -import com.skyflow.generated.rest.ApiException; -import com.skyflow.generated.rest.api.TokensApi; -import com.skyflow.generated.rest.models.V1DetokenizeResponse; import com.skyflow.utils.Constants; import com.skyflow.utils.Utils; import com.skyflow.utils.validations.Validations; import org.junit.Assert; +import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import java.util.ArrayList; -//@RunWith(PowerMockRunner.class) -//@PrepareForTest(fullyQualifiedNames = { -// "com.skyflow.serviceaccount.util.Token", -// "com.skyflow.generated.rest.ApiClient", -// "com.skyflow.generated.rest.api.TokensApi", -//}) public class DetokenizeTests { private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; - private static String vaultID = null; - private static String clusterID = null; - private static VaultConfig vaultConfig = null; private static String token = null; private static ArrayList tokens = null; - private static Skyflow skyflowClient = null; - private ApiClient mockApiClient; - private TokensApi mockTokensApi; @BeforeClass public static void setup() throws SkyflowException, NoSuchMethodException { -// PowerMockito.mockStatic(Token.class); -// PowerMockito.when(Token.isExpired("valid_token")).thenReturn(true); -// PowerMockito.when(Token.isExpired("not_a_valid_token")).thenReturn(false); - - vaultID = "vault123"; - clusterID = "cluster123"; - - Credentials credentials = new Credentials(); - credentials.setToken("valid-token"); - - vaultConfig = new VaultConfig(); - vaultConfig.setVaultId(vaultID); - vaultConfig.setClusterId(clusterID); - vaultConfig.setEnv(Env.DEV); - vaultConfig.setCredentials(credentials); - - token = "test_token_1"; tokens = new ArrayList<>(); - -// System.setProperty("ssl.TrustManagerFactory.algorithm", "PKIX"); + token = "test_token_1"; } -// @Before -// public void setupMock() throws ApiException { -// mockApiClient = PowerMockito.mock(ApiClient.class); -// mockTokensApi = PowerMockito.mock(TokensApi.class); -// -// V1DetokenizeResponse mockResponse = new V1DetokenizeResponse(); -// PowerMockito -// .when(mockTokensApi.recordServiceDetokenize(ArgumentMatchers.anyString(), ArgumentMatchers.any())) -// .thenReturn(mockResponse); -// -// } + @Before + public void setupTest() { + tokens.clear(); + } @Test public void testValidInputInDetokenizeRequestValidations() { @@ -110,7 +65,6 @@ public void testNoTokensInDetokenizeRequestValidations() { @Test public void testEmptyTokensInDetokenizeRequestValidations() { - tokens.clear(); DetokenizeRequest request = DetokenizeRequest.builder().tokens(tokens).build(); try { Validations.validateDetokenizeRequest(request); @@ -147,7 +101,6 @@ public void testEmptyTokenInTokensInDetokenizeRequestValidations() { @Test public void testRedactionAndContinueOnErrorInDetokenizeRequestValidations() { - tokens.clear(); tokens.add(token); DetokenizeRequest request = DetokenizeRequest.builder(). tokens(tokens).redactionType(null).continueOnError(null).build(); From 8efdf12e903c037ec62ee81f230b15084efad53e Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Fri, 15 Nov 2024 17:38:16 +0530 Subject: [PATCH 11/18] SK-1623 Java SDK v2 Removed v1,v2 modules and moved all v2 code directly to parent module Removed unnecessary dependencies --- pom.xml | 76 +- .../java/com/skyflow/ConnectionClient.java | 0 .../main/java/com/skyflow/Skyflow.java | 0 .../main/java/com/skyflow/VaultClient.java | 0 .../com/skyflow/config/ConnectionConfig.java | 0 .../java/com/skyflow/config/Credentials.java | 0 .../com/skyflow/config/ManagementConfig.java | 0 .../java/com/skyflow/config/VaultConfig.java | 0 .../main/java/com/skyflow/enums/Byot.java | 0 .../main/java/com/skyflow/enums/Env.java | 0 .../java/com/skyflow/enums/InterfaceName.java | 0 .../main/java/com/skyflow/enums/LogLevel.java | 0 .../java/com/skyflow/enums/RedactionType.java | 0 .../java/com/skyflow/enums/RequestMethod.java | 0 .../java/com/skyflow/errors/ErrorCode.java | 0 .../java/com/skyflow/errors/ErrorMessage.java | 0 .../com/skyflow/errors/SkyflowException.java | 0 .../skyflow/generated/rest/ApiCallback.java | 0 .../com/skyflow/generated/rest/ApiClient.java | 0 .../skyflow/generated/rest/ApiException.java | 0 .../skyflow/generated/rest/ApiResponse.java | 0 .../skyflow/generated/rest/Configuration.java | 0 .../rest/GzipRequestInterceptor.java | 0 .../java/com/skyflow/generated/rest/JSON.java | 0 .../java/com/skyflow/generated/rest/Pair.java | 0 .../generated/rest/ProgressRequestBody.java | 0 .../generated/rest/ProgressResponseBody.java | 0 .../generated/rest/ServerConfiguration.java | 0 .../generated/rest/ServerVariable.java | 0 .../skyflow/generated/rest/StringUtil.java | 0 .../skyflow/generated/rest/api/AuditApi.java | 0 .../generated/rest/api/AuthenticationApi.java | 0 .../generated/rest/api/BinLookupApi.java | 0 .../skyflow/generated/rest/api/QueryApi.java | 0 .../generated/rest/api/RecordsApi.java | 0 .../skyflow/generated/rest/api/TokensApi.java | 0 .../generated/rest/auth/ApiKeyAuth.java | 0 .../generated/rest/auth/Authentication.java | 0 .../generated/rest/auth/HttpBasicAuth.java | 0 .../generated/rest/auth/HttpBearerAuth.java | 0 .../rest/models/AbstractOpenApiSchema.java | 0 .../models/AuditEventAuditResourceType.java | 0 .../rest/models/AuditEventContext.java | 0 .../generated/rest/models/AuditEventData.java | 0 .../rest/models/AuditEventHTTPInfo.java | 0 .../rest/models/BatchRecordMethod.java | 0 .../rest/models/ContextAccessType.java | 0 .../rest/models/ContextAuthMode.java | 0 .../DetokenizeRecordResponseValueType.java | 0 .../rest/models/GooglerpcStatus.java | 0 .../generated/rest/models/ProtobufAny.java | 0 .../models/QueryServiceExecuteQueryBody.java | 0 .../RecordServiceBatchOperationBody.java | 0 .../RecordServiceBulkDeleteRecordBody.java | 0 .../models/RecordServiceInsertRecordBody.java | 0 .../models/RecordServiceUpdateRecordBody.java | 0 .../rest/models/RedactionEnumREDACTION.java | 0 .../rest/models/RequestActionType.java | 0 .../rest/models/V1AuditAfterOptions.java | 0 .../rest/models/V1AuditEventResponse.java | 0 .../rest/models/V1AuditResponse.java | 0 .../rest/models/V1AuditResponseEvent.java | 0 .../models/V1AuditResponseEventRequest.java | 0 .../rest/models/V1BINListRequest.java | 0 .../rest/models/V1BINListResponse.java | 0 .../skyflow/generated/rest/models/V1BYOT.java | 0 .../rest/models/V1BatchOperationResponse.java | 0 .../generated/rest/models/V1BatchRecord.java | 0 .../models/V1BulkDeleteRecordResponse.java | 0 .../rest/models/V1BulkGetRecordResponse.java | 0 .../skyflow/generated/rest/models/V1Card.java | 0 .../rest/models/V1DeleteFileResponse.java | 0 .../rest/models/V1DeleteRecordResponse.java | 0 .../rest/models/V1DetokenizePayload.java | 0 .../models/V1DetokenizeRecordRequest.java | 0 .../models/V1DetokenizeRecordResponse.java | 0 .../rest/models/V1DetokenizeResponse.java | 0 .../generated/rest/models/V1FieldRecords.java | 0 .../rest/models/V1FileAVScanStatus.java | 0 .../rest/models/V1GetAuthTokenRequest.java | 0 .../rest/models/V1GetAuthTokenResponse.java | 0 .../models/V1GetFileScanStatusResponse.java | 0 .../rest/models/V1GetQueryResponse.java | 0 .../rest/models/V1InsertRecordResponse.java | 0 .../generated/rest/models/V1MemberType.java | 0 .../rest/models/V1RecordMetaProperties.java | 0 .../rest/models/V1TokenizePayload.java | 0 .../rest/models/V1TokenizeRecordRequest.java | 0 .../rest/models/V1TokenizeRecordResponse.java | 0 .../rest/models/V1TokenizeResponse.java | 0 .../rest/models/V1UpdateRecordResponse.java | 0 .../rest/models/V1VaultFieldMapping.java | 0 .../rest/models/V1VaultSchemaConfig.java | 0 .../main/java/com/skyflow/logs/ErrorLogs.java | 0 .../main/java/com/skyflow/logs/InfoLogs.java | 0 .../serviceaccount/util/BearerToken.java | 0 .../util/SignedDataTokenResponse.java | 0 .../serviceaccount/util/SignedDataTokens.java | 0 .../skyflow/serviceaccount/util/Token.java | 0 .../java/com/skyflow/utils/Constants.java | 0 .../java/com/skyflow/utils/HttpUtility.java | 0 .../main/java/com/skyflow/utils/Utils.java | 0 .../com/skyflow/utils/logger/LogUtil.java | 0 .../utils/validations/Validations.java | 0 .../skyflow/vault/audit/ListEventRequest.java | 0 .../vault/audit/ListEventResponse.java | 0 .../com/skyflow/vault/bin/GetBinRequest.java | 0 .../com/skyflow/vault/bin/GetBinResponse.java | 0 .../connection/InvokeConnectionRequest.java | 0 .../connection/InvokeConnectionResponse.java | 0 .../vault/controller/AuditController.java | 0 .../vault/controller/BinLookupController.java | 0 .../controller/ConnectionController.java | 0 .../vault/controller/DetectController.java | 0 .../vault/controller/VaultController.java | 0 .../com/skyflow/vault/data/DeleteRequest.java | 0 .../skyflow/vault/data/DeleteResponse.java | 0 .../com/skyflow/vault/data/GetRequest.java | 0 .../com/skyflow/vault/data/GetResponse.java | 0 .../com/skyflow/vault/data/InsertRequest.java | 0 .../skyflow/vault/data/InsertResponse.java | 0 .../com/skyflow/vault/data/QueryRequest.java | 0 .../com/skyflow/vault/data/QueryResponse.java | 0 .../com/skyflow/vault/data/UpdateRequest.java | 0 .../skyflow/vault/data/UpdateResponse.java | 0 .../vault/detect/DeIdentifyRequest.java | 0 .../vault/detect/DeIdentifyResponse.java | 0 .../com/skyflow/vault/tokens/ColumnValue.java | 0 .../tokens/DetokenizeRecordResponse.java | 0 .../vault/tokens/DetokenizeRequest.java | 0 .../vault/tokens/DetokenizeResponse.java | 0 .../skyflow/vault/tokens/TokenizeRequest.java | 0 .../vault/tokens/TokenizeResponse.java | 0 .../test/java/com/skyflow/SkyflowTests.java | 0 .../skyflow/config/ConnectionConfigTests.java | 0 .../com/skyflow/config/CredentialsTests.java | 0 .../com/skyflow/config/VaultConfigTests.java | 0 .../serviceaccount/util/BearerTokenTests.java | 0 .../util/SignedDataTokensTests.java | 0 .../serviceaccount/util/TokenTests.java | 12 +- .../com/skyflow/utils/HttpUtilityTests.java | 0 .../java/com/skyflow/utils/UtilsTests.java | 0 .../connection/InvokeConnectionTests.java | 15 + .../controller/ConnectionControllerTests.java | 0 .../controller/VaultControllerTests.java | 0 .../com/skyflow/vault/data/DeleteTests.java | 13 +- .../java/com/skyflow/vault/data/GetTests.java | 0 .../com/skyflow/vault/data/InsertTests.java | 0 .../com/skyflow/vault/data/QueryTests.java | 0 .../com/skyflow/vault/data/UpdateTests.java | 70 +- .../skyflow/vault/tokens/DetokenizeTests.java | 0 .../skyflow/vault/tokens/TokenizeTests.java | 0 .../invalidPrivateKeyCredentials.json | 0 .../resources/invalidTokenURICredentials.json | 0 .../test/resources/noClientIDCredentials.json | 0 .../test/resources/noKeyIDCredentials.json | 0 .../resources/noPrivateKeyCredentials.json | 0 .../test/resources/noTokenURICredentials.json | 0 {v2/src => src}/test/resources/notJson.txt | 0 v1/pom.xml | 20 - v1/src/main/java/DetokenizeExample.java | 71 - v1/src/main/java/InsertExample.java | 84 - .../main/java/com/skyflow/Configuration.java | 16 - .../com/skyflow/common/utils/Constants.java | 8 - .../com/skyflow/common/utils/Helpers.java | 440 --- .../com/skyflow/common/utils/HttpUtility.java | 107 - .../com/skyflow/common/utils/LogUtil.java | 102 - .../com/skyflow/common/utils/TokenUtils.java | 74 - .../com/skyflow/common/utils/Validators.java | 176 -- .../com/skyflow/entities/DeleteInput.java | 13 - .../com/skyflow/entities/DeleteOptions.java | 5 - .../skyflow/entities/DeleteRecordInput.java | 22 - .../com/skyflow/entities/DetokenizeInput.java | 16 - .../skyflow/entities/DetokenizeRecord.java | 25 - .../com/skyflow/entities/GetByIdInput.java | 16 - .../skyflow/entities/GetByIdRecordInput.java | 34 - .../java/com/skyflow/entities/GetInput.java | 16 - .../java/com/skyflow/entities/GetOptions.java | 16 - .../com/skyflow/entities/GetRecordInput.java | 52 - .../skyflow/entities/InsertBulkOptions.java | 35 - .../com/skyflow/entities/InsertInput.java | 17 - .../com/skyflow/entities/InsertOptions.java | 60 - .../skyflow/entities/InsertRecordInput.java | 27 - .../java/com/skyflow/entities/LogLevel.java | 12 - .../java/com/skyflow/entities/QueryInput.java | 13 - .../com/skyflow/entities/QueryOptions.java | 8 - .../skyflow/entities/QueryRecordInput.java | 11 - .../com/skyflow/entities/RedactionType.java | 24 - .../com/skyflow/entities/RequestMethod.java | 25 - .../com/skyflow/entities/ResponseToken.java | 25 - .../entities/SkyflowConfiguration.java | 46 - .../com/skyflow/entities/TokenProvider.java | 10 - .../com/skyflow/entities/UpdateInput.java | 13 - .../com/skyflow/entities/UpdateOptions.java | 18 - .../skyflow/entities/UpdateRecordInput.java | 35 - .../com/skyflow/entities/UpsertOption.java | 22 - .../java/com/skyflow/errors/ErrorCode.java | 79 - .../com/skyflow/errors/SkyflowException.java | 54 - .../main/java/com/skyflow/logs/DebugLogs.java | 19 - .../main/java/com/skyflow/logs/ErrorLogs.java | 70 - .../main/java/com/skyflow/logs/InfoLogs.java | 39 - .../main/java/com/skyflow/logs/WarnLogs.java | 18 - .../serviceaccount/util/BearerToken.java | 229 -- .../util/SignedDataTokenResponse.java | 20 - .../serviceaccount/util/SignedDataTokens.java | 224 -- .../skyflow/serviceaccount/util/Token.java | 231 -- .../com/skyflow/vault/DeleteBySkyflowId.java | 94 - .../java/com/skyflow/vault/Detokenize.java | 102 - v1/src/main/java/com/skyflow/vault/Get.java | 138 - .../com/skyflow/vault/GetBySkyflowId.java | 110 - .../main/java/com/skyflow/vault/Insert.java | 120 - .../main/java/com/skyflow/vault/Skyflow.java | 565 ---- .../com/skyflow/vault/UpdateBySkyflowId.java | 106 - .../com/skyflow/common/utils/HelpersTest.java | 205 -- .../skyflow/common/utils/HttpUtilityTest.java | 154 - .../skyflow/common/utils/TokenUtilsTest.java | 87 - .../utils/TokenUtilsValidTokenTest.java | 88 - .../skyflow/common/utils/ValidatorsTest.java | 160 -- .../serviceaccount/util/BearerTokenTest.java | 275 -- .../util/SignedDataTokenResponseTest.java | 19 - .../util/SignedDataTokensTest.java | 197 -- .../serviceaccount/util/TokenTest.java | 229 -- .../com/skyflow/vault/DeleteMethodTest.java | 421 --- .../java/com/skyflow/vault/GetMethodTest.java | 870 ------ .../skyflow/vault/InvokeConnectionTest.java | 258 -- .../java/com/skyflow/vault/SkyflowTest.java | 2485 ----------------- v1/src/test/resources/invalidCredentials.json | 1 - v1/src/test/resources/notJson.txt | 0 v2/pom.xml | 70 - 229 files changed, 125 insertions(+), 9512 deletions(-) rename {v2/src => src}/main/java/com/skyflow/ConnectionClient.java (100%) rename {v2/src => src}/main/java/com/skyflow/Skyflow.java (100%) rename {v2/src => src}/main/java/com/skyflow/VaultClient.java (100%) rename {v2/src => src}/main/java/com/skyflow/config/ConnectionConfig.java (100%) rename {v2/src => src}/main/java/com/skyflow/config/Credentials.java (100%) rename {v2/src => src}/main/java/com/skyflow/config/ManagementConfig.java (100%) rename {v2/src => src}/main/java/com/skyflow/config/VaultConfig.java (100%) rename {v2/src => src}/main/java/com/skyflow/enums/Byot.java (100%) rename {v2/src => src}/main/java/com/skyflow/enums/Env.java (100%) rename {v2/src => src}/main/java/com/skyflow/enums/InterfaceName.java (100%) rename {v2/src => src}/main/java/com/skyflow/enums/LogLevel.java (100%) rename {v2/src => src}/main/java/com/skyflow/enums/RedactionType.java (100%) rename {v2/src => src}/main/java/com/skyflow/enums/RequestMethod.java (100%) rename {v2/src => src}/main/java/com/skyflow/errors/ErrorCode.java (100%) rename {v2/src => src}/main/java/com/skyflow/errors/ErrorMessage.java (100%) rename {v2/src => src}/main/java/com/skyflow/errors/SkyflowException.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/ApiCallback.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/ApiClient.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/ApiException.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/ApiResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/Configuration.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/GzipRequestInterceptor.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/JSON.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/Pair.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/ProgressRequestBody.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/ProgressResponseBody.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/ServerConfiguration.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/ServerVariable.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/StringUtil.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/api/AuditApi.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/api/AuthenticationApi.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/api/BinLookupApi.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/api/QueryApi.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/api/RecordsApi.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/api/TokensApi.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/auth/ApiKeyAuth.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/auth/Authentication.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/auth/HttpBasicAuth.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/auth/HttpBearerAuth.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/AbstractOpenApiSchema.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/AuditEventAuditResourceType.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/AuditEventContext.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/AuditEventData.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/AuditEventHTTPInfo.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/BatchRecordMethod.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/ContextAccessType.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/ContextAuthMode.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/DetokenizeRecordResponseValueType.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/GooglerpcStatus.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/ProtobufAny.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/QueryServiceExecuteQueryBody.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/RecordServiceBatchOperationBody.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/RecordServiceBulkDeleteRecordBody.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/RecordServiceInsertRecordBody.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/RecordServiceUpdateRecordBody.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/RedactionEnumREDACTION.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/RequestActionType.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1AuditAfterOptions.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1AuditEventResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1AuditResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1AuditResponseEvent.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1AuditResponseEventRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1BINListRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1BINListResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1BYOT.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1BatchOperationResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1BatchRecord.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1BulkDeleteRecordResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1BulkGetRecordResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1Card.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1DeleteFileResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1DeleteRecordResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1DetokenizePayload.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1DetokenizeRecordRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1DetokenizeRecordResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1DetokenizeResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1FieldRecords.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1FileAVScanStatus.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1GetAuthTokenRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1GetAuthTokenResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1GetFileScanStatusResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1GetQueryResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1InsertRecordResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1MemberType.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1RecordMetaProperties.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1TokenizePayload.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1TokenizeRecordRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1TokenizeRecordResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1TokenizeResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1UpdateRecordResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1VaultFieldMapping.java (100%) rename {v2/src => src}/main/java/com/skyflow/generated/rest/models/V1VaultSchemaConfig.java (100%) rename {v2/src => src}/main/java/com/skyflow/logs/ErrorLogs.java (100%) rename {v2/src => src}/main/java/com/skyflow/logs/InfoLogs.java (100%) rename {v2/src => src}/main/java/com/skyflow/serviceaccount/util/BearerToken.java (100%) rename {v2/src => src}/main/java/com/skyflow/serviceaccount/util/SignedDataTokenResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java (100%) rename {v2/src => src}/main/java/com/skyflow/serviceaccount/util/Token.java (100%) rename {v2/src => src}/main/java/com/skyflow/utils/Constants.java (100%) rename {v2/src => src}/main/java/com/skyflow/utils/HttpUtility.java (100%) rename {v2/src => src}/main/java/com/skyflow/utils/Utils.java (100%) rename {v2/src => src}/main/java/com/skyflow/utils/logger/LogUtil.java (100%) rename {v2/src => src}/main/java/com/skyflow/utils/validations/Validations.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/audit/ListEventRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/audit/ListEventResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/bin/GetBinRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/bin/GetBinResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/connection/InvokeConnectionResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/controller/AuditController.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/controller/BinLookupController.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/controller/ConnectionController.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/controller/DetectController.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/controller/VaultController.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/data/DeleteRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/data/DeleteResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/data/GetRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/data/GetResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/data/InsertRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/data/InsertResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/data/QueryRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/data/QueryResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/data/UpdateRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/data/UpdateResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/detect/DeIdentifyRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/detect/DeIdentifyResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/tokens/ColumnValue.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/tokens/DetokenizeRecordResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/tokens/DetokenizeRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/tokens/DetokenizeResponse.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/tokens/TokenizeRequest.java (100%) rename {v2/src => src}/main/java/com/skyflow/vault/tokens/TokenizeResponse.java (100%) rename {v2/src => src}/test/java/com/skyflow/SkyflowTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/config/ConnectionConfigTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/config/CredentialsTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/config/VaultConfigTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/serviceaccount/util/TokenTests.java (75%) rename {v2/src => src}/test/java/com/skyflow/utils/HttpUtilityTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/utils/UtilsTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java (96%) rename {v2/src => src}/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/vault/controller/VaultControllerTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/vault/data/DeleteTests.java (97%) rename {v2/src => src}/test/java/com/skyflow/vault/data/GetTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/vault/data/InsertTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/vault/data/QueryTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/vault/data/UpdateTests.java (88%) rename {v2/src => src}/test/java/com/skyflow/vault/tokens/DetokenizeTests.java (100%) rename {v2/src => src}/test/java/com/skyflow/vault/tokens/TokenizeTests.java (100%) rename {v2/src => src}/test/resources/invalidPrivateKeyCredentials.json (100%) rename {v2/src => src}/test/resources/invalidTokenURICredentials.json (100%) rename {v2/src => src}/test/resources/noClientIDCredentials.json (100%) rename {v2/src => src}/test/resources/noKeyIDCredentials.json (100%) rename {v2/src => src}/test/resources/noPrivateKeyCredentials.json (100%) rename {v2/src => src}/test/resources/noTokenURICredentials.json (100%) rename {v2/src => src}/test/resources/notJson.txt (100%) delete mode 100644 v1/pom.xml delete mode 100644 v1/src/main/java/DetokenizeExample.java delete mode 100644 v1/src/main/java/InsertExample.java delete mode 100644 v1/src/main/java/com/skyflow/Configuration.java delete mode 100644 v1/src/main/java/com/skyflow/common/utils/Constants.java delete mode 100644 v1/src/main/java/com/skyflow/common/utils/Helpers.java delete mode 100644 v1/src/main/java/com/skyflow/common/utils/HttpUtility.java delete mode 100644 v1/src/main/java/com/skyflow/common/utils/LogUtil.java delete mode 100644 v1/src/main/java/com/skyflow/common/utils/TokenUtils.java delete mode 100644 v1/src/main/java/com/skyflow/common/utils/Validators.java delete mode 100644 v1/src/main/java/com/skyflow/entities/DeleteInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/DeleteOptions.java delete mode 100644 v1/src/main/java/com/skyflow/entities/DeleteRecordInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/DetokenizeInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/DetokenizeRecord.java delete mode 100644 v1/src/main/java/com/skyflow/entities/GetByIdInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/GetByIdRecordInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/GetInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/GetOptions.java delete mode 100644 v1/src/main/java/com/skyflow/entities/GetRecordInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/InsertBulkOptions.java delete mode 100644 v1/src/main/java/com/skyflow/entities/InsertInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/InsertOptions.java delete mode 100644 v1/src/main/java/com/skyflow/entities/InsertRecordInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/LogLevel.java delete mode 100644 v1/src/main/java/com/skyflow/entities/QueryInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/QueryOptions.java delete mode 100644 v1/src/main/java/com/skyflow/entities/QueryRecordInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/RedactionType.java delete mode 100644 v1/src/main/java/com/skyflow/entities/RequestMethod.java delete mode 100644 v1/src/main/java/com/skyflow/entities/ResponseToken.java delete mode 100644 v1/src/main/java/com/skyflow/entities/SkyflowConfiguration.java delete mode 100644 v1/src/main/java/com/skyflow/entities/TokenProvider.java delete mode 100644 v1/src/main/java/com/skyflow/entities/UpdateInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/UpdateOptions.java delete mode 100644 v1/src/main/java/com/skyflow/entities/UpdateRecordInput.java delete mode 100644 v1/src/main/java/com/skyflow/entities/UpsertOption.java delete mode 100644 v1/src/main/java/com/skyflow/errors/ErrorCode.java delete mode 100644 v1/src/main/java/com/skyflow/errors/SkyflowException.java delete mode 100644 v1/src/main/java/com/skyflow/logs/DebugLogs.java delete mode 100644 v1/src/main/java/com/skyflow/logs/ErrorLogs.java delete mode 100644 v1/src/main/java/com/skyflow/logs/InfoLogs.java delete mode 100644 v1/src/main/java/com/skyflow/logs/WarnLogs.java delete mode 100644 v1/src/main/java/com/skyflow/serviceaccount/util/BearerToken.java delete mode 100644 v1/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokenResponse.java delete mode 100644 v1/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java delete mode 100644 v1/src/main/java/com/skyflow/serviceaccount/util/Token.java delete mode 100644 v1/src/main/java/com/skyflow/vault/DeleteBySkyflowId.java delete mode 100644 v1/src/main/java/com/skyflow/vault/Detokenize.java delete mode 100644 v1/src/main/java/com/skyflow/vault/Get.java delete mode 100644 v1/src/main/java/com/skyflow/vault/GetBySkyflowId.java delete mode 100644 v1/src/main/java/com/skyflow/vault/Insert.java delete mode 100644 v1/src/main/java/com/skyflow/vault/Skyflow.java delete mode 100644 v1/src/main/java/com/skyflow/vault/UpdateBySkyflowId.java delete mode 100644 v1/src/test/java/com/skyflow/common/utils/HelpersTest.java delete mode 100644 v1/src/test/java/com/skyflow/common/utils/HttpUtilityTest.java delete mode 100644 v1/src/test/java/com/skyflow/common/utils/TokenUtilsTest.java delete mode 100644 v1/src/test/java/com/skyflow/common/utils/TokenUtilsValidTokenTest.java delete mode 100644 v1/src/test/java/com/skyflow/common/utils/ValidatorsTest.java delete mode 100644 v1/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTest.java delete mode 100644 v1/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokenResponseTest.java delete mode 100644 v1/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTest.java delete mode 100644 v1/src/test/java/com/skyflow/serviceaccount/util/TokenTest.java delete mode 100644 v1/src/test/java/com/skyflow/vault/DeleteMethodTest.java delete mode 100644 v1/src/test/java/com/skyflow/vault/GetMethodTest.java delete mode 100644 v1/src/test/java/com/skyflow/vault/InvokeConnectionTest.java delete mode 100644 v1/src/test/java/com/skyflow/vault/SkyflowTest.java delete mode 100644 v1/src/test/resources/invalidCredentials.json delete mode 100644 v1/src/test/resources/notJson.txt delete mode 100644 v2/pom.xml diff --git a/pom.xml b/pom.xml index 85befa48..12533834 100644 --- a/pom.xml +++ b/pom.xml @@ -7,7 +7,7 @@ com.skyflow skyflow-java 1.15.0 - pom + jar ${project.groupId}:${project.artifactId} Skyflow SDK for the Java programming language @@ -25,10 +25,6 @@ skyflow - - v1 - v2 - scm:git:git://github.com:skyflowapi/skyflow-java.git scm:git:ssh://github.com:skyflowapi/skyflow-java.git @@ -41,6 +37,11 @@ 4.12.0 2.10.1 1.9.0 + UTF-8 + 4.12.0 + 5.10.3 + 1.10.0 + 1.3.5 @@ -55,49 +56,68 @@ + - com.fasterxml.jackson.core - jackson-core - 2.13.0 + io.github.cdimascio + dotenv-java + 3.0.0 - com.googlecode.json-simple - json-simple - 1.1.1 + com.google.code.findbugs + jsr305 + 3.0.2 - io.jsonwebtoken - jjwt - 0.9.1 + io.gsonfire + gson-fire + ${gson-fire-version} + + + com.google.code.gson + gson + ${gson-version} + + + com.squareup.okhttp3 + okhttp + ${okhttp-version} + + com.squareup.okhttp3 + logging-interceptor + ${okhttp-version} + + commons-codec commons-codec 1.15 - javax.xml.bind - jaxb-api - 2.3.1 + io.jsonwebtoken + jjwt + 0.9.1 - io.jsonwebtoken - jjwt-impl - 0.11.2 - runtime + jakarta.annotation + jakarta.annotation-api + ${jakarta-annotation-version} + provided + - io.jsonwebtoken - jjwt-jackson - 0.11.2 - runtime + org.junit.jupiter + junit-jupiter-engine + ${junit-version} + test - junit - junit - 4.13.2 + org.junit.platform + junit-platform-runner + ${junit-platform-runner.version} test + org.powermock powermock-module-junit4 diff --git a/v2/src/main/java/com/skyflow/ConnectionClient.java b/src/main/java/com/skyflow/ConnectionClient.java similarity index 100% rename from v2/src/main/java/com/skyflow/ConnectionClient.java rename to src/main/java/com/skyflow/ConnectionClient.java diff --git a/v2/src/main/java/com/skyflow/Skyflow.java b/src/main/java/com/skyflow/Skyflow.java similarity index 100% rename from v2/src/main/java/com/skyflow/Skyflow.java rename to src/main/java/com/skyflow/Skyflow.java diff --git a/v2/src/main/java/com/skyflow/VaultClient.java b/src/main/java/com/skyflow/VaultClient.java similarity index 100% rename from v2/src/main/java/com/skyflow/VaultClient.java rename to src/main/java/com/skyflow/VaultClient.java diff --git a/v2/src/main/java/com/skyflow/config/ConnectionConfig.java b/src/main/java/com/skyflow/config/ConnectionConfig.java similarity index 100% rename from v2/src/main/java/com/skyflow/config/ConnectionConfig.java rename to src/main/java/com/skyflow/config/ConnectionConfig.java diff --git a/v2/src/main/java/com/skyflow/config/Credentials.java b/src/main/java/com/skyflow/config/Credentials.java similarity index 100% rename from v2/src/main/java/com/skyflow/config/Credentials.java rename to src/main/java/com/skyflow/config/Credentials.java diff --git a/v2/src/main/java/com/skyflow/config/ManagementConfig.java b/src/main/java/com/skyflow/config/ManagementConfig.java similarity index 100% rename from v2/src/main/java/com/skyflow/config/ManagementConfig.java rename to src/main/java/com/skyflow/config/ManagementConfig.java diff --git a/v2/src/main/java/com/skyflow/config/VaultConfig.java b/src/main/java/com/skyflow/config/VaultConfig.java similarity index 100% rename from v2/src/main/java/com/skyflow/config/VaultConfig.java rename to src/main/java/com/skyflow/config/VaultConfig.java diff --git a/v2/src/main/java/com/skyflow/enums/Byot.java b/src/main/java/com/skyflow/enums/Byot.java similarity index 100% rename from v2/src/main/java/com/skyflow/enums/Byot.java rename to src/main/java/com/skyflow/enums/Byot.java diff --git a/v2/src/main/java/com/skyflow/enums/Env.java b/src/main/java/com/skyflow/enums/Env.java similarity index 100% rename from v2/src/main/java/com/skyflow/enums/Env.java rename to src/main/java/com/skyflow/enums/Env.java diff --git a/v2/src/main/java/com/skyflow/enums/InterfaceName.java b/src/main/java/com/skyflow/enums/InterfaceName.java similarity index 100% rename from v2/src/main/java/com/skyflow/enums/InterfaceName.java rename to src/main/java/com/skyflow/enums/InterfaceName.java diff --git a/v2/src/main/java/com/skyflow/enums/LogLevel.java b/src/main/java/com/skyflow/enums/LogLevel.java similarity index 100% rename from v2/src/main/java/com/skyflow/enums/LogLevel.java rename to src/main/java/com/skyflow/enums/LogLevel.java diff --git a/v2/src/main/java/com/skyflow/enums/RedactionType.java b/src/main/java/com/skyflow/enums/RedactionType.java similarity index 100% rename from v2/src/main/java/com/skyflow/enums/RedactionType.java rename to src/main/java/com/skyflow/enums/RedactionType.java diff --git a/v2/src/main/java/com/skyflow/enums/RequestMethod.java b/src/main/java/com/skyflow/enums/RequestMethod.java similarity index 100% rename from v2/src/main/java/com/skyflow/enums/RequestMethod.java rename to src/main/java/com/skyflow/enums/RequestMethod.java diff --git a/v2/src/main/java/com/skyflow/errors/ErrorCode.java b/src/main/java/com/skyflow/errors/ErrorCode.java similarity index 100% rename from v2/src/main/java/com/skyflow/errors/ErrorCode.java rename to src/main/java/com/skyflow/errors/ErrorCode.java diff --git a/v2/src/main/java/com/skyflow/errors/ErrorMessage.java b/src/main/java/com/skyflow/errors/ErrorMessage.java similarity index 100% rename from v2/src/main/java/com/skyflow/errors/ErrorMessage.java rename to src/main/java/com/skyflow/errors/ErrorMessage.java diff --git a/v2/src/main/java/com/skyflow/errors/SkyflowException.java b/src/main/java/com/skyflow/errors/SkyflowException.java similarity index 100% rename from v2/src/main/java/com/skyflow/errors/SkyflowException.java rename to src/main/java/com/skyflow/errors/SkyflowException.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/ApiCallback.java b/src/main/java/com/skyflow/generated/rest/ApiCallback.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/ApiCallback.java rename to src/main/java/com/skyflow/generated/rest/ApiCallback.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/ApiClient.java b/src/main/java/com/skyflow/generated/rest/ApiClient.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/ApiClient.java rename to src/main/java/com/skyflow/generated/rest/ApiClient.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/ApiException.java b/src/main/java/com/skyflow/generated/rest/ApiException.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/ApiException.java rename to src/main/java/com/skyflow/generated/rest/ApiException.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/ApiResponse.java b/src/main/java/com/skyflow/generated/rest/ApiResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/ApiResponse.java rename to src/main/java/com/skyflow/generated/rest/ApiResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/Configuration.java b/src/main/java/com/skyflow/generated/rest/Configuration.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/Configuration.java rename to src/main/java/com/skyflow/generated/rest/Configuration.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/GzipRequestInterceptor.java b/src/main/java/com/skyflow/generated/rest/GzipRequestInterceptor.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/GzipRequestInterceptor.java rename to src/main/java/com/skyflow/generated/rest/GzipRequestInterceptor.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/JSON.java b/src/main/java/com/skyflow/generated/rest/JSON.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/JSON.java rename to src/main/java/com/skyflow/generated/rest/JSON.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/Pair.java b/src/main/java/com/skyflow/generated/rest/Pair.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/Pair.java rename to src/main/java/com/skyflow/generated/rest/Pair.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/ProgressRequestBody.java b/src/main/java/com/skyflow/generated/rest/ProgressRequestBody.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/ProgressRequestBody.java rename to src/main/java/com/skyflow/generated/rest/ProgressRequestBody.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/ProgressResponseBody.java b/src/main/java/com/skyflow/generated/rest/ProgressResponseBody.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/ProgressResponseBody.java rename to src/main/java/com/skyflow/generated/rest/ProgressResponseBody.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/ServerConfiguration.java b/src/main/java/com/skyflow/generated/rest/ServerConfiguration.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/ServerConfiguration.java rename to src/main/java/com/skyflow/generated/rest/ServerConfiguration.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/ServerVariable.java b/src/main/java/com/skyflow/generated/rest/ServerVariable.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/ServerVariable.java rename to src/main/java/com/skyflow/generated/rest/ServerVariable.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/StringUtil.java b/src/main/java/com/skyflow/generated/rest/StringUtil.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/StringUtil.java rename to src/main/java/com/skyflow/generated/rest/StringUtil.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/api/AuditApi.java b/src/main/java/com/skyflow/generated/rest/api/AuditApi.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/api/AuditApi.java rename to src/main/java/com/skyflow/generated/rest/api/AuditApi.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/api/AuthenticationApi.java b/src/main/java/com/skyflow/generated/rest/api/AuthenticationApi.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/api/AuthenticationApi.java rename to src/main/java/com/skyflow/generated/rest/api/AuthenticationApi.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/api/BinLookupApi.java b/src/main/java/com/skyflow/generated/rest/api/BinLookupApi.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/api/BinLookupApi.java rename to src/main/java/com/skyflow/generated/rest/api/BinLookupApi.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/api/QueryApi.java b/src/main/java/com/skyflow/generated/rest/api/QueryApi.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/api/QueryApi.java rename to src/main/java/com/skyflow/generated/rest/api/QueryApi.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/api/RecordsApi.java b/src/main/java/com/skyflow/generated/rest/api/RecordsApi.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/api/RecordsApi.java rename to src/main/java/com/skyflow/generated/rest/api/RecordsApi.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/api/TokensApi.java b/src/main/java/com/skyflow/generated/rest/api/TokensApi.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/api/TokensApi.java rename to src/main/java/com/skyflow/generated/rest/api/TokensApi.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/auth/ApiKeyAuth.java b/src/main/java/com/skyflow/generated/rest/auth/ApiKeyAuth.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/auth/ApiKeyAuth.java rename to src/main/java/com/skyflow/generated/rest/auth/ApiKeyAuth.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/auth/Authentication.java b/src/main/java/com/skyflow/generated/rest/auth/Authentication.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/auth/Authentication.java rename to src/main/java/com/skyflow/generated/rest/auth/Authentication.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/auth/HttpBasicAuth.java b/src/main/java/com/skyflow/generated/rest/auth/HttpBasicAuth.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/auth/HttpBasicAuth.java rename to src/main/java/com/skyflow/generated/rest/auth/HttpBasicAuth.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/auth/HttpBearerAuth.java b/src/main/java/com/skyflow/generated/rest/auth/HttpBearerAuth.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/auth/HttpBearerAuth.java rename to src/main/java/com/skyflow/generated/rest/auth/HttpBearerAuth.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/AbstractOpenApiSchema.java b/src/main/java/com/skyflow/generated/rest/models/AbstractOpenApiSchema.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/AbstractOpenApiSchema.java rename to src/main/java/com/skyflow/generated/rest/models/AbstractOpenApiSchema.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/AuditEventAuditResourceType.java b/src/main/java/com/skyflow/generated/rest/models/AuditEventAuditResourceType.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/AuditEventAuditResourceType.java rename to src/main/java/com/skyflow/generated/rest/models/AuditEventAuditResourceType.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/AuditEventContext.java b/src/main/java/com/skyflow/generated/rest/models/AuditEventContext.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/AuditEventContext.java rename to src/main/java/com/skyflow/generated/rest/models/AuditEventContext.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/AuditEventData.java b/src/main/java/com/skyflow/generated/rest/models/AuditEventData.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/AuditEventData.java rename to src/main/java/com/skyflow/generated/rest/models/AuditEventData.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/AuditEventHTTPInfo.java b/src/main/java/com/skyflow/generated/rest/models/AuditEventHTTPInfo.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/AuditEventHTTPInfo.java rename to src/main/java/com/skyflow/generated/rest/models/AuditEventHTTPInfo.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/BatchRecordMethod.java b/src/main/java/com/skyflow/generated/rest/models/BatchRecordMethod.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/BatchRecordMethod.java rename to src/main/java/com/skyflow/generated/rest/models/BatchRecordMethod.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/ContextAccessType.java b/src/main/java/com/skyflow/generated/rest/models/ContextAccessType.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/ContextAccessType.java rename to src/main/java/com/skyflow/generated/rest/models/ContextAccessType.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/ContextAuthMode.java b/src/main/java/com/skyflow/generated/rest/models/ContextAuthMode.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/ContextAuthMode.java rename to src/main/java/com/skyflow/generated/rest/models/ContextAuthMode.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/DetokenizeRecordResponseValueType.java b/src/main/java/com/skyflow/generated/rest/models/DetokenizeRecordResponseValueType.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/DetokenizeRecordResponseValueType.java rename to src/main/java/com/skyflow/generated/rest/models/DetokenizeRecordResponseValueType.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/GooglerpcStatus.java b/src/main/java/com/skyflow/generated/rest/models/GooglerpcStatus.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/GooglerpcStatus.java rename to src/main/java/com/skyflow/generated/rest/models/GooglerpcStatus.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/ProtobufAny.java b/src/main/java/com/skyflow/generated/rest/models/ProtobufAny.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/ProtobufAny.java rename to src/main/java/com/skyflow/generated/rest/models/ProtobufAny.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/QueryServiceExecuteQueryBody.java b/src/main/java/com/skyflow/generated/rest/models/QueryServiceExecuteQueryBody.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/QueryServiceExecuteQueryBody.java rename to src/main/java/com/skyflow/generated/rest/models/QueryServiceExecuteQueryBody.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/RecordServiceBatchOperationBody.java b/src/main/java/com/skyflow/generated/rest/models/RecordServiceBatchOperationBody.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/RecordServiceBatchOperationBody.java rename to src/main/java/com/skyflow/generated/rest/models/RecordServiceBatchOperationBody.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/RecordServiceBulkDeleteRecordBody.java b/src/main/java/com/skyflow/generated/rest/models/RecordServiceBulkDeleteRecordBody.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/RecordServiceBulkDeleteRecordBody.java rename to src/main/java/com/skyflow/generated/rest/models/RecordServiceBulkDeleteRecordBody.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/RecordServiceInsertRecordBody.java b/src/main/java/com/skyflow/generated/rest/models/RecordServiceInsertRecordBody.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/RecordServiceInsertRecordBody.java rename to src/main/java/com/skyflow/generated/rest/models/RecordServiceInsertRecordBody.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/RecordServiceUpdateRecordBody.java b/src/main/java/com/skyflow/generated/rest/models/RecordServiceUpdateRecordBody.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/RecordServiceUpdateRecordBody.java rename to src/main/java/com/skyflow/generated/rest/models/RecordServiceUpdateRecordBody.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/RedactionEnumREDACTION.java b/src/main/java/com/skyflow/generated/rest/models/RedactionEnumREDACTION.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/RedactionEnumREDACTION.java rename to src/main/java/com/skyflow/generated/rest/models/RedactionEnumREDACTION.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/RequestActionType.java b/src/main/java/com/skyflow/generated/rest/models/RequestActionType.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/RequestActionType.java rename to src/main/java/com/skyflow/generated/rest/models/RequestActionType.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1AuditAfterOptions.java b/src/main/java/com/skyflow/generated/rest/models/V1AuditAfterOptions.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1AuditAfterOptions.java rename to src/main/java/com/skyflow/generated/rest/models/V1AuditAfterOptions.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1AuditEventResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1AuditEventResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1AuditEventResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1AuditEventResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1AuditResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1AuditResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1AuditResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1AuditResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1AuditResponseEvent.java b/src/main/java/com/skyflow/generated/rest/models/V1AuditResponseEvent.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1AuditResponseEvent.java rename to src/main/java/com/skyflow/generated/rest/models/V1AuditResponseEvent.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1AuditResponseEventRequest.java b/src/main/java/com/skyflow/generated/rest/models/V1AuditResponseEventRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1AuditResponseEventRequest.java rename to src/main/java/com/skyflow/generated/rest/models/V1AuditResponseEventRequest.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1BINListRequest.java b/src/main/java/com/skyflow/generated/rest/models/V1BINListRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1BINListRequest.java rename to src/main/java/com/skyflow/generated/rest/models/V1BINListRequest.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1BINListResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1BINListResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1BINListResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1BINListResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1BYOT.java b/src/main/java/com/skyflow/generated/rest/models/V1BYOT.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1BYOT.java rename to src/main/java/com/skyflow/generated/rest/models/V1BYOT.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1BatchOperationResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1BatchOperationResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1BatchOperationResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1BatchOperationResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1BatchRecord.java b/src/main/java/com/skyflow/generated/rest/models/V1BatchRecord.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1BatchRecord.java rename to src/main/java/com/skyflow/generated/rest/models/V1BatchRecord.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1BulkDeleteRecordResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1BulkDeleteRecordResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1BulkDeleteRecordResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1BulkDeleteRecordResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1BulkGetRecordResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1BulkGetRecordResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1BulkGetRecordResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1BulkGetRecordResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1Card.java b/src/main/java/com/skyflow/generated/rest/models/V1Card.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1Card.java rename to src/main/java/com/skyflow/generated/rest/models/V1Card.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1DeleteFileResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1DeleteFileResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1DeleteFileResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1DeleteFileResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1DeleteRecordResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1DeleteRecordResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1DeleteRecordResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1DeleteRecordResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1DetokenizePayload.java b/src/main/java/com/skyflow/generated/rest/models/V1DetokenizePayload.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1DetokenizePayload.java rename to src/main/java/com/skyflow/generated/rest/models/V1DetokenizePayload.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1DetokenizeRecordRequest.java b/src/main/java/com/skyflow/generated/rest/models/V1DetokenizeRecordRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1DetokenizeRecordRequest.java rename to src/main/java/com/skyflow/generated/rest/models/V1DetokenizeRecordRequest.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1DetokenizeRecordResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1DetokenizeRecordResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1DetokenizeRecordResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1DetokenizeRecordResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1DetokenizeResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1DetokenizeResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1DetokenizeResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1DetokenizeResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1FieldRecords.java b/src/main/java/com/skyflow/generated/rest/models/V1FieldRecords.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1FieldRecords.java rename to src/main/java/com/skyflow/generated/rest/models/V1FieldRecords.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1FileAVScanStatus.java b/src/main/java/com/skyflow/generated/rest/models/V1FileAVScanStatus.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1FileAVScanStatus.java rename to src/main/java/com/skyflow/generated/rest/models/V1FileAVScanStatus.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1GetAuthTokenRequest.java b/src/main/java/com/skyflow/generated/rest/models/V1GetAuthTokenRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1GetAuthTokenRequest.java rename to src/main/java/com/skyflow/generated/rest/models/V1GetAuthTokenRequest.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1GetAuthTokenResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1GetAuthTokenResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1GetAuthTokenResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1GetAuthTokenResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1GetFileScanStatusResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1GetFileScanStatusResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1GetFileScanStatusResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1GetFileScanStatusResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1GetQueryResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1GetQueryResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1GetQueryResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1GetQueryResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1InsertRecordResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1InsertRecordResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1InsertRecordResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1InsertRecordResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1MemberType.java b/src/main/java/com/skyflow/generated/rest/models/V1MemberType.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1MemberType.java rename to src/main/java/com/skyflow/generated/rest/models/V1MemberType.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1RecordMetaProperties.java b/src/main/java/com/skyflow/generated/rest/models/V1RecordMetaProperties.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1RecordMetaProperties.java rename to src/main/java/com/skyflow/generated/rest/models/V1RecordMetaProperties.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1TokenizePayload.java b/src/main/java/com/skyflow/generated/rest/models/V1TokenizePayload.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1TokenizePayload.java rename to src/main/java/com/skyflow/generated/rest/models/V1TokenizePayload.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1TokenizeRecordRequest.java b/src/main/java/com/skyflow/generated/rest/models/V1TokenizeRecordRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1TokenizeRecordRequest.java rename to src/main/java/com/skyflow/generated/rest/models/V1TokenizeRecordRequest.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1TokenizeRecordResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1TokenizeRecordResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1TokenizeRecordResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1TokenizeRecordResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1TokenizeResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1TokenizeResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1TokenizeResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1TokenizeResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1UpdateRecordResponse.java b/src/main/java/com/skyflow/generated/rest/models/V1UpdateRecordResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1UpdateRecordResponse.java rename to src/main/java/com/skyflow/generated/rest/models/V1UpdateRecordResponse.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1VaultFieldMapping.java b/src/main/java/com/skyflow/generated/rest/models/V1VaultFieldMapping.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1VaultFieldMapping.java rename to src/main/java/com/skyflow/generated/rest/models/V1VaultFieldMapping.java diff --git a/v2/src/main/java/com/skyflow/generated/rest/models/V1VaultSchemaConfig.java b/src/main/java/com/skyflow/generated/rest/models/V1VaultSchemaConfig.java similarity index 100% rename from v2/src/main/java/com/skyflow/generated/rest/models/V1VaultSchemaConfig.java rename to src/main/java/com/skyflow/generated/rest/models/V1VaultSchemaConfig.java diff --git a/v2/src/main/java/com/skyflow/logs/ErrorLogs.java b/src/main/java/com/skyflow/logs/ErrorLogs.java similarity index 100% rename from v2/src/main/java/com/skyflow/logs/ErrorLogs.java rename to src/main/java/com/skyflow/logs/ErrorLogs.java diff --git a/v2/src/main/java/com/skyflow/logs/InfoLogs.java b/src/main/java/com/skyflow/logs/InfoLogs.java similarity index 100% rename from v2/src/main/java/com/skyflow/logs/InfoLogs.java rename to src/main/java/com/skyflow/logs/InfoLogs.java diff --git a/v2/src/main/java/com/skyflow/serviceaccount/util/BearerToken.java b/src/main/java/com/skyflow/serviceaccount/util/BearerToken.java similarity index 100% rename from v2/src/main/java/com/skyflow/serviceaccount/util/BearerToken.java rename to src/main/java/com/skyflow/serviceaccount/util/BearerToken.java diff --git a/v2/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokenResponse.java b/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokenResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokenResponse.java rename to src/main/java/com/skyflow/serviceaccount/util/SignedDataTokenResponse.java diff --git a/v2/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java b/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java similarity index 100% rename from v2/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java rename to src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java diff --git a/v2/src/main/java/com/skyflow/serviceaccount/util/Token.java b/src/main/java/com/skyflow/serviceaccount/util/Token.java similarity index 100% rename from v2/src/main/java/com/skyflow/serviceaccount/util/Token.java rename to src/main/java/com/skyflow/serviceaccount/util/Token.java diff --git a/v2/src/main/java/com/skyflow/utils/Constants.java b/src/main/java/com/skyflow/utils/Constants.java similarity index 100% rename from v2/src/main/java/com/skyflow/utils/Constants.java rename to src/main/java/com/skyflow/utils/Constants.java diff --git a/v2/src/main/java/com/skyflow/utils/HttpUtility.java b/src/main/java/com/skyflow/utils/HttpUtility.java similarity index 100% rename from v2/src/main/java/com/skyflow/utils/HttpUtility.java rename to src/main/java/com/skyflow/utils/HttpUtility.java diff --git a/v2/src/main/java/com/skyflow/utils/Utils.java b/src/main/java/com/skyflow/utils/Utils.java similarity index 100% rename from v2/src/main/java/com/skyflow/utils/Utils.java rename to src/main/java/com/skyflow/utils/Utils.java diff --git a/v2/src/main/java/com/skyflow/utils/logger/LogUtil.java b/src/main/java/com/skyflow/utils/logger/LogUtil.java similarity index 100% rename from v2/src/main/java/com/skyflow/utils/logger/LogUtil.java rename to src/main/java/com/skyflow/utils/logger/LogUtil.java diff --git a/v2/src/main/java/com/skyflow/utils/validations/Validations.java b/src/main/java/com/skyflow/utils/validations/Validations.java similarity index 100% rename from v2/src/main/java/com/skyflow/utils/validations/Validations.java rename to src/main/java/com/skyflow/utils/validations/Validations.java diff --git a/v2/src/main/java/com/skyflow/vault/audit/ListEventRequest.java b/src/main/java/com/skyflow/vault/audit/ListEventRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/audit/ListEventRequest.java rename to src/main/java/com/skyflow/vault/audit/ListEventRequest.java diff --git a/v2/src/main/java/com/skyflow/vault/audit/ListEventResponse.java b/src/main/java/com/skyflow/vault/audit/ListEventResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/audit/ListEventResponse.java rename to src/main/java/com/skyflow/vault/audit/ListEventResponse.java diff --git a/v2/src/main/java/com/skyflow/vault/bin/GetBinRequest.java b/src/main/java/com/skyflow/vault/bin/GetBinRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/bin/GetBinRequest.java rename to src/main/java/com/skyflow/vault/bin/GetBinRequest.java diff --git a/v2/src/main/java/com/skyflow/vault/bin/GetBinResponse.java b/src/main/java/com/skyflow/vault/bin/GetBinResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/bin/GetBinResponse.java rename to src/main/java/com/skyflow/vault/bin/GetBinResponse.java diff --git a/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java b/src/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java rename to src/main/java/com/skyflow/vault/connection/InvokeConnectionRequest.java diff --git a/v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionResponse.java b/src/main/java/com/skyflow/vault/connection/InvokeConnectionResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/connection/InvokeConnectionResponse.java rename to src/main/java/com/skyflow/vault/connection/InvokeConnectionResponse.java diff --git a/v2/src/main/java/com/skyflow/vault/controller/AuditController.java b/src/main/java/com/skyflow/vault/controller/AuditController.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/controller/AuditController.java rename to src/main/java/com/skyflow/vault/controller/AuditController.java diff --git a/v2/src/main/java/com/skyflow/vault/controller/BinLookupController.java b/src/main/java/com/skyflow/vault/controller/BinLookupController.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/controller/BinLookupController.java rename to src/main/java/com/skyflow/vault/controller/BinLookupController.java diff --git a/v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java b/src/main/java/com/skyflow/vault/controller/ConnectionController.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/controller/ConnectionController.java rename to src/main/java/com/skyflow/vault/controller/ConnectionController.java diff --git a/v2/src/main/java/com/skyflow/vault/controller/DetectController.java b/src/main/java/com/skyflow/vault/controller/DetectController.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/controller/DetectController.java rename to src/main/java/com/skyflow/vault/controller/DetectController.java diff --git a/v2/src/main/java/com/skyflow/vault/controller/VaultController.java b/src/main/java/com/skyflow/vault/controller/VaultController.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/controller/VaultController.java rename to src/main/java/com/skyflow/vault/controller/VaultController.java diff --git a/v2/src/main/java/com/skyflow/vault/data/DeleteRequest.java b/src/main/java/com/skyflow/vault/data/DeleteRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/data/DeleteRequest.java rename to src/main/java/com/skyflow/vault/data/DeleteRequest.java diff --git a/v2/src/main/java/com/skyflow/vault/data/DeleteResponse.java b/src/main/java/com/skyflow/vault/data/DeleteResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/data/DeleteResponse.java rename to src/main/java/com/skyflow/vault/data/DeleteResponse.java diff --git a/v2/src/main/java/com/skyflow/vault/data/GetRequest.java b/src/main/java/com/skyflow/vault/data/GetRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/data/GetRequest.java rename to src/main/java/com/skyflow/vault/data/GetRequest.java diff --git a/v2/src/main/java/com/skyflow/vault/data/GetResponse.java b/src/main/java/com/skyflow/vault/data/GetResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/data/GetResponse.java rename to src/main/java/com/skyflow/vault/data/GetResponse.java diff --git a/v2/src/main/java/com/skyflow/vault/data/InsertRequest.java b/src/main/java/com/skyflow/vault/data/InsertRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/data/InsertRequest.java rename to src/main/java/com/skyflow/vault/data/InsertRequest.java diff --git a/v2/src/main/java/com/skyflow/vault/data/InsertResponse.java b/src/main/java/com/skyflow/vault/data/InsertResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/data/InsertResponse.java rename to src/main/java/com/skyflow/vault/data/InsertResponse.java diff --git a/v2/src/main/java/com/skyflow/vault/data/QueryRequest.java b/src/main/java/com/skyflow/vault/data/QueryRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/data/QueryRequest.java rename to src/main/java/com/skyflow/vault/data/QueryRequest.java diff --git a/v2/src/main/java/com/skyflow/vault/data/QueryResponse.java b/src/main/java/com/skyflow/vault/data/QueryResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/data/QueryResponse.java rename to src/main/java/com/skyflow/vault/data/QueryResponse.java diff --git a/v2/src/main/java/com/skyflow/vault/data/UpdateRequest.java b/src/main/java/com/skyflow/vault/data/UpdateRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/data/UpdateRequest.java rename to src/main/java/com/skyflow/vault/data/UpdateRequest.java diff --git a/v2/src/main/java/com/skyflow/vault/data/UpdateResponse.java b/src/main/java/com/skyflow/vault/data/UpdateResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/data/UpdateResponse.java rename to src/main/java/com/skyflow/vault/data/UpdateResponse.java diff --git a/v2/src/main/java/com/skyflow/vault/detect/DeIdentifyRequest.java b/src/main/java/com/skyflow/vault/detect/DeIdentifyRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/detect/DeIdentifyRequest.java rename to src/main/java/com/skyflow/vault/detect/DeIdentifyRequest.java diff --git a/v2/src/main/java/com/skyflow/vault/detect/DeIdentifyResponse.java b/src/main/java/com/skyflow/vault/detect/DeIdentifyResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/detect/DeIdentifyResponse.java rename to src/main/java/com/skyflow/vault/detect/DeIdentifyResponse.java diff --git a/v2/src/main/java/com/skyflow/vault/tokens/ColumnValue.java b/src/main/java/com/skyflow/vault/tokens/ColumnValue.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/tokens/ColumnValue.java rename to src/main/java/com/skyflow/vault/tokens/ColumnValue.java diff --git a/v2/src/main/java/com/skyflow/vault/tokens/DetokenizeRecordResponse.java b/src/main/java/com/skyflow/vault/tokens/DetokenizeRecordResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/tokens/DetokenizeRecordResponse.java rename to src/main/java/com/skyflow/vault/tokens/DetokenizeRecordResponse.java diff --git a/v2/src/main/java/com/skyflow/vault/tokens/DetokenizeRequest.java b/src/main/java/com/skyflow/vault/tokens/DetokenizeRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/tokens/DetokenizeRequest.java rename to src/main/java/com/skyflow/vault/tokens/DetokenizeRequest.java diff --git a/v2/src/main/java/com/skyflow/vault/tokens/DetokenizeResponse.java b/src/main/java/com/skyflow/vault/tokens/DetokenizeResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/tokens/DetokenizeResponse.java rename to src/main/java/com/skyflow/vault/tokens/DetokenizeResponse.java diff --git a/v2/src/main/java/com/skyflow/vault/tokens/TokenizeRequest.java b/src/main/java/com/skyflow/vault/tokens/TokenizeRequest.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/tokens/TokenizeRequest.java rename to src/main/java/com/skyflow/vault/tokens/TokenizeRequest.java diff --git a/v2/src/main/java/com/skyflow/vault/tokens/TokenizeResponse.java b/src/main/java/com/skyflow/vault/tokens/TokenizeResponse.java similarity index 100% rename from v2/src/main/java/com/skyflow/vault/tokens/TokenizeResponse.java rename to src/main/java/com/skyflow/vault/tokens/TokenizeResponse.java diff --git a/v2/src/test/java/com/skyflow/SkyflowTests.java b/src/test/java/com/skyflow/SkyflowTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/SkyflowTests.java rename to src/test/java/com/skyflow/SkyflowTests.java diff --git a/v2/src/test/java/com/skyflow/config/ConnectionConfigTests.java b/src/test/java/com/skyflow/config/ConnectionConfigTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/config/ConnectionConfigTests.java rename to src/test/java/com/skyflow/config/ConnectionConfigTests.java diff --git a/v2/src/test/java/com/skyflow/config/CredentialsTests.java b/src/test/java/com/skyflow/config/CredentialsTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/config/CredentialsTests.java rename to src/test/java/com/skyflow/config/CredentialsTests.java diff --git a/v2/src/test/java/com/skyflow/config/VaultConfigTests.java b/src/test/java/com/skyflow/config/VaultConfigTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/config/VaultConfigTests.java rename to src/test/java/com/skyflow/config/VaultConfigTests.java diff --git a/v2/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java b/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java rename to src/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java diff --git a/v2/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java b/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java rename to src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java diff --git a/v2/src/test/java/com/skyflow/serviceaccount/util/TokenTests.java b/src/test/java/com/skyflow/serviceaccount/util/TokenTests.java similarity index 75% rename from v2/src/test/java/com/skyflow/serviceaccount/util/TokenTests.java rename to src/test/java/com/skyflow/serviceaccount/util/TokenTests.java index d1ac044b..ed5c72b2 100644 --- a/v2/src/test/java/com/skyflow/serviceaccount/util/TokenTests.java +++ b/src/test/java/com/skyflow/serviceaccount/util/TokenTests.java @@ -1,11 +1,20 @@ package com.skyflow.serviceaccount.util; +import com.skyflow.Skyflow; +import com.skyflow.enums.LogLevel; +import io.github.cdimascio.dotenv.Dotenv; import org.junit.Assert; +import org.junit.BeforeClass; import org.junit.Test; public class TokenTests { private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; + @BeforeClass + public static void setup() { + Skyflow skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).build(); + } + @Test public void testNoTokenForIsExpiredToken() { try { @@ -36,7 +45,8 @@ public void testInvalidTokenForIsExpiredToken() { @Test public void testExpiredTokenForIsExpiredToken() { try { - String token = System.getProperty("TEST_EXPIRED_TOKEN"); + Dotenv dotenv = Dotenv.load(); + String token = dotenv.get("TEST_EXPIRED_TOKEN"); Assert.assertTrue(Token.isExpired(token)); } catch (Exception e) { Assert.fail(INVALID_EXCEPTION_THROWN); diff --git a/v2/src/test/java/com/skyflow/utils/HttpUtilityTests.java b/src/test/java/com/skyflow/utils/HttpUtilityTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/utils/HttpUtilityTests.java rename to src/test/java/com/skyflow/utils/HttpUtilityTests.java diff --git a/v2/src/test/java/com/skyflow/utils/UtilsTests.java b/src/test/java/com/skyflow/utils/UtilsTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/utils/UtilsTests.java rename to src/test/java/com/skyflow/utils/UtilsTests.java diff --git a/v2/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java b/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java similarity index 96% rename from v2/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java rename to src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java index 2294bdaa..db23e010 100644 --- a/v2/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java +++ b/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java @@ -1,5 +1,6 @@ package com.skyflow.vault.connection; +import com.google.gson.JsonObject; import com.skyflow.enums.RequestMethod; import com.skyflow.errors.ErrorCode; import com.skyflow.errors.ErrorMessage; @@ -391,4 +392,18 @@ public void testEmptyRequestBodyInInvokeConnectionRequestValidations() { Assert.assertEquals(ErrorMessage.EmptyRequestBody.getMessage(), e.getMessage()); } } + + @Test + public void testInvokeConnectionResponse() { + try { + JsonObject responseObject = new JsonObject(); + responseObject.addProperty("test_key_1", "test_value_1"); + responseObject.addProperty("test_key_2", "test_value_2"); + InvokeConnectionResponse connectionResponse = new InvokeConnectionResponse(responseObject); + String responseString = "InvokeConnectionResponse{" + "response=" + responseObject + "}"; + Assert.assertEquals(responseString, connectionResponse.toString()); + } catch (Exception e) { + Assert.fail(INVALID_EXCEPTION_THROWN); + } + } } diff --git a/v2/src/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java b/src/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java rename to src/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java diff --git a/v2/src/test/java/com/skyflow/vault/controller/VaultControllerTests.java b/src/test/java/com/skyflow/vault/controller/VaultControllerTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/vault/controller/VaultControllerTests.java rename to src/test/java/com/skyflow/vault/controller/VaultControllerTests.java diff --git a/v2/src/test/java/com/skyflow/vault/data/DeleteTests.java b/src/test/java/com/skyflow/vault/data/DeleteTests.java similarity index 97% rename from v2/src/test/java/com/skyflow/vault/data/DeleteTests.java rename to src/test/java/com/skyflow/vault/data/DeleteTests.java index 9ab78af6..5f2eefc7 100644 --- a/v2/src/test/java/com/skyflow/vault/data/DeleteTests.java +++ b/src/test/java/com/skyflow/vault/data/DeleteTests.java @@ -12,6 +12,7 @@ import com.skyflow.utils.Utils; import com.skyflow.utils.validations.Validations; import org.junit.Assert; +import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; @@ -58,6 +59,11 @@ public static void setup() throws SkyflowException { table = "test_table"; } + @Before + public void setupTest() { + ids.clear(); + } + @Test public void testValidInputInDeleteRequestValidations() { try { @@ -88,7 +94,7 @@ public void testNoIdsInDeleteRequestValidations() { @Test public void testEmptyIdsInDeleteRequestValidations() { - ids.clear(); +// ids.clear(); DeleteRequest request = DeleteRequest.builder().ids(ids).table(table).build(); try { Validations.validateDeleteRequest(request); @@ -121,7 +127,7 @@ public void testEmptyIdInIdsInDeleteRequestValidations() { @Test public void testNoTableInDeleteRequestValidations() { - ids.clear(); +// ids.clear(); ids.add(skyflowID); DeleteRequest request = DeleteRequest.builder().ids(ids).build(); try { @@ -138,7 +144,7 @@ public void testNoTableInDeleteRequestValidations() { @Test public void testEmptyTableInDeleteRequestValidations() { - ids.clear(); +// ids.clear(); ids.add(skyflowID); DeleteRequest request = DeleteRequest.builder().ids(ids).table("").build(); try { @@ -156,6 +162,7 @@ public void testEmptyTableInDeleteRequestValidations() { @Test public void testDeleteResponse() { try { + ids.add(skyflowID); DeleteResponse response = new DeleteResponse(ids); String responseString = "{\n\t\"deletedIds\": [\n\t\t\"" + skyflowID + "\"]\n}"; Assert.assertEquals(1, response.getDeletedIds().size()); diff --git a/v2/src/test/java/com/skyflow/vault/data/GetTests.java b/src/test/java/com/skyflow/vault/data/GetTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/vault/data/GetTests.java rename to src/test/java/com/skyflow/vault/data/GetTests.java diff --git a/v2/src/test/java/com/skyflow/vault/data/InsertTests.java b/src/test/java/com/skyflow/vault/data/InsertTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/vault/data/InsertTests.java rename to src/test/java/com/skyflow/vault/data/InsertTests.java diff --git a/v2/src/test/java/com/skyflow/vault/data/QueryTests.java b/src/test/java/com/skyflow/vault/data/QueryTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/vault/data/QueryTests.java rename to src/test/java/com/skyflow/vault/data/QueryTests.java diff --git a/v2/src/test/java/com/skyflow/vault/data/UpdateTests.java b/src/test/java/com/skyflow/vault/data/UpdateTests.java similarity index 88% rename from v2/src/test/java/com/skyflow/vault/data/UpdateTests.java rename to src/test/java/com/skyflow/vault/data/UpdateTests.java index 3780a417..22417257 100644 --- a/v2/src/test/java/com/skyflow/vault/data/UpdateTests.java +++ b/src/test/java/com/skyflow/vault/data/UpdateTests.java @@ -13,6 +13,7 @@ import com.skyflow.utils.Utils; import com.skyflow.utils.validations.Validations; import org.junit.Assert; +import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; @@ -53,20 +54,24 @@ public static void setup() throws SkyflowException { vaultConfig.setEnv(Env.DEV); vaultConfig.setCredentials(credentials); -// skyflowClient = Skyflow.builder().setLogLevel(LogLevel.DEBUG).addVaultConfig(vaultConfig).build(); - skyflowID = "test_update_id_1"; table = "test_table"; valueMap = new HashMap<>(); - valueMap.put("test_column_1", "test_value_1"); - valueMap.put("test_column_2", "test_value_2"); tokenMap = new HashMap<>(); - tokenMap.put("test_column_1", "test_token_1"); + } + + @Before + public void setupTest() { + valueMap.clear(); + tokenMap.clear(); } @Test public void testValidInputInUpdateRequestValidations() { try { + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); + tokenMap.put("test_column_1", "test_token_1"); UpdateRequest request = UpdateRequest.builder() .id(skyflowID) .table(table) @@ -163,8 +168,7 @@ public void testNoValuesInUpdateRequestValidations() { @Test public void testEmptyValuesInUpdateRequestValidations() { - HashMap emptyValueMap = new HashMap<>(); - UpdateRequest request = UpdateRequest.builder().id(skyflowID).table(table).values(emptyValueMap).build(); + UpdateRequest request = UpdateRequest.builder().id(skyflowID).table(table).values(valueMap).build(); try { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); @@ -179,6 +183,8 @@ public void testEmptyValuesInUpdateRequestValidations() { @Test public void testEmptyKeyInValuesInUpdateRequestValidations() { + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); valueMap.put("", "test_value_3"); UpdateRequest request = UpdateRequest.builder().id(skyflowID).table(table).values(valueMap).build(); try { @@ -195,7 +201,8 @@ public void testEmptyKeyInValuesInUpdateRequestValidations() { @Test public void testEmptyValueInValuesInUpdateRequestValidations() { - valueMap.remove(""); + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); valueMap.put("test_column_3", ""); UpdateRequest request = UpdateRequest.builder().id(skyflowID).table(table).values(valueMap).build(); try { @@ -212,7 +219,9 @@ public void testEmptyValueInValuesInUpdateRequestValidations() { @Test public void testTokensWithTokenStrictDisableInUpdateRequestValidations() { - valueMap.remove("test_column_3"); + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); + tokenMap.put("test_column_1", "test_token_1"); UpdateRequest request = UpdateRequest.builder() .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.DISABLE) .build(); @@ -230,6 +239,8 @@ public void testTokensWithTokenStrictDisableInUpdateRequestValidations() { @Test public void testNoTokensWithTokenStrictEnableInUpdateRequestValidations() { + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); UpdateRequest request = UpdateRequest.builder() .id(skyflowID).table(table).values(valueMap).tokenStrict(Byot.ENABLE) .build(); @@ -247,6 +258,8 @@ public void testNoTokensWithTokenStrictEnableInUpdateRequestValidations() { @Test public void testNoTokensWithTokenStrictEnableStrictInUpdateRequestValidations() { + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); UpdateRequest request = UpdateRequest.builder() .id(skyflowID).table(table).values(valueMap).tokenStrict(Byot.ENABLE_STRICT) .build(); @@ -264,9 +277,10 @@ public void testNoTokensWithTokenStrictEnableStrictInUpdateRequestValidations() @Test public void testEmptyTokensWithTokenStrictEnableInUpdateRequestValidations() { - HashMap emptyTokenMap = new HashMap<>(); + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); UpdateRequest request = UpdateRequest.builder() - .id(skyflowID).table(table).values(valueMap).tokens(emptyTokenMap).tokenStrict(Byot.ENABLE) + .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE) .build(); try { Validations.validateUpdateRequest(request); @@ -278,21 +292,10 @@ public void testEmptyTokensWithTokenStrictEnableInUpdateRequestValidations() { } @Test - public void testInsufficientTokensWithTokenStrictEnableStrictInUpdateRequestValidations1() { - UpdateRequest request = UpdateRequest.builder() - .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) - .build(); - try { - Validations.validateUpdateRequest(request); - Assert.fail(EXCEPTION_NOT_THROWN); - } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); - Assert.assertEquals(ErrorMessage.InsufficientTokensPassedForByotEnableStrict.getMessage(), e.getMessage()); - } - } - - @Test - public void testInsufficientTokensWithTokenStrictEnableStrictInUpdateRequestValidations2() { + public void testInsufficientTokensWithTokenStrictEnableStrictInUpdateRequestValidations() { + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); + tokenMap.put("test_column_1", "test_token_1"); UpdateRequest request = UpdateRequest.builder() .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) .build(); @@ -307,6 +310,9 @@ public void testInsufficientTokensWithTokenStrictEnableStrictInUpdateRequestVali @Test public void testTokenValueMismatchInUpdateRequestValidations() { + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); + tokenMap.put("test_column_1", "test_token_1"); tokenMap.put("test_column_3", "test_token_3"); UpdateRequest request = UpdateRequest.builder() .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) @@ -322,8 +328,9 @@ public void testTokenValueMismatchInUpdateRequestValidations() { @Test public void testEmptyKeyInTokensInUpdateRequestValidations() { - tokenMap.remove("test_column_2"); - tokenMap.remove("test_column_3"); + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); + tokenMap.put("test_column_1", "test_token_1"); tokenMap.put("", "test_token_2"); UpdateRequest request = UpdateRequest.builder() .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) @@ -339,7 +346,9 @@ public void testEmptyKeyInTokensInUpdateRequestValidations() { @Test public void testEmptyValueInTokensInUpdateRequestValidations() { - tokenMap.remove(""); + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); + tokenMap.put("test_column_1", "test_token_1"); tokenMap.put("test_column_2", ""); UpdateRequest request = UpdateRequest.builder() .id(skyflowID).table(table).values(valueMap).tokens(tokenMap).tokenStrict(Byot.ENABLE_STRICT) @@ -356,6 +365,9 @@ public void testEmptyValueInTokensInUpdateRequestValidations() { @Test public void testUpdateResponse() { try { + valueMap.put("test_column_1", "test_value_1"); + valueMap.put("test_column_2", "test_value_2"); + tokenMap.put("test_column_1", "test_token_1"); tokenMap.put("test_column_2", "test_token_2"); UpdateResponse response = new UpdateResponse(skyflowID, tokenMap); String responseString = "{\n\t\"skyflowId\": " + skyflowID + "\n\t\"tokens\": " diff --git a/v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java b/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java rename to src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java diff --git a/v2/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java b/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java similarity index 100% rename from v2/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java rename to src/test/java/com/skyflow/vault/tokens/TokenizeTests.java diff --git a/v2/src/test/resources/invalidPrivateKeyCredentials.json b/src/test/resources/invalidPrivateKeyCredentials.json similarity index 100% rename from v2/src/test/resources/invalidPrivateKeyCredentials.json rename to src/test/resources/invalidPrivateKeyCredentials.json diff --git a/v2/src/test/resources/invalidTokenURICredentials.json b/src/test/resources/invalidTokenURICredentials.json similarity index 100% rename from v2/src/test/resources/invalidTokenURICredentials.json rename to src/test/resources/invalidTokenURICredentials.json diff --git a/v2/src/test/resources/noClientIDCredentials.json b/src/test/resources/noClientIDCredentials.json similarity index 100% rename from v2/src/test/resources/noClientIDCredentials.json rename to src/test/resources/noClientIDCredentials.json diff --git a/v2/src/test/resources/noKeyIDCredentials.json b/src/test/resources/noKeyIDCredentials.json similarity index 100% rename from v2/src/test/resources/noKeyIDCredentials.json rename to src/test/resources/noKeyIDCredentials.json diff --git a/v2/src/test/resources/noPrivateKeyCredentials.json b/src/test/resources/noPrivateKeyCredentials.json similarity index 100% rename from v2/src/test/resources/noPrivateKeyCredentials.json rename to src/test/resources/noPrivateKeyCredentials.json diff --git a/v2/src/test/resources/noTokenURICredentials.json b/src/test/resources/noTokenURICredentials.json similarity index 100% rename from v2/src/test/resources/noTokenURICredentials.json rename to src/test/resources/noTokenURICredentials.json diff --git a/v2/src/test/resources/notJson.txt b/src/test/resources/notJson.txt similarity index 100% rename from v2/src/test/resources/notJson.txt rename to src/test/resources/notJson.txt diff --git a/v1/pom.xml b/v1/pom.xml deleted file mode 100644 index ff3fc13a..00000000 --- a/v1/pom.xml +++ /dev/null @@ -1,20 +0,0 @@ - - - 4.0.0 - - com.skyflow - skyflow-java - 1.15.0 - - - v1 - - - 8 - 8 - UTF-8 - - - \ No newline at end of file diff --git a/v1/src/main/java/DetokenizeExample.java b/v1/src/main/java/DetokenizeExample.java deleted file mode 100644 index 8b2a657f..00000000 --- a/v1/src/main/java/DetokenizeExample.java +++ /dev/null @@ -1,71 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ - -import com.skyflow.Configuration; -import com.skyflow.entities.*; -import com.skyflow.errors.SkyflowException; -import com.skyflow.serviceaccount.util.Token; -import com.skyflow.vault.Skyflow; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; - - -public class DetokenizeExample { - - public static void main(String[] args) { - - try { - SkyflowConfiguration config = new SkyflowConfiguration( - "l906001b0b4e4843a69b091f278f7017", - "https://sb.area51.vault.skyflowapis.dev", - new DemoTokenProvider() - ); - - Configuration.setLogLevel(LogLevel.DEBUG); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - record.put("token", "4304-0207-2378-9259"); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - JSONObject record1 = new JSONObject(); - record1.put("token", "3809-9467-7122-3994"); - record1.put("redaction", RedactionType.PLAIN_TEXT.toString()); - recordsArray.add(record); - recordsArray.add(record1); - records.put("records", recordsArray); - - JSONObject response = skyflowClient.detokenize(records); - System.out.println(response); - - } catch (SkyflowException e) { - e.printStackTrace(); - System.out.println(e.getData()); - } - - } - - static class DemoTokenProvider implements TokenProvider { - - private String bearerToken = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJodHRwczovL21hbmFnZS5za3lmbG93YXBpcy5kZXYiLCJjbGkiOiJ2OGY0NTE1OWYxNjA0NzViYTk4MjAxOGJkMmFiMmVlZSIsImV4cCI6MTcxMTA5NDYwMSwiaWF0IjoxNzExMDkxMDAyLCJpc3MiOiJzYS1hdXRoQG1hbmFnZS5za3lmbG93YXBpcy5kZXYiLCJqdGkiOiJuMzk0OGI1ODIxOGQ0NWQ2OWQyYTExZjMwYjk2YmRiMiIsImtleSI6Imc0NDRmZTQxMmEzZTQ5ZTA5YjJlN2E4ZGE2ZDhkZWNlIiwic2NwIjpudWxsLCJzdWIiOiJzZGstZTJlLWJsaXR6LW5ldyJ9.D1bkgk8U5yC7Ped-eC8W4zc7CSImRdMbH2jvx9o_ADGYLmRsUJg3Jm004RtmCz6Vqy1hfgBobje4SgccavlYQTO3JUdtwx9SLJVwMGSEYnM_LvTAKqTVInJkvkKgJThHfh6na4iKWZlzUjNjhIFVjLcEhJuikRO68dpw8YFo84mc8iAjzW4BiKIyfAPzEUqIYq6VNUtz80ZsIhkfMz99_93NFf_KKzIR_a-MVYa7LzJfCrO6EQ-1fXLrTeJkusuco4MFSOf3-x55TimJygcQJjJC34lEtDK0OhFJWbM65gJRpRv6ftaknXRcp8caVE6xkqXI320O6GcBZK933aHw8w"; - - @Override - public String getBearerToken() throws Exception { -// ResponseToken response = null; -// try { -// String filePath = "/home/vivekj/SKYFLOW/SDKs/skyflow-java/samples/credentials.json"; -// if (Token.isExpired(bearerToken)) { -// response = Token.generateBearerToken(filePath); -// bearerToken = response.getAccessToken(); -// } -// } catch (SkyflowException e) { -// e.printStackTrace(); -// } - - return bearerToken; - } - } -} diff --git a/v1/src/main/java/InsertExample.java b/v1/src/main/java/InsertExample.java deleted file mode 100644 index 1cdd0900..00000000 --- a/v1/src/main/java/InsertExample.java +++ /dev/null @@ -1,84 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ - -import com.skyflow.Configuration; -import com.skyflow.entities.*; -import com.skyflow.errors.SkyflowException; -import com.skyflow.serviceaccount.util.Token; -import com.skyflow.vault.Skyflow; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; - -public class InsertExample { - - public static void main(String[] args) { - // blitz -// String vaultID = ""; -// String vaultURL = ""; - - // stage - String vaultID = "aef438f3be974c8f897795ab02248f78"; - String vaultURL = "https://cf5643204594.vault.skyflowapis.tech"; - - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Configuration.setLogLevel(LogLevel.DEBUG); - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - record.put("table", "customers"); - JSONObject fields = new JSONObject(); - fields.put("name", "chandragupta maurya"); - fields.put("card_number", "4111111111111111"); - fields.put("email", "chandragupta.maurya@test.com"); - record.put("fields", fields); - - JSONObject record2 = new JSONObject(); - record2.put("table", "pii_fields_upsert"); - JSONObject fields2 = new JSONObject(); - fields2.put("name", "java coe"); - fields2.put("card_number", "4111111111111111"); - fields2.put("expiration_year", "2025"); - fields2.put("expiration_month", "11"); - fields2.put("expiration_date", "11/25"); - fields2.put("cvv", "123"); - record2.put("fields", fields2); - - recordsArray.add(record); -// recordsArray.add(record2); - records.put("records", recordsArray); - - InsertOptions insertOptions = new InsertOptions(false); - JSONObject res = skyflowClient.insert(records, insertOptions); - - System.out.println("final response " + res); - } catch (SkyflowException e) { - System.out.println(e); - e.printStackTrace(); - } - } - - static class DemoTokenProvider implements TokenProvider { - private String bearerToken; - - @Override - public String getBearerToken() throws Exception { - ResponseToken response = null; - String env = "stage"; - try { - String filePath = "/home/vivekj/Documents/credentials/sdk-integration-tests/" + env + "-credentials.json"; - if (Token.isExpired(bearerToken)) { - response = Token.generateBearerToken(filePath); - bearerToken = response.getAccessToken(); - } - } catch (SkyflowException e) { - e.printStackTrace(); - } - return bearerToken; - } - } -} diff --git a/v1/src/main/java/com/skyflow/Configuration.java b/v1/src/main/java/com/skyflow/Configuration.java deleted file mode 100644 index fac93b8b..00000000 --- a/v1/src/main/java/com/skyflow/Configuration.java +++ /dev/null @@ -1,16 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow; - -import com.skyflow.common.utils.Helpers; -import com.skyflow.common.utils.LogUtil; -import com.skyflow.entities.LogLevel; -import com.skyflow.logs.InfoLogs; - -public final class Configuration { - public static void setLogLevel(LogLevel level) { - LogUtil.setupLogger(level); - LogUtil.printInfoLog(Helpers.parameterizedString(InfoLogs.CurrentLogLevel.getLog(), String.valueOf(level))); - } -} diff --git a/v1/src/main/java/com/skyflow/common/utils/Constants.java b/v1/src/main/java/com/skyflow/common/utils/Constants.java deleted file mode 100644 index 05e22578..00000000 --- a/v1/src/main/java/com/skyflow/common/utils/Constants.java +++ /dev/null @@ -1,8 +0,0 @@ -package com.skyflow.common.utils; - -public class Constants { - - public static final String SDK_METRICS_HEADER_KEY = "sky-metadata"; - public static final String SDK_VERSION = "1.15.0"; - -} diff --git a/v1/src/main/java/com/skyflow/common/utils/Helpers.java b/v1/src/main/java/com/skyflow/common/utils/Helpers.java deleted file mode 100644 index e5c3bbfe..00000000 --- a/v1/src/main/java/com/skyflow/common/utils/Helpers.java +++ /dev/null @@ -1,440 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.common.utils; - -import com.skyflow.entities.*; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.DebugLogs; -import com.skyflow.logs.ErrorLogs; -import org.apache.commons.codec.binary.Base64; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; - -import java.security.KeyFactory; -import java.security.NoSuchAlgorithmException; -import java.security.PrivateKey; -import java.security.spec.InvalidKeySpecException; -import java.security.spec.PKCS8EncodedKeySpec; -import java.util.*; - -public final class Helpers { - - private static final String LINE_FEED = "\r\n"; - - public static String getUpsertColumn(String tableName, UpsertOption[] upsertOptions) { - String upsertColumn = ""; - - for (UpsertOption upsertOption : upsertOptions) { - if (Objects.equals(tableName, upsertOption.getTable())) { - upsertColumn = upsertOption.getColumn(); - } - } - return upsertColumn; - } - - public static JSONObject constructInsertRequest(InsertInput recordsInput, InsertOptions options) - throws SkyflowException { - JSONObject finalRequest = new JSONObject(); - List requestBodyContent = new ArrayList(); - boolean isTokens = options.isTokens(); - boolean continueOnError = options.isContinueOnError(); - InsertRecordInput[] records = recordsInput.getRecords(); - - if (records == null || records.length == 0) { - throw new SkyflowException(ErrorCode.EmptyRecords); - } - - for (int i = 0; i < records.length; i++) { - InsertRecordInput record = records[i]; - - if (record.getTable() == null || record.getTable().isEmpty()) { - throw new SkyflowException(ErrorCode.InvalidTable); - } - if (record.getFields() == null) { - throw new SkyflowException(ErrorCode.InvalidFields); - } - - JSONObject postRequestInput = new JSONObject(); - postRequestInput.put("method", "POST"); - postRequestInput.put("quorum", true); - postRequestInput.put("tableName", record.getTable()); - postRequestInput.put("fields", record.getFields()); - if (options.getUpsertOptions() != null) - postRequestInput.put("upsert", getUpsertColumn(record.getTable(), options.getUpsertOptions())); - if (isTokens){ - postRequestInput.put("tokenization", true); - } - requestBodyContent.add(postRequestInput); - - } - finalRequest.put("records", requestBodyContent); - finalRequest.put("continueOnError", continueOnError); - - return finalRequest; - } - - public static JSONObject constructUpdateRequest(UpdateRecordInput record, UpdateOptions options) throws SkyflowException { - if (record == null) { - LogUtil.printErrorLog(ErrorLogs.InvalidUpdateInput.getLog()); - throw new SkyflowException(ErrorCode.EmptyRecords); - } - if (record.getId() == null || record.getId().isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.InvalidSkyflowId.getLog()); - throw new SkyflowException(ErrorCode.InvalidSkyflowId); - } - if (record.getTable() == null || record.getTable().isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.InvalidTable.getLog()); - throw new SkyflowException(ErrorCode.InvalidTable); - } - if (record.getFields() == null || record.getFields().isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.InvalidField.getLog()); - throw new SkyflowException(ErrorCode.InvalidFields); - } - - JSONObject postRequestInput = new JSONObject(); - postRequestInput.put("fields", record.getFields()); - return postRequestInput; - - } - public static JSONObject constructQueryRequest(QueryRecordInput queryInput, QueryOptions options) - throws SkyflowException { - if (queryInput == null) { - throw new SkyflowException(ErrorCode.EmptyRecords); - } - JSONObject postRequestInput = new JSONObject(); - if (queryInput.getQuery() == null||queryInput.getQuery().trim().isEmpty()) { - throw new SkyflowException(ErrorCode.InvalidQuery); - } - postRequestInput.put("query", queryInput.getQuery()); - return postRequestInput; - } - - public static JSONObject constructQueryErrorObject(SkyflowException skyflowException) { - JSONObject finalResponseError = new JSONObject(); - try { - JSONObject errorObject = (JSONObject) ((JSONObject) new JSONParser().parse(skyflowException.getMessage())).get("error"); - if (errorObject != null) { - JSONObject responseError = new JSONObject(); - responseError.put("code", errorObject.get("http_code")); - responseError.put("description", errorObject.get("message")); - finalResponseError.put("error", responseError); - } - } catch (ParseException e) { - JSONObject responseError = new JSONObject(); - responseError.put("code", skyflowException.getCode()); - responseError.put("description", skyflowException.getMessage()); - finalResponseError.put("error", responseError); - - } - return finalResponseError; - } - - public static StringBuilder constructGetByIdRequestURLParams(GetByIdRecordInput record) { - StringBuilder paramsList = new StringBuilder(); - - for (String id : record.getIds()) { - paramsList.append("skyflow_ids=").append(id).append("&"); - } - - paramsList.append("redaction=").append(record.getRedaction()); - return paramsList; - } - - public static StringBuilder constructGetRequestURLParams(GetRecordInput record, GetOptions getOptions) { - StringBuilder paramsList = new StringBuilder(); - - if (record.getIds() != null) { - for (String id : record.getIds()) { - paramsList.append("skyflow_ids=").append(id).append("&"); - } - } - - if (record.getColumnName() != null && record.getColumnValues() != null) { - paramsList.append("column_name=").append(record.getColumnName()).append("&"); - for (String value : record.getColumnValues()) { - paramsList.append("column_values=").append(value).append("&"); - } - } - if(record.getRedaction() == null && getOptions.getOptionToken() == true){ - paramsList.append("tokenization=").append(getOptions.getOptionToken()); - } else { - paramsList.append("redaction=").append(record.getRedaction()); - } - return paramsList; - } - - public static JSONObject constructInsertResponse(JSONObject response, List requestRecords, InsertOptions options) { - JSONArray responses = (JSONArray) response.get("responses"); - JSONArray successResponses = new JSONArray(); - JSONArray failureResponses = new JSONArray(); - JSONObject insertResponse = new JSONObject(); - - boolean tokens = options.isTokens(); - boolean continueOnError = options.isContinueOnError(); - - if (continueOnError) { - for (int index = 0; index < responses.size(); index++) { - JSONObject body = (JSONObject) ((JSONObject) responses.get(index)).get("Body"); - Long status = (Long) ((JSONObject) responses.get(index)).get("Status"); - if (body.containsKey("records")) { - JSONObject record = ((JSONObject) ((JSONArray) body.get("records")).get(0)); - String skyflowID = (String) record.get("skyflow_id"); - JSONObject responseTokens = (JSONObject) record.get("tokens"); - String table = (String) ((JSONObject) requestRecords.get(index)).get("tableName"); - JSONObject successObj = new JSONObject(); - successObj.put("table", table); - successObj.put("request_index", index); - if (tokens) { - responseTokens.remove("*"); - responseTokens.put("skyflow_id", skyflowID); - successObj.put("fields", responseTokens); - } else { - successObj.put("skyflow_id", skyflowID); - } - successResponses.add(successObj); - } else { - JSONObject failureObj = new JSONObject(); - JSONObject errorObj = new JSONObject(); - errorObj.put("code", status); - errorObj.put("description", appendRequestId((String) body.get("error"), HttpUtility.getRequestID())); - errorObj.put("request_index", index); - failureObj.put("error", errorObj); - failureResponses.add(failureObj); - } - } - } else if (tokens) { - for (int index = 0; index < responses.size(); index++) { - String skyflowId = (String) ((JSONObject) ((JSONArray) ((JSONObject) responses.get(index)) - .get("records")).get(0)).get("skyflow_id"); - JSONObject newObj = new JSONObject(); - newObj.put("table", ((JSONObject) requestRecords.get(index)).get("tableName")); - JSONObject newFields = (JSONObject) ((JSONObject) ((JSONArray) ((JSONObject) responses.get(index)) - .get("records")).get(0)).get("tokens"); - newFields.remove("*"); - newFields.put("skyflow_id", skyflowId); - newObj.put("fields", newFields); - newObj.put("request_index", index); - successResponses.add(newObj); - } - } else { - for (int index = 0; index < responses.size(); index++) { - JSONObject newObj = new JSONObject(); - - newObj.put("table", ((JSONObject) requestRecords.get(index)).get("tableName")); - newObj.put("skyflow_id", - ((JSONObject) ((JSONArray) ((JSONObject) responses.get(index)).get("records")).get(0)) - .get("skyflow_id")); - newObj.put("request_index", index); - successResponses.add(newObj); - } - } - if (successResponses.size() > 0) { - insertResponse.put("records", successResponses); - } - if (failureResponses.size() > 0) { - insertResponse.put("errors", failureResponses); - } - return insertResponse; - } - - public static String parameterizedString(String base, String... args) { - for (int index = 0; index < args.length; index++) { - base = base.replace("%s" + (index + 1), args[index]); - } - return base; - } - - public static String constructConnectionURL(JSONObject config) { - StringBuilder filledURL = new StringBuilder((String) config.get("connectionURL")); - - if (config.containsKey("pathParams")) { - JSONObject pathParams = (JSONObject) config.get("pathParams"); - for (Object key : pathParams.keySet()) { - Object value = pathParams.get(key); - filledURL = new StringBuilder(filledURL.toString().replace(String.format("{%s}", key), (String) value)); - } - } - - if (config.containsKey("queryParams")) { - JSONObject queryParams = (JSONObject) config.get("queryParams"); - filledURL.append("?"); - for (Object key : queryParams.keySet()) { - Object value = queryParams.get(key); - filledURL.append(key).append("=").append(value).append("&"); - } - filledURL = new StringBuilder(filledURL.substring(0, filledURL.length() - 1)); - - } - return filledURL.toString(); - } - - public static Map constructConnectionHeadersMap(JSONObject configHeaders) { - Map headersMap = new HashMap<>(); - for (Object key : configHeaders.keySet()) { - Object value = configHeaders.get(key); - headersMap.put(((String) key).toLowerCase(), (String) value); - } - return headersMap; - } - - public static String appendRequestId(String message, String requestId) { - if (requestId != null && !requestId.isEmpty()) { - message = message + " - requestId: " + requestId; - } - return message; - } - - public static String appendRequestIdToErrorObj(int status, String error, String requestId) throws SkyflowException { - try { - if (requestId != null && !requestId.isEmpty()) { - JSONObject errorObject = (JSONObject) new JSONParser().parse(error); - JSONObject tempError = (JSONObject) errorObject.get("error"); - if (tempError != null) { - String message = (String) tempError.get("message"); - message = message + " - requestId: " + requestId; - - tempError.put("message", message); - errorObject.put("error", tempError); - } - error = errorObject.toString(); - } - } catch (ParseException e) { - throw new SkyflowException(status, error); - } - return error; - } - - public static String formatJsonToFormEncodedString(JSONObject requestBody) { - LogUtil.printDebugLog(DebugLogs.FormatRequestBodyFormUrlFormEncoded.getLog()); - StringBuilder formEncodeString = new StringBuilder(); - HashMap jsonMap = convertJsonToMap(requestBody, ""); - - for (Map.Entry currentEntry : jsonMap.entrySet()) - formEncodeString.append(makeFormEncodeKeyValuePair(currentEntry.getKey(), currentEntry.getValue())); - - return formEncodeString.substring(0, formEncodeString.length() - 1); - } - - public static String formatJsonToMultiPartFormDataString(JSONObject requestBody, String boundary) { - LogUtil.printDebugLog(DebugLogs.FormatRequestBodyFormData.getLog()); - StringBuilder formEncodeString = new StringBuilder(); - HashMap jsonMap = convertJsonToMap(requestBody, ""); - - for (Map.Entry currentEntry : jsonMap.entrySet()) - formEncodeString.append(makeFormDataKeyValuePair(currentEntry.getKey(), currentEntry.getValue(), boundary)); - - formEncodeString.append(LINE_FEED); - formEncodeString.append("--").append(boundary).append("--").append(LINE_FEED); - - return formEncodeString.toString(); - } - - private static HashMap convertJsonToMap(JSONObject json, String rootKey) { - HashMap currentMap = new HashMap<>(); - for (Object key : json.keySet()) { - Object currentValue = json.get(key); - String currentKey = rootKey.length() != 0 ? rootKey + '[' + key.toString() + ']' : rootKey + key.toString(); - if (currentValue instanceof JSONObject) { - currentMap.putAll(convertJsonToMap((JSONObject) currentValue, currentKey)); - } else { - currentMap.put(currentKey, currentValue.toString()); - } - } - return currentMap; - } - - private static String makeFormEncodeKeyValuePair(String key, String value) { - return key + "=" + value + "&"; - } - - private static String makeFormDataKeyValuePair(String key, String value, String boundary) { - StringBuilder formDataTextField = new StringBuilder(); - formDataTextField.append("--").append(boundary).append(LINE_FEED); - formDataTextField.append("Content-Disposition: form-data; name=\"").append(key).append("\"").append(LINE_FEED); - formDataTextField.append(LINE_FEED); - formDataTextField.append(value).append(LINE_FEED); - - return formDataTextField.toString(); - } - - public static PrivateKey getPrivateKeyFromPem(String pemKey) throws SkyflowException { - - String PKCS8PrivateHeader = "-----BEGIN PRIVATE KEY-----"; - String PKCS8PrivateFooter = "-----END PRIVATE KEY-----"; - - String privateKeyContent = pemKey; - PrivateKey privateKey = null; - - if (pemKey.contains(PKCS8PrivateHeader)) { - privateKeyContent = privateKeyContent.replace(PKCS8PrivateHeader, ""); - privateKeyContent = privateKeyContent.replace(PKCS8PrivateFooter, ""); - privateKeyContent = privateKeyContent.replace("\n", ""); - privateKeyContent = privateKeyContent.replace("\r\n", ""); - privateKey = parsePkcs8PrivateKey(Base64.decodeBase64(privateKeyContent)); - } else { - LogUtil.printErrorLog(ErrorLogs.UnableToRetrieveRSA.getLog()); - throw new SkyflowException(ErrorCode.UnableToRetrieveRSA); - } - return privateKey; - } - - /** - * Create a PrivateKey instance from raw PKCS#8 bytes. - */ - public static PrivateKey parsePkcs8PrivateKey(byte[] pkcs8Bytes) throws SkyflowException { - KeyFactory keyFactory; - PrivateKey privateKey = null; - try { - PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(pkcs8Bytes); - keyFactory = KeyFactory.getInstance("RSA"); - privateKey = keyFactory.generatePrivate(keySpec); - } catch (NoSuchAlgorithmException e) { - LogUtil.printErrorLog(ErrorLogs.NoSuchAlgorithm.getLog()); - throw new SkyflowException(ErrorCode.NoSuchAlgorithm, e); - } catch (InvalidKeySpecException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidKeySpec.getLog()); - throw new SkyflowException(ErrorCode.InvalidKeySpec, e); - } - return privateKey; - } - public static JSONObject getMetrics(){ - JSONObject details = new JSONObject(); - - String sdkVersion = Constants.SDK_VERSION; - String deviceModel = ""; - String osDetails = ""; - String javaVersion = ""; - - details.put("sdk_name_version", "skyflow-java@" + sdkVersion); - - // Retrieve device model - try { - deviceModel = System.getProperty("os.name"); - } catch (Exception e) { - deviceModel = ""; - } - details.put("sdk_client_device_model", deviceModel); - - // Retrieve OS details - try { - osDetails = System.getProperty("os.version"); - } catch (Exception e) { - osDetails = ""; - } - details.put("sdk_client_os_details", osDetails); - - // Retrieve Java version details - try { - javaVersion = System.getProperty("java.version"); - } catch (Exception e) { - javaVersion = ""; - } - details.put("sdk_runtime_details", "Java@" + javaVersion); - - return details; - } -} diff --git a/v1/src/main/java/com/skyflow/common/utils/HttpUtility.java b/v1/src/main/java/com/skyflow/common/utils/HttpUtility.java deleted file mode 100644 index 60cf9aac..00000000 --- a/v1/src/main/java/com/skyflow/common/utils/HttpUtility.java +++ /dev/null @@ -1,107 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.common.utils; - -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import org.json.simple.JSONObject; - -import java.io.*; -import java.net.HttpURLConnection; -import java.net.URL; -import java.nio.charset.StandardCharsets; -import java.util.Map; - -import static com.skyflow.common.utils.Helpers.formatJsonToFormEncodedString; -import static com.skyflow.common.utils.Helpers.formatJsonToMultiPartFormDataString; - -public final class HttpUtility { - private static String requestID; - - public static String getRequestID() { - return requestID; - } - - public static String sendRequest(String method, URL url, JSONObject params, Map headers) throws IOException, SkyflowException { - HttpURLConnection connection = null; - BufferedReader in = null; - StringBuffer response = null; - String boundary = String.valueOf(System.currentTimeMillis()); - try { - connection = (HttpURLConnection) url.openConnection(); - connection.setRequestMethod(method); - connection.setRequestProperty("content-type", "application/json"); - connection.setRequestProperty("Accept", "*/*"); - - if (headers != null && headers.size() > 0) { - for (Map.Entry entry : headers.entrySet()) - connection.setRequestProperty(entry.getKey(), entry.getValue()); - - // append dynamic boundary if content-type is multipart/form-data - if (headers.containsKey("content-type")) { - if (headers.get("content-type") == "multipart/form-data") { - connection.setRequestProperty("content-type", "multipart/form-data; boundary=" + boundary); - } - } - } - if (params != null && params.size() > 0) { - connection.setDoOutput(true); - try (DataOutputStream wr = new DataOutputStream(connection.getOutputStream())) { - byte[] input = null; - String requestContentType = connection.getRequestProperty("content-type"); - - if (requestContentType.contains("application/x-www-form-urlencoded")) { - input = formatJsonToFormEncodedString(params).getBytes(StandardCharsets.UTF_8); - } else if (requestContentType.contains("multipart/form-data")) { - input = formatJsonToMultiPartFormDataString(params, boundary).getBytes(StandardCharsets.UTF_8); - }else { - input = params.toString().getBytes(StandardCharsets.UTF_8); - } - - wr.write(input, 0, input.length); - wr.flush(); - } - } - - int status = connection.getResponseCode(); - String requestID = connection.getHeaderField("x-request-id"); - HttpUtility.requestID = requestID; - - Reader streamReader; - if (status > 299) { - if (connection.getErrorStream() != null) - streamReader = new InputStreamReader(connection.getErrorStream()); - else { - String description = Helpers.appendRequestId(ErrorCode.Server.getDescription(), requestID); - LogUtil.printErrorLog(description); - throw new SkyflowException(status, description); - } - } else { - streamReader = new InputStreamReader(connection.getInputStream()); - } - - response = new StringBuffer(); - in = new BufferedReader(streamReader); - String inputLine; - while ((inputLine = in.readLine()) != null) { - response.append(inputLine); - } - - if (status > 299) { - LogUtil.printErrorLog(Helpers.appendRequestId(response.toString(), requestID)); - String errorMsg = Helpers.appendRequestIdToErrorObj(status, response.toString(), requestID); - throw new SkyflowException(status, errorMsg); - } - } finally { - if (in != null) { - in.close(); - } - if (connection != null) { - connection.disconnect(); - } - } - return response.toString(); - } - -} diff --git a/v1/src/main/java/com/skyflow/common/utils/LogUtil.java b/v1/src/main/java/com/skyflow/common/utils/LogUtil.java deleted file mode 100644 index fa48cdb3..00000000 --- a/v1/src/main/java/com/skyflow/common/utils/LogUtil.java +++ /dev/null @@ -1,102 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.common.utils; - -import com.skyflow.entities.LogLevel; -import com.skyflow.logs.InfoLogs; - -import java.util.logging.*; - -public final class LogUtil { - private static final Logger LOGGER = Logger.getLogger(LogUtil.class.getName()); - private static final String SDK_OWNER = "[Skyflow] "; - private static boolean IS_LOGGER_SETUP_DONE = false; - - - synchronized public static void setupLogger(LogLevel logLevel) { - IS_LOGGER_SETUP_DONE = true; - LogManager.getLogManager().reset(); - LOGGER.setUseParentHandlers(false); - Formatter formatter = new SimpleFormatter() { - private static final String format = "%s: %s %n"; - - // Override format method - @Override - public synchronized String format(LogRecord logRecord) { - return String.format(format, loggerLevelToLogLevelMap(logRecord.getLevel()), - logRecord.getMessage()); - } - }; - ConsoleHandler consoleHandler = new ConsoleHandler(); - consoleHandler.setFormatter(formatter); - consoleHandler.setLevel(Level.CONFIG); - - LOGGER.addHandler(consoleHandler); - LOGGER.setLevel(logLevelToLoggerLevelMap(logLevel)); - printInfoLog(InfoLogs.LoggerSetup.getLog()); - } - - public static void printErrorLog(String message) { - if (IS_LOGGER_SETUP_DONE) - LOGGER.severe(SDK_OWNER + message); - else { - setupLogger(LogLevel.ERROR); - LOGGER.severe(SDK_OWNER + message); - } - } - - public static void printDebugLog(String message) { - if (IS_LOGGER_SETUP_DONE) - LOGGER.config(SDK_OWNER + message); - } - - public static void printWarningLog(String message) { - if (IS_LOGGER_SETUP_DONE) - LOGGER.warning(SDK_OWNER + message); - } - - public static void printInfoLog(String message) { - if (IS_LOGGER_SETUP_DONE) - LOGGER.info(SDK_OWNER + message); - } - - - private static Level logLevelToLoggerLevelMap(LogLevel logLevel) { - Level loggerLevel; - switch (logLevel) { - case ERROR: - loggerLevel = Level.SEVERE; - break; - case WARN: - loggerLevel = Level.WARNING; - break; - case INFO: - loggerLevel = Level.INFO; - break; - case DEBUG: - loggerLevel = Level.CONFIG; - break; - default: - loggerLevel = Level.OFF; - } - return loggerLevel; - } - - private static LogLevel loggerLevelToLogLevelMap(Level loggerLevel) { - LogLevel logLevel; - if (Level.SEVERE.equals(loggerLevel)) { - logLevel = LogLevel.ERROR; - } else if (Level.WARNING.equals(loggerLevel)) { - logLevel = LogLevel.WARN; - } else if (Level.INFO.equals(loggerLevel)) { - logLevel = LogLevel.INFO; - } else if (Level.CONFIG.equals(loggerLevel)){ - logLevel = LogLevel.DEBUG; - }else - logLevel = LogLevel.OFF; - return logLevel; - } - - -} diff --git a/v1/src/main/java/com/skyflow/common/utils/TokenUtils.java b/v1/src/main/java/com/skyflow/common/utils/TokenUtils.java deleted file mode 100644 index 288f2faa..00000000 --- a/v1/src/main/java/com/skyflow/common/utils/TokenUtils.java +++ /dev/null @@ -1,74 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.common.utils; - -import com.skyflow.entities.TokenProvider; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.ErrorLogs; -import com.skyflow.logs.InfoLogs; -import org.apache.commons.codec.binary.Base64; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; - -import java.nio.charset.StandardCharsets; -import java.util.Date; - -public final class TokenUtils { - - private String token; - - public TokenUtils() { - LogUtil.printInfoLog(InfoLogs.TokenUtilsInstanceCreated.getLog()); - this.token = null; - } - - public static boolean isTokenValid(String token) throws SkyflowException { - try { - if (token != null) { - return !isExpired(token); - } - } catch (ParseException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidBearerToken.getLog()); - throw new SkyflowException(ErrorCode.InvalidBearerToken, e); - } - - return false; - } - - private static boolean isExpired(String encodedToken) throws ParseException, SkyflowException { - long currentTime = new Date().getTime() / 1000; - long expiryTime = (long) decoded(encodedToken).get("exp"); - return currentTime > expiryTime; - } - - public static JSONObject decoded(String encodedToken) throws ParseException, SkyflowException { - String[] split = encodedToken.split("\\."); - if (split.length < 3) { - throw new SkyflowException(ErrorCode.InvalidBearerToken); - } - byte[] decodedBytes = Base64.decodeBase64(split[1]); - return (JSONObject) new JSONParser().parse(new String(decodedBytes, StandardCharsets.UTF_8)); - } - - public String getBearerToken(TokenProvider tokenProvider) throws SkyflowException { - if (token != null && isTokenValid(token)) - return token; - - try { - token = tokenProvider.getBearerToken(); - if(!isTokenValid(token)){ - LogUtil.printErrorLog(ErrorLogs.BearerTokenExpired.getLog()); - throw new SkyflowException(ErrorCode.BearerTokenExpired); - } - } catch (SkyflowException exception) { - throw exception; - } catch (Exception e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.BearerThrownException.getLog(), e.getMessage())); - throw new SkyflowException(ErrorCode.BearerThrownException.getCode(), e.getMessage(), e); - } - return token; - } -} diff --git a/v1/src/main/java/com/skyflow/common/utils/Validators.java b/v1/src/main/java/com/skyflow/common/utils/Validators.java deleted file mode 100644 index c1eda9e1..00000000 --- a/v1/src/main/java/com/skyflow/common/utils/Validators.java +++ /dev/null @@ -1,176 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.common.utils; - -import com.skyflow.entities.*; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.ErrorLogs; -import com.skyflow.logs.InfoLogs; -import org.json.simple.JSONObject; - -import java.net.URL; -import java.util.Objects; - -public final class Validators { - public static void validateConfiguration(SkyflowConfiguration config) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.ValidatingSkyflowConfiguration.getLog()); - if (config.getVaultID() == null || config.getVaultID().length() <= 0) { - LogUtil.printErrorLog(ErrorLogs.InvalidVaultId.getLog()); - throw new SkyflowException(ErrorCode.EmptyVaultID); - } - - if (config.getVaultURL() == null || isInvalidURL(config.getVaultURL())) { - LogUtil.printErrorLog(ErrorLogs.InvalidVaultURL.getLog()); - throw new SkyflowException(ErrorCode.InvalidVaultURL); - } - - if (config.getTokenProvider() == null) { - LogUtil.printErrorLog(ErrorLogs.InvalidTokenProvider.getLog()); - throw new SkyflowException(ErrorCode.InvalidTokenProvider); - } - - } - - public static void validateConnectionConfiguration(JSONObject connectionConfig, SkyflowConfiguration skyflowConfiguration) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.ValidatingInvokeConnectionConfig.getLog()); - if (skyflowConfiguration.getTokenProvider() == null) { - LogUtil.printErrorLog(ErrorLogs.InvalidTokenProvider.getLog()); - throw new SkyflowException(ErrorCode.InvalidTokenProvider); - } - - if (connectionConfig.containsKey("connectionURL")) { - String connectionURL = (String) connectionConfig.get("connectionURL"); - if (isInvalidURL(connectionURL)) { - LogUtil.printErrorLog(ErrorLogs.InvalidConnectionURL.getLog()); - throw new SkyflowException(ErrorCode.InvalidConnectionURL); - } - } else { - LogUtil.printErrorLog(ErrorLogs.ConnectionURLMissing.getLog()); - throw new SkyflowException(ErrorCode.ConnectionURLMissing); - } - - if (connectionConfig.containsKey("methodName")) { - try { - RequestMethod requestMethod = (RequestMethod) connectionConfig.get("methodName"); - } catch (Exception e) { - LogUtil.printErrorLog(ErrorLogs.InvalidMethodName.getLog()); - throw new SkyflowException(ErrorCode.InvalidMethodName); - } - } else { - LogUtil.printErrorLog(ErrorLogs.MethodNameMissing.getLog()); - throw new SkyflowException(ErrorCode.MethodNameMissing); - } - } - - public static void validateUpsertOptions(UpsertOption[] upsertOptions) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.ValidatingUpsertOptions.getLog()); - if (upsertOptions.length == 0) { - LogUtil.printErrorLog(ErrorLogs.InvalidUpsertOptionType.getLog()); - throw new SkyflowException(ErrorCode.InvalidUpsertOptionType); - } - - for (UpsertOption upsertOption : upsertOptions) { - if (upsertOption == null) { - LogUtil.printErrorLog(ErrorLogs.InvalidUpsertObjectType.getLog()); - throw new SkyflowException(ErrorCode.InvalidUpsertObjectType); - } - - if (upsertOption.getTable() == null || Objects.equals(upsertOption.getTable(), "")) { - LogUtil.printErrorLog(ErrorLogs.InvalidTableInUpsertOption.getLog()); - throw new SkyflowException(ErrorCode.InvalidTableInUpsertOption); - } - if (upsertOption.getColumn() == null || Objects.equals(upsertOption.getColumn(), "")) { - LogUtil.printErrorLog(ErrorLogs.InvalidColumnInUpsertOption.getLog()); - throw new SkyflowException(ErrorCode.InvalidColumnInUpsertOption); - } - } - - } - - private static boolean isInvalidURL(String configURL) { - try { - URL url = new URL(configURL); - if (!url.getProtocol().equals("https")) throw new Exception(); - } catch (Exception e) { - return true; - } - return false; - } - - public static void validateGetByIdRequestRecord(GetByIdRecordInput record) throws SkyflowException { - String table = record.getTable(); - - if (table == null || table.trim().isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.InvalidTable.getLog()); - throw new SkyflowException(ErrorCode.InvalidTable); - } - } - - public static void validateGetRequestRecord(GetRecordInput record, GetOptions getOptions) throws SkyflowException { - String[] ids = record.getIds(); - String table = record.getTable(); - String columnName = record.getColumnName(); - String[] columnValues = record.getColumnValues(); - RedactionType redaction = record.getRedaction(); - - if (table == null || table.trim().isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.InvalidTable.getLog()); - throw new SkyflowException(ErrorCode.InvalidTable); - } - if (getOptions.getOptionToken() == false && redaction == null) { - LogUtil.printErrorLog((ErrorLogs.MissingRedaction.getLog())); - throw new SkyflowException(ErrorCode.MissingRedaction); - } - - if (ids == null && columnName == null && columnValues == null) { - LogUtil.printErrorLog(ErrorLogs.MissingIdAndColumnName.getLog()); - throw new SkyflowException(ErrorCode.MissingIdAndColumnName); - } - if( ids != null && columnName != null) { - LogUtil.printErrorLog(ErrorLogs.SkyflowIdAndColumnNameBothSpecified.getLog()); - throw new SkyflowException(ErrorCode.SkyflowIdAndColumnNameBothSpecified); - } - - if (columnName != null && columnValues == null) { - LogUtil.printErrorLog(ErrorLogs.MissingRecordColumnValue.getLog()); - throw new SkyflowException(ErrorCode.MissingRecordColumnValue); - } - if (columnName == null && columnValues != null) { - LogUtil.printErrorLog(ErrorLogs.MissingRecordColumnName.getLog()); - throw new SkyflowException(ErrorCode.MissingRecordColumnName); - } - if (getOptions.getOptionToken() == true) { - if (columnName != null || columnValues != null) { - LogUtil.printErrorLog(ErrorLogs.TokensGetColumnNotSupported.getLog()); - throw new SkyflowException(ErrorCode.TokensGetColumnNotSupported); - } - if (redaction != null) { - LogUtil.printErrorLog(ErrorLogs.RedactionWithTokenNotSupported.getLog()); - throw new SkyflowException(ErrorCode.RedactionWithTokenNotSupported); - } - } - } - public static void validateDeleteBySkyflowId(DeleteRecordInput deleteRecordInput) throws SkyflowException{ - String table = deleteRecordInput.getTable(); - String id = deleteRecordInput.getId(); - if (table == null || table.trim().isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.InvalidTable.getLog()); - throw new SkyflowException(ErrorCode.InvalidTable); - } - if (id == null || id.trim().isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.InvalidId.getLog()); - throw new SkyflowException(ErrorCode.InvalidId); - } - - } - public static void validateInsertRecord(InsertRecordInput record) throws SkyflowException { - if (record.getTable() == null || record.getTable().isEmpty()) { - throw new SkyflowException(ErrorCode.InvalidTable); - } - if (record.getFields() == null) { - throw new SkyflowException(ErrorCode.InvalidFields); - } - } -} diff --git a/v1/src/main/java/com/skyflow/entities/DeleteInput.java b/v1/src/main/java/com/skyflow/entities/DeleteInput.java deleted file mode 100644 index 422d929d..00000000 --- a/v1/src/main/java/com/skyflow/entities/DeleteInput.java +++ /dev/null @@ -1,13 +0,0 @@ -package com.skyflow.entities; - -public class DeleteInput { - private DeleteRecordInput[] records; - - public DeleteRecordInput[] getRecords() { - return records; - } - - public void setRecords(DeleteRecordInput[] records) { - this.records = records; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/DeleteOptions.java b/v1/src/main/java/com/skyflow/entities/DeleteOptions.java deleted file mode 100644 index affa26c6..00000000 --- a/v1/src/main/java/com/skyflow/entities/DeleteOptions.java +++ /dev/null @@ -1,5 +0,0 @@ -package com.skyflow.entities; - -public class DeleteOptions { - public DeleteOptions(){} -} diff --git a/v1/src/main/java/com/skyflow/entities/DeleteRecordInput.java b/v1/src/main/java/com/skyflow/entities/DeleteRecordInput.java deleted file mode 100644 index 6e11b2a4..00000000 --- a/v1/src/main/java/com/skyflow/entities/DeleteRecordInput.java +++ /dev/null @@ -1,22 +0,0 @@ -package com.skyflow.entities; - -public class DeleteRecordInput { - private String id; - private String table; - - public String getId() { - return id; - } - - public void setId(String id) { - this.id = id; - } - - public String getTable() { - return table; - } - - public void setTable(String table) { - this.table = table; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/DetokenizeInput.java b/v1/src/main/java/com/skyflow/entities/DetokenizeInput.java deleted file mode 100644 index b8d8f908..00000000 --- a/v1/src/main/java/com/skyflow/entities/DetokenizeInput.java +++ /dev/null @@ -1,16 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public class DetokenizeInput { - private DetokenizeRecord[] records; - - public DetokenizeRecord[] getRecords() { - return records; - } - - public void setRecords(DetokenizeRecord[] records) { - this.records = records; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/DetokenizeRecord.java b/v1/src/main/java/com/skyflow/entities/DetokenizeRecord.java deleted file mode 100644 index 4bd9ee40..00000000 --- a/v1/src/main/java/com/skyflow/entities/DetokenizeRecord.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public class DetokenizeRecord { - private String token; - private RedactionType redaction = RedactionType.PLAIN_TEXT; - - public String getToken() { - return token; - } - - void setToken(String token) { - this.token = token; - } - - public RedactionType getRedaction() { - return redaction; - } - - public void setRedaction(RedactionType redaction) { - this.redaction = redaction; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/GetByIdInput.java b/v1/src/main/java/com/skyflow/entities/GetByIdInput.java deleted file mode 100644 index a31f4b49..00000000 --- a/v1/src/main/java/com/skyflow/entities/GetByIdInput.java +++ /dev/null @@ -1,16 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public class GetByIdInput { - private GetByIdRecordInput[] records; - - public GetByIdRecordInput[] getRecords() { - return records; - } - - public void setRecords(GetByIdRecordInput[] records) { - this.records = records; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/GetByIdRecordInput.java b/v1/src/main/java/com/skyflow/entities/GetByIdRecordInput.java deleted file mode 100644 index e858bb24..00000000 --- a/v1/src/main/java/com/skyflow/entities/GetByIdRecordInput.java +++ /dev/null @@ -1,34 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public class GetByIdRecordInput { - private String[] ids; - private String table; - private RedactionType redaction; - - public String[] getIds() { - return ids; - } - - public void setIds(String[] ids) { - this.ids = ids; - } - - public String getTable() { - return table; - } - - public void setTable(String table) { - this.table = table; - } - - public RedactionType getRedaction() { - return redaction; - } - - public void setRedaction(RedactionType redaction) { - this.redaction = redaction; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/GetInput.java b/v1/src/main/java/com/skyflow/entities/GetInput.java deleted file mode 100644 index 786be682..00000000 --- a/v1/src/main/java/com/skyflow/entities/GetInput.java +++ /dev/null @@ -1,16 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public class GetInput { - private GetRecordInput[] records; - - public GetRecordInput[] getRecords() { - return records; - } - - public void setRecords(GetRecordInput[] records) { - this.records = records; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/GetOptions.java b/v1/src/main/java/com/skyflow/entities/GetOptions.java deleted file mode 100644 index 7620b761..00000000 --- a/v1/src/main/java/com/skyflow/entities/GetOptions.java +++ /dev/null @@ -1,16 +0,0 @@ -package com.skyflow.entities; - -public class GetOptions { - private boolean tokens; - - public GetOptions(){ - this.tokens = false; - } - public GetOptions(boolean tokens){ - this.tokens = tokens; - } - - public boolean getOptionToken(){ - return tokens; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/GetRecordInput.java b/v1/src/main/java/com/skyflow/entities/GetRecordInput.java deleted file mode 100644 index 169c0c18..00000000 --- a/v1/src/main/java/com/skyflow/entities/GetRecordInput.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public class GetRecordInput { - private String[] ids; - private String table; - private String columnName; - private String[] columnValues; - private RedactionType redaction; - - public String[] getIds() { - return ids; - } - - public void setIds(String[] ids) { - this.ids = ids; - } - - public String getTable() { - return table; - } - - public void setTable(String table) { - this.table = table; - } - - public String getColumnName() { - return columnName; - } - - public void setColumnName(String columnName) { - this.columnName = columnName; - } - - public String[] getColumnValues() { - return columnValues; - } - - public void setColumnValues(String[] columnValues) { - this.columnValues = columnValues; - } - - public RedactionType getRedaction() { - return redaction; - } - - public void setRedaction(RedactionType redaction) { - this.redaction = redaction; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/InsertBulkOptions.java b/v1/src/main/java/com/skyflow/entities/InsertBulkOptions.java deleted file mode 100644 index b7c03963..00000000 --- a/v1/src/main/java/com/skyflow/entities/InsertBulkOptions.java +++ /dev/null @@ -1,35 +0,0 @@ -package com.skyflow.entities; - -public class InsertBulkOptions { - - private boolean tokens; - private UpsertOption[] upsertOptions; - - public InsertBulkOptions() { - this.tokens = true; - this.upsertOptions = null; - } - - public InsertBulkOptions(boolean tokens) { - this.tokens = tokens; - this.upsertOptions = null; - } - - public InsertBulkOptions(UpsertOption[] upsertOptions) { - this.tokens = true; - this.upsertOptions = upsertOptions; - } - - public InsertBulkOptions(boolean tokens, UpsertOption[] upsertOptions) { - this.tokens = tokens; - this.upsertOptions = upsertOptions; - } - - public boolean isTokens() { - return tokens; - } - - public UpsertOption[] getUpsertOptions() { - return upsertOptions; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/InsertInput.java b/v1/src/main/java/com/skyflow/entities/InsertInput.java deleted file mode 100644 index 0163aace..00000000 --- a/v1/src/main/java/com/skyflow/entities/InsertInput.java +++ /dev/null @@ -1,17 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public class InsertInput { - - private InsertRecordInput[] records; - - public InsertRecordInput[] getRecords() { - return records; - } - - public void setRecords(InsertRecordInput[] records) { - this.records = records; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/InsertOptions.java b/v1/src/main/java/com/skyflow/entities/InsertOptions.java deleted file mode 100644 index 16739892..00000000 --- a/v1/src/main/java/com/skyflow/entities/InsertOptions.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public class InsertOptions { - - private boolean tokens; - private UpsertOption[] upsertOptions; - private boolean continueOnError; - - public InsertOptions() { - this.tokens = true; - this.upsertOptions = null; - this.continueOnError = false; - } - - public InsertOptions(boolean tokens) { - this.tokens = tokens; - this.upsertOptions = null; - } - - public InsertOptions(UpsertOption[] upsertOptions) { - this.tokens = true; - this.upsertOptions = upsertOptions; - } - - public InsertOptions(boolean tokens, UpsertOption[] upsertOptions) { - this.tokens = tokens; - this.upsertOptions = upsertOptions; - } - - public InsertOptions(boolean tokens, boolean continueOnError) { - this.tokens = tokens; - this.continueOnError = continueOnError; - } - - public InsertOptions(UpsertOption[] upsertOptions, boolean continueOnError) { - this.upsertOptions = upsertOptions; - this.continueOnError = continueOnError; - } - - public InsertOptions(boolean tokens, UpsertOption[] upsertOptions, boolean continueOnError) { - this.tokens = tokens; - this.upsertOptions = upsertOptions; - this.continueOnError = continueOnError; - } - - public boolean isTokens() { - return tokens; - } - - public UpsertOption[] getUpsertOptions() { - return upsertOptions; - } - - public boolean isContinueOnError() { - return continueOnError; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/InsertRecordInput.java b/v1/src/main/java/com/skyflow/entities/InsertRecordInput.java deleted file mode 100644 index 6572b5c0..00000000 --- a/v1/src/main/java/com/skyflow/entities/InsertRecordInput.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -import org.json.simple.JSONObject; - -public class InsertRecordInput { - private String table; - private JSONObject fields; - - public String getTable() { - return table; - } - - public void setTable(String table) { - this.table = table; - } - - public JSONObject getFields() { - return fields; - } - - public void setFields(JSONObject fields) { - this.fields = fields; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/LogLevel.java b/v1/src/main/java/com/skyflow/entities/LogLevel.java deleted file mode 100644 index 3bed5284..00000000 --- a/v1/src/main/java/com/skyflow/entities/LogLevel.java +++ /dev/null @@ -1,12 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public enum LogLevel { - DEBUG, - INFO, - WARN, - ERROR, - OFF -} diff --git a/v1/src/main/java/com/skyflow/entities/QueryInput.java b/v1/src/main/java/com/skyflow/entities/QueryInput.java deleted file mode 100644 index 7e578d41..00000000 --- a/v1/src/main/java/com/skyflow/entities/QueryInput.java +++ /dev/null @@ -1,13 +0,0 @@ -package com.skyflow.entities; - -public class QueryInput { - private QueryRecordInput queryInput; - - public QueryRecordInput getQueryInput() { - return queryInput; - } - - public void setQueryInput(QueryRecordInput queryInput) { - this.queryInput = queryInput; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/QueryOptions.java b/v1/src/main/java/com/skyflow/entities/QueryOptions.java deleted file mode 100644 index 7cc1a3de..00000000 --- a/v1/src/main/java/com/skyflow/entities/QueryOptions.java +++ /dev/null @@ -1,8 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public class QueryOptions { - -} diff --git a/v1/src/main/java/com/skyflow/entities/QueryRecordInput.java b/v1/src/main/java/com/skyflow/entities/QueryRecordInput.java deleted file mode 100644 index 032c4fd0..00000000 --- a/v1/src/main/java/com/skyflow/entities/QueryRecordInput.java +++ /dev/null @@ -1,11 +0,0 @@ -package com.skyflow.entities; - -public class QueryRecordInput { - private String query; - public String getQuery() { - return query; - } - public void setQuery(String query) { - this.query = query; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/RedactionType.java b/v1/src/main/java/com/skyflow/entities/RedactionType.java deleted file mode 100644 index 7bf240fc..00000000 --- a/v1/src/main/java/com/skyflow/entities/RedactionType.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public enum RedactionType { - DEFAULT("DEFAULT"), - PLAIN_TEXT("PLAIN_TEXT"), - MASKED("MASKED"), - REDACTED("REDACTED"), - ; - - private final String text; - - RedactionType(final String text) { - this.text = text; - } - - @Override - public String toString() { - return text; - } - -} diff --git a/v1/src/main/java/com/skyflow/entities/RequestMethod.java b/v1/src/main/java/com/skyflow/entities/RequestMethod.java deleted file mode 100644 index 7e2cea75..00000000 --- a/v1/src/main/java/com/skyflow/entities/RequestMethod.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public enum RequestMethod { - GET("GET"), - POST("POST"), - PUT("PUT"), - PATCH("PATCH"), - DELETE("DELETE"), - ; - - private final String requestMethod; - - - RequestMethod(String requestMethod) { - this.requestMethod = requestMethod; - } - - @Override - public String toString() { - return requestMethod; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/ResponseToken.java b/v1/src/main/java/com/skyflow/entities/ResponseToken.java deleted file mode 100644 index d1e4e978..00000000 --- a/v1/src/main/java/com/skyflow/entities/ResponseToken.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public class ResponseToken { - private String accessToken; - private String tokenType; - - public String getAccessToken() { - return accessToken; - } - - public void setAccessToken(String accessToken) { - this.accessToken = accessToken; - } - - public String getTokenType() { - return tokenType; - } - - public void setTokenType(String tokenType) { - this.tokenType = tokenType; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/SkyflowConfiguration.java b/v1/src/main/java/com/skyflow/entities/SkyflowConfiguration.java deleted file mode 100644 index a240e8ca..00000000 --- a/v1/src/main/java/com/skyflow/entities/SkyflowConfiguration.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public final class SkyflowConfiguration { - private final String vaultID; - private final String vaultURL; - private final TokenProvider tokenProvider; - - /** - * - * @param vaultID is the Skyflow vaultID, which can be found in EditVault Details. - * @param vaultURL is the vaultURL, which can be found in EditVault Details. - * @param tokenProvider class which implements the TokenProvider interface. - */ - public SkyflowConfiguration(String vaultID, String vaultURL, TokenProvider tokenProvider) { - this.vaultID = vaultID; - this.vaultURL = formatVaultURL(vaultURL); - this.tokenProvider = tokenProvider; - } - public SkyflowConfiguration(TokenProvider tokenProvider){ - this.vaultID = ""; - this.vaultURL = ""; - this.tokenProvider = tokenProvider; - } - - - public String getVaultID() { - return vaultID; - } - - public String getVaultURL() { - return vaultURL; - } - - public TokenProvider getTokenProvider() { - return tokenProvider; - } - - private String formatVaultURL(String vaultURL){ - if(vaultURL != null && vaultURL.trim().length() > 0 && vaultURL.trim().charAt(vaultURL.trim().length() - 1) == '/') - return vaultURL.trim().substring(0,vaultURL.trim().length()-1); - return vaultURL; - } -} \ No newline at end of file diff --git a/v1/src/main/java/com/skyflow/entities/TokenProvider.java b/v1/src/main/java/com/skyflow/entities/TokenProvider.java deleted file mode 100644 index 95863a21..00000000 --- a/v1/src/main/java/com/skyflow/entities/TokenProvider.java +++ /dev/null @@ -1,10 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -import com.skyflow.errors.SkyflowException; - -public interface TokenProvider { - String getBearerToken() throws Exception; -} diff --git a/v1/src/main/java/com/skyflow/entities/UpdateInput.java b/v1/src/main/java/com/skyflow/entities/UpdateInput.java deleted file mode 100644 index 9c7319d2..00000000 --- a/v1/src/main/java/com/skyflow/entities/UpdateInput.java +++ /dev/null @@ -1,13 +0,0 @@ -package com.skyflow.entities; - -public class UpdateInput { - private UpdateRecordInput[] records; - - public UpdateRecordInput[] getRecords() { - return records; - } - - public void setRecords(UpdateRecordInput[] records) { - this.records = records; - } -} diff --git a/v1/src/main/java/com/skyflow/entities/UpdateOptions.java b/v1/src/main/java/com/skyflow/entities/UpdateOptions.java deleted file mode 100644 index 0f3703ec..00000000 --- a/v1/src/main/java/com/skyflow/entities/UpdateOptions.java +++ /dev/null @@ -1,18 +0,0 @@ -package com.skyflow.entities; - -public class UpdateOptions { - private boolean tokens; - - public UpdateOptions() { - this.tokens = true; - } - - public UpdateOptions(boolean tokens) { - this.tokens = tokens; - } - - public boolean isTokens() { - return tokens; - } - -} diff --git a/v1/src/main/java/com/skyflow/entities/UpdateRecordInput.java b/v1/src/main/java/com/skyflow/entities/UpdateRecordInput.java deleted file mode 100644 index b6283e80..00000000 --- a/v1/src/main/java/com/skyflow/entities/UpdateRecordInput.java +++ /dev/null @@ -1,35 +0,0 @@ -package com.skyflow.entities; - -import org.json.simple.JSONObject; - -public class UpdateRecordInput { - private String id; - private String table; - private JSONObject fields; - - public String getTable() { - return table; - } - - public String getId() { - return id; - } - - public void setId(String id) { - this.id = id; - } - - public void setTable(String table) { - this.table = table; - } - - public JSONObject getFields() { - return fields; - } - - public void setFields(JSONObject fields) { - this.fields = fields; - } - - -} diff --git a/v1/src/main/java/com/skyflow/entities/UpsertOption.java b/v1/src/main/java/com/skyflow/entities/UpsertOption.java deleted file mode 100644 index 7c50eb71..00000000 --- a/v1/src/main/java/com/skyflow/entities/UpsertOption.java +++ /dev/null @@ -1,22 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.entities; - -public class UpsertOption { - private String table; - private String column; - - public UpsertOption(String table, String column) { - this.table = table; - this.column = column; - } - - public String getTable() { - return table; - } - - public String getColumn() { - return column; - } -} diff --git a/v1/src/main/java/com/skyflow/errors/ErrorCode.java b/v1/src/main/java/com/skyflow/errors/ErrorCode.java deleted file mode 100644 index f996d828..00000000 --- a/v1/src/main/java/com/skyflow/errors/ErrorCode.java +++ /dev/null @@ -1,79 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.errors; - -public enum ErrorCode { - InvalidVaultURL(400, "Invalid Vault URL"), - EmptyVaultID(400, "Empty Vault ID"), - InvalidTokenProvider(400, "Invalid TokenProvider"), - InvalidKeySpec(400, "Unable to parse RSA private key"), - NoSuchAlgorithm(400, "Invalid algorithm"), - UnableToRetrieveRSA(400, "Unable to retrieve RSA private key"), - UnableToReadResponse(400, "Unable to read response payload"), - InvalidTokenURI(400, "Unable to read tokenURI"), - InvalidKeyID(400, "Unable to read keyID"), - InvalidClientID(400, "Unable to read clientID"), - InvalidCredentialsPath(400, "Unable to open credentials - file %s1"), - InvalidJsonFormat(400, "Provided json file is in wrong format - file %s1"), - InvalidBearerToken(400, "Invalid token"), - BearerThrownException(400, "getBearer() thrown exception"), - EmptyRecords(400, "Records cannot be empty"), - InvalidTable(400, "Table name is missing"), - InvalidId(400, "Skyflow id is missing"), - InvalidFields(400, "Fields are missing"), - InvalidQueryInput(400, "Invalid query input"), - InvalidQuery(400, "Query is missing"), - InvalidSkyflowId(400, "Skyflow id are missing"), - InvalidToken(400, "Token is empty"), - InvalidDetokenizeInput(400, "Invalid Detokenize Input"), - InvalidInsertInput(400, "Invalid insert input"), - InvalidUpdateInput(400, "Invalid update input"), - InvalidDeleteInput(400, "Invalid delete input"), - InvalidGetByIdInput(400, "Invalid getById input"), - InvalidGetInput(400, "Invalid get input"), - MissingIdAndColumnName(400, "Provide either Ids or column name to get records."), - SkyflowIdAndColumnNameBothSpecified(400, "ids and columnName can not be specified together."), - MissingRecordColumnValue(400, "Column Values can not be empty when Column Name is specified."), - MissingRecordColumnName(400, "Column Name can not be empty when Column Values are specified."), - ResponseParsingError(500, "Unable to parse response"), - ThreadInterruptedException(500, "Thread was interrupted"), - ThreadExecutionException(500, "ThreadExecution exception"), - Server(500, "Internal server error"), - ServerReturnedErrors(500, "Server returned errors, check SkyflowException.getData() for more"), - ConnectionURLMissing(400, "connectionURL is required"), - InvalidConnectionURL(400, "Invalid connectionURL"), - MethodNameMissing(400, "methodName is required"), - InvalidMethodName(400, "methodName is invalid"), - InvalidConnectionInput(400, "Invalid connection Input"), - EmptyJSONString(400, "credentials string cannot be empty"), - InvalidJSONStringFormat(400, "credentials string is not a valid json string format"), - EmptyFilePath(400, "file path cannot be empty or null"), - EmptyContext(400, "ctx claim field is missing from the jwt assertion"), - IncorrectRole(400, "Requested scope cannot be granted"), - IncorrectCredentials(400, "Incorrect credentials provided"), - InvalidUpsertOptionType(400, "upsert options should be an non empty UpsertOption array."), - InvalidUpsertObjectType(400, "upsert option cannot be null, should be an UpsertOption object."), - InvalidTableInUpsertOption(400, "Invalid table in upsert object, non empty string is required."), - InvalidColumnInUpsertOption(400, "Invalid column in upsert object, non empty string is required."), - MissingRedaction(400, "Missing Redaction Property"), - TokensGetColumnNotSupported(400,"Interface: get method - column_name or column_values cannot be used with tokens in options."), - RedactionWithTokenNotSupported(400, "Interface: get method - redaction cannot be used when tokens are true in options."), - - BearerTokenExpired(400,"Bearer token is invalid or expired."); - private final int code; - private final String description; - - ErrorCode(int code, String description) { - this.code = code; - this.description = description; - } - - public int getCode() { - return code; - } - - public String getDescription() { - return description; - } -} diff --git a/v1/src/main/java/com/skyflow/errors/SkyflowException.java b/v1/src/main/java/com/skyflow/errors/SkyflowException.java deleted file mode 100644 index 129eb67d..00000000 --- a/v1/src/main/java/com/skyflow/errors/SkyflowException.java +++ /dev/null @@ -1,54 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.errors; - -import org.json.simple.JSONObject; - -public final class SkyflowException extends Exception { - private int code; - private JSONObject data; - - public SkyflowException(ErrorCode errorCode) { - super(errorCode.getDescription()); - this.setCode(errorCode.getCode()); - } - - public SkyflowException(ErrorCode errorCode, Throwable cause) { - super(errorCode.getDescription(), cause); - this.setCode(errorCode.getCode()); - } - - public SkyflowException(int code, String description) { - super(description); - this.setCode(code); - } - - public SkyflowException(int code, String description, Throwable cause) { - super(description, cause); - this.setCode(code); - } - - public SkyflowException(int code, String description, JSONObject data) { - super(description); - this.setCode(code); - setData(data); - } - - public int getCode() { - return code; - } - - void setCode(int code) { - this.code = code; - } - - - public JSONObject getData() { - return data; - } - - void setData(JSONObject data) { - this.data = data; - } -} diff --git a/v1/src/main/java/com/skyflow/logs/DebugLogs.java b/v1/src/main/java/com/skyflow/logs/DebugLogs.java deleted file mode 100644 index 82e636d4..00000000 --- a/v1/src/main/java/com/skyflow/logs/DebugLogs.java +++ /dev/null @@ -1,19 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.logs; - -public enum DebugLogs { - - FormatRequestBodyFormUrlFormEncoded("Formatting request body for form-urlencoded content-type"), - FormatRequestBodyFormData("Formatting request body for form-data content-type"); - private final String log; - - DebugLogs(String log) { - this.log = log; - } - - public String getLog() { - return log; - } -} \ No newline at end of file diff --git a/v1/src/main/java/com/skyflow/logs/ErrorLogs.java b/v1/src/main/java/com/skyflow/logs/ErrorLogs.java deleted file mode 100644 index 2f7c78ff..00000000 --- a/v1/src/main/java/com/skyflow/logs/ErrorLogs.java +++ /dev/null @@ -1,70 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.logs; - -public enum ErrorLogs { - InvalidVaultId("empty or invalid vaultID"), - InvalidVaultURL("invalid vault url"), - InvalidTokenProvider("invalid TokenProvider. TokenProvider cannot be null"), - InvalidInsertInput("invalid insert input"), - InvalidUpdateInput("invalid update input"), - InvalidDeleteInput("invalid delete input"), - InvalidDetokenizeInput("invalid detokenize input"), - InvalidQueryInput("Invalid query input"), - ResponseParsingError("Unable to parse response in %s1 method"), - ThreadInterruptedException("Thread was interrupted in %s1 method"), - ThreadExecutionException("ThreadExecution exception in %s1 method"), - InvalidGetByIdInput("Invalid getById input"), - InvalidGetInput("Invalid get input"), - MissingIdAndColumnName("Provide either Ids or column name to get records."), - SkyflowIdAndColumnNameBothSpecified("ids and columnName can not be specified together."), - MissingRecordColumnValue("Column Values can not be empty when Column Name is specified."), - MissingRecordColumnName("Column Name can not be empty when Column Values are specified."), - InvalidInvokeConnectionInput("Invalid invokeConnection Input"), - ConnectionURLMissing("connectionURL is required"), - InvalidConnectionURL("Invalid connectionURL"), - MethodNameMissing("methodName is required"), - InvalidMethodName("methodName is invalid"), - InvalidKeySpec("Unable to parse RSA private key"), - NoSuchAlgorithm("Invalid algorithm"), - UnableToRetrieveRSA("Unable to retrieve RSA private key"), - UnableToReadResponse("Unable to read response payload"), - InvalidTokenURI("Unable to read tokenURI"), - InvalidKeyID("Unable to read keyID"), - InvalidClientID("Unable to read clientID"), - InvalidCredentialsPath("Unable to open credentials - file %s1"), - InvalidJsonFormat("Provided json file is in wrong format - file %s1"), - EmptyJSONString("credentials string cannot be empty or null"), - EmptyFilePath("file path cannot be empty or null"), - InvalidJSONStringFormat("credentials string is not a valid json string format"), - BearerThrownException("getBearer() thrown exception "), - InvalidBearerToken("Invalid Bearer token"), - InvalidTable("Table name is missing"), - InvalidId("Skyflow id is missing"), - InvalidQuery("Query is missing"), - - Server("Internal server error"), - ServerReturnedErrors("Server returned errors, check SkyflowException.getData() for more"), - InvalidUpsertOptionType("upsert options cannot be null, should be an non empty UpsertOption array."), - InvalidTableInUpsertOption("Invalid table in upsert object, non empty string is required."), - InvalidColumnInUpsertOption("Invalid column in upsert object, non empty string is required."), - InvalidUpsertObjectType("upsert option cannot be null, should be an UpsertOption object."), - InvalidSkyflowId("Skyflow Id is missing"), - InvalidField("Fields missing"), - MissingRedaction("Missing Redaction property."), - TokensGetColumnNotSupported("Interface: get method - column_name or column_values cannot be used with tokens in options."), - RedactionWithTokenNotSupported("Interface: get method - redaction cannot be used when tokens are true in options."), - InvalidToken("Invalid Token value"), - BearerTokenExpired("Bearer token is invalid or expired."); - - private final String log; - - ErrorLogs(String log) { - this.log = log; - } - - public final String getLog() { - return log; - } -} diff --git a/v1/src/main/java/com/skyflow/logs/InfoLogs.java b/v1/src/main/java/com/skyflow/logs/InfoLogs.java deleted file mode 100644 index 33728a3a..00000000 --- a/v1/src/main/java/com/skyflow/logs/InfoLogs.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.logs; - -public enum InfoLogs { - EmptyBearerToken("BearerToken is empty"), - InitializedClient("skyflow client initialized successfully"), - CurrentLogLevel("client LogLevel is %s1"), - LoggerSetup("logger has setup successfully"), - ValidatingSkyflowConfiguration("validating skyflow configuration"), - ValidatedSkyflowConfiguration("validated skyflow configuration in %s1 method"), - ValidatingInvokeConnectionConfig("validating invoke connection configuration"), - InsertMethodCalled("insert method has triggered"), - InsertBulkMethodCalled("insertBulk method has triggered"), - - UpdateMethodCalled("update method has triggered"), - deleteMethodCalled("delete method has triggered"), - ConstructInsertResponse("constructing insert response"), - ConstructUpdateResponse("constructing update response"), - DetokenizeMethodCalled("detokenize method has triggered"), - GetByIdMethodCalled("getById method has triggered"), - GetMethodCalled("get method has triggered"), - InvokeConnectionCalled("invokeConnection method has triggered"), - GenerateBearerTokenCalled("generateBearerToken method has triggered"), - QuerySupportCalled("query method has triggered"), - GenerateBearerTokenFromCredsCalled("generateBearerTokenFromCreds method has triggered"), - ValidatingUpsertOptions("validating upsert options."), - TokenUtilsInstanceCreated("token utils instance created"); - private final String log; - - InfoLogs(String log) { - this.log = log; - } - - public String getLog() { - return log; - } -} diff --git a/v1/src/main/java/com/skyflow/logs/WarnLogs.java b/v1/src/main/java/com/skyflow/logs/WarnLogs.java deleted file mode 100644 index 6a1a3d16..00000000 --- a/v1/src/main/java/com/skyflow/logs/WarnLogs.java +++ /dev/null @@ -1,18 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.logs; - -public enum WarnLogs { - GetTokenDeprecated("GenerateToken method is deprecated, will be removed in future, use generateBearerToken()"), - IsValidDeprecated("isValid method is deprecated, will be removed in future, use isExpired()"); - private final String log; - - WarnLogs(String log) { - this.log = log; - } - - public String getLog() { - return log; - } -} diff --git a/v1/src/main/java/com/skyflow/serviceaccount/util/BearerToken.java b/v1/src/main/java/com/skyflow/serviceaccount/util/BearerToken.java deleted file mode 100644 index a40ec2c2..00000000 --- a/v1/src/main/java/com/skyflow/serviceaccount/util/BearerToken.java +++ /dev/null @@ -1,229 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.serviceaccount.util; - -import com.fasterxml.jackson.databind.ObjectMapper; -import com.skyflow.common.utils.Constants; -import com.skyflow.common.utils.Helpers; -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.common.utils.LogUtil; -import com.skyflow.entities.ResponseToken; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.ErrorLogs; -import com.skyflow.logs.InfoLogs; -import io.jsonwebtoken.Jwts; -import io.jsonwebtoken.SignatureAlgorithm; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; -import java.io.File; -import java.io.FileReader; -import java.io.IOException; -import java.net.URL; -import java.security.PrivateKey; -import java.util.Date; -import java.util.HashMap; -import java.util.Map; -import java.util.Objects; - -public class BearerToken { - private final File credentialsFile; - private final String credentialsString; - private final String ctx; - - private final String[] roles; - - private final String credentialsType; - - private BearerToken(BearerTokenBuilder builder) { - this.credentialsFile = builder.credentialsFile; - this.credentialsString = builder.credentialsString; - this.ctx = builder.ctx; - this.roles = builder.roles; - this.credentialsType = builder.credentialsType; - } - - // Builder class - public static class BearerTokenBuilder { - private File credentialsFile; - private String credentialsString; - private String ctx; - private String[] roles; - - private String credentialsType; - - private void setCredentialsType(String credentialsType) { - this.credentialsType = credentialsType; - } - - public BearerTokenBuilder setCredentials(File credentialsFile) { - setCredentialsType("FILE"); - this.credentialsFile = credentialsFile; - return this; - } - - public BearerTokenBuilder setCredentials(String credentialsString) { - setCredentialsType("STRING"); - this.credentialsString = credentialsString; - return this; - } - - public BearerTokenBuilder setCtx(String ctx) { - this.ctx = ctx; - return this; - } - - public BearerTokenBuilder setRoles(String[] roles) { - this.roles = roles; - return this; - } - - public BearerToken build() { - return new BearerToken(this); - } - } - - public synchronized String getBearerToken() throws SkyflowException { - // Make API call in generateBearerToken function to get the token - ResponseToken response; - String accessToken = null; - - try { - if (this.credentialsFile != null && Objects.equals(this.credentialsType, "FILE")) { - response = generateBearerTokenFromCredentials(this.credentialsFile, this.ctx, this.roles); - accessToken = response.getAccessToken(); - - } else if (this.credentialsString != null && Objects.equals(this.credentialsType, "STRING")) { - response = generateBearerTokenFromCredentialString(this.credentialsString, this.ctx, this.roles); - accessToken = response.getAccessToken(); - } - } catch (SkyflowException e) { - e.printStackTrace(); - } - return accessToken; - } - - private static ResponseToken generateBearerTokenFromCredentials(File credentialsPath, String context, - String[] roles) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.GenerateBearerTokenFromCredsCalled.getLog()); - JSONParser parser = new JSONParser(); - ResponseToken responseToken; - try { - if (credentialsPath == null || !credentialsPath.isFile()) { - LogUtil.printErrorLog(ErrorLogs.EmptyJSONString.getLog()); - throw new SkyflowException(ErrorCode.EmptyJSONString); - } - - Object obj = parser.parse(new FileReader(String.valueOf(credentialsPath))); - JSONObject saCreds = (JSONObject) obj; - - responseToken = getBearerTokenFromCreds(saCreds, context, roles); - - } catch (ParseException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidJSONStringFormat.getLog()); - throw new SkyflowException(ErrorCode.InvalidJSONStringFormat, e); - } catch (IOException e) { - throw new RuntimeException(e); - } - - return responseToken; - } - - private static ResponseToken generateBearerTokenFromCredentialString(String credentials, String context, - String[] roles) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.GenerateBearerTokenFromCredsCalled.getLog()); - JSONParser parser = new JSONParser(); - ResponseToken responseToken; - try { - if (credentials == null || credentials.isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.EmptyJSONString.getLog()); - throw new SkyflowException(ErrorCode.EmptyJSONString); - } - - Object obj = parser.parse(credentials); - JSONObject saCreds = (JSONObject) obj; - - responseToken = getBearerTokenFromCreds(saCreds, context, roles); - - } catch (ParseException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidJSONStringFormat.getLog()); - throw new SkyflowException(ErrorCode.InvalidJSONStringFormat, e); - } - return responseToken; - } - - private static ResponseToken getBearerTokenFromCreds(JSONObject creds, String context, String[] roles) - throws SkyflowException { - ResponseToken responseToken; - try { - String clientID = (String) creds.get("clientID"); - if (clientID == null) { - LogUtil.printErrorLog(ErrorLogs.InvalidClientID.getLog()); - throw new SkyflowException(ErrorCode.InvalidClientID); - } - String keyID = (String) creds.get("keyID"); - if (keyID == null) { - LogUtil.printErrorLog(ErrorLogs.InvalidKeyID.getLog()); - throw new SkyflowException(ErrorCode.InvalidKeyID); - } - String tokenURI = (String) creds.get("tokenURI"); - if (tokenURI == null) { - LogUtil.printErrorLog(ErrorLogs.InvalidTokenURI.getLog()); - throw new SkyflowException(ErrorCode.InvalidTokenURI); - } - - PrivateKey pvtKey = Helpers.getPrivateKeyFromPem((String) creds.get("privateKey")); - - String signedUserJWT = getSignedToken(clientID, keyID, tokenURI, pvtKey, context); - - Map headers = new HashMap<>(); - headers.put(Constants.SDK_METRICS_HEADER_KEY, Helpers.getMetrics().toJSONString()); - - JSONObject parameters = new JSONObject(); - parameters.put("grant_type", "urn:ietf:params:oauth:grant-type:jwt-bearer"); - parameters.put("assertion", signedUserJWT); - if (roles != null) { - String scopedRoles = getScopeUsingRoles(roles); - parameters.put("scope", scopedRoles); - } - - String response = HttpUtility.sendRequest("POST", new URL(tokenURI), parameters, headers); - - responseToken = new ObjectMapper().readValue(response, ResponseToken.class); - - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.UnableToReadResponse.getLog()); - throw new SkyflowException(ErrorCode.UnableToReadResponse, e); - } - - return responseToken; - } - - private static String getSignedToken(String clientID, String keyID, String tokenURI, PrivateKey pvtKey, - String context) { - final Date createdDate = new Date(); - final Date expirationDate = new Date(createdDate.getTime() + (3600 * 1000)); - - return Jwts.builder() - .claim("iss", clientID) - .claim("key", keyID) - .claim("aud", tokenURI) - .claim("sub", clientID) - .claim("ctx", context) - .setExpiration(expirationDate) - .signWith(SignatureAlgorithm.RS256, pvtKey) - .compact(); - } - - private static String getScopeUsingRoles(String[] roles) { - StringBuilder scope = new StringBuilder(); - if (roles != null) { - for (String role : roles) { - scope.append(" role:").append(role); - } - } - return scope.toString(); - } -} diff --git a/v1/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokenResponse.java b/v1/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokenResponse.java deleted file mode 100644 index ed05e541..00000000 --- a/v1/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokenResponse.java +++ /dev/null @@ -1,20 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.serviceaccount.util; - -public class SignedDataTokenResponse { - String dataToken; - String signedDataToken; - - public SignedDataTokenResponse(String dataToken, String signedDataToken) { - this.dataToken = dataToken; - this.signedDataToken = signedDataToken; - } - - @Override - public String toString() { - return "{" + "dataToken: " + dataToken + "," + "signedDataToken: " + signedDataToken + "}"; - - } -} diff --git a/v1/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java b/v1/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java deleted file mode 100644 index d31c5b85..00000000 --- a/v1/src/main/java/com/skyflow/serviceaccount/util/SignedDataTokens.java +++ /dev/null @@ -1,224 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.serviceaccount.util; - -import com.skyflow.common.utils.Helpers; -import com.skyflow.common.utils.LogUtil; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.ErrorLogs; -import com.skyflow.logs.InfoLogs; -import io.jsonwebtoken.Jwts; -import io.jsonwebtoken.SignatureAlgorithm; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; - -import java.io.File; -import java.io.FileReader; -import java.io.IOException; -import java.security.PrivateKey; -import java.util.ArrayList; -import java.util.Date; -import java.util.List; -import java.util.Objects; - -public class SignedDataTokens { - private final File credentialsFile; - private final String credentialsString; - private final String ctx; - - private final String[] dataTokens; - private final Integer timeToLive; - - private final String credentialsType; - - private SignedDataTokens(SignedDataTokensBuilder builder) { - this.credentialsFile = builder.credentialsFile; - this.credentialsString = builder.credentialsString; - this.ctx = builder.ctx; - this.timeToLive = builder.timeToLive; - this.dataTokens = builder.dataTokens; - this.credentialsType = builder.credentialsType; - } - - // Builder class - public static class SignedDataTokensBuilder { - private File credentialsFile; - private String credentialsString; - private String ctx; - - private String[] dataTokens; - private Integer timeToLive; - - private String credentialsType; - - private void setCredentialsType(String credentialsType) { - this.credentialsType = credentialsType; - } - - public SignedDataTokensBuilder setCredentials(File credentialsFile) { - setCredentialsType("FILE"); - this.credentialsFile = credentialsFile; - return this; - } - - public SignedDataTokensBuilder setCredentials(String credentialsString) { - setCredentialsType("STRING"); - this.credentialsString = credentialsString; - return this; - } - - public SignedDataTokensBuilder setCtx(String ctx) { - this.ctx = ctx; - return this; - } - - public SignedDataTokensBuilder setDataTokens(String[] dataTokens) { - this.dataTokens = dataTokens; - return this; - } - - public SignedDataTokensBuilder setTimeToLive(Integer timeToLive) { - this.timeToLive = timeToLive; - return this; - } - - public SignedDataTokens build() { - return new SignedDataTokens(this); - } - } - - public synchronized List getSignedDataTokens() throws SkyflowException { - List signedToken = new ArrayList<>(); - - try { - if (this.credentialsFile != null && Objects.equals(this.credentialsType, "FILE")) { - signedToken = generateSignedTokens(this.credentialsFile, this.dataTokens, this.timeToLive, - this.ctx); - } else if (this.credentialsString != null && Objects.equals(this.credentialsType, "STRING")) { - signedToken = generateSignedTokensFromCredentialsString(this.credentialsString, this.dataTokens, - this.timeToLive, this.ctx); - - } - } catch (SkyflowException e) { - e.printStackTrace(); - } - return signedToken; - } - - private static List generateSignedTokens(File credentialsPath, String[] dataTokens, - Integer timeToLive, String context) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.GenerateBearerTokenFromCredsCalled.getLog()); - JSONParser parser = new JSONParser(); - List responseToken; - - try { - if (credentialsPath == null || !credentialsPath.isFile()) { - LogUtil.printErrorLog(ErrorLogs.EmptyJSONString.getLog()); - throw new SkyflowException(ErrorCode.EmptyJSONString); - } - - Object obj = parser.parse(new FileReader(String.valueOf(credentialsPath))); - JSONObject saCreds = (JSONObject) obj; - - responseToken = getSignedTokenFromCredsFile(saCreds, dataTokens, timeToLive, context); - - } catch (ParseException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidJSONStringFormat.getLog()); - throw new SkyflowException(ErrorCode.InvalidJSONStringFormat, e); - } catch (IOException e) { - throw new RuntimeException(e); - } - - return responseToken; - } - - private static List generateSignedTokensFromCredentialsString(String credentials, - String[] dataTokens, Integer timeToLive, String context) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.GenerateBearerTokenFromCredsCalled.getLog()); - JSONParser parser = new JSONParser(); - List responseToken; - LogUtil.printInfoLog(InfoLogs.GenerateBearerTokenFromCredsCalled.getLog()); - - try { - if (credentials == null || credentials.isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.EmptyJSONString.getLog()); - throw new SkyflowException(ErrorCode.EmptyJSONString); - } - - Object obj = parser.parse(credentials); - JSONObject saCreds = (JSONObject) obj; - - responseToken = getSignedTokenFromCredsFile(saCreds, dataTokens, timeToLive, context); - - } catch (ParseException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidJSONStringFormat.getLog()); - throw new SkyflowException(ErrorCode.InvalidJSONStringFormat, e); - } - - return responseToken; - } - - private static List getSignedTokenFromCredsFile(JSONObject creds, String[] dataTokens, - Integer timeToLive, String context) throws SkyflowException { - List responseToken; - - try { - String clientID = (String) creds.get("clientID"); - if (clientID == null) { - LogUtil.printErrorLog(ErrorLogs.InvalidClientID.getLog()); - throw new SkyflowException(ErrorCode.InvalidClientID); - } - String keyID = (String) creds.get("keyID"); - if (keyID == null) { - LogUtil.printErrorLog(ErrorLogs.InvalidKeyID.getLog()); - throw new SkyflowException(ErrorCode.InvalidKeyID); - } - - PrivateKey pvtKey = Helpers.getPrivateKeyFromPem((String) creds.get("privateKey")); - - responseToken = getSignedToken(clientID, keyID, pvtKey, dataTokens, timeToLive, context); - - } catch (RuntimeException e) { - throw new SkyflowException(ErrorCode.IncorrectCredentials, e); - } - - return responseToken; - } - - private static List getSignedToken(String clientID, String keyID, PrivateKey pvtKey, - String[] dataTokens, Integer timeToLive, String context) { - final Date createdDate = new Date(); - final Date expirationDate; - - if (timeToLive != null) { - expirationDate = new Date(createdDate.getTime() + (timeToLive * 1000)); - } else { - expirationDate = new Date(createdDate.getTime() + 60000); // Valid for 60 seconds - } - - List list = new ArrayList<>(); - String prefix = "signed_token_"; - for (String dataToken : dataTokens) { - - String eachSignedDataToken = Jwts.builder() - .claim("iss", "sdk") - .claim("iat", (createdDate.getTime()/1000)) - .claim("key", keyID) - .claim("sub", clientID) - .claim("ctx", context) - .claim("tok", dataToken) - .setExpiration(expirationDate) - .signWith(SignatureAlgorithm.RS256, pvtKey) - .compact(); - - SignedDataTokenResponse responseObject = new SignedDataTokenResponse(dataToken, - prefix + eachSignedDataToken); - - list.add(responseObject); - } - return list; - } -} diff --git a/v1/src/main/java/com/skyflow/serviceaccount/util/Token.java b/v1/src/main/java/com/skyflow/serviceaccount/util/Token.java deleted file mode 100644 index 42155e27..00000000 --- a/v1/src/main/java/com/skyflow/serviceaccount/util/Token.java +++ /dev/null @@ -1,231 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.serviceaccount.util; - -import com.fasterxml.jackson.core.JsonParseException; -import com.fasterxml.jackson.databind.JsonMappingException; -import com.fasterxml.jackson.databind.ObjectMapper; -import com.skyflow.common.utils.*; -import com.skyflow.entities.ResponseToken; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.ErrorLogs; -import com.skyflow.logs.InfoLogs; -import com.skyflow.logs.WarnLogs; -import io.jsonwebtoken.Jwts; -import io.jsonwebtoken.SignatureAlgorithm; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; - -import java.io.FileNotFoundException; -import java.io.FileReader; -import java.io.IOException; -import java.net.URL; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.security.PrivateKey; -import java.util.Date; -import java.util.HashMap; -import java.util.Map; - -public final class Token { - - /** - * @param filepath - * @deprecated use generateBearerToken(string filepath), GenerateToken will be removed in future - */ - @Deprecated - public static ResponseToken GenerateToken(String filepath) throws SkyflowException { - LogUtil.printWarningLog(WarnLogs.GetTokenDeprecated.getLog()); - return generateBearerToken(filepath); - } - - /** - * Generates a Bearer Token from the given Service Account Credential file with a default timeout of 60minutes. - * - * @param filepath - */ - public static ResponseToken generateBearerToken(String filepath) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.GenerateBearerTokenCalled.getLog()); - JSONParser parser = new JSONParser(); - ResponseToken responseToken = null; - Path path = null; - try { - if (filepath == null || filepath.isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.EmptyFilePath.getLog()); - throw new SkyflowException(ErrorCode.EmptyFilePath); - } - path = Paths.get((filepath)); - Object obj = parser.parse(new FileReader(String.valueOf(path))); - JSONObject saCreds = (JSONObject) obj; - - responseToken = getSATokenFromCredsFile(saCreds); - - } catch (FileNotFoundException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.InvalidCredentialsPath.getLog(), String.valueOf(path))); - throw new SkyflowException(ErrorCode.InvalidCredentialsPath.getCode(), Helpers.parameterizedString(ErrorCode.InvalidCredentialsPath.getDescription(), String.valueOf(path)), e); - } catch (IOException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.InvalidCredentialsPath.getLog(), String.valueOf(path))); - throw new SkyflowException(ErrorCode.InvalidCredentialsPath.getCode(), Helpers.parameterizedString(ErrorCode.InvalidCredentialsPath.getDescription(), String.valueOf(path)), e); - } catch (ParseException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.InvalidJsonFormat.getLog(), String.valueOf(path))); - throw new SkyflowException(ErrorCode.InvalidJsonFormat.getCode(), Helpers.parameterizedString(ErrorCode.InvalidJsonFormat.getDescription(), String.valueOf(path)), e); - } - - return responseToken; - } - - /** - * Generates a Bearer Token from the given Service Account Credential json string with a default timeout of 60minutes. - * - * @param credentials JSON string of credentials file - */ - - public static ResponseToken generateBearerTokenFromCreds(String credentials) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.GenerateBearerTokenFromCredsCalled.getLog()); - JSONParser parser = new JSONParser(); - ResponseToken responseToken = null; - try { - if (credentials == null || credentials.isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.EmptyJSONString.getLog()); - throw new SkyflowException(ErrorCode.EmptyJSONString); - } - - Object obj = parser.parse(credentials); - JSONObject saCreds = (JSONObject) obj; - - responseToken = getSATokenFromCredsFile(saCreds); - - } catch (ParseException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidJSONStringFormat.getLog()); - throw new SkyflowException(ErrorCode.InvalidJSONStringFormat, e); - } - - return responseToken; - } - - /** - * getSATokenFromCredsFile gets bearer token from service account endpoint - * - * @param creds - */ - private static ResponseToken getSATokenFromCredsFile(JSONObject creds) throws SkyflowException { - ResponseToken responseToken = null; - try { - String clientID = (String) creds.get("clientID"); - if (clientID == null) { - LogUtil.printErrorLog(ErrorLogs.InvalidClientID.getLog()); - throw new SkyflowException(ErrorCode.InvalidClientID); - } - String keyID = (String) creds.get("keyID"); - if (keyID == null) { - LogUtil.printErrorLog(ErrorLogs.InvalidKeyID.getLog()); - throw new SkyflowException(ErrorCode.InvalidKeyID); - } - String tokenURI = (String) creds.get("tokenURI"); - if (tokenURI == null) { - LogUtil.printErrorLog(ErrorLogs.InvalidTokenURI.getLog()); - throw new SkyflowException(ErrorCode.InvalidTokenURI); - } - Map headers = new HashMap<>(); - headers.put(Constants.SDK_METRICS_HEADER_KEY, Helpers.getMetrics().toJSONString()); - - PrivateKey pvtKey = Helpers.getPrivateKeyFromPem((String) creds.get("privateKey")); - - String signedUserJWT = getSignedUserToken(clientID, keyID, tokenURI, pvtKey); - - JSONObject parameters = new JSONObject(); - parameters.put("grant_type", "urn:ietf:params:oauth:grant-type:jwt-bearer"); - parameters.put("assertion", signedUserJWT); - - String response = HttpUtility.sendRequest("POST", new URL(tokenURI), parameters, headers); - - responseToken = new ObjectMapper().readValue(response, ResponseToken.class); - - } catch (JsonMappingException e) { - LogUtil.printErrorLog(ErrorLogs.UnableToReadResponse.getLog()); - throw new SkyflowException(ErrorCode.UnableToReadResponse, e); - } catch (JsonParseException e) { - LogUtil.printErrorLog(ErrorLogs.UnableToReadResponse.getLog()); - throw new SkyflowException(ErrorCode.UnableToReadResponse, e); - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.UnableToReadResponse.getLog()); - throw new SkyflowException(ErrorCode.UnableToReadResponse, e); - } - - return responseToken; - } -// /** -// * Create a PrivateKey instance from raw PKCS#1 bytes. -// */ -// private static PrivateKey parsePkcs1PrivateKey(byte[] pkcs1Bytes) throws SkyflowException { -// int pkcs1Length = pkcs1Bytes.length; -// int totalLength = pkcs1Length + 22; -// byte[] pkcs8Header = new byte[]{ -// 0x30, (byte) 0x82, (byte) ((totalLength >> 8) & 0xff), (byte) (totalLength & 0xff), // Sequence + total length -// 0x2, 0x1, 0x0, // Integer (0) -// 0x30, 0xD, 0x6, 0x9, 0x2A, (byte) 0x86, 0x48, (byte) 0x86, (byte) 0xF7, 0xD, 0x1, 0x1, 0x1, 0x5, 0x0, // Sequence: 1.2.840.113549.1.1.1, NULL -// 0x4, (byte) 0x82, (byte) ((pkcs1Length >> 8) & 0xff), (byte) (pkcs1Length & 0xff) // Octet string + length -// }; -// byte[] pkcs8bytes = joinBytes(pkcs8Header, pkcs1Bytes); -// return parsePkcs8PrivateKey(pkcs8bytes); -// } -// -// private static byte[] joinBytes(byte[] a, byte[] b) { -// byte[] bytes = new byte[a.length + b.length]; -// System.arraycopy(a, 0, bytes, 0, a.length); -// System.arraycopy(b, 0, bytes, a.length, b.length); -// return bytes; -// } - - private static String getSignedUserToken(String clientID, String keyID, String tokenURI, PrivateKey pvtKey) { - final Date createdDate = new Date(); - final Date expirationDate = new Date(createdDate.getTime() + (3600 * 1000)); - String signedToken = Jwts.builder() - .claim("iss", clientID) - .claim("key", keyID) - .claim("aud", tokenURI) - .claim("sub", clientID) - .setExpiration(expirationDate) - .signWith(SignatureAlgorithm.RS256, pvtKey) - .compact(); - - return signedToken; - } - - /** - * @param token - * @deprecated use isExpired(String token), isValid will be removed in future - */ - @Deprecated - public static boolean isValid(String token) { - LogUtil.printWarningLog(WarnLogs.IsValidDeprecated.getLog()); - return !isExpired(token); - } - - public static boolean isExpired(String token) { - - long expiryTime; - long currentTime; - try { - if (token == null || token.isEmpty()) { - LogUtil.printInfoLog(InfoLogs.EmptyBearerToken.getLog()); - return true; - } - - currentTime = new Date().getTime() / 1000; - expiryTime = (long) TokenUtils.decoded(token).get("exp"); - - } catch (ParseException e) { - LogUtil.printInfoLog(ErrorLogs.InvalidBearerToken.getLog()); - return true; - } catch (SkyflowException e) { - LogUtil.printInfoLog(ErrorLogs.InvalidBearerToken.getLog()); - return true; - } - return currentTime > expiryTime; - } -} - diff --git a/v1/src/main/java/com/skyflow/vault/DeleteBySkyflowId.java b/v1/src/main/java/com/skyflow/vault/DeleteBySkyflowId.java deleted file mode 100644 index 3d38787f..00000000 --- a/v1/src/main/java/com/skyflow/vault/DeleteBySkyflowId.java +++ /dev/null @@ -1,94 +0,0 @@ -package com.skyflow.vault; - -import com.skyflow.common.utils.Helpers; -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.common.utils.LogUtil; -import com.skyflow.common.utils.Validators; -import com.skyflow.entities.DeleteOptions; -import com.skyflow.entities.DeleteRecordInput; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.ErrorLogs; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; - -import java.io.IOException; -import java.net.URL; -import java.util.Map; -import java.util.concurrent.Callable; - -public class DeleteBySkyflowId implements Callable { - private final DeleteRecordInput recordInput; - private final String vaultID; - private final String vaultURL; - private final Map headers; - private final DeleteOptions deleteOptions; - - public DeleteBySkyflowId(DeleteRecordInput recordInput, String vaultID, String vaultURL, Map headers, DeleteOptions deleteOptions) { - this.recordInput = recordInput; - this.vaultID = vaultID; - this.vaultURL = vaultURL; - this.headers = headers; - this.deleteOptions = deleteOptions; - } - - - @Override - public String call() throws SkyflowException { - String response = null; - try { - Validators.validateDeleteBySkyflowId(recordInput); - String url = vaultURL+ "/v1/vaults/"+ vaultID + "/" + recordInput.getTable() + "/" + recordInput.getId(); - response = HttpUtility.sendRequest("DELETE", new URL(url), null,headers); - JSONObject formattedResponse = new JSONObject(); - JSONArray formattedRecords = new JSONArray(); - - JSONObject responseRecords = ((JSONObject) (new JSONParser().parse(response))); - if (responseRecords != null && responseRecords.size() > 0) { - String id = (String) responseRecords.get("skyflow_id"); - JSONObject formattedRecord = new JSONObject(); - formattedRecord.put("skyflow_id", responseRecords.get("skyflow_id")); - formattedRecord.put("deleted", responseRecords.get("deleted")); - formattedRecords.add(formattedRecord); - } - formattedResponse.put("records", formattedRecords); - response = formattedResponse.toJSONString(); - - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.Server.getLog()); - throw new SkyflowException(ErrorCode.Server, e); - } catch (ParseException e) { - LogUtil.printErrorLog(ErrorLogs.ResponseParsingError.getLog()); - throw new SkyflowException(ErrorCode.ResponseParsingError, e); - } catch (SkyflowException e) { - response = constructDeleteByIdErrorObject(e, recordInput.getId()); - } - return response; - } - private String constructDeleteByIdErrorObject(SkyflowException skyflowException, String id){ - String deleteByIdResponse = null; - JSONObject finalResponseError = new JSONObject(); - finalResponseError.put("id", id); - try{ - JSONObject errorObject = (JSONObject) ((JSONObject) new JSONParser().parse(skyflowException.getMessage())).get("error"); - if (errorObject != null) { - JSONObject responseError = new JSONObject(); - responseError.put("code", errorObject.get("http_code")); - responseError.put("description", errorObject.get("message")); - finalResponseError.put("error", responseError); - - deleteByIdResponse = finalResponseError.toString(); - } - - } catch (ParseException e){ - JSONObject responseError = new JSONObject(); - responseError.put("code", skyflowException.getCode()); - responseError.put("description", skyflowException.getMessage()); - finalResponseError.put("error", responseError); - deleteByIdResponse = finalResponseError.toString(); - } - return deleteByIdResponse; - } -} diff --git a/v1/src/main/java/com/skyflow/vault/Detokenize.java b/v1/src/main/java/com/skyflow/vault/Detokenize.java deleted file mode 100644 index da0baec4..00000000 --- a/v1/src/main/java/com/skyflow/vault/Detokenize.java +++ /dev/null @@ -1,102 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.vault; - -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.common.utils.LogUtil; -import com.skyflow.entities.DetokenizeRecord; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.ErrorLogs; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; - -import java.io.IOException; -import java.net.URL; -import java.util.Map; -import java.util.concurrent.Callable; - -final class Detokenize implements Callable { - private final DetokenizeRecord record; - private final String endPointURL; - private final Map headers; - - public Detokenize(DetokenizeRecord record, String endPointURL, Map headers) { - this.record = record; - this.endPointURL = endPointURL; - this.headers = headers; - } - - @Override - public String call() throws SkyflowException { - String response = null; - - try { - if (record.getToken() == null || record.getToken().isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.InvalidToken.getLog()); - throw new SkyflowException(ErrorCode.InvalidToken); - } else if (record.getRedaction() == null || record.getRedaction().toString().isEmpty()) { - LogUtil.printErrorLog(ErrorLogs.InvalidDetokenizeInput.getLog()); - throw new SkyflowException(ErrorCode.InvalidDetokenizeInput); - } - - JSONObject bodyJson = new JSONObject(); - JSONArray detokenizationParameters = new JSONArray(); - JSONObject parameterObject = new JSONObject(); - parameterObject.put("token", record.getToken()); - parameterObject.put("redaction", record.getRedaction().toString()); - detokenizationParameters.add(parameterObject); - bodyJson.put("detokenizationParameters", detokenizationParameters); - - String apiResponse = HttpUtility.sendRequest("POST", new URL(endPointURL), bodyJson, headers); - JSONParser parser = new JSONParser(); - JSONObject responseJson = (JSONObject) parser.parse(apiResponse); - JSONArray responseRecords = (JSONArray) responseJson.get("records"); - JSONObject responseObject = (JSONObject) responseRecords.get(0); - JSONObject formattedResponseJson = new JSONObject(); - formattedResponseJson.put("value", responseObject.get("value")); - formattedResponseJson.put("token", responseObject.get("token")); - response = formattedResponseJson.toJSONString(); - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.Server.getLog()); - throw new SkyflowException(ErrorCode.Server, e); - } catch (ParseException e) { - LogUtil.printErrorLog(ErrorLogs.ResponseParsingError.getLog()); - throw new SkyflowException(ErrorCode.ResponseParsingError, e); - } catch (SkyflowException exception) { - response = parseDetokenizeError(exception); - } - return response; - } - - private String parseDetokenizeError(SkyflowException exception) { - String errorResponse = null; - String exceptionMessage = exception.getMessage(); - int exceptionCode = exception.getCode(); - JSONObject errorObject = new JSONObject(); - errorObject.put("token", record.getToken()); - JSONObject errorData = new JSONObject(); - - try { - JSONParser parser = new JSONParser(); - JSONObject errorJson = (JSONObject) parser.parse(exceptionMessage); - JSONObject error = (JSONObject) errorJson.get("error"); - if (error != null) { - errorData.put("code", error.get("http_code")); - errorData.put("description", error.get("message")); - errorObject.put("error", errorData); - errorResponse = errorObject.toJSONString(); - } - } catch (ParseException e) { - errorData.put("code", exceptionCode); - errorData.put("description", exceptionMessage); - errorObject.put("error", errorData); - errorResponse = errorObject.toJSONString(); - } - - return errorResponse; - } -} diff --git a/v1/src/main/java/com/skyflow/vault/Get.java b/v1/src/main/java/com/skyflow/vault/Get.java deleted file mode 100644 index 5951c275..00000000 --- a/v1/src/main/java/com/skyflow/vault/Get.java +++ /dev/null @@ -1,138 +0,0 @@ -package com.skyflow.vault; - -import com.skyflow.common.utils.Helpers; -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.common.utils.LogUtil; -import com.skyflow.common.utils.Validators; -import com.skyflow.entities.GetOptions; -import com.skyflow.entities.GetRecordInput; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.ErrorLogs; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; - -import java.io.IOException; -import java.net.URL; -import java.util.Collections; -import java.util.Map; -import java.util.concurrent.Callable; - -public final class Get implements Callable { - private final GetRecordInput record; - private final String vaultID; - private final String vaultURL; - private final Map headers; - - private final GetOptions getOptions; - - public Get(GetRecordInput record, String vaultID, String vaultURL, Map headers, GetOptions getOptions) { - this.record = record; - this.vaultID = vaultID; - this.vaultURL = vaultURL; - this.headers = headers; - this.getOptions = getOptions; - } - - @Override - public String call() throws Exception { - String response = null; - try { - Validators.validateGetRequestRecord(record, getOptions); - StringBuilder paramsList = Helpers.constructGetRequestURLParams(record, getOptions); - - String url = vaultURL + "/v1/vaults/" + vaultID + "/" + record.getTable() + "?" + paramsList; - - response = HttpUtility.sendRequest("GET", new URL(url), null, headers); - - JSONObject formattedResponse = new JSONObject(); - JSONArray formattedRecords = new JSONArray(); - - JSONArray responseRecords = (JSONArray) ((JSONObject) (new JSONParser().parse(response))).get("records"); - if (responseRecords != null && responseRecords.size() > 0) { - for (Object responseRecord : responseRecords) { - JSONObject fields = (JSONObject) ((JSONObject) responseRecord).get("fields"); - String id = (String) fields.get("skyflow_id"); - fields.remove("skyflow_id"); - fields.put("id", id); - - JSONObject formattedRecord = new JSONObject(); - formattedRecord.put("fields", fields); - formattedRecord.put("table", record.getTable()); - formattedRecords.add(formattedRecord); - } - formattedResponse.put("records", formattedRecords); - - response = formattedResponse.toJSONString(); - } - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.Server.getLog()); - throw new SkyflowException(ErrorCode.Server, e); - } - catch (ParseException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ResponseParsingError.getLog(), "get")); - throw new SkyflowException(ErrorCode.ResponseParsingError, e); - } catch (SkyflowException e) { - response = record.getIds() == null - ? constructGetErrorObject(e, record.getColumnName()) - : constructGetErrorObject(e, record.getIds()); - } - - return response; - } - - private String constructGetErrorObject(SkyflowException skyflowException, String[] ids) { - String getResponse = null; - JSONObject finalResponseError = new JSONObject(); - - try { - JSONObject errorObject = (JSONObject) ((JSONObject) new JSONParser().parse(skyflowException.getMessage())).get("error"); - if (errorObject != null) { - JSONObject responseError = new JSONObject(); - responseError.put("code", errorObject.get("http_code")); - responseError.put("description", errorObject.get("message")); - finalResponseError.put("error", responseError); - - JSONArray idsArray = new JSONArray(); - Collections.addAll(idsArray, ids); - finalResponseError.put("ids", idsArray); - - getResponse = finalResponseError.toString(); - } - } catch (ParseException e) { - JSONObject responseError = new JSONObject(); - responseError.put("code", skyflowException.getCode()); - responseError.put("description", skyflowException.getMessage()); - finalResponseError.put("error", responseError); - getResponse = finalResponseError.toString(); - } - return getResponse; - } - - private String constructGetErrorObject(SkyflowException skyflowException, String columnName) { - String getResponse = null; - JSONObject finalResponseError = new JSONObject(); - - try { - JSONObject errorObject = (JSONObject) ((JSONObject) new JSONParser().parse(skyflowException.getMessage())).get("error"); - if (errorObject != null) { - JSONObject responseError = new JSONObject(); - responseError.put("code", errorObject.get("http_code")); - responseError.put("description", errorObject.get("message")); - finalResponseError.put("error", responseError); - finalResponseError.put("columnName", columnName); - - getResponse = finalResponseError.toString(); - } - } catch (ParseException e) { - JSONObject responseError = new JSONObject(); - responseError.put("code", skyflowException.getCode()); - responseError.put("description", skyflowException.getMessage()); - finalResponseError.put("error", responseError); - getResponse = finalResponseError.toString(); - } - return getResponse; - } -} diff --git a/v1/src/main/java/com/skyflow/vault/GetBySkyflowId.java b/v1/src/main/java/com/skyflow/vault/GetBySkyflowId.java deleted file mode 100644 index 370d1f8f..00000000 --- a/v1/src/main/java/com/skyflow/vault/GetBySkyflowId.java +++ /dev/null @@ -1,110 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.vault; - -import com.skyflow.common.utils.Helpers; -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.common.utils.LogUtil; -import com.skyflow.common.utils.Validators; -import com.skyflow.entities.GetByIdRecordInput; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.ErrorLogs; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; - -import java.io.IOException; -import java.net.URL; -import java.util.Collections; -import java.util.Map; -import java.util.concurrent.Callable; - -final class GetBySkyflowId implements Callable { - - private final GetByIdRecordInput record; - private final Map headers; - private final String vaultID; - private final String vaultURL; - - GetBySkyflowId(GetByIdRecordInput record, String vaultID, String vaultURL, Map headers) { - this.record = record; - this.vaultID = vaultID; - this.vaultURL = vaultURL; - this.headers = headers; - } - - @Override - public String call() throws SkyflowException { - String response = null; - try { - Validators.validateGetByIdRequestRecord(record); - StringBuilder paramsList = Helpers.constructGetByIdRequestURLParams(record); - - String url = vaultURL + "/v1/vaults/" + vaultID + "/" + record.getTable() + "?" + paramsList; - - response = HttpUtility.sendRequest("GET", new URL(url), null, headers); - - JSONObject formattedResponse = new JSONObject(); - JSONArray formattedRecords = new JSONArray(); - - JSONArray responseRecords = (JSONArray) ((JSONObject) (new JSONParser().parse(response))).get("records"); - if (responseRecords != null && responseRecords.size() > 0) { - for (Object responseRecord : responseRecords) { - JSONObject fields = (JSONObject) ((JSONObject) responseRecord).get("fields"); - String id = (String) fields.get("skyflow_id"); - fields.remove("skyflow_id"); - fields.put("id", id); - - JSONObject formattedRecord = new JSONObject(); - formattedRecord.put("fields", fields); - formattedRecord.put("table", record.getTable()); - formattedRecords.add(formattedRecord); - } - formattedResponse.put("records", formattedRecords); - - response = formattedResponse.toJSONString(); - } - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.Server.getLog()); - throw new SkyflowException(ErrorCode.Server, e); - } catch (ParseException e) { - LogUtil.printErrorLog(ErrorLogs.ResponseParsingError.getLog()); - throw new SkyflowException(ErrorCode.ResponseParsingError, e); - } catch (SkyflowException e) { - response = constructGetByIdErrorObject(e, record.getIds()); - } - - return response; - } - - private String constructGetByIdErrorObject(SkyflowException skyflowException, String[] ids) { - String getByIdResponse = null; - JSONObject finalResponseError = new JSONObject(); - - try { - JSONArray idsArray = new JSONArray(); - Collections.addAll(idsArray, ids); - finalResponseError.put("ids", idsArray); - - JSONObject errorObject = (JSONObject) ((JSONObject) new JSONParser().parse(skyflowException.getMessage())).get("error"); - if (errorObject != null) { - JSONObject responseError = new JSONObject(); - responseError.put("code", errorObject.get("http_code")); - responseError.put("description", errorObject.get("message")); - finalResponseError.put("error", responseError); - - getByIdResponse = finalResponseError.toString(); - } - } catch (ParseException e) { - JSONObject responseError = new JSONObject(); - responseError.put("code", skyflowException.getCode()); - responseError.put("description", skyflowException.getMessage()); - finalResponseError.put("error", responseError); - getByIdResponse = finalResponseError.toString(); - } - return getByIdResponse; - } -} diff --git a/v1/src/main/java/com/skyflow/vault/Insert.java b/v1/src/main/java/com/skyflow/vault/Insert.java deleted file mode 100644 index 94435ee9..00000000 --- a/v1/src/main/java/com/skyflow/vault/Insert.java +++ /dev/null @@ -1,120 +0,0 @@ -package com.skyflow.vault; - -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.common.utils.LogUtil; -import com.skyflow.entities.InsertBulkOptions; -import com.skyflow.entities.InsertRecordInput; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.ErrorLogs; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; - -import java.io.IOException; -import java.net.URL; -import java.util.Map; -import java.util.concurrent.Callable; - -import static com.skyflow.common.utils.Helpers.getUpsertColumn; - -public final class Insert implements Callable { - private final InsertRecordInput record; - private final String vaultID; - private final String vaultURL; - private final Map headers; - - private final InsertBulkOptions insertOptions; - private final int requestIndex; - - public Insert(InsertRecordInput record, String vaultID, String vaultURL, Map headers, InsertBulkOptions insertOptions, int requestIndex) { - this.record = record; - this.vaultID = vaultID; - this.vaultURL = vaultURL; - this.headers = headers; - this.insertOptions = insertOptions; - this.requestIndex = requestIndex; - } - - @Override - public String call() throws Exception{ - String response = null; - try { - String url = vaultURL+ "/v1/vaults/" +vaultID+"/"+ record.getTable(); - - JSONObject jsonBody = new JSONObject(); - JSONArray insertArray = new JSONArray(); - JSONObject recordObject = new JSONObject(); - recordObject.put("fields", record.getFields()); - - if (insertOptions.getUpsertOptions() != null) - jsonBody.put("upsert", getUpsertColumn(record.getTable(), insertOptions.getUpsertOptions())); - - insertArray.add(recordObject); - jsonBody.put("records", insertArray); - jsonBody.put("tokenization", insertOptions.isTokens()); - response = HttpUtility.sendRequest("POST", new URL(url), jsonBody, headers); - - JSONParser parser = new JSONParser(); - JSONObject responseJson = (JSONObject) parser.parse(response); - JSONArray responseRecords = (JSONArray) responseJson.get("records"); - JSONObject responseObject = (JSONObject) responseRecords.get(0); - JSONObject formattedResponseJson = new JSONObject(); - formattedResponseJson.put("table", record.getTable()); - formattedResponseJson.put("request_index", requestIndex); - if (insertOptions.isTokens()) { - JSONObject responseTokens = (JSONObject) responseObject.get("tokens"); - responseTokens.remove("*"); - responseTokens.put("skyflow_id", responseObject.get("skyflow_id")); - formattedResponseJson.put("fields", responseTokens); - - } else { - formattedResponseJson.put("skyflow_id", responseObject.get("skyflow_id")); - } - - JSONObject resRecords = new JSONObject(); - JSONArray responseArray = new JSONArray(); - responseArray.add(formattedResponseJson); - resRecords.put("records", responseArray); - - response = resRecords.toJSONString(); - - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.Server.getLog()); - throw new SkyflowException(ErrorCode.Server, e); - } catch (SkyflowException exception){ - response = parseInsertError(exception, requestIndex); - } - return response; - } - private String parseInsertError(SkyflowException exception, int requestIndex) { - String errorResponse = null; - String exceptionMessage = exception.getMessage(); - int exceptionCode = exception.getCode(); - JSONObject errorObject = new JSONObject(); - JSONObject errorData = new JSONObject(); - - try { - JSONParser parser = new JSONParser(); - JSONObject errorJson = (JSONObject) parser.parse(exceptionMessage); - JSONObject error = (JSONObject) errorJson.get("error"); - if (error != null) { - errorData.put("code", error.get("http_code")); - errorData.put("description", error.get("message")); - errorData.put("request_index", requestIndex); - errorObject.put("error", errorData); - errorResponse = errorObject.toJSONString(); - } - } catch (ParseException e) { - errorData.put("code", exceptionCode); - errorData.put("description", exceptionMessage); - errorData.put("request_index", requestIndex); - errorObject.put("error", errorData); - errorResponse = errorObject.toJSONString(); - } - - return errorResponse; - } - - } diff --git a/v1/src/main/java/com/skyflow/vault/Skyflow.java b/v1/src/main/java/com/skyflow/vault/Skyflow.java deleted file mode 100644 index b444dc4d..00000000 --- a/v1/src/main/java/com/skyflow/vault/Skyflow.java +++ /dev/null @@ -1,565 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.vault; - - -import com.fasterxml.jackson.databind.ObjectMapper; -import com.skyflow.common.utils.*; -import com.skyflow.entities.*; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.ErrorLogs; -import com.skyflow.logs.InfoLogs; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; - -import java.io.IOException; -import java.net.URL; -import java.util.Collection; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.Callable; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.FutureTask; - -public final class Skyflow { - private final SkyflowConfiguration configuration; - private final TokenUtils tokenUtils; - - private Skyflow(SkyflowConfiguration config) { - this.configuration = config; - this.tokenUtils = new TokenUtils(); - LogUtil.printInfoLog(InfoLogs.InitializedClient.getLog()); - } - - public static Skyflow init(SkyflowConfiguration clientConfig) throws SkyflowException { - return new Skyflow(clientConfig); - } - - public JSONObject insert(JSONObject records) throws SkyflowException { - return insert(records, new InsertOptions(true)); - } - - public JSONObject insertBulk(JSONObject records) throws SkyflowException { - return insertBulk(records, new InsertBulkOptions(true)); - } - - public JSONObject query(JSONObject queryObject) throws SkyflowException { - return query(queryObject, new QueryOptions()); - } - - public JSONObject update(JSONObject records) throws SkyflowException { - return update(records, new UpdateOptions(true)); - } - public JSONObject delete(JSONObject records) throws SkyflowException { - return delete(records, new DeleteOptions()); - } - - public JSONObject insert(JSONObject records, InsertOptions insertOptions) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.InsertMethodCalled.getLog()); - Validators.validateConfiguration(configuration); - LogUtil.printInfoLog(Helpers.parameterizedString(InfoLogs.ValidatedSkyflowConfiguration.getLog(), "insert")); - - if (insertOptions.getUpsertOptions() != null) - Validators.validateUpsertOptions(insertOptions.getUpsertOptions()); - JSONObject insertResponse = null; - try { - InsertInput insertInput = new ObjectMapper().readValue(records.toString(), InsertInput.class); - JSONObject requestBody = Helpers.constructInsertRequest(insertInput, insertOptions); - - String url = configuration.getVaultURL() + "/v1/vaults/" + configuration.getVaultID(); - - Map headers = new HashMap<>(); - headers.put("Authorization", "Bearer " + tokenUtils.getBearerToken(configuration.getTokenProvider())); - headers.put(Constants.SDK_METRICS_HEADER_KEY, Helpers.getMetrics().toJSONString()); - String response = HttpUtility.sendRequest("POST", new URL(url), requestBody, headers); - insertResponse = (JSONObject) new JSONParser().parse(response); - LogUtil.printInfoLog(InfoLogs.ConstructInsertResponse.getLog()); - insertResponse = Helpers.constructInsertResponse(insertResponse, (List) requestBody.get("records"), insertOptions); - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidInsertInput.getLog()); - throw new SkyflowException(ErrorCode.InvalidInsertInput, e); - } catch (ParseException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ResponseParsingError.getLog(), "insert")); - throw new SkyflowException(ErrorCode.ResponseParsingError, e); - } - - return insertResponse; - } - - public JSONObject detokenize(JSONObject records) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.DetokenizeMethodCalled.getLog()); - Validators.validateConfiguration(configuration); - LogUtil.printInfoLog(Helpers.parameterizedString(InfoLogs.ValidatedSkyflowConfiguration.getLog(), "detokenize")); - - JSONObject finalResponse = new JSONObject(); - JSONArray successRecordsArray = new JSONArray(); - JSONArray errorRecordsArray = new JSONArray(); - try { - DetokenizeInput detokenizeInput = new ObjectMapper().readValue(records.toJSONString(), DetokenizeInput.class); - DetokenizeRecord[] inputRecords = detokenizeInput.getRecords(); - if (inputRecords == null || inputRecords.length == 0) { - throw new SkyflowException(ErrorCode.EmptyRecords); - } - String apiEndpointURL = this.configuration.getVaultURL() + "/v1/vaults/" + this.configuration.getVaultID() + "/detokenize"; - Map headers = new HashMap<>(); - headers.put("Authorization", "Bearer " + tokenUtils.getBearerToken(configuration.getTokenProvider())); - headers.put(Constants.SDK_METRICS_HEADER_KEY, Helpers.getMetrics().toJSONString()); - - FutureTask[] futureTasks = new FutureTask[inputRecords.length]; - for (int index = 0; index < inputRecords.length; index++) { - Callable callable = new Detokenize(inputRecords[index], apiEndpointURL, headers); - futureTasks[index] = new FutureTask(callable); - Thread thread = new Thread(futureTasks[index]); - thread.start(); - } - for (FutureTask task : futureTasks) { - String taskData = (String) task.get(); - JSONParser parser = new JSONParser(); - JSONObject responseJson = (JSONObject) parser.parse(taskData); - if (responseJson.containsKey("error")) { - errorRecordsArray.add(responseJson); - } else if (responseJson.containsKey("value")) { - successRecordsArray.add(responseJson); - } - } - if (errorRecordsArray.isEmpty()) { - finalResponse.put("records", successRecordsArray); - } else if (successRecordsArray.isEmpty()) { - finalResponse.put("errors", errorRecordsArray); - throw new SkyflowException(500, "Server returned errors, check SkyflowException.getData() for more", finalResponse); - } else { - finalResponse.put("records", successRecordsArray); - finalResponse.put("errors", errorRecordsArray); - throw new SkyflowException(500, "Server returned errors, check SkyflowException.getData() for more", finalResponse); - } - } catch (IOException exception) { - LogUtil.printErrorLog(ErrorLogs.InvalidDetokenizeInput.getLog()); - throw new SkyflowException(ErrorCode.InvalidDetokenizeInput, exception); - } catch (InterruptedException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ThreadInterruptedException.getLog(), "detokenize")); - throw new SkyflowException(ErrorCode.ThreadInterruptedException, e); - } catch (ExecutionException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ThreadExecutionException.getLog(), "detokenize")); - throw new SkyflowException(ErrorCode.ThreadExecutionException, e); - } catch (ParseException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ResponseParsingError.getLog(), "detokenize")); - throw new SkyflowException(ErrorCode.ResponseParsingError, e); - } - return finalResponse; - } - - public JSONObject getById(JSONObject getByIdInput) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.GetByIdMethodCalled.getLog()); - Validators.validateConfiguration(configuration); - LogUtil.printInfoLog(Helpers.parameterizedString(InfoLogs.ValidatedSkyflowConfiguration.getLog(), "getById")); - - JSONObject finalResponse = new JSONObject(); - JSONArray successRecordsArray = new JSONArray(); - JSONArray errorRecordsArray = new JSONArray(); - try { - GetByIdInput input = new ObjectMapper().readValue(getByIdInput.toString(), GetByIdInput.class); - GetByIdRecordInput[] recordInputs = input.getRecords(); - - if (recordInputs == null || recordInputs.length == 0) { - throw new SkyflowException(ErrorCode.EmptyRecords); - } - - Map headers = new HashMap<>(); - headers.put("Authorization", "Bearer " + tokenUtils.getBearerToken(configuration.getTokenProvider())); - headers.put(Constants.SDK_METRICS_HEADER_KEY, Helpers.getMetrics().toJSONString()); - - FutureTask[] futureTasks = new FutureTask[recordInputs.length]; - for (int i = 0; i < recordInputs.length; i++) { - Callable callable = new GetBySkyflowId(recordInputs[i], configuration.getVaultID(), configuration.getVaultURL(), headers); - futureTasks[i] = new FutureTask(callable); - - Thread t = new Thread(futureTasks[i]); - t.start(); - } - - for (FutureTask task : futureTasks) { - String taskData = (String) task.get(); - JSONObject responseJson = (JSONObject) new JSONParser().parse(taskData); - if (responseJson.containsKey("error")) { - errorRecordsArray.add(responseJson); - } else if (responseJson.containsKey("records")) { - successRecordsArray.addAll((Collection) responseJson.get("records")); - } - } - - if (errorRecordsArray.isEmpty()) { - finalResponse.put("records", successRecordsArray); - } else if (successRecordsArray.isEmpty()) { - finalResponse.put("errors", errorRecordsArray); - ErrorCode serverError = ErrorCode.ServerReturnedErrors; - throw new SkyflowException(serverError.getCode(), serverError.getDescription(), finalResponse); - } else { - finalResponse.put("records", successRecordsArray); - finalResponse.put("errors", errorRecordsArray); - ErrorCode serverError = ErrorCode.ServerReturnedErrors; - throw new SkyflowException(serverError.getCode(), serverError.getDescription(), finalResponse); - } - - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidGetByIdInput.getLog()); - throw new SkyflowException(ErrorCode.InvalidGetByIdInput, e); - } catch (InterruptedException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ThreadInterruptedException.getLog(), "getById")); - throw new SkyflowException(ErrorCode.ThreadInterruptedException, e); - } catch (ExecutionException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ThreadExecutionException.getLog(), "getById")); - throw new SkyflowException(ErrorCode.ThreadExecutionException, e); - } catch (ParseException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ResponseParsingError.getLog(), "getById")); - throw new SkyflowException(ErrorCode.ResponseParsingError, e); - } - - return finalResponse; - } - public JSONObject get(JSONObject getInput) throws SkyflowException { - return get(getInput, new GetOptions(false)); - } - public JSONObject get(JSONObject getInput, GetOptions getOptions ) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.GetMethodCalled.getLog()); - Validators.validateConfiguration(configuration); - LogUtil.printInfoLog(Helpers.parameterizedString(InfoLogs.ValidatedSkyflowConfiguration.getLog(), "get")); - - JSONObject finalResponse = new JSONObject(); - JSONArray successRecordsArray = new JSONArray(); - JSONArray errorRecordsArray = new JSONArray(); - try { - GetInput input = new ObjectMapper().readValue(getInput.toJSONString(), GetInput.class); - GetRecordInput[] recordInputs = input.getRecords(); - - if (recordInputs == null || recordInputs.length == 0) { - throw new SkyflowException(ErrorCode.EmptyRecords); - } - - Map headers = new HashMap<>(); - headers.put("Authorization", "Bearer " + tokenUtils.getBearerToken(configuration.getTokenProvider())); - headers.put(Constants.SDK_METRICS_HEADER_KEY, Helpers.getMetrics().toJSONString()); - - FutureTask[] futureTasks = new FutureTask[recordInputs.length]; - for (int i = 0; i < recordInputs.length; i++) { - Callable callable = new Get(recordInputs[i], configuration.getVaultID(), configuration.getVaultURL(), headers, getOptions); - futureTasks[i] = new FutureTask(callable); - - Thread t = new Thread(futureTasks[i]); - t.start(); - } - - for (FutureTask task : futureTasks) { - String taskData = (String) task.get(); - JSONObject responseJson = (JSONObject) new JSONParser().parse(taskData); - if (responseJson.containsKey("error")) { - errorRecordsArray.add(responseJson); - } else if (responseJson.containsKey("records")) { - successRecordsArray.addAll((Collection) responseJson.get("records")); - } - } - - if (errorRecordsArray.isEmpty()) { - finalResponse.put("records", successRecordsArray); - } else if (successRecordsArray.isEmpty()) { - finalResponse.put("errors", errorRecordsArray); - ErrorCode serverError = ErrorCode.ServerReturnedErrors; - throw new SkyflowException(serverError.getCode(), serverError.getDescription(), finalResponse); - } else { - finalResponse.put("records", successRecordsArray); - finalResponse.put("errors", errorRecordsArray); - ErrorCode serverError = ErrorCode.ServerReturnedErrors; - throw new SkyflowException(serverError.getCode(), serverError.getDescription(), finalResponse); - } - - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidGetInput.getLog()); - throw new SkyflowException(ErrorCode.InvalidGetInput, e); - } catch (InterruptedException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ThreadInterruptedException.getLog(), "get")); - throw new SkyflowException(ErrorCode.ThreadInterruptedException, e); - } catch (ExecutionException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ThreadExecutionException.getLog(), "get")); - throw new SkyflowException(ErrorCode.ThreadExecutionException, e); - } catch (ParseException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ResponseParsingError.getLog(), "get")); - throw new SkyflowException(ErrorCode.ResponseParsingError, e); - } - - return finalResponse; - } - - public JSONObject update(JSONObject records, UpdateOptions updateOptions) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.UpdateMethodCalled.getLog()); - Validators.validateConfiguration(configuration); - LogUtil.printInfoLog(Helpers.parameterizedString(InfoLogs.ValidatedSkyflowConfiguration.getLog(), "update")); - - JSONArray successRecordsArray = new JSONArray(); - JSONArray errorRecordsArray = new JSONArray(); - - JSONObject updateResponse = new JSONObject(); - - try { - UpdateInput updateInput = new ObjectMapper().readValue(records.toString(), UpdateInput.class); - UpdateRecordInput[] recordInputs = updateInput.getRecords(); - if (recordInputs == null || recordInputs.length == 0) { - throw new SkyflowException(ErrorCode.EmptyRecords); - } - - Map headers = new HashMap<>(); - headers.put("Authorization", "Bearer " + tokenUtils.getBearerToken(configuration.getTokenProvider())); - headers.put(Constants.SDK_METRICS_HEADER_KEY, Helpers.getMetrics().toJSONString()); - - FutureTask[] futureTasks = new FutureTask[recordInputs.length]; - for (int i = 0; i < recordInputs.length; i++) { - Callable callable = new UpdateBySkyflowId(recordInputs[i], configuration.getVaultID(), configuration.getVaultURL(), headers, updateOptions); - futureTasks[i] = new FutureTask(callable); - Thread t = new Thread(futureTasks[i]); - t.start(); - } - - for (FutureTask task : futureTasks) { - String taskData = (String) task.get(); - JSONObject responseJson = (JSONObject) new JSONParser().parse(taskData); - if (responseJson.containsKey("error")) { - errorRecordsArray.add(responseJson); - } else if (responseJson.containsKey("records")) { - successRecordsArray.add(responseJson.get("records")); - } - } - if (errorRecordsArray.isEmpty()) { - updateResponse.put("records", successRecordsArray); - } else if (successRecordsArray.isEmpty()) { - updateResponse.put("error", errorRecordsArray); - throw new SkyflowException(500, "Server returned errors, check SkyflowException.Update() for more", updateResponse); - } else { - updateResponse.put("records", successRecordsArray); - updateResponse.put("error", errorRecordsArray); - throw new SkyflowException(500, "Server returned errors, check SkyflowException.Update() for more", updateResponse); - } - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidUpdateInput.getLog()); - throw new SkyflowException(ErrorCode.InvalidUpdateInput, e); - } catch (InterruptedException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ThreadInterruptedException.getLog(), "updateById")); - throw new SkyflowException(ErrorCode.ThreadInterruptedException, e); - } catch (ExecutionException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ThreadExecutionException.getLog(), "updateById")); - throw new SkyflowException(ErrorCode.ThreadExecutionException, e); - } catch (ParseException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ResponseParsingError.getLog(), "updateById")); - throw new SkyflowException(ErrorCode.ResponseParsingError, e); - } - return updateResponse; - - } - - public JSONObject delete(JSONObject records, DeleteOptions deleteOptions) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.deleteMethodCalled.getLog()); - Validators.validateConfiguration(configuration); - LogUtil.printInfoLog(Helpers.parameterizedString(InfoLogs.ValidatedSkyflowConfiguration.getLog(), "delete")); - - JSONObject deleteResponse = new JSONObject(); - JSONArray successRecordsArray = new JSONArray(); - JSONArray errorRecordsArray = new JSONArray(); - - try { - DeleteInput deleteInput = new ObjectMapper().readValue(records.toString(), DeleteInput.class); - DeleteRecordInput[] recordInputs = deleteInput.getRecords(); - if (recordInputs == null || recordInputs.length == 0) { - throw new SkyflowException(ErrorCode.EmptyRecords); - } - Map headers = new HashMap<>(); - headers.put("Authorization", "Bearer " + tokenUtils.getBearerToken(configuration.getTokenProvider())); - headers.put(Constants.SDK_METRICS_HEADER_KEY, Helpers.getMetrics().toJSONString()); - FutureTask[] futureTasks = new FutureTask[recordInputs.length]; - - - for (int i = 0; i < recordInputs.length; i++) { - Callable callable = new DeleteBySkyflowId(recordInputs[i], configuration.getVaultID(), configuration.getVaultURL(), headers, deleteOptions); - futureTasks[i] = new FutureTask(callable); - Thread t = new Thread(futureTasks[i]); - t.start(); - } - for (FutureTask task : futureTasks) { - String taskData = (String) task.get(); - JSONObject responseJson = (JSONObject) new JSONParser().parse(taskData); - if (responseJson.containsKey("error")) { - errorRecordsArray.add(responseJson); - } else if (responseJson.containsKey("records")) { - JSONArray resp = (JSONArray) new JSONParser().parse(responseJson.get("records").toString()) ; - successRecordsArray.add(resp.get(0)); - } - } - if (errorRecordsArray.isEmpty()) { - deleteResponse.put("records", successRecordsArray); - } else if (successRecordsArray.isEmpty()) { - deleteResponse.put("errors", errorRecordsArray); - ErrorCode serverError = ErrorCode.ServerReturnedErrors; - throw new SkyflowException(serverError.getCode(), serverError.getDescription(), deleteResponse); - } else { - deleteResponse.put("records", successRecordsArray); - deleteResponse.put("errors", errorRecordsArray); - ErrorCode serverError = ErrorCode.ServerReturnedErrors; - throw new SkyflowException(serverError.getCode(), serverError.getDescription(), deleteResponse); - } - - }catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidDeleteInput.getLog()); - throw new SkyflowException(ErrorCode.InvalidDeleteInput, e); - } catch (InterruptedException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ThreadInterruptedException.getLog(), "deleteById")); - throw new SkyflowException(ErrorCode.ThreadInterruptedException, e); - } catch (ExecutionException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ThreadExecutionException.getLog(), "deleteById")); - throw new SkyflowException(ErrorCode.ThreadExecutionException, e); - } catch (ParseException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ResponseParsingError.getLog(), "deleteById")); - throw new SkyflowException(ErrorCode.ResponseParsingError, e); - } - return deleteResponse; - } - public JSONObject invokeConnection(JSONObject connectionConfig) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.InvokeConnectionCalled.getLog()); - JSONObject connectionResponse; - try { - Validators.validateConnectionConfiguration(connectionConfig, configuration); - String filledURL = Helpers.constructConnectionURL(connectionConfig); - - Map headers = new HashMap<>(); - - if (connectionConfig.containsKey("requestHeader")) { - headers = Helpers.constructConnectionHeadersMap((JSONObject) connectionConfig.get("requestHeader")); - } - if (!headers.containsKey("x-skyflow-authorization")) { - headers.put("x-skyflow-authorization", tokenUtils.getBearerToken(configuration.getTokenProvider())); - } - headers.put(Constants.SDK_METRICS_HEADER_KEY, Helpers.getMetrics().toJSONString()); - String requestMethod = connectionConfig.get("methodName").toString(); - JSONObject requestBody = null; - if (connectionConfig.containsKey("requestBody")) { - requestBody = (JSONObject) connectionConfig.get("requestBody"); - } - - String response = HttpUtility.sendRequest(requestMethod, new URL(filledURL), requestBody, headers); - connectionResponse = (JSONObject) new JSONParser().parse(response); - - } catch (IOException exception) { - LogUtil.printErrorLog(ErrorLogs.InvalidInvokeConnectionInput.getLog()); - throw new SkyflowException(ErrorCode.InvalidConnectionInput, exception); - } catch (ParseException exception) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ResponseParsingError.getLog(), "invokeConnection")); - throw new SkyflowException(ErrorCode.ResponseParsingError, exception); - } - return connectionResponse; - } - - public JSONObject query(JSONObject queryObject,QueryOptions queryOptions) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.QuerySupportCalled.getLog()); - Validators.validateConfiguration(configuration); - LogUtil.printInfoLog(Helpers.parameterizedString(InfoLogs.ValidatedSkyflowConfiguration.getLog(), "query")); - JSONObject queryResponse = null; - try { - JSONObject queryJsonbject = (JSONObject) queryObject; - - QueryRecordInput queryInput = new ObjectMapper().readValue(queryJsonbject.toString(), QueryRecordInput.class); - - JSONObject requestBody = Helpers.constructQueryRequest(queryInput, queryOptions); - - String url = configuration.getVaultURL() + "/v1/vaults/" + configuration.getVaultID() + "/query"; - Map headers = new HashMap<>(); - headers.put("Authorization", "Bearer " + tokenUtils.getBearerToken(configuration.getTokenProvider())); - headers.put(Constants.SDK_METRICS_HEADER_KEY, Helpers.getMetrics().toJSONString()); - String response = HttpUtility.sendRequest("POST", new URL(url), requestBody, headers); - queryResponse = (JSONObject) new JSONParser().parse(response); - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.InvalidQueryInput.getLog()); - throw new SkyflowException(ErrorCode.InvalidQueryInput,e); - } catch (ParseException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ResponseParsingError.getLog(), "query")); - throw new SkyflowException(ErrorCode.ResponseParsingError, e); - } - catch (SkyflowException e) { - JSONObject queryErrorResponse = Helpers.constructQueryErrorObject(e); - throw new SkyflowException(400, "Query is missing", queryErrorResponse); - } - return queryResponse; - } - public JSONObject insertBulk(JSONObject records, InsertBulkOptions insertOptions) throws SkyflowException { - LogUtil.printInfoLog(InfoLogs.InsertBulkMethodCalled.getLog()); - Validators.validateConfiguration(configuration); - LogUtil.printInfoLog(Helpers.parameterizedString(InfoLogs.ValidatedSkyflowConfiguration.getLog(), "insert")); - JSONObject finalResponse = new JSONObject(); - JSONArray successRecordsArray = new JSONArray(); - JSONArray errorRecordsArray = new JSONArray(); - - if (insertOptions.getUpsertOptions() != null) - Validators.validateUpsertOptions(insertOptions.getUpsertOptions()); - try { - InsertInput insertInput = new ObjectMapper().readValue(records.toString(), InsertInput.class); - - Map headers = new HashMap<>(); - headers.put("Authorization", "Bearer " + tokenUtils.getBearerToken(configuration.getTokenProvider())); - headers.put(Constants.SDK_METRICS_HEADER_KEY, Helpers.getMetrics().toJSONString()); - - InsertRecordInput[] inputRecords = insertInput.getRecords(); - - if (inputRecords == null || insertInput.getRecords().length == 0) { - throw new SkyflowException(ErrorCode.EmptyRecords); - } - - for (int i = 0; i < inputRecords.length; i++) { - Validators.validateInsertRecord(inputRecords[i]); - } - FutureTask[] futureTasks = new FutureTask[inputRecords.length]; - for (int index = 0; index < inputRecords.length; index++) { - Callable callable = new Insert(inputRecords[index], configuration.getVaultID(), configuration.getVaultURL(), headers, insertOptions, index); - futureTasks[index] = new FutureTask(callable); - - Thread thread = new Thread(futureTasks[index]); - thread.start(); - } - for (FutureTask task : futureTasks) { - String taskData = (String) task.get(); - JSONParser parser = new JSONParser(); - JSONObject responseJson = (JSONObject) parser.parse(taskData); - if (responseJson.containsKey("error")) { - errorRecordsArray.add(responseJson); - } else if (responseJson.containsKey("records")) { - JSONArray successRes = (JSONArray) responseJson.get("records"); - successRecordsArray.add(successRes.get(0)); - } - } - if (errorRecordsArray.isEmpty()) { - finalResponse.put("records", successRecordsArray); - } else if (successRecordsArray.isEmpty()) { - finalResponse.put("errors", errorRecordsArray); - throw new SkyflowException(ErrorCode.ServerReturnedErrors.getCode(), ErrorLogs.ServerReturnedErrors.getLog(), finalResponse); - } else { - finalResponse.put("records", successRecordsArray); - finalResponse.put("errors", errorRecordsArray); - throw new SkyflowException(ErrorCode.ServerReturnedErrors.getCode(), ErrorLogs.ServerReturnedErrors.getLog(), finalResponse); - } - - } catch (IOException var9) { - LogUtil.printErrorLog(ErrorLogs.InvalidInsertInput.getLog()); - throw new SkyflowException(ErrorCode.InvalidInsertInput, var9); - } catch (ParseException var10) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ResponseParsingError.getLog(), new String[]{"Insert"})); - throw new SkyflowException(ErrorCode.ResponseParsingError, var10); - } catch (InterruptedException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ThreadInterruptedException.getLog(), "Insert")); - throw new SkyflowException(ErrorCode.ThreadInterruptedException, e); - } catch (ExecutionException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ThreadExecutionException.getLog(), "Insert")); - throw new SkyflowException(ErrorCode.ThreadExecutionException, e); - } - - return finalResponse; - - } -} diff --git a/v1/src/main/java/com/skyflow/vault/UpdateBySkyflowId.java b/v1/src/main/java/com/skyflow/vault/UpdateBySkyflowId.java deleted file mode 100644 index e26299a0..00000000 --- a/v1/src/main/java/com/skyflow/vault/UpdateBySkyflowId.java +++ /dev/null @@ -1,106 +0,0 @@ -package com.skyflow.vault; - -import com.skyflow.common.utils.Helpers; -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.common.utils.LogUtil; -import com.skyflow.entities.UpdateOptions; -import com.skyflow.entities.UpdateRecordInput; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import com.skyflow.logs.ErrorLogs; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; - -import java.io.IOException; -import java.net.URL; -import java.util.Collections; -import java.util.Map; -import java.util.concurrent.Callable; - -final class UpdateBySkyflowId implements Callable { - - public final UpdateOptions options; - private final UpdateRecordInput record; - private final Map headers; - private final String vaultID; - private final String vaultURL; - - UpdateBySkyflowId(UpdateRecordInput record, String vaultID, String vaultURL, Map headers, UpdateOptions updateOptions) { - this.record = record; - this.vaultID = vaultID; - this.vaultURL = vaultURL; - this.headers = headers; - this.options = updateOptions; - } - - - @Override - public String call() throws Exception { - String response = null; - try { - JSONObject requestBody = Helpers.constructUpdateRequest(record, options); - JSONObject finalBody = new JSONObject(); - - finalBody.put("record", requestBody); - finalBody.put("tokenization", options.isTokens()); - - String url = vaultURL + "/v1/vaults/" + vaultID + "/" + record.getTable() + "/" + record.getId(); - response = HttpUtility.sendRequest("PUT", new URL(url), finalBody, headers); - JSONObject formattedRecords = new JSONObject(); - JSONObject responseRecords = (JSONObject) (new JSONParser().parse(response)); - - - if (responseRecords != null && responseRecords.size() > 0) { - JSONObject fields = (JSONObject) responseRecords.get("tokens"); - String id = (String) responseRecords.get("skyflow_id"); - - JSONObject formattedRecord = new JSONObject(); - formattedRecord.put("id", id); - formattedRecord.put("table", record.getTable()); - formattedRecord.put("fields", fields); - formattedRecords.put("records", formattedRecord); - } - response = formattedRecords.toJSONString(); - } catch (IOException e) { - LogUtil.printErrorLog(ErrorLogs.Server.getLog()); - throw new SkyflowException(ErrorCode.Server, e); - } catch (ParseException e) { - LogUtil.printErrorLog(Helpers.parameterizedString(ErrorLogs.ResponseParsingError.getLog(), "updateById")); - throw new SkyflowException(ErrorCode.ResponseParsingError, e); - } catch (SkyflowException e) { - response = constructUpdateByIdErrorObject(e, record.getId()); - } - return response; - } - - private String constructUpdateByIdErrorObject(SkyflowException skyflowException, String ids) { - - String updateByIdResponse = null; - JSONObject finalResponseError = new JSONObject(); - - try { - JSONArray idsArray = new JSONArray(); - Collections.addAll(idsArray, ids); - finalResponseError.put("ids", idsArray); - - JSONObject errorObject = (JSONObject) ((JSONObject) new JSONParser().parse(skyflowException.getMessage())).get("error"); - if (errorObject != null) { - JSONObject responseError = new JSONObject(); - responseError.put("code", errorObject.get("http_code")); - responseError.put("description", errorObject.get("message")); - finalResponseError.put("error", responseError); - - updateByIdResponse = finalResponseError.toString(); - } - } catch (ParseException e) { - JSONObject responseError = new JSONObject(); - responseError.put("code", skyflowException.getCode()); - responseError.put("description", skyflowException.getMessage()); - finalResponseError.put("error", responseError); - updateByIdResponse = finalResponseError.toString(); - } - return updateByIdResponse; - } -} diff --git a/v1/src/test/java/com/skyflow/common/utils/HelpersTest.java b/v1/src/test/java/com/skyflow/common/utils/HelpersTest.java deleted file mode 100644 index fea055d2..00000000 --- a/v1/src/test/java/com/skyflow/common/utils/HelpersTest.java +++ /dev/null @@ -1,205 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.common.utils; - -import com.skyflow.Configuration; -import com.skyflow.entities.GetOptions; -import com.skyflow.entities.GetRecordInput; -import com.skyflow.entities.LogLevel; -import com.skyflow.entities.RedactionType; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; - -import static com.skyflow.common.utils.Helpers.constructGetRequestURLParams; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.powermock.api.mockito.PowerMockito.mock; -import static org.powermock.api.mockito.PowerMockito.when; - -import java.security.PrivateKey; -import org.json.simple.JSONObject; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Mockito; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - - -@RunWith(PowerMockRunner.class) -@PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.TokenUtils", "com.skyflow.common.utils.HttpUtility"}) -public class HelpersTest { - - private static String tableName = null; - private static String columnName = null; - private static String reqId = null; - private static String[] columnValue = new String[1]; - private static String[] ids = new String[1]; - private static String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; - - @BeforeClass - public static void setup() throws SkyflowException { - PowerMockito.mockStatic(TokenUtils.class); - PowerMockito.when(TokenUtils.isTokenValid("valid_token")).thenReturn(true); - PowerMockito.when(TokenUtils.isTokenValid("not_a_valid_token")).thenReturn(false); - - PowerMockito.mockStatic(HttpUtility.class); - PowerMockito.when(HttpUtility.getRequestID()).thenReturn("abc"); - reqId = HttpUtility.getRequestID(); - tableName = "account_details"; - columnName = "card_number"; - columnValue[0] = "123451234554321"; - ids[0] = "123451234554321"; - } - - @Test - public void testMessageWithRequestID(){ - String message = Helpers.appendRequestId("message", reqId); - String expectedMessage = "message" + " - requestId: " + "abc"; - assertEquals(expectedMessage, message); - } - - @Test - public void testFormatJsonToFormEncodedString(){ - Configuration.setLogLevel(LogLevel.DEBUG); - JSONObject testJson = new JSONObject(); - testJson.put("key1","value1"); - JSONObject nestedObj = new JSONObject(); - nestedObj.put("key2","value2"); - testJson.put("nest",nestedObj); - - String testResponse = Helpers.formatJsonToFormEncodedString(testJson); - assert testResponse.contains("key1=value1"); - assert testResponse.contains("nest[key2]=value2"); - } - - @Test - public void testFormatJsonToMultiPartFormDataString(){ - JSONObject testJson = new JSONObject(); - testJson.put("key1","value1"); - JSONObject nestedObj = new JSONObject(); - nestedObj.put("key2","value2"); - testJson.put("nest",nestedObj); - String testBoundary = "123"; - String testResponse = Helpers.formatJsonToMultiPartFormDataString(testJson,testBoundary); - assert testResponse.contains("--"+testBoundary); - assert testResponse.contains("--"+testBoundary+"--"); - assert testResponse.contains("Content-Disposition: form-data; name=\"key1\""); - assert testResponse.contains("value1"); - assert testResponse.contains("Content-Disposition: form-data; name=\"nest[key2]\""); - assert testResponse.contains("value2"); - } - - @Test - public void testInvalidPrivateKey(){ - String pemKey = "abc"; - - try{ - PrivateKey key = Helpers.getPrivateKeyFromPem(pemKey); - }catch (SkyflowException exception) { - assertEquals(exception.getMessage(), ErrorCode.UnableToRetrieveRSA.getDescription()); - } - } - @Test - public void testInvalidKeySpec(){ - byte[] pkcs8Bytes = {}; - try{ - Helpers.parsePkcs8PrivateKey(pkcs8Bytes); - }catch (SkyflowException exception) { - assertEquals(exception.getMessage(), ErrorCode.InvalidKeySpec.getDescription()); - } - } - @Test - public void constructGetRequestURLParamsColumnValueTest(){ - GetRecordInput recordInput = new GetRecordInput(); - - recordInput.setTable(tableName); - recordInput.setColumnValues(columnValue); - recordInput.setColumnName(columnName); - recordInput.setRedaction(RedactionType.PLAIN_TEXT); - StringBuilder paramsList = constructGetRequestURLParams(recordInput, new GetOptions(false)); - - Assert.assertTrue(paramsList.toString().contains("&")); - - Assert.assertTrue(paramsList.toString().contains("column_name="+ columnName)); - Assert.assertTrue(paramsList.toString().contains("column_values="+ columnValue[0])); - Assert.assertTrue(paramsList.toString().contains("redaction="+ RedactionType.PLAIN_TEXT.toString())); - } - @Test - public void constructGetRequestURLParamsIdTest(){ - GetRecordInput recordInput = new GetRecordInput(); - - recordInput.setTable(tableName); - recordInput.setIds(ids); - recordInput.setRedaction(RedactionType.PLAIN_TEXT); - StringBuilder paramsList = constructGetRequestURLParams(recordInput, new GetOptions(false)); - Assert.assertTrue(paramsList.toString().contains("&")); - - Assert.assertTrue(paramsList.toString().contains("skyflow_ids="+ ids[0])); - Assert.assertTrue(paramsList.toString().contains("redaction="+"PLAIN_TEXT")); - - } - @Test - public void constructGetRequestURLParamsIdTokenTrueTest(){ - GetRecordInput recordInput = new GetRecordInput(); - - recordInput.setTable(tableName); - recordInput.setIds(ids); - StringBuilder paramsList = constructGetRequestURLParams(recordInput, new GetOptions(true)); - - Assert.assertTrue(paramsList.toString().contains("&")); - Assert.assertFalse(paramsList.toString().contains("redaction=PLAIN_TEXT")); - - Assert.assertTrue(paramsList.toString().contains("skyflow_ids="+ ids[0])); - Assert.assertTrue(paramsList.toString().contains("tokenization="+"true")); - - } - @Test - public void testGetMetrics() { - JSONObject metrics = Helpers.getMetrics(); - assertEquals(true, metrics.containsKey("sdk_name_version")); - assertEquals(true, metrics.containsKey("sdk_client_device_model")); - assertEquals(true, metrics.containsKey("sdk_client_os_details")); - assertEquals(true, metrics.containsKey("sdk_runtime_details")); - - assertEquals("skyflow-java@"+ Constants.SDK_VERSION, metrics.get("sdk_name_version")); - assertNotNull(metrics.get("sdk_client_device_model")); - - assertNotNull(metrics.get("sdk_client_os_details")); - assertNotNull(metrics.get("sdk_runtime_details")); - assertNotNull(metrics.get("sdk_client_device_model")); - - String runtimeDetails = (String) metrics.get("sdk_runtime_details"); - assertEquals(true, runtimeDetails.startsWith("Java@")); - - } - @Test - public void testGetMetricsWithException() { - // Arrange - String expectedSdkVersion = Constants.SDK_VERSION; - String expectedDeviceModel = ""; - String expectedOsDetails = ""; - String expectedJavaVersion = ""; - - // Mocking the System.getProperty() method to throw an exception - System.setProperty("os.name", ""); - System.setProperty("os.version", ""); - System.setProperty("java.version", ""); - - // Act - JSONObject metrics = Helpers.getMetrics(); - assertEquals(true, metrics.containsKey("sdk_name_version")); - assertEquals(true, metrics.containsKey("sdk_client_device_model")); - assertEquals(true, metrics.containsKey("sdk_client_os_details")); - assertEquals(true, metrics.containsKey("sdk_runtime_details")); - // Assert - assertEquals("skyflow-java@" + expectedSdkVersion, metrics.get("sdk_name_version")); - assertEquals(expectedDeviceModel, metrics.get("sdk_client_device_model")); - assertEquals(expectedOsDetails, metrics.get("sdk_client_os_details")); - assertEquals("Java@" + expectedJavaVersion, metrics.get("sdk_runtime_details")); - } -} - diff --git a/v1/src/test/java/com/skyflow/common/utils/HttpUtilityTest.java b/v1/src/test/java/com/skyflow/common/utils/HttpUtilityTest.java deleted file mode 100644 index e473ee1f..00000000 --- a/v1/src/test/java/com/skyflow/common/utils/HttpUtilityTest.java +++ /dev/null @@ -1,154 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.common.utils; - -import com.skyflow.errors.SkyflowException; -import org.json.simple.JSONObject; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - -import java.io.ByteArrayInputStream; -import java.io.IOException; -import java.io.OutputStream; -import java.net.HttpURLConnection; -import java.net.URL; -import java.net.URLConnection; -import java.net.URLStreamHandler; - -import static org.junit.Assert.fail; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.BDDMockito.given; - -@RunWith(PowerMockRunner.class) -@PrepareForTest({ URL.class, HttpURLConnection.class }) -public class HttpUtilityTest { - - @InjectMocks - HttpUtility httpUtility; - - @Mock - OutputStream outputStream; - - private String expected; - - private String expectedError; - private URL url; - - private HttpURLConnection mockConnection; - private static String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; - - @Before - public void setup() throws IOException { - expected = "{\"status\":\"success\"}"; - expectedError = "{\"status\":\"something went wrong\"}"; - mockConnection = Mockito.mock(HttpURLConnection.class); - given(mockConnection.getInputStream()).willReturn(new ByteArrayInputStream(expected.getBytes())); - given(mockConnection.getErrorStream()).willReturn(new ByteArrayInputStream(expectedError.getBytes())); - given(mockConnection.getOutputStream()).willReturn(outputStream); - given(mockConnection.getResponseCode()).willReturn(200); - given(mockConnection.getHeaderField(anyString())).willReturn("id"); - final URLStreamHandler handler = new URLStreamHandler() { - @Override - protected URLConnection openConnection(final URL arg0) throws IOException { - return mockConnection; - } - }; - url = new URL("https://google.com", "google.com", 80, "", handler); - } - - @Test - @PrepareForTest({ URL.class, HttpURLConnection.class }) - public void testSendRequest() { - try { - given(mockConnection.getRequestProperty("content-type")).willReturn("application/json"); - - JSONObject headers = new JSONObject(); - headers.put("content-type", "application/json"); - - JSONObject params = new JSONObject(); - params.put("key", "value"); - - String response = httpUtility.sendRequest("GET", url, params, headers); - - Assert.assertEquals(expected, response); - } catch (IOException e) { - fail(INVALID_EXCEPTION_THROWN); - } catch (SkyflowException e) { - fail(INVALID_EXCEPTION_THROWN); - } catch (Exception e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - - @Test - @PrepareForTest({ URL.class, HttpURLConnection.class }) - public void testSendRequestFormData() { - try { - given(mockConnection.getRequestProperty("content-type")).willReturn("multipart/form-data"); - - JSONObject headers = new JSONObject(); - headers.put("content-type", "multipart/form-data"); - - JSONObject params = new JSONObject(); - params.put("key", "value"); - - String response = httpUtility.sendRequest("GET", url, params, headers); - Assert.assertEquals(expected, response); - } catch (IOException e) { - fail(INVALID_EXCEPTION_THROWN); - } catch (SkyflowException e) { - fail(INVALID_EXCEPTION_THROWN); - } catch (Exception e) { - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest({ URL.class, HttpURLConnection.class }) - public void testSendRequestFormURLEncoded() { - try { - given(mockConnection.getRequestProperty("content-type")).willReturn("application/x-www-form-urlencoded"); - - JSONObject headers = new JSONObject(); - headers.put("content-type", "application/x-www-form-urlencoded"); - - JSONObject params = new JSONObject(); - params.put("key", "value"); - - String response = httpUtility.sendRequest("GET", url, params, headers); - Assert.assertEquals(expected, response); - } catch (IOException e) { - fail(INVALID_EXCEPTION_THROWN); - } catch (SkyflowException e) { - fail(INVALID_EXCEPTION_THROWN); - } catch (Exception e) { - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest({ URL.class, HttpURLConnection.class }) - public void testSendRequestError() { - try { - given(mockConnection.getResponseCode()).willReturn(500); - - String response = httpUtility.sendRequest("GET", url, null, null); - } catch (IOException e) { - fail(INVALID_EXCEPTION_THROWN); - } catch (SkyflowException e) { - Assert.assertEquals(expectedError, e.getMessage()); - } catch (Exception e) { - fail(INVALID_EXCEPTION_THROWN); - } - } -} diff --git a/v1/src/test/java/com/skyflow/common/utils/TokenUtilsTest.java b/v1/src/test/java/com/skyflow/common/utils/TokenUtilsTest.java deleted file mode 100644 index 1e242cfb..00000000 --- a/v1/src/test/java/com/skyflow/common/utils/TokenUtilsTest.java +++ /dev/null @@ -1,87 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.common.utils; - -import com.skyflow.entities.TokenProvider; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - -import static org.junit.Assert.assertEquals; - -class InvalidTokenProvider implements TokenProvider { - - private final boolean isException; - - public InvalidTokenProvider() { - this.isException = false; - } - - public InvalidTokenProvider(boolean isException) { - this.isException = isException; - } - - @Override - public String getBearerToken() throws Exception { - if (!isException) - return "invalid_token"; - else - throw new Exception("EXCEPTION THROWN!!"); - } -} - -class InvalidTokenProvider2 implements TokenProvider { - @Override - public String getBearerToken() throws Exception { - return "a.b.c"; - } -} - -@RunWith(PowerMockRunner.class) -@PrepareForTest -public class TokenUtilsTest { - - TokenUtils tokenUtils = new TokenUtils(); - - @Test - public void testInvalidGetBearerToken() { - try { - String token = tokenUtils.getBearerToken(new InvalidTokenProvider()); - } catch (SkyflowException e) { - assertEquals(e.getMessage(), ErrorCode.InvalidBearerToken.getDescription()); - } - } - - @Test - @PrepareForTest - public void testInvalidGetBearerToken2() { - try { - String token = tokenUtils.getBearerToken(new InvalidTokenProvider2()); - } catch (SkyflowException e) { - assertEquals(e.getMessage(), ErrorCode.InvalidBearerToken.getDescription()); - } - } - - @Test - public void testIsTokenValid() { - try { - String token = System.getProperty("TEST_EXPIRED_TOKEN"); - assertEquals(false, TokenUtils.isTokenValid(token)); - } catch (SkyflowException e) { - throw new RuntimeException(e); - } - } - - @Test - public void testGetBearerTokenException() { - try { - String token = tokenUtils.getBearerToken(new InvalidTokenProvider(true)); - } catch (SkyflowException e) { - assertEquals(e.getMessage(), "EXCEPTION THROWN!!"); - } - } -} diff --git a/v1/src/test/java/com/skyflow/common/utils/TokenUtilsValidTokenTest.java b/v1/src/test/java/com/skyflow/common/utils/TokenUtilsValidTokenTest.java deleted file mode 100644 index 75623fb7..00000000 --- a/v1/src/test/java/com/skyflow/common/utils/TokenUtilsValidTokenTest.java +++ /dev/null @@ -1,88 +0,0 @@ -package com.skyflow.common.utils; - -import com.skyflow.entities.TokenProvider; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import org.apache.commons.codec.binary.Base64; -import org.json.simple.JSONObject; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; -import static org.junit.Assert.assertEquals; - -class ValidTokenProvider implements TokenProvider { - - @Override - public String getBearerToken() throws Exception { - return "aa.valid_token.dd"; - } -} -class InvalidBearerTokenProvider implements TokenProvider { - - @Override - public String getBearerToken() throws Exception { - return "aa.invalid_token.dd"; - } -} - -class MockDataProvider { - - public byte[] returnValidDecodeBytes(){ - JSONObject validJson = new JSONObject(); - validJson.put("exp", (System.currentTimeMillis()+3000) / 1000); - byte[] encodedBytes = Base64.encodeBase64(validJson.toJSONString().getBytes()); - return Base64.decodeBase64(encodedBytes); - - } - public byte[] returnInValidDecodeBytes(){ - JSONObject expiredJson = new JSONObject(); - expiredJson.put("exp", (System.currentTimeMillis()-3000) / 1000); - byte[] encodedByte = Base64.encodeBase64(expiredJson.toJSONString().getBytes()); - return Base64.decodeBase64(encodedByte); - - } -} - - -@RunWith(PowerMockRunner.class) -@PrepareForTest(fullyQualifiedNames = "org.apache.commons.codec.binary.Base64") -public class TokenUtilsValidTokenTest { - - @Before - public void init(){ - MockDataProvider dd = new MockDataProvider(); - byte[] validDecodeBytes = dd.returnValidDecodeBytes(); - byte[] inValidDecodeBytes = dd.returnInValidDecodeBytes(); - PowerMockito.mockStatic(Base64.class); - PowerMockito.when(Base64.decodeBase64("valid_token")).thenReturn(validDecodeBytes); - PowerMockito.when(Base64.decodeBase64("invalid_token")).thenReturn(inValidDecodeBytes); - } - @Test - public void testValidToken() { - try { - TokenUtils tokenUtils = new TokenUtils(); - String token = tokenUtils.getBearerToken(new ValidTokenProvider()); - assertEquals(token,"aa.valid_token.dd"); - String secondToken = tokenUtils.getBearerToken(new ValidTokenProvider()); - assertEquals(secondToken,"aa.valid_token.dd"); - } catch (SkyflowException e) { - Assert.fail("Should not throw EXCEPTION !!"); - } - } - - @Test - public void testInValidToken() { - try { - TokenUtils tokenUtils = new TokenUtils(); - String token = tokenUtils.getBearerToken(new InvalidBearerTokenProvider()); - Assert.fail("should throw execution"); - } catch (SkyflowException e) { - assertEquals(e.getMessage(), ErrorCode.BearerTokenExpired.getDescription()); - - } - } -} diff --git a/v1/src/test/java/com/skyflow/common/utils/ValidatorsTest.java b/v1/src/test/java/com/skyflow/common/utils/ValidatorsTest.java deleted file mode 100644 index 52abcc15..00000000 --- a/v1/src/test/java/com/skyflow/common/utils/ValidatorsTest.java +++ /dev/null @@ -1,160 +0,0 @@ -package com.skyflow.common.utils; - - -import com.skyflow.entities.GetOptions; -import com.skyflow.entities.GetRecordInput; -import com.skyflow.entities.RedactionType; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - -@RunWith(PowerMockRunner.class) -@PrepareForTest(fullyQualifiedNames = "com.skyflow.common.utils.TokenUtils") -public class ValidatorsTest { - private static String tableName = null; - private static String columnName = null; - private static String[] columnValue = new String[1]; - private static String[] ids = new String[1]; - private static String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; - - @BeforeClass - public static void setup() throws SkyflowException { - PowerMockito.mockStatic(TokenUtils.class); - PowerMockito.when(TokenUtils.isTokenValid("valid_token")).thenReturn(true); - PowerMockito.when(TokenUtils.isTokenValid("not_a_valid_token")).thenReturn(false); - - tableName = "account_details"; - columnName = "card_number"; - columnValue[0] = "123451234554321"; - ids[0] = "123451234554321"; - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void validateGetRequestRecordValidTest() { - //column values with redaction - GetRecordInput recordInput = new GetRecordInput(); - - recordInput.setTable(tableName); - recordInput.setColumnValues(columnValue); - recordInput.setColumnName(columnName); - recordInput.setRedaction(RedactionType.PLAIN_TEXT); - try { - Validators.validateGetRequestRecord(recordInput, new GetOptions(false)); - } catch (SkyflowException exception) { - exception.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void validateGetRequestRecordValidIdTest() { - //Id values with redaction - - GetRecordInput recordInput = new GetRecordInput(); - recordInput.setTable(tableName); - recordInput.setIds(ids); - recordInput.setRedaction(RedactionType.PLAIN_TEXT); - try { - Validators.validateGetRequestRecord(recordInput, new GetOptions(false)); - } catch (SkyflowException exception) { - exception.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - // missing redaction when token is false - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void validateGetRequestRecordMisiingRedaction() { - //Id values with redaction - - GetRecordInput recordInput = new GetRecordInput(); - recordInput.setTable(tableName); - recordInput.setIds(ids); - try { - Validators.validateGetRequestRecord(recordInput, new GetOptions(false)); - } catch (SkyflowException exception) { - Assert.assertTrue(ErrorCode.MissingRedaction.getDescription().contains(exception.getMessage())); - exception.printStackTrace(); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void validateGetRequestRecordValidIdTokenTrueTest() throws SkyflowException { - //Id values with redaction - - GetRecordInput recordInput = new GetRecordInput(); - recordInput.setTable(tableName); - recordInput.setIds(ids); - try { - Validators.validateGetRequestRecord(recordInput, new GetOptions(true)); - } catch (SkyflowException exception) { - exception.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void validateGetRequestRecordIdRedactionTokenTest() throws SkyflowException { - //Id values with redaction - - GetRecordInput recordInput = new GetRecordInput(); - recordInput.setTable(tableName); - recordInput.setIds(ids); - recordInput.setRedaction(RedactionType.PLAIN_TEXT); - - try { - Validators.validateGetRequestRecord(recordInput, new GetOptions(true)); - } catch (SkyflowException e) { - Assert.assertTrue(ErrorCode.RedactionWithTokenNotSupported.getDescription().contains(e.getMessage())); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void validateGetRequestRecordColumnRedactionTokenTest() { - //Id values with redaction - GetRecordInput recordInput = new GetRecordInput(); - recordInput.setTable(tableName); - recordInput.setColumnName(columnName); - recordInput.setColumnValues(columnValue); - recordInput.setRedaction(RedactionType.PLAIN_TEXT); - - try { - Validators.validateGetRequestRecord(recordInput, new GetOptions(true)); - } catch (SkyflowException e) { - Assert.assertTrue(ErrorCode.TokensGetColumnNotSupported.getDescription().contains(e.getMessage())); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void validateGetRecordColumnNameIDSBothSpecified() { - GetRecordInput recordInput = new GetRecordInput(); - recordInput.setTable(tableName); - recordInput.setIds(ids); - recordInput.setColumnName(columnName); - recordInput.setColumnValues(columnValue); - recordInput.setRedaction(RedactionType.PLAIN_TEXT); - - try { - Validators.validateGetRequestRecord(recordInput, new GetOptions(false)); - } catch (SkyflowException e) { - Assert.assertTrue(ErrorCode.SkyflowIdAndColumnNameBothSpecified.getDescription().contains(e.getMessage())); - } - } - @Test - public void getOptionsTest(){ - GetOptions options = new GetOptions(); - Assert.assertFalse(options.getOptionToken()); - } - @Test - public void getOptionsTestWhenTokenTrue(){ - GetOptions options = new GetOptions(true); - Assert.assertTrue(options.getOptionToken()); - } - -} diff --git a/v1/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTest.java b/v1/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTest.java deleted file mode 100644 index e78501e0..00000000 --- a/v1/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTest.java +++ /dev/null @@ -1,275 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.serviceaccount.util; - -import com.skyflow.Configuration; -import com.skyflow.common.utils.Helpers; -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.entities.LogLevel; -import com.skyflow.entities.ResponseToken; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; - -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; -import org.junit.Assert; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentMatchers; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; -import java.io.File; -import java.io.FileNotFoundException; -import java.io.FileReader; -import java.io.IOException; -import java.net.URL; -import java.util.Map; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.ArgumentMatchers.eq; - -@RunWith(PowerMockRunner.class) -@PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility"}) -public class BearerTokenTest { - - private final String VALID_CREDENTIALS_FILE_PATH = "./credentials.json"; - - @Test - public void testEmptyFilePath() { - Configuration.setLogLevel(LogLevel.DEBUG); - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials(new File("")) - .build(); - try { - token.getBearerToken(); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), ErrorCode.EmptyFilePath.getDescription()); - } - } - - @Test - public void testNullFile() { - Configuration.setLogLevel(LogLevel.DEBUG); - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials((File) null) - .build(); - try { - token.getBearerToken(); - - } catch (SkyflowException exception) { - assertEquals(ErrorCode.EmptyJSONString.getDescription(), exception.getMessage()); - } - } - - @Test - public void testInvalidFileContent() { - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials(new File("./src/test/resources/invalidCredentials.json")) - .build(); - try { - token.getBearerToken(); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), ErrorCode.InvalidClientID.getDescription()); - } - - } - - @Test - public void testFileNotFound() { - String fileNotFoundPath = "./src/test/resources/nofile.json"; - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials(new File(fileNotFoundPath)) - .build(); - try { - token.getBearerToken(); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), - Helpers.parameterizedString(ErrorCode.InvalidCredentialsPath.getDescription(), fileNotFoundPath)); - } - } - - @Test - public void testFiledIsNotJsonFile() { - String notJsonFilePath = "./src/test/resources/notJson.txt"; - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials(new File(notJsonFilePath)) - .build(); - try { - token.getBearerToken(); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), - Helpers.parameterizedString(ErrorCode.InvalidJsonFormat.getDescription(), notJsonFilePath)); - } - } - - @Test - public void testEmptyString() { - Configuration.setLogLevel(LogLevel.DEBUG); - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials("") - .build(); - try { - token.getBearerToken(); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), ErrorCode.EmptyFilePath.getDescription()); - } - } - - @Test - public void testNullString() { - Configuration.setLogLevel(LogLevel.DEBUG); - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials((String) null) - .build(); - try { - token.getBearerToken(); - - } catch (SkyflowException exception) { - assertEquals(ErrorCode.EmptyJSONString.getDescription(), exception.getMessage()); - } - } - - @Test - public void testInvalidString() { - String creds = "key:'not_a_json'"; - Configuration.setLogLevel(LogLevel.DEBUG); - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials(creds) - .build(); - try { - token.getBearerToken(); - } catch (SkyflowException exception) { - assertEquals(ErrorCode.InvalidJSONStringFormat.getDescription(), exception.getMessage()); - } - } - - @Test - public void testInvalidKeyId() { - String creds = "{\"clientID\":\"test_client_ID\"}"; - Configuration.setLogLevel(LogLevel.DEBUG); - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials(creds) - .build(); - try { - token.getBearerToken(); - } catch (SkyflowException exception) { - assertEquals(ErrorCode.InvalidKeyID.getDescription(), exception.getMessage()); - } - } - - @Test - public void testInvalidTokenURI() { - String creds = "{\"clientID\":\"test_client_ID\",\"keyID\":\"test_key_id\"}"; - Configuration.setLogLevel(LogLevel.DEBUG); - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials(creds) - .build(); - try { - token.getBearerToken(); - } catch (SkyflowException exception) { - assertEquals(ErrorCode.InvalidTokenURI.getDescription(), exception.getMessage()); - } - } - - @Test - public void testEmptyContext() { - Configuration.setLogLevel(LogLevel.DEBUG); - String creds = System.getProperty("TEST_CREDENTIALS_FILE_STRING_WITH_CONTEXT"); - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials(creds) - .setCtx("") - .build(); - try { - token.getBearerToken(); - } catch (SkyflowException exception) { - assertEquals(ErrorCode.EmptyContext.getDescription(), exception.getMessage()); - } - } - - @Test - public void testEmptyRoleProvided() { - Configuration.setLogLevel(LogLevel.DEBUG); - String creds = System.getProperty("TEST_CREDENTIALS_FILE_STRING_WITH_CONTEXT"); - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials(creds) - .setCtx("abcd") - .setRoles(new String[] { "" }) - .build(); - try { - token.getBearerToken(); - } catch (SkyflowException exception) { - assertEquals(ErrorCode.IncorrectRole.getDescription(), exception.getMessage()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility"}) - public void testValidWithContextString() { - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"accessToken\":\"valid.bearer.token\",\"tokenType\":\"Bearer\"}"; - try { - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials(new File(VALID_CREDENTIALS_FILE_PATH)) - .setCtx("abc") - .build(); - - String bearerToken = token.getBearerToken(); - assertEquals(bearerToken,"valid.bearer.token"); - } catch (SkyflowException | IOException exception) { - assertNull(exception); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility"}) - public void testValidWithRoles() { - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"accessToken\":\"valid.bearer.token\",\"tokenType\":\"Bearer\"}"; - try { - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials(new File(VALID_CREDENTIALS_FILE_PATH)) - .setCtx("abc") - .setRoles(new String[]{"role_id"}) - .build(); - - String bearerToken = token.getBearerToken(); - assertEquals(bearerToken,"valid.bearer.token"); - } catch (SkyflowException | IOException exception) { - assertNull(exception); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility"}) - public void testValidWithContextFromCreds() { - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"accessToken\":\"valid.bearer.token\",\"tokenType\":\"Bearer\"}"; - try { - JSONParser parser = new JSONParser(); - Object obj = parser.parse(new FileReader(VALID_CREDENTIALS_FILE_PATH)); - JSONObject saCreds = (JSONObject) obj; - - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - BearerToken token = new BearerToken.BearerTokenBuilder() - .setCredentials(saCreds.toJSONString()) - .setCtx("abc") - .setRoles(new String[]{"role_id"}) - .build(); - - String bearerToken = token.getBearerToken(); - assertEquals(bearerToken,"valid.bearer.token"); - } catch (SkyflowException | IOException | ParseException exception) { - assertNull(exception); - } - } - - -} diff --git a/v1/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokenResponseTest.java b/v1/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokenResponseTest.java deleted file mode 100644 index b75cb031..00000000 --- a/v1/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokenResponseTest.java +++ /dev/null @@ -1,19 +0,0 @@ -package com.skyflow.serviceaccount.util; - -import com.skyflow.errors.ErrorCode; -import org.junit.Assert; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; - -public class SignedDataTokenResponseTest { - @Test - public void testSignedDataTokenResponse() { - String response = "{dataToken: token,signedDataToken: signed_token}"; - SignedDataTokenResponse res = new SignedDataTokenResponse("token", "signed_token"); - Assert.assertNotNull(res); - assertEquals(response,res.toString()); - assertEquals(res.dataToken, "token"); - assertEquals(res.signedDataToken, "signed_token"); - } -} diff --git a/v1/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTest.java b/v1/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTest.java deleted file mode 100644 index 00e74383..00000000 --- a/v1/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTest.java +++ /dev/null @@ -1,197 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.serviceaccount.util; - -import com.skyflow.Configuration; -import com.skyflow.common.utils.Helpers; -import com.skyflow.entities.LogLevel; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; -import org.junit.Assert; -import org.junit.Test; -import java.io.File; -import java.io.FileReader; -import java.io.IOException; -import java.util.List; - -import static org.junit.Assert.*; - -public class SignedDataTokensTest { - - private final String VALID_CREDENTIALS_FILE_PATH = "./credentials.json"; - - @Test - public void testEmptyFilePath() { - Configuration.setLogLevel(LogLevel.DEBUG); - SignedDataTokens token = new SignedDataTokens.SignedDataTokensBuilder() - .setCredentials(new File("")) - .build(); - try { - token.getSignedDataTokens(); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), ErrorCode.EmptyFilePath.getDescription()); - } - } - - @Test - public void testNullFile() { - Configuration.setLogLevel(LogLevel.DEBUG); - SignedDataTokens token = new SignedDataTokens.SignedDataTokensBuilder() - .setCredentials((File) null) - .build(); - try { - token.getSignedDataTokens(); - - } catch (SkyflowException exception) { - assertEquals(ErrorCode.EmptyJSONString.getDescription(), exception.getMessage()); - } - } - - @Test - public void testInvalidFileContent() { - SignedDataTokens token = new SignedDataTokens.SignedDataTokensBuilder() - .setCredentials(new File("./src/test/resources/invalidCredentials.json")) - .build(); - try { - token.getSignedDataTokens(); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), ErrorCode.InvalidClientID.getDescription()); - } - } - - @Test - public void testFileNotFound() { - String fileNotFoundPath = "./src/test/resources/nofile.json"; - SignedDataTokens token = new SignedDataTokens.SignedDataTokensBuilder() - .setCredentials(new File(fileNotFoundPath)) - .build(); - try { - token.getSignedDataTokens(); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), - Helpers.parameterizedString(ErrorCode.InvalidCredentialsPath.getDescription(), fileNotFoundPath)); - } - } - - @Test - public void testFiledIsNotJsonFile() { - String notJsonFilePath = "./src/test/resources/notJson.txt"; - SignedDataTokens token = new SignedDataTokens.SignedDataTokensBuilder() - .setCredentials(new File(notJsonFilePath)) - .build(); - try { - token.getSignedDataTokens(); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), - Helpers.parameterizedString(ErrorCode.InvalidJsonFormat.getDescription(), notJsonFilePath)); - } - } - - @Test - public void testEmptyString() { - Configuration.setLogLevel(LogLevel.DEBUG); - SignedDataTokens token = new SignedDataTokens.SignedDataTokensBuilder() - .setCredentials("") - .build(); - try { - token.getSignedDataTokens(); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), ErrorCode.EmptyFilePath.getDescription()); - } - } - - @Test - public void testNullString() { - Configuration.setLogLevel(LogLevel.DEBUG); - SignedDataTokens token = new SignedDataTokens.SignedDataTokensBuilder() - .setCredentials((String) null) - .build(); - try { - token.getSignedDataTokens(); - - } catch (SkyflowException exception) { - assertEquals(ErrorCode.EmptyJSONString.getDescription(), exception.getMessage()); - } - } - - @Test - public void testInvalidString() { - String creds = "key:'not_a_json'"; - Configuration.setLogLevel(LogLevel.DEBUG); - SignedDataTokens token = new SignedDataTokens.SignedDataTokensBuilder() - .setCredentials(creds) - .build(); - try { - token.getSignedDataTokens(); - } catch (SkyflowException exception) { - assertEquals(ErrorCode.InvalidJSONStringFormat.getDescription(), exception.getMessage()); - } - } - - @Test - public void testInvalidKeyId() { - String creds = "{\"clientID\":\"test_client_ID\"}"; - Configuration.setLogLevel(LogLevel.DEBUG); - SignedDataTokens token = new SignedDataTokens.SignedDataTokensBuilder() - .setCredentials(creds) - .build(); - try { - token.getSignedDataTokens(); - } catch (SkyflowException exception) { - assertEquals(ErrorCode.InvalidKeyID.getDescription(), exception.getMessage()); - } - } - - @Test - public void testNoDataTokenProvided() { - String creds = System.getProperty("TEST_CREDENTIALS_FILE_STRING"); - SignedDataTokens token = new SignedDataTokens.SignedDataTokensBuilder() - .setCredentials(creds) - .setDataTokens(new String[] {}).build(); - try { - assertTrue(token.getSignedDataTokens().isEmpty()); - - } catch (SkyflowException exception) { - System.out.println(exception); - } - } - - @Test - public void testValidSignedTokenWithTTL() { - try { - JSONParser parser = new JSONParser(); - Object obj = parser.parse(new FileReader(VALID_CREDENTIALS_FILE_PATH)); - JSONObject saCreds = (JSONObject) obj; - SignedDataTokens token = new SignedDataTokens.SignedDataTokensBuilder() - .setCredentials(saCreds.toJSONString()) - .setCtx("abc") - .setTimeToLive(30) - .setDataTokens(new String[] { "5230-0316-0674-5728" }).build(); - List signedToken = token.getSignedDataTokens(); - Assert.assertNotNull(signedToken); - - } catch (SkyflowException | IOException | ParseException exception) { - assertNull(exception); - } - } - - @Test - public void testValidSignedToken() { - try { - SignedDataTokens token = new SignedDataTokens.SignedDataTokensBuilder() - .setCredentials(new File(VALID_CREDENTIALS_FILE_PATH)) - .setCtx("abc") - .setDataTokens(new String[] { "5230-0316-0674-5728" }).build(); - List signedToken = token.getSignedDataTokens(); - Assert.assertNotNull(signedToken); - - } catch (SkyflowException exception) { - assertNull(exception); - } - } - -} diff --git a/v1/src/test/java/com/skyflow/serviceaccount/util/TokenTest.java b/v1/src/test/java/com/skyflow/serviceaccount/util/TokenTest.java deleted file mode 100644 index 19eee9e1..00000000 --- a/v1/src/test/java/com/skyflow/serviceaccount/util/TokenTest.java +++ /dev/null @@ -1,229 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.serviceaccount.util; - -import com.skyflow.Configuration; -import com.skyflow.common.utils.Helpers; -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.common.utils.TokenUtils; -import com.skyflow.entities.LogLevel; -import com.skyflow.entities.ResponseToken; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentMatchers; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - -import java.io.FileReader; -import java.io.IOException; -import java.net.URL; -import java.nio.file.Paths; -import java.util.Map; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; -import static org.mockito.ArgumentMatchers.anyString; - -@RunWith(PowerMockRunner.class) -@PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) -public class TokenTest { - // replace the path, when running local, do not commit - private final String VALID_CREDENTIALS_FILE_PATH = "./credentials.json"; - - private static String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; - @Test - public void testInvalidFilePath() { - try { - Configuration.setLogLevel(LogLevel.DEBUG); - Token.GenerateToken(""); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), ErrorCode.EmptyFilePath.getDescription()); - } - - } - - @Test - public void testNullFilePath() { - try { - Token.generateBearerToken(""); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), ErrorCode.EmptyFilePath.getDescription()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInvalidFileContent() { - try { - Token.generateBearerToken(Paths.get("./src/test/resources/invalidCredentials.json").toString()); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), ErrorCode.InvalidClientID.getDescription()); - } - - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testFileNotFoundPath() { - String fileNotFoundPath = "./src/test/resources/nofile.json"; - try { - Token.generateBearerToken(Paths.get(fileNotFoundPath).toString()); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), Helpers.parameterizedString(ErrorCode.InvalidCredentialsPath.getDescription(), fileNotFoundPath)); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testFiledNotJsonFile() { - String notJsonFilePath = "./src/test/resources/notJson.txt"; - try { - Token.generateBearerToken(Paths.get(notJsonFilePath).toString()); - } catch (SkyflowException exception) { - assertEquals(exception.getMessage(), Helpers.parameterizedString(ErrorCode.InvalidJsonFormat.getDescription(), notJsonFilePath)); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testCallingDeprecatedMethod() { - try { - PowerMockito.mockStatic(TokenUtils.class); - PowerMockito.when(TokenUtils.isTokenValid("a.b.c")).thenReturn(true); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"accessToken\":\"a.b.c\",\"tokenType\":\"Bearer\"}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - ResponseToken token = Token.GenerateToken(VALID_CREDENTIALS_FILE_PATH); - Assert.assertNotNull(token.getAccessToken()); - Assert.assertEquals("Bearer", token.getTokenType()); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - Assert.assertNull(skyflowException); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testValidFileContent() { - try { - PowerMockito.mockStatic(TokenUtils.class); - PowerMockito.when(TokenUtils.isTokenValid("a.b.c")).thenReturn(true); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"accessToken\":\"a.b.c\",\"tokenType\":\"Bearer\"}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - ResponseToken token = Token.generateBearerToken(VALID_CREDENTIALS_FILE_PATH); - Assert.assertNotNull(token.getAccessToken()); - Assert.assertEquals("Bearer", token.getTokenType()); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - Assert.assertNull(skyflowException); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testValidString() { - try { - JSONParser parser = new JSONParser(); - Object obj = parser.parse(new FileReader(VALID_CREDENTIALS_FILE_PATH)); - JSONObject saCreds = (JSONObject) obj; - - PowerMockito.mockStatic(TokenUtils.class); - PowerMockito.when(TokenUtils.isTokenValid("a.b.c")).thenReturn(true); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"accessToken\":\"a.b.c\",\"tokenType\":\"Bearer\"}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - - ResponseToken token = Token.generateBearerTokenFromCreds(saCreds.toJSONString()); - Assert.assertNotNull(token.getAccessToken()); - Assert.assertEquals("Bearer", token.getTokenType()); - } catch (SkyflowException | IOException | ParseException skyflowException) { - skyflowException.printStackTrace(); - Assert.assertNull(skyflowException); - } - } - - @Test - public void testEmptyString() { - try { - ResponseToken token = Token.generateBearerTokenFromCreds(""); - } catch (SkyflowException exception) { - assertEquals(ErrorCode.EmptyJSONString.getDescription(), exception.getMessage()); - } - } - - @Test - public void testNullString() { - try { - ResponseToken token = Token.generateBearerTokenFromCreds(null); - } catch (SkyflowException exception) { - assertEquals(ErrorCode.EmptyJSONString.getDescription(), exception.getMessage()); - } - } - - @Test - public void testInvalidString() { - String creds = "key:'not_a_json'"; - try { - ResponseToken token = Token.generateBearerTokenFromCreds(creds); - } catch (SkyflowException exception) { - assertEquals(ErrorCode.InvalidJSONStringFormat.getDescription(), exception.getMessage()); - } - } - - @Test - public void testInvalidKeyId() { - String creds = "{\"clientID\":\"test_client_ID\"}"; - try { - ResponseToken token = Token.generateBearerTokenFromCreds(creds); - } catch (SkyflowException exception) { - assertEquals(ErrorCode.InvalidKeyID.getDescription(), exception.getMessage()); - } - } - - @Test - public void testInvalidTokenURI() { - String creds = "{\"clientID\":\"test_client_ID\",\"keyID\":\"test_key_id\"}"; - try { - ResponseToken token = Token.generateBearerTokenFromCreds(creds); - } catch (SkyflowException exception) { - assertEquals(ErrorCode.InvalidTokenURI.getDescription(), exception.getMessage()); - } - } - - @Test - public void testIsValidForEmptyToken() { - String token = ""; - assertEquals(false, Token.isValid(token)); - } - - @Test - public void testIsValidForInvalidToken() { - String token = "invalidToken"; - assertEquals(false, Token.isValid(token)); - } - - @Test - public void testIsExpiredForExpiredToken() { - String token = System.getProperty("TEST_EXPIRED_TOKEN"); - assertEquals(true, Token.isExpired(token)); - } - -} \ No newline at end of file diff --git a/v1/src/test/java/com/skyflow/vault/DeleteMethodTest.java b/v1/src/test/java/com/skyflow/vault/DeleteMethodTest.java deleted file mode 100644 index 9ad439e8..00000000 --- a/v1/src/test/java/com/skyflow/vault/DeleteMethodTest.java +++ /dev/null @@ -1,421 +0,0 @@ -package com.skyflow.vault; - -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.common.utils.TokenUtils; -import com.skyflow.common.utils.Validators; -import com.skyflow.entities.DeleteRecordInput; -import com.skyflow.entities.RedactionType; -import com.skyflow.entities.SkyflowConfiguration; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentMatchers; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - -import java.io.IOException; -import java.net.URL; - -import static org.junit.Assert.*; - -@RunWith(PowerMockRunner.class) -@PrepareForTest(fullyQualifiedNames = "com.skyflow.common.utils.TokenUtils") -public class DeleteMethodTest { - private static String vaultID = null; - private static String vaultURL = null; - private static String skyflowId = null; - private static String token = null; - private static String tableName = null; - private static String columnName = null; - private static String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; - - - @BeforeClass - public static void setup() throws SkyflowException { - PowerMockito.mockStatic(TokenUtils.class); - PowerMockito.when(TokenUtils.isTokenValid("valid_token")).thenReturn(true); - PowerMockito.when(TokenUtils.isTokenValid("not_a_valid_token")).thenReturn(false); - - vaultID = "vault123"; - vaultURL = "https://test.com"; - skyflowId = "skyflowId123"; - token = "token123"; - tableName = "pii_fields"; - columnName = "first_name"; - } - @Test - public void testValidInput() { - DeleteRecordInput validInput = new DeleteRecordInput(); - validInput.setTable("users"); - validInput.setId("12345"); - - try { - Validators.validateDeleteBySkyflowId(validInput); - } catch (SkyflowException e) { - fail("Unexpected exception thrown"); - } - } - @Test - public void testValidInputCase2() { - DeleteRecordInput validInput = new DeleteRecordInput(); - validInput.setTable(""); - validInput.setId("12345"); - - try { - Validators.validateDeleteBySkyflowId(validInput); - } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.InvalidTable.getDescription(), e.getMessage()); - } - } - @Test - public void testValidInputCase3() { - DeleteRecordInput validInput = new DeleteRecordInput(); - validInput.setTable(null); - validInput.setId("12345"); - - try { - Validators.validateDeleteBySkyflowId(validInput); - } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.InvalidTable.getDescription(), e.getMessage()); - } - } - @Test - public void testValidInputCase4() { - DeleteRecordInput validInput = new DeleteRecordInput(); - validInput.setTable("table"); - validInput.setId(null); - - try { - Validators.validateDeleteBySkyflowId(validInput); - } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.InvalidId.getDescription(), e.getMessage()); - } - } - @Test - public void testValidInputInvalidInput() { - DeleteRecordInput validInput = new DeleteRecordInput(); - validInput.setTable("table"); - validInput.setId(""); - - try { - Validators.validateDeleteBySkyflowId(validInput); - } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.InvalidId.getDescription(), e.getMessage()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testDeleteEmptyRecords() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - records.put("records", recordsArray); - JSONObject response = skyflowClient.delete(records); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.EmptyRecords.getDescription(), skyflowException.getMessage()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testDeleteEmptyRecordsCase2() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - records.put("", recordsArray); - JSONObject response = skyflowClient.delete(records); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidDeleteInput.getDescription(), skyflowException.getMessage()); - } - } - @Test - public void testDeleteMethodErrorWhenNullRecordsArePassed() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - records.put("records", null); - - JSONObject response = skyflowClient.delete(records); - - } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.EmptyRecords.getDescription(), e.getMessage()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.TokenUtils"}) - public void testDeleteMethodErrorWhenNullTableNameIsPassed() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - record.put("table", null); - - recordsArray.add(record); - records.put("records", recordsArray); - - JSONObject response = skyflowClient.delete(records); - - } catch (SkyflowException skyflowException) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) skyflowException.getData().get("errors")).get(0))).get("error"); - Assert.assertEquals(ErrorCode.InvalidTable.getDescription(), error.get("description")); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testDeleteEmptyRecordsCase3() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONObject record = new JSONObject(); - - JSONArray recordsArray = new JSONArray(); - recordsArray.add(record); - record.put("table", "name"); - records.put("records", recordsArray); - JSONObject response = skyflowClient.delete(records); - } catch (SkyflowException skyflowException) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) skyflowException.getData().get("errors")).get(0))).get("error"); - Assert.assertEquals(ErrorCode.InvalidId.getDescription(), error.get("description")); - } - - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testDeleteMethodErrorWhenWrongTableNameIsPassed() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - record.put("id", "skyflowid"); - record.put("table", "invalidTable"); - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"error\":{\"grpc_code\":13,\"http_code\":500,\"message\":\"Couldn't load data\",\"http_status\":\"Internal Server Error\"}}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new SkyflowException(500, mockResponse)); - - JSONObject response = skyflowClient.delete(records); - - } catch (SkyflowException e) { - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - } catch (IOException e) { - e.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testDeleteMethodPartialError() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject firstRecord = new JSONObject(); - firstRecord.put("id", "id1"); - firstRecord.put("table", "table1"); - - - JSONObject secondRecord = new JSONObject(); - secondRecord.put("id", "id2"); - secondRecord.put("table", "invalidTable1"); - - JSONObject thirdRecord = new JSONObject(); - thirdRecord.put("id", "id3"); - thirdRecord.put("table", "invalidTable2"); - - - recordsArray.add(firstRecord); - recordsArray.add(secondRecord); - recordsArray.add(thirdRecord); - records.put("records", recordsArray); - - String firstRequestUrl = "https://test.com/v1/vaults/vault123/table1/id1"; - String secondRequestUrl = "https://test.com/v1/vaults/vault123/invalidTable1/id2"; - String thirdRequestUrl = "https://test.com/v1/vaults/vault123/invalidTable2/id3"; - - PowerMockito.mockStatic(HttpUtility.class); - String mockValidResponse = "{\"skyflow_id\":\"id1\",\"deleted\":\"true\"}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.eq(new URL(firstRequestUrl)), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenReturn(mockValidResponse); - - String mockInvalidResponse1 = "{\"error\":{\"http_code\":404,\"http_status\":\"Not Found\",\"details\":[],\"message\":\"No Records Found - requestId: 968fc4a8-53ef-92fb-9c0d-3393d3361790\",\"grpc_code\":5}}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.eq(new URL(secondRequestUrl)), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new SkyflowException(500, mockInvalidResponse1)); - - String mockInvalidResponse2 = "{\"error\":{\"http_code\":404,\"http_status\":\"Not Found\",\"details\":[],\"message\":\"No Records Found - requestId: 968fc4a8-53ef-92fb-9c0d-3393d3361790\",\"grpc_code\":5}}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.eq(new URL(thirdRequestUrl)), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new SkyflowException(500, mockInvalidResponse2)); - - JSONObject response = skyflowClient.delete(records); - - } catch (SkyflowException e) { - JSONObject partialError = e.getData(); - Assert.assertTrue(partialError.containsKey("records")); - Assert.assertTrue(partialError.containsKey("errors")); - - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(2, errors.size()); - } catch (IOException e) { - e.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testDeleteMethodSuccess() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - record.put("table", tableName); - record.put("id", "id1"); - - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"skyflow_id\":\"id1\",\"deleted\":\"true\"}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenReturn(mockResponse); - JSONObject response = skyflowClient.delete(records); - JSONArray responseRecords = (JSONArray) response.get("records"); - Assert.assertEquals(1, responseRecords.size()); - Assert.assertEquals("id1", ((JSONObject) responseRecords.get(0)).get("skyflow_id")); - Assert.assertEquals("true", ((JSONObject) responseRecords.get(0)).get("deleted")); - - } catch (SkyflowException | IOException exception) { - exception.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testDeleteMethodParseException() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - record.put("table", tableName); - record.put("id", "id1"); - - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"skyflow_id\":\"id1\",\"deleted\":\"true\"}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenReturn(mockResponse); - JSONObject response = skyflowClient.delete(records); - - } catch (SkyflowException e) { - String error = e.getMessage(); - assertEquals(ErrorCode.ThreadExecutionException.getDescription(), error); - } catch (IOException exception) { - exception.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodIOException() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - record.put("table", tableName); - record.put("id", "id1"); - - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"skyflow_id\":\"id1\",\"deleted\":\"true\"}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new IOException()); - - JSONObject response = skyflowClient.delete(records); - } catch (SkyflowException e) { - String error = e.getMessage(); - assertEquals(ErrorCode.ThreadExecutionException.getDescription(), error); - } catch (IOException exception) { - exception.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } -} diff --git a/v1/src/test/java/com/skyflow/vault/GetMethodTest.java b/v1/src/test/java/com/skyflow/vault/GetMethodTest.java deleted file mode 100644 index 2477cbbf..00000000 --- a/v1/src/test/java/com/skyflow/vault/GetMethodTest.java +++ /dev/null @@ -1,870 +0,0 @@ -package com.skyflow.vault; - -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.common.utils.TokenUtils; -import com.skyflow.entities.GetOptions; -import com.skyflow.entities.GetRecordInput; -import com.skyflow.entities.RedactionType; -import com.skyflow.entities.SkyflowConfiguration; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentMatchers; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - -import java.io.IOException; -import java.net.URL; - -import static org.junit.Assert.assertEquals; - -@RunWith(PowerMockRunner.class) -@PrepareForTest(fullyQualifiedNames = "com.skyflow.common.utils.TokenUtils") -public class GetMethodTest { - private static String vaultID = null; - private static String vaultURL = null; - private static String skyflowId = null; - private static String token = null; - private static String tableName = null; - private static String columnName = null; - private static String columnValue = null; - private static String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; - - @BeforeClass - public static void setup() throws SkyflowException { - PowerMockito.mockStatic(TokenUtils.class); - PowerMockito.when(TokenUtils.isTokenValid("valid_token")).thenReturn(true); - PowerMockito.when(TokenUtils.isTokenValid("not_a_valid_token")).thenReturn(false); - - vaultID = "vault123"; - vaultURL = "https://test.com"; - skyflowId = "skyflowId123"; - token = "token123"; - tableName = "account_details"; - columnName = "bank_account_number"; - columnValue = "123451234554321"; - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodSuccess() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray values = new JSONArray(); - values.add(columnValue); - - record.put("table", tableName); - record.put("columnName", columnName); - record.put("columnValues", values); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"records\":[{\"fields\":{\"bank_account_number\":\"123451234554321\",\"pin_code\":\"121342\",\"name\":\"vivek jain\",\"skyflow_id\":\"skyflowId123\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenReturn(mockResponse); - JSONObject response = skyflowClient.get(records); - JSONArray responseRecords = (JSONArray) response.get("records"); - - Assert.assertEquals(1, responseRecords.size()); - Assert.assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - Assert.assertNotNull(((JSONObject) responseRecords.get(0)).get("fields")); - - } catch (SkyflowException | IOException exception) { - exception.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - public void testGetMethodErrorWhenInvalidInputIsPassed() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - records.put("invalidRecordsKey", recordsArray); - - JSONObject response = skyflowClient.get(records); - } catch (SkyflowException skyflowException) { - Assert.assertEquals(ErrorCode.InvalidGetInput.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testGetMethodErrorWhenEmptyRecordsArePassed() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - records.put("records", recordsArray); - - JSONObject response = skyflowClient.get(records); - - } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.EmptyRecords.getDescription(), e.getMessage()); - } - } - - @Test - public void testGetMethodErrorWhenNullRecordsArePassed() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - records.put("records", null); - - JSONObject response = skyflowClient.get(records); - - } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.EmptyRecords.getDescription(), e.getMessage()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodErrorWhenNullTableNameIsPassed() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - record.put("table", null); - - recordsArray.add(record); - records.put("records", recordsArray); - - JSONObject response = skyflowClient.get(records); - - } catch (SkyflowException skyflowException) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) skyflowException.getData().get("errors")).get(0))).get("error"); - Assert.assertEquals(ErrorCode.InvalidTable.getDescription(), error.get("description")); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodErrorWhenEmptyTableNameIsPassed() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - record.put("table", " "); - - recordsArray.add(record); - records.put("records", recordsArray); - - JSONObject response = skyflowClient.get(records); - - } catch (SkyflowException skyflowException) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) skyflowException.getData().get("errors")).get(0))).get("error"); - Assert.assertEquals(ErrorCode.InvalidTable.getDescription(), error.get("description")); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodErrorWhenWrongTableNameIsPassed() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray ids = new JSONArray(); - ids.add(skyflowId); - - record.put("ids", ids); - record.put("table", "invalidTable"); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"error\":{\"grpc_code\":13,\"http_code\":500,\"message\":\"Couldn't load data\",\"http_status\":\"Internal Server Error\"}}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new SkyflowException(500, mockResponse)); - - JSONObject response = skyflowClient.get(records); - - } catch (SkyflowException e) { - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - } catch (IOException e) { - e.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodPartialError() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject firstRecord = new JSONObject(); - JSONArray firstRecordColumnValues = new JSONArray(); - firstRecordColumnValues.add(columnValue); - firstRecord.put("table", tableName); - firstRecord.put("columnName", columnName); - firstRecord.put("columnValues", firstRecordColumnValues); - firstRecord.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - JSONObject secondRecord = new JSONObject(); - JSONArray ids = new JSONArray(); - ids.add(skyflowId); - secondRecord.put("ids", ids); - secondRecord.put("table", "invalidTable"); - secondRecord.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - JSONObject thirdRecord = new JSONObject(); - JSONArray thirdRecordColumnValues = new JSONArray(); - thirdRecordColumnValues.add(columnValue); - thirdRecord.put("table", "invalidTable"); - thirdRecord.put("columnName", columnName); - thirdRecord.put("columnValues", thirdRecordColumnValues); - thirdRecord.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - recordsArray.add(firstRecord); - recordsArray.add(secondRecord); - recordsArray.add(thirdRecord); - records.put("records", recordsArray); - - String firstRequestUrl = "https://test.com/v1/vaults/vault123/account_details?column_name=bank_account_number&column_values=123451234554321&redaction=PLAIN_TEXT"; - String secondRequestUrl = "https://test.com/v1/vaults/vault123/invalidTable?skyflow_ids=skyflowId123&redaction=PLAIN_TEXT"; - String thirdRequestUrl = "https://test.com/v1/vaults/vault123/invalidTable?column_name=bank_account_number&column_values=123451234554321&redaction=PLAIN_TEXT"; - - PowerMockito.mockStatic(HttpUtility.class); - String mockValidResponse = "{\"records\":[{\"fields\":{\"bank_account_number\":\"123455432112345\",\"pin_code\":\"123123\",\"name\":\"vivek jain\",\"id\":\"492c21a1-107f-4d10-ba2c-3482a411827d\"},\"table\":\"account_details\"}]}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.eq(new URL(firstRequestUrl)), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenReturn(mockValidResponse); - - String mockInvalidResponse1 = "{\"error\":{\"code\":500,\"description\":\"Couldn't load data - requestId: 496c3a0b-3d24-9052-bbba-28bf3f04b97d\"},\"ids\":[\"skyflowId123\"]}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.eq(new URL(secondRequestUrl)), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new SkyflowException(500, mockInvalidResponse1)); - - String mockInvalidResponse2 = "{\"error\":{\"code\":500,\"description\":\"Couldn't load data - requestId: 496c3a0b-3d24-9052-bbba-28bf3f04b97d\"},\"columnName\":\"bank_account_number\"}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.eq(new URL(thirdRequestUrl)), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new SkyflowException(500, mockInvalidResponse2)); - - JSONObject response = skyflowClient.get(records); - - } catch (SkyflowException e) { - JSONObject partialError = e.getData(); - Assert.assertTrue(partialError.containsKey("records")); - Assert.assertTrue(partialError.containsKey("errors")); - - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(2, errors.size()); - } catch (IOException e) { - e.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodErrorWhenBothSkyflowIDsAndColumnDetailsArePassed() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray values = new JSONArray(); - values.add(columnValue); - - JSONArray ids = new JSONArray(); - ids.add(skyflowId); - - record.put("ids", ids); - record.put("table", tableName); - record.put("columnName", columnName); - record.put("columnValues", values); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"error\":{\"grpc_code\":13,\"http_code\":500,\"message\":\"Couldn't load data\",\"http_status\":\"Internal Server Error\"}}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new SkyflowException(500, mockResponse)); - JSONObject response = skyflowClient.get(records); - - } catch (SkyflowException e) { - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - } catch (IOException e) { - e.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodErrorWhenNeitherSkyflowIDsNorColumnDetailsArePassed() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - record.put("table", tableName); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"errors\":[{\"error\":{\"code\":400,\"description\":\"Provide either Ids or column name to get records.\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new SkyflowException(400, mockResponse)); - JSONObject response = skyflowClient.get(records); - - } catch (SkyflowException e) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) e.getData().get("errors")).get(0))).get("error"); - Assert.assertEquals(ErrorCode.MissingIdAndColumnName.getDescription(), error.get("description")); - } catch (IOException e) { - e.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodErrorWhenColumnNameIsPassedWithoutColumnValues() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - record.put("table", tableName); - record.put("columnName", columnName); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"errors\":[{\"error\":{\"code\":400,\"description\":\"Column Values can not be empty when Column Name is specified.\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new SkyflowException(500, mockResponse)); - JSONObject response = skyflowClient.get(records); - - } catch (SkyflowException e) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) e.getData().get("errors")).get(0))).get("error"); - Assert.assertEquals(ErrorCode.MissingRecordColumnValue.getDescription(), error.get("description")); - } catch (IOException e) { - e.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodErrorWhenColumnValuesArePassedWithoutColumnName() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray values = new JSONArray(); - values.add(columnValue); - - record.put("table", tableName); - record.put("columnValues", values); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"errors\":[{\"error\":{\"code\":400,\"description\":\"Column Name can not be empty when Column Values are specified.\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new SkyflowException(500, mockResponse)); - JSONObject response = skyflowClient.get(records); - - } catch (SkyflowException e) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) e.getData().get("errors")).get(0))).get("error"); - Assert.assertEquals(ErrorCode.MissingRecordColumnName.getDescription(), error.get("description")); - } catch (IOException e) { - e.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodIOException() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray values = new JSONArray(); - values.add(columnValue); - - record.put("table", tableName); - record.put("columnName", columnName); - record.put("columnValues", values); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "a{\"records\":[{\"fields\":{\"bank_account_number\":\"123451234554321\",\"pin_code\":\"121342\",\"name\":\"vivek jain\",\"skyflow_id\":\"skyflowId123\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new IOException()); - - JSONObject response = skyflowClient.get(records); - - } catch (SkyflowException e) { - String error = e.getMessage(); - assertEquals(ErrorCode.ThreadExecutionException.getDescription(), error); - } catch (IOException exception) { - exception.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodParseException() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray values = new JSONArray(); - values.add(columnValue); - - record.put("table", tableName); - record.put("columnName", columnName); - record.put("columnValues", values); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "a{\"records\":[{\"fields\":{\"bank_account_number\":\"123451234554321\",\"pin_code\":\"121342\",\"name\":\"vivek jain\",\"skyflow_id\":\"skyflowId123\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenReturn(mockResponse); - JSONObject response = skyflowClient.get(records); - - } catch (SkyflowException e) { - String error = e.getMessage(); - assertEquals(ErrorCode.ThreadExecutionException.getDescription(), error); - } catch (IOException exception) { - exception.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodWithNoRedactionNoToken() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray ids = new JSONArray(); - ids.add(skyflowId); - - record.put("ids", ids); - record.put("table", tableName); - - recordsArray.add(record); - records.put("records", recordsArray); - - skyflowClient.get(records); - - } catch (SkyflowException e) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) e.getData().get("errors")).get(0))).get("error"); - - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - Assert.assertEquals(error.get("description"), ErrorCode.MissingRedaction.getDescription()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodWithRedactionToken() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray ids = new JSONArray(); - ids.add(skyflowId); - - record.put("ids", ids); - record.put("table", tableName); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - recordsArray.add(record); - records.put("records", recordsArray); - - skyflowClient.get(records, new GetOptions(true)); - - } catch (SkyflowException e) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) e.getData().get("errors")).get(0))).get("error"); - - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - Assert.assertEquals(error.get("description"), ErrorCode.RedactionWithTokenNotSupported.getDescription()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodWithNoRedactionTokenForColumnValues() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray values = new JSONArray(); - values.add(columnValue); - - record.put("table", tableName); - record.put("columnName", columnName); - record.put("columnValues", values); - - recordsArray.add(record); - records.put("records", recordsArray); - - skyflowClient.get(records, new GetOptions(true)); - - } catch (SkyflowException e) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) e.getData().get("errors")).get(0))).get("error"); - - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - Assert.assertEquals(error.get("description"), ErrorCode.TokensGetColumnNotSupported.getDescription()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodWithRedactionWithTokenForColumnValues() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray values = new JSONArray(); - values.add(columnValue); - - record.put("table", tableName); - record.put("columnName", columnName); - record.put("columnValues", values); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - recordsArray.add(record); - records.put("records", recordsArray); - - - skyflowClient.get(records, new GetOptions(true)); - - } catch (SkyflowException e) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) e.getData().get("errors")).get(0))).get("error"); - - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - Assert.assertEquals(error.get("description"), ErrorCode.TokensGetColumnNotSupported.getDescription()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodWithNoRedactionNoTokenForColumnValues() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray values = new JSONArray(); - values.add(columnValue); - - record.put("table", tableName); - record.put("columnName", columnName); - record.put("columnValues", values); - - recordsArray.add(record); - records.put("records", recordsArray); - - skyflowClient.get(records); - - } catch (SkyflowException e) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) e.getData().get("errors")).get(0))).get("error"); - - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - Assert.assertEquals(error.get("description"), ErrorCode.MissingRedaction.getDescription()); - } - - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodWithNoRedactionFalseTokenForColumnValues() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray values = new JSONArray(); - values.add(columnValue); - - record.put("table", tableName); - record.put("columnName", columnName); - record.put("columnValues", values); - - recordsArray.add(record); - records.put("records", recordsArray); - - skyflowClient.get(records, new GetOptions(false)); - - } catch (SkyflowException e) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) e.getData().get("errors")).get(0))).get("error"); - - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - Assert.assertEquals(error.get("description"), ErrorCode.MissingRedaction.getDescription()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodWithNoRedactionFalseToken() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray ids = new JSONArray(); - ids.add(skyflowId); - - record.put("ids", ids); - record.put("table", tableName); - recordsArray.add(record); - records.put("records", recordsArray); - - skyflowClient.get(records, new GetOptions(false)); - - } catch (SkyflowException e) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) e.getData().get("errors")).get(0))).get("error"); - - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - Assert.assertEquals(error.get("description"), ErrorCode.MissingRedaction.getDescription()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodWithRedactionFalseTokenSuccess() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray ids = new JSONArray(); - ids.add(skyflowId); - - record.put("ids", ids); - record.put("table", tableName); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"records\":[{\"fields\":{\"bank_account_number\":\"123451234554321\",\"pin_code\":\"121342\",\"name\":\"demo\",\"skyflow_id\":\"skyflowId123\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenReturn(mockResponse); - JSONObject response = skyflowClient.get(records, new GetOptions(false)); - JSONArray responseRecords = (JSONArray) response.get("records"); - - Assert.assertEquals(1, responseRecords.size()); - Assert.assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - Assert.assertNotNull(((JSONObject) responseRecords.get(0)).get("fields")); - - } catch (SkyflowException | IOException exception) { - exception.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetMethodWithRedactionFalseTokenSuccess2() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - - JSONArray values = new JSONArray(); - values.add(columnValue); - - record.put("table", tableName); - record.put("columnName", columnName); - record.put("columnValues", values); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"records\":[{\"fields\":{\"bank_account_number\":\"123451234554321\",\"pin_code\":\"121342\",\"name\":\"demo\",\"skyflow_id\":\"skyflowId123\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenReturn(mockResponse); - JSONObject response = skyflowClient.get(records, new GetOptions(false)); - JSONArray responseRecords = (JSONArray) response.get("records"); - - Assert.assertEquals(1, responseRecords.size()); - Assert.assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - Assert.assertNotNull(((JSONObject) responseRecords.get(0)).get("fields")); - - } catch (SkyflowException | IOException exception) { - exception.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } - } - -} diff --git a/v1/src/test/java/com/skyflow/vault/InvokeConnectionTest.java b/v1/src/test/java/com/skyflow/vault/InvokeConnectionTest.java deleted file mode 100644 index 70319cc3..00000000 --- a/v1/src/test/java/com/skyflow/vault/InvokeConnectionTest.java +++ /dev/null @@ -1,258 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.vault; - -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.common.utils.TokenUtils; -import com.skyflow.entities.RequestMethod; -import com.skyflow.entities.SkyflowConfiguration; -import com.skyflow.entities.TokenProvider; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import org.json.simple.JSONObject; -import org.junit.Assert; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentMatchers; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - -import java.io.IOException; -import java.net.URL; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; -import static org.mockito.ArgumentMatchers.anyString; - - -class TestTokenProvider implements TokenProvider { - @Override - public String getBearerToken() throws Exception { - return "test_auth_token"; - } -} - - -@RunWith(PowerMockRunner.class) -@PrepareForTest(fullyQualifiedNames = "com.skyflow.common.utils.TokenUtils") -public class InvokeConnectionTest { - private static final String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; - private JSONObject testConfig; - private static Skyflow skyflowClient; - - @BeforeClass - public static void init() throws Exception { - SkyflowConfiguration config = new SkyflowConfiguration(new TestTokenProvider()); - skyflowClient = Skyflow.init(config); - - PowerMockito.mockStatic(TokenUtils.class); - PowerMockito.when(TokenUtils.isTokenValid("test_auth_token")).thenReturn(true); - } - - @Before - public void setup() { - testConfig = new JSONObject(); - testConfig.put("connectionURL", "https://testgatewayurl.com/{card_number}/pay"); - testConfig.put("methodName", RequestMethod.POST); - - JSONObject pathParamsJson = new JSONObject(); - pathParamsJson.put("card_number", "1234"); - testConfig.put("pathParams", pathParamsJson); - - JSONObject queryParamsJson = new JSONObject(); - queryParamsJson.put("id", "1"); - testConfig.put("queryParams", queryParamsJson); - - JSONObject requestHeadersJson = new JSONObject(); - requestHeadersJson.put("content-type", "application/json"); - testConfig.put("requestHeader", requestHeadersJson); - - JSONObject requestBodyJson = new JSONObject(); - requestBodyJson.put("userName", "testUser"); - requestBodyJson.put("itemName", "item1"); - testConfig.put("requestBody", requestBodyJson); - - } - - @Test - public void testInvokeConnectionWithInvalidSkyflowConfig() { - try{ - SkyflowConfiguration config = new SkyflowConfiguration(null); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject request = new JSONObject(); - - JSONObject res = skyflowClient.invokeConnection(request); - } catch (SkyflowException e) { - assertEquals(ErrorCode.InvalidTokenProvider.getDescription(), e.getMessage()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInvokeConnectionValidInput() { - try { - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"processingTimeinMs\":\"116\"}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject gatewayResponse = skyflowClient.invokeConnection(testConfig); - - Assert.assertNotNull(gatewayResponse); - Assert.assertEquals(gatewayResponse.toJSONString(), mockResponse); - } catch (SkyflowException exception) { - Assert.assertNull(exception); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException exception) { - exception.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - - - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInvokeConnectionThrowsErrorResponse() { - String mockErrorResponse = "{\"error\":{\"code\":\"400\",\"message\":\"missing required field\"}}"; - try { - PowerMockito.mockStatic(HttpUtility.class); - PowerMockito.when(HttpUtility.sendRequest(anyString(),ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenThrow(new SkyflowException(400, mockErrorResponse)); - JSONObject gatewayResponse = skyflowClient.invokeConnection(testConfig); - Assert.assertNull(gatewayResponse); - } catch (SkyflowException exception) { - Assert.assertEquals(exception.getCode(), 400); - Assert.assertEquals(exception.getMessage(), mockErrorResponse); - } catch (IOException exception) { - exception.printStackTrace(); - } - } - - - @Test - public void testInvokeConnectionInvalidConnectionURL() { - JSONObject testConnectionConfig = new JSONObject(); - testConnectionConfig.put("connectionURL", "INVALID_CONNECTION_URL"); - try { - skyflowClient.invokeConnection(testConnectionConfig); - } catch (SkyflowException exception) { - Assert.assertEquals(exception.getCode(), ErrorCode.InvalidConnectionURL.getCode()); - Assert.assertEquals(exception.getMessage(), ErrorCode.InvalidConnectionURL.getDescription()); - } - - } - - @Test - public void testInvokeConnectionMissingConnectionURL() { - JSONObject testConnectionConfig = new JSONObject(); - try { - skyflowClient.invokeConnection(testConnectionConfig); - } catch (SkyflowException exception) { - Assert.assertEquals(exception.getCode(), ErrorCode.ConnectionURLMissing.getCode()); - Assert.assertEquals(exception.getMessage(), ErrorCode.ConnectionURLMissing.getDescription()); - } - } - - @Test - public void testInvokeConnectionMissingMethodName() { - JSONObject testConnectionConfig = new JSONObject(); - testConnectionConfig.put("connectionURL", "https://testgatewayurl.com/{card_number}/pay"); - try { - skyflowClient.invokeConnection(testConnectionConfig); - } catch (SkyflowException exception) { - Assert.assertEquals(exception.getCode(), ErrorCode.MethodNameMissing.getCode()); - Assert.assertEquals(exception.getMessage(), ErrorCode.MethodNameMissing.getDescription()); - } - } - - @Test - public void testInvokeConnectionInvalidMethodName() { - JSONObject testConnectionConfig = new JSONObject(); - testConnectionConfig.put("connectionURL", "https://testgatewayurl.com/{card_number}/pay"); - testConnectionConfig.put("methodName", "INVALID_METHOD_NAME"); - try { - Skyflow.init(new SkyflowConfiguration(new TestTokenProvider())).invokeConnection(testConnectionConfig); - } catch (SkyflowException exception) { - Assert.assertEquals(exception.getCode(), ErrorCode.InvalidMethodName.getCode()); - Assert.assertEquals(exception.getMessage(), ErrorCode.InvalidMethodName.getDescription()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInvokeConnectionWithFormEncoded() { - JSONObject testConfig = new JSONObject(); - testConfig.put("connectionURL", "https://testgatewayurl.com/"); - testConfig.put("methodName", RequestMethod.POST); - - JSONObject requestHeadersJson = new JSONObject(); - requestHeadersJson.put("content-type", "application/x-www-form-urlencoded"); - testConfig.put("requestHeader", requestHeadersJson); - - JSONObject testJson = new JSONObject(); - testJson.put("key1","value1"); - JSONObject nestedObj = new JSONObject(); - nestedObj.put("key2","value2"); - testJson.put("nest",nestedObj); - - testConfig.put("requestBody", testJson); - - try { - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"id\":\"12345\"}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject gatewayResponse = skyflowClient.invokeConnection(testConfig); - - Assert.assertNotNull(gatewayResponse); - Assert.assertEquals(gatewayResponse.toJSONString(), mockResponse); - } catch (SkyflowException exception) { - Assert.assertNull(exception); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException exception) { - exception.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInvokeConnectionWithMultipartFormData() { - JSONObject testConfig = new JSONObject(); - testConfig.put("connectionURL", "https://testgatewayurl.com/"); - testConfig.put("methodName", RequestMethod.POST); - - JSONObject requestHeadersJson = new JSONObject(); - requestHeadersJson.put("content-type", "multipart/form-data"); - testConfig.put("requestHeader", requestHeadersJson); - - JSONObject testJson = new JSONObject(); - testJson.put("key1","value1"); - JSONObject nestedObj = new JSONObject(); - nestedObj.put("key2","value2"); - testJson.put("nest",nestedObj); - - testConfig.put("requestBody", testJson); - - try { - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"id\":\"12345\"}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject gatewayResponse = skyflowClient.invokeConnection(testConfig); - - Assert.assertNotNull(gatewayResponse); - Assert.assertEquals(gatewayResponse.toJSONString(), mockResponse); - } catch (SkyflowException exception) { - Assert.assertNull(exception); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException exception) { - exception.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - - } - -} diff --git a/v1/src/test/java/com/skyflow/vault/SkyflowTest.java b/v1/src/test/java/com/skyflow/vault/SkyflowTest.java deleted file mode 100644 index 70dd193f..00000000 --- a/v1/src/test/java/com/skyflow/vault/SkyflowTest.java +++ /dev/null @@ -1,2485 +0,0 @@ -/* - Copyright (c) 2022 Skyflow, Inc. -*/ -package com.skyflow.vault; - -import com.skyflow.Configuration; -import com.skyflow.common.utils.Helpers; -import com.skyflow.common.utils.HttpUtility; -import com.skyflow.common.utils.TokenUtils; -import com.skyflow.entities.*; -import com.skyflow.errors.ErrorCode; -import com.skyflow.errors.SkyflowException; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentMatchers; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - -import java.io.IOException; -import java.net.URL; -import java.util.concurrent.Callable; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.FutureTask; - -import static org.junit.Assert.*; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; - -class DemoTokenProvider implements TokenProvider { - @Override - public String getBearerToken() throws Exception { - return "valid_token"; - } -} - -class InvalidTokenProvider implements TokenProvider { - @Override - public String getBearerToken() throws Exception { - return "not_a_valid_token"; - } -} - -@RunWith(PowerMockRunner.class) -@PrepareForTest(fullyQualifiedNames = "com.skyflow.common.utils.TokenUtils") -public class SkyflowTest { - - private static String vaultID = null; - private static String vaultURL = null; - private static String skyflowId = null; - private static String token = null; - private static String tableName = null; - private static String columnName = null; - private static String INVALID_EXCEPTION_THROWN = "Should not have thrown any exception"; - private static final String EXCEPTION_NOT_THROWN = "Should have thrown an exception"; - - - @BeforeClass - public static void setup() throws SkyflowException { - PowerMockito.mockStatic(TokenUtils.class); - PowerMockito.when(TokenUtils.isTokenValid("valid_token")).thenReturn(true); - PowerMockito.when(TokenUtils.isTokenValid("not_a_valid_token")).thenReturn(false); - - vaultID = "vault123"; - vaultURL = "https://test.com"; - skyflowId = "skyflowId123"; - token = "token123"; - tableName = "pii_fields"; - columnName = "first_name"; - } - - @Test - public void testValidConfig() { - Configuration.setLogLevel(LogLevel.INFO); - SkyflowConfiguration testConfig = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - try { - Skyflow skyflow = Skyflow.init(testConfig); - assert (skyflow instanceof Skyflow); - } catch (SkyflowException e) { - assertNotNull(e); - } - } - - - @Test - public void testInValidConfigWithNullValues() { - Configuration.setLogLevel(LogLevel.ERROR); - SkyflowConfiguration testConfig = new SkyflowConfiguration(null, null, new DemoTokenProvider()); - try { - Skyflow skyflow = Skyflow.init(testConfig); - skyflow.detokenize(new JSONObject()); - - } catch (SkyflowException e) { - assertEquals(e.getCode(), ErrorCode.EmptyVaultID.getCode()); - assertEquals(e.getMessage(), ErrorCode.EmptyVaultID.getDescription()); - } - } - - @Test - public void testInValidConfigWithNullValues2() { - Configuration.setLogLevel(LogLevel.DEBUG); - SkyflowConfiguration testConfig = new SkyflowConfiguration(vaultID, null, new DemoTokenProvider()); - try { - Skyflow skyflow = Skyflow.init(testConfig); - skyflow.detokenize(new JSONObject()); - - } catch (SkyflowException e) { - assertEquals(e.getCode(), ErrorCode.InvalidVaultURL.getCode()); - assertEquals(e.getMessage(), ErrorCode.InvalidVaultURL.getDescription()); - } - } - - @Test - public void testInvalidConfigWithEmptyVaultID() { - Configuration.setLogLevel(LogLevel.WARN); - SkyflowConfiguration testConfig = new SkyflowConfiguration("", vaultURL, new DemoTokenProvider()); - try { - Skyflow skyflow = Skyflow.init(testConfig); - skyflow.insert(new JSONObject(), new InsertOptions()); - } catch (SkyflowException e) { - assertEquals(e.getCode(), ErrorCode.EmptyVaultID.getCode()); - assertEquals(e.getMessage(), ErrorCode.EmptyVaultID.getDescription()); - } - } - - @Test - public void testInvalidConfigWithInvalidVaultURL() { - Configuration.setLogLevel(LogLevel.OFF); - SkyflowConfiguration testConfig = new SkyflowConfiguration(vaultID, "//valid.url.com", new DemoTokenProvider()); - try { - Skyflow skyflow = Skyflow.init(testConfig); - skyflow.insert(new JSONObject(), new InsertOptions()); - } catch (SkyflowException e) { - assertEquals(e.getCode(), ErrorCode.InvalidVaultURL.getCode()); - assertEquals(e.getMessage(), ErrorCode.InvalidVaultURL.getDescription()); - } - } - - @Test - public void testInvalidConfigWithHttpVaultURL() { - SkyflowConfiguration testConfig = new SkyflowConfiguration(vaultID, "http://valid.url.com", new DemoTokenProvider()); - try { - Skyflow skyflow = Skyflow.init(testConfig); - } catch (SkyflowException e) { - assertEquals(e.getCode(), ErrorCode.InvalidVaultURL.getCode()); - assertEquals(e.getMessage(), ErrorCode.InvalidVaultURL.getDescription()); - } - } - - @Test - public void testInsertWithInvalidSkyflowConfig() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, null); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - - JSONObject res = skyflowClient.insert(records); - } catch (SkyflowException e) { - assertEquals(ErrorCode.InvalidTokenProvider.getDescription(), e.getMessage()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertSuccessWithTokens() { - try { - SkyflowConfiguration config = new SkyflowConfiguration("vaultID", "https://vaulturl.com", new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertOptions insertOptions = new InsertOptions(); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = - "{\"vaultID\":\"vault123\",\"responses\":[{\"records\":[{\"skyflow_id\":\"id1\", \"tokens\":{\"first_name\":\"token1\"}}]}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - - JSONObject res = skyflowClient.insert(records, insertOptions); - JSONArray responseRecords = (JSONArray) res.get("records"); - - assertEquals(1, responseRecords.size()); - assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - assertNotNull(((JSONObject) responseRecords.get(0)).get("fields")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertSuccessWithoutInsertOptions() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = - "{\"vaultID\":\"vault123\",\"responses\":[{\"records\":[{\"skyflow_id\":\"id1\", \"tokens\":{\"first_name\":\"token1\"}}]}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject res = skyflowClient.insert(records); - JSONArray responseRecords = (JSONArray) res.get("records"); - - assertEquals(1, responseRecords.size()); - assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - assertNotNull(((JSONObject) responseRecords.get(0)).get("fields")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertSuccessWithUpsertOptions() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - UpsertOption upsertOption = new UpsertOption(tableName, columnName); - InsertOptions insertOptions = new InsertOptions(new UpsertOption[]{upsertOption}); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = - "{\"vaultID\":\"vault123\",\"responses\":[{\"records\":[{\"skyflow_id\":\"id1\", \"tokens\":{\"first_name\":\"token1\"}}]}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - - JSONObject res = skyflowClient.insert(records, insertOptions); - JSONArray responseRecords = (JSONArray) res.get("records"); - - assertEquals(1, responseRecords.size()); - assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - assertNotNull(((JSONObject) responseRecords.get(0)).get("fields")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertSuccessWithoutTokens() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertOptions insertOptions = new InsertOptions(false); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"vaultID\":\"vault123\",\"responses\":[{\"records\":[{\"skyflow_id\":\"id1\"}]}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject res = skyflowClient.insert(records, insertOptions); - JSONArray responseRecords = (JSONArray) res.get("records"); - - assertEquals(1, responseRecords.size()); - assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - assertNotNull(((JSONObject) responseRecords.get(0)).get("skyflow_id")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertWithContinueOnErrorAsTrueWithTokens() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record1 = new JSONObject(); - record1.put("table", tableName); - JSONObject fields1 = new JSONObject(); - fields1.put(columnName, "john"); - record1.put("fields", fields1); - - JSONObject record2 = new JSONObject(); - record2.put("table", tableName); - JSONObject fields2 = new JSONObject(); - fields2.put(columnName, "jane"); - record2.put("fields", fields2); - - recordsArray.add(record1); - recordsArray.add(record2); - records.put("records", recordsArray); - - InsertOptions insertOptions = new InsertOptions(true, true); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"vaultID\":\"vault123\",\"responses\":[{\"Status\":400,\"Body\":{\"error\":\"Error Inserting Records due to unique constraint violation\"}},{\"Status\":200,\"Body\":{\"records\":[{\"skyflow_id\":\"id1\",\"tokens\":{\"first_name\":\"token1\"}}]}}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject res = skyflowClient.insert(records, insertOptions); - JSONArray responseSuccessRecords = (JSONArray) res.get("records"); - JSONArray responseErrorRecords = (JSONArray) res.get("errors"); - - assertEquals(1, responseSuccessRecords.size()); - assertEquals(tableName, ((JSONObject) responseSuccessRecords.get(0)).get("table")); - assertEquals(1, ((JSONObject) responseSuccessRecords.get(0)).get("request_index")); - assertNotNull(((JSONObject) responseSuccessRecords.get(0)).get("fields")); - - assertEquals(1, responseErrorRecords.size()); - assertEquals(0, ((JSONObject) ((JSONObject) responseErrorRecords.get(0)).get("error")).get("request_index")); - assertNotNull(((JSONObject) ((JSONObject) responseErrorRecords.get(0)).get("error")).get("description")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertWithContinueOnErrorAsTrueWithoutTokens() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record1 = new JSONObject(); - record1.put("table", tableName); - JSONObject fields1 = new JSONObject(); - fields1.put(columnName, "first"); - record1.put("fields", fields1); - - JSONObject record2 = new JSONObject(); - record2.put("table", tableName); - JSONObject fields2 = new JSONObject(); - fields2.put(columnName, "second"); - record2.put("fields", fields2); - - recordsArray.add(record1); - recordsArray.add(record2); - records.put("records", recordsArray); - - InsertOptions insertOptions = new InsertOptions(false, true); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"vaultID\":\"vault123\",\"responses\":[{\"Status\":400,\"Body\":{\"error\":\"Error Inserting Records due to unique constraint violation\"}},{\"Status\":200,\"Body\":{\"records\":[{\"skyflow_id\":\"id1\"}]}}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject res = skyflowClient.insert(records, insertOptions); - JSONArray responseSuccessRecords = (JSONArray) res.get("records"); - JSONArray responseErrorRecords = (JSONArray) res.get("errors"); - - assertEquals(1, responseSuccessRecords.size()); - assertEquals(tableName, ((JSONObject) responseSuccessRecords.get(0)).get("table")); - assertEquals(1, ((JSONObject) responseSuccessRecords.get(0)).get("request_index")); - assertNotNull(((JSONObject) responseSuccessRecords.get(0)).get("skyflow_id")); - assertNull(((JSONObject) responseSuccessRecords.get(0)).get("tokens")); - - assertEquals(1, responseErrorRecords.size()); - assertEquals(0, ((JSONObject) ((JSONObject) responseErrorRecords.get(0)).get("error")).get("request_index")); - assertNotNull(((JSONObject) ((JSONObject) responseErrorRecords.get(0)).get("error")).get("description")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertWithContinueOnErrorAsTrueWithUpsert() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record1 = new JSONObject(); - record1.put("table", tableName); - JSONObject fields1 = new JSONObject(); - fields1.put(columnName, "first"); - record1.put("fields", fields1); - - JSONObject record2 = new JSONObject(); - record2.put("table", tableName); - JSONObject fields2 = new JSONObject(); - fields2.put(columnName, "second"); - record2.put("fields", fields2); - - recordsArray.add(record1); - recordsArray.add(record2); - records.put("records", recordsArray); - - UpsertOption upsertOption = new UpsertOption(tableName, columnName); - InsertOptions insertOptions = new InsertOptions(new UpsertOption[]{upsertOption}, true); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"vaultID\":\"vault123\",\"responses\":[{\"Status\":400,\"Body\":{\"error\":\"Error Inserting Records due to unique constraint violation\"}},{\"Status\":200,\"Body\":{\"records\":[{\"skyflow_id\":\"id1\"}]}}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject res = skyflowClient.insert(records, insertOptions); - JSONArray responseSuccessRecords = (JSONArray) res.get("records"); - JSONArray responseErrorRecords = (JSONArray) res.get("errors"); - - assertEquals(1, responseSuccessRecords.size()); - assertEquals(tableName, ((JSONObject) responseSuccessRecords.get(0)).get("table")); - assertEquals(1, ((JSONObject) responseSuccessRecords.get(0)).get("request_index")); - assertNotNull(((JSONObject) responseSuccessRecords.get(0)).get("skyflow_id")); - assertNull(((JSONObject) responseSuccessRecords.get(0)).get("tokens")); - - assertEquals(1, responseErrorRecords.size()); - assertEquals(0, ((JSONObject) ((JSONObject) responseErrorRecords.get(0)).get("error")).get("request_index")); - assertNotNull(((JSONObject) ((JSONObject) responseErrorRecords.get(0)).get("error")).get("description")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertWithContinueOnErrorWithUpsertAndTokens() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record1 = new JSONObject(); - record1.put("table", tableName); - JSONObject fields1 = new JSONObject(); - fields1.put(columnName, "first"); - record1.put("fields", fields1); - - JSONObject record2 = new JSONObject(); - record2.put("table", tableName); - JSONObject fields2 = new JSONObject(); - fields2.put(columnName, "second"); - record2.put("fields", fields2); - - recordsArray.add(record1); - recordsArray.add(record2); - records.put("records", recordsArray); - - UpsertOption upsertOption = new UpsertOption(tableName, columnName); - InsertOptions insertOptions = new InsertOptions(false, new UpsertOption[]{upsertOption}, true); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"vaultID\":\"vault123\",\"responses\":[{\"Status\":400,\"Body\":{\"error\":\"Error Inserting Records due to unique constraint violation\"}},{\"Status\":200,\"Body\":{\"records\":[{\"skyflow_id\":\"id1\"}]}}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject res = skyflowClient.insert(records, insertOptions); - JSONArray responseSuccessRecords = (JSONArray) res.get("records"); - JSONArray responseErrorRecords = (JSONArray) res.get("errors"); - - assertEquals(1, responseSuccessRecords.size()); - assertEquals(tableName, ((JSONObject) responseSuccessRecords.get(0)).get("table")); - assertEquals(1, ((JSONObject) responseSuccessRecords.get(0)).get("request_index")); - assertNotNull(((JSONObject) responseSuccessRecords.get(0)).get("skyflow_id")); - assertNull(((JSONObject) responseSuccessRecords.get(0)).get("tokens")); - - assertEquals(1, responseErrorRecords.size()); - assertEquals(0, ((JSONObject) ((JSONObject) responseErrorRecords.get(0)).get("error")).get("request_index")); - assertNotNull(((JSONObject) ((JSONObject) responseErrorRecords.get(0)).get("error")).get("description")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertParseException() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record1 = new JSONObject(); - record1.put("table", tableName); - JSONObject fields1 = new JSONObject(); - fields1.put(columnName, "first"); - record1.put("fields", fields1); - - recordsArray.add(record1); - records.put("records", recordsArray); - - InsertOptions insertOptions = new InsertOptions(false, true); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"vaultID\":\"vault123\",\"responses\":[{\"Status\":200,\"Body\":{\"records\":[{\"skyflow_id\":\"id1\"]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject res = skyflowClient.insert(records, insertOptions); - fail(EXCEPTION_NOT_THROWN); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.ResponseParsingError.getDescription(), skyflowException.getMessage()); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - public void testInsertEmptyRecords() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - records.put("records", recordsArray); - - InsertOptions insertOptions = new InsertOptions(false); - JSONObject res = skyflowClient.insert(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.EmptyRecords.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testInsertEmptyTable() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertOptions insertOptions = new InsertOptions(false); - JSONObject res = skyflowClient.insert(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidTable.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testInsertEmptyFields() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertOptions insertOptions = new InsertOptions(true); - JSONObject res = skyflowClient.insert(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidFields.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testInsertInvalidInput() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("invalidTableKey", tableName); - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertOptions insertOptions = new InsertOptions(true); - JSONObject res = skyflowClient.insert(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidInsertInput.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testInsertWithEmptyArrayUpsertOptions() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - UpsertOption[] upsertOptions = new UpsertOption[]{}; - InsertOptions insertOptions = new InsertOptions(true, upsertOptions); - JSONObject records = new JSONObject(); - JSONObject res = skyflowClient.insert(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidUpsertOptionType.getDescription(), skyflowException.getMessage()); - } - - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - UpsertOption[] upsertOptions = new UpsertOption[3]; - InsertOptions insertOptions = new InsertOptions(true, upsertOptions); - JSONObject records = new JSONObject(); - JSONObject res = skyflowClient.insert(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidUpsertObjectType.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testInsertWithInvalidTableInUpsertOptions() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - InsertOptions insertOptions = new InsertOptions(true, new UpsertOption[]{new UpsertOption(null, "column")}); - JSONObject records = new JSONObject(); - JSONObject res = skyflowClient.insert(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidTableInUpsertOption.getDescription(), skyflowException.getMessage()); - } - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - InsertOptions insertOptions = new InsertOptions(true, new UpsertOption[]{new UpsertOption("", "column")}); - JSONObject records = new JSONObject(); - JSONObject res = skyflowClient.insert(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidTableInUpsertOption.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testInsertWithInvalidColumnInUpsertOptions() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - InsertOptions insertOptions = new InsertOptions(true, new UpsertOption[]{new UpsertOption("table1", null)}); - JSONObject records = new JSONObject(); - JSONObject res = skyflowClient.insert(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidColumnInUpsertOption.getDescription(), skyflowException.getMessage()); - } - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - InsertOptions insertOptions = new InsertOptions(true, new UpsertOption[]{new UpsertOption("table2", "")}); - JSONObject records = new JSONObject(); - JSONObject res = skyflowClient.insert(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidColumnInUpsertOption.getDescription(), skyflowException.getMessage()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testQuerySuccess() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - Skyflow skyflowClient = Skyflow.init(config); - JSONObject queryInput = new JSONObject(); - queryInput.put("query", "SELECT * FROM users"); - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"response_key\":\"response_value\"}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject response = skyflowClient.query(queryInput, new QueryOptions()); - assertNotNull(response); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - public void testQueryMissing() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - Skyflow skyflowClient = Skyflow.init(config); - JSONObject queryInput = new JSONObject(); - queryInput.put("query", ""); - QueryOptions queryOptions = new QueryOptions(); - boolean exceptionThrown = false; - try { - JSONObject res = skyflowClient.query(queryInput, queryOptions); - } catch (SkyflowException skyflowException) { - exceptionThrown = true; - assertEquals(ErrorCode.InvalidQuery.getCode(), skyflowException.getCode()); - assertEquals("Query is missing", skyflowException.getMessage()); - } - assertTrue(exceptionThrown); - } catch (Exception e) { - fail("Caught unexpected exception: " + e.getMessage()); - } - } - @Test - public void testInvalidQueryInput() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - Skyflow skyflowClient = Skyflow.init(config); - JSONObject queryInput = new JSONObject(); - queryInput.put("invalidQueryKey", "select * from cards"); - QueryOptions queryOptions = new QueryOptions(); - boolean exceptionThrown = false; - try { - JSONObject res = skyflowClient.query(queryInput, queryOptions); - } catch (SkyflowException skyflowException) { - exceptionThrown = true; - assertEquals("Invalid query input", skyflowException.getMessage()); - } - assertTrue(exceptionThrown); - } catch (Exception e) { - } - } - @Test - public void testValidJsonParsing() { - String jsonMessage = "{\"error\":{\"http_code\":404,\"message\":\"Not Found\"}}"; - SkyflowException skyflowException = new SkyflowException( - ErrorCode.InvalidVaultURL.getCode(), - jsonMessage - ); - JSONObject result = Helpers.constructQueryErrorObject(skyflowException); - } - - @Test - public void testValidSkyflowExceptionWithoutJson() { - SkyflowException skyflowException = new SkyflowException( - ErrorCode.EmptyVaultID.getCode(), - "Empty vaultID" - ); - JSONObject result = Helpers.constructQueryErrorObject(skyflowException); - } - @Test - public void testInvalidJsonParsing() { - String invalidJsonMessage = "Invalid JSON"; - SkyflowException skyflowException = new SkyflowException( - ErrorCode.InvalidVaultURL.getCode(), - invalidJsonMessage - ); - JSONObject result = Helpers.constructQueryErrorObject(skyflowException); - } - @Test - public void testMissingErrorKeyInJson() { - String jsonMessage = "{\"status\":\"error\",\"http_code\":404,\"message\":\"Not Found\"}"; - SkyflowException skyflowException = new SkyflowException( - ErrorCode.InvalidVaultURL.getCode(), - jsonMessage - ); - JSONObject result = Helpers.constructQueryErrorObject(skyflowException); - } - @Test - public void testMissingHttpCodeInErrorJson() { - String jsonMessage = "{\"error\":{\"message\":\"Not Found\"}}"; - SkyflowException skyflowException = new SkyflowException( - ErrorCode.InvalidVaultURL.getCode(), - jsonMessage - ); - JSONObject result = Helpers.constructQueryErrorObject(skyflowException); - } - @Test - public void testMissingMessageInErrorJson() { - String jsonMessage = "{\"error\":{\"http_code\":404}}"; - SkyflowException skyflowException = new SkyflowException( - ErrorCode.InvalidVaultURL.getCode(), - jsonMessage - ); - JSONObject result = Helpers.constructQueryErrorObject(skyflowException); - } - @Test - public void testEmptyErrorObjectInJson() { - String jsonMessage = "{\"error\":{}}"; - SkyflowException skyflowException = new SkyflowException( - ErrorCode.InvalidVaultURL.getCode(), - jsonMessage - ); - JSONObject result = Helpers.constructQueryErrorObject(skyflowException); - } - @Test - public void testConstructQueryRequest() throws SkyflowException { - QueryRecordInput record = new QueryRecordInput(); - record.setQuery("SELECT * FROM users"); - QueryOptions options = new QueryOptions(); - - JSONObject result = Helpers.constructQueryRequest(record, options); - assertTrue(result.containsKey("query")); - assertEquals("SELECT * FROM users", result.get("query")); - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testQueryIOException() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - Skyflow skyflowClient = Skyflow.init(config); - JSONObject queryInput = new JSONObject(); - queryInput.put("query", "SELECT * FROM table"); - QueryOptions queryOptions = new QueryOptions(); - PowerMockito.mockStatic(HttpUtility.class); - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenThrow(new IOException()); - - try { - skyflowClient.query(queryInput, queryOptions); - fail("Expected SkyflowException to be thrown"); - } catch (SkyflowException e) { - assertEquals(ErrorCode.InvalidQueryInput.getCode(), e.getCode()); - } - } catch (SkyflowException e) { - fail("Caught unexpected SkyflowException: " + e.getMessage()); - } catch (IOException ioException) { - fail("Caught unexpected IOException: " + ioException.getMessage()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testQueryParseException() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject queryInput = new JSONObject(); - queryInput.put("query", "SELECT * FROM table"); - QueryOptions queryOptions = new QueryOptions(); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "Invalid JSON"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - - try { - skyflowClient.query(queryInput, queryOptions); - fail("Expected SkyflowException to be thrown"); - } catch (SkyflowException e) { - assertEquals(ErrorCode.ResponseParsingError.getCode(), e.getCode()); - } - } catch (SkyflowException e) { - fail("Caught unexpected SkyflowException: " + e.getMessage()); - } catch (IOException e) { - fail("Caught unexpected IOException: " + e.getMessage()); - } - } - @Test - public void testGetAndSetRecords() { - QueryRecordInput inputRecord = new QueryRecordInput(); - QueryInput queryInput = new QueryInput(); - - assertNull(queryInput.getQueryInput()); - - queryInput.setQueryInput(inputRecord); - assertEquals(inputRecord, queryInput.getQueryInput()); - } - @Test - public void testGetAndSetQuery() { - QueryRecordInput queryRecordInput = new QueryRecordInput(); - assertNull(queryRecordInput.getQuery()); - - String testQuery = "SELECT * FROM table"; - queryRecordInput.setQuery(testQuery); - assertEquals(testQuery, queryRecordInput.getQuery()); - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testDetokenizeSuccess() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("token", token); - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"records\":[{\"token\":\"token123\",\"valueType\":\"INTEGER\",\"value\":\"10\"}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - - JSONObject res = skyflowClient.detokenize(records); - JSONArray responseRecords = (JSONArray) res.get("records"); - assertEquals(1, responseRecords.size()); - assertEquals(token, ((JSONObject) responseRecords.get(0)).get("token")); - assertTrue(((JSONObject) responseRecords.get(0)).containsKey("value")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testFormattedDetokenizeSuccess() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("token", token); - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"records\":[{\"token\":\"token123\",\"valueType\":\"INTEGER\",\"value\":\"10\",\"test\":\"test123\"}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - - JSONObject res = skyflowClient.detokenize(records); - JSONArray responseRecords = (JSONArray) res.get("records"); - assertEquals(1, responseRecords.size()); - assertEquals(token, ((JSONObject) responseRecords.get(0)).get("token")); - assertEquals(null, ((JSONObject) responseRecords.get(0)).get("test")); - assertTrue(((JSONObject) responseRecords.get(0)).containsKey("value")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testDetokenizeError() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("token", "invalidToken"); - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = - "{\"error\":{\"grpc_code\":5,\"http_code\":404,\"message\":\"Token not found for invalidToken\",\"http_status\":\"Not Found\",\"details\":[]}}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenThrow(new SkyflowException(404, mockResponse)); - - JSONObject res = skyflowClient.detokenize(records); - } catch (SkyflowException skyflowException) { - JSONArray errors = (JSONArray) skyflowException.getData().get("errors"); - assertEquals(1, errors.size()); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testDetokenizePartialError() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("token", "invalidToken1"); - JSONObject validRecord = new JSONObject(); - validRecord.put("token", token); - recordsArray.add(record); - recordsArray.add(validRecord); - records.put("records", recordsArray); - - JSONParser jsonParser = new JSONParser(); - JSONObject validRequest = (JSONObject) - jsonParser.parse("{\"detokenizationParameters\":[{\"token\":\"token123\",\"redaction\":\"PLAIN_TEXT\"}]}"); - PowerMockito.mockStatic(HttpUtility.class); - String mockValidResponse = "{\"records\":[{\"token\":\"token123\",\"valueType\":\"INTEGER\",\"value\":\"10\"}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), eq(validRequest), ArgumentMatchers.anyMap())).thenReturn(mockValidResponse); - - JSONObject invalidRequest = (JSONObject) - jsonParser.parse("{\"detokenizationParameters\":[{\"token\":\"invalidToken1\",\"redaction\":\"PLAIN_TEXT\"}]}"); - String mockInvalidResponse = - "{\"error\":{\"grpc_code\":5,\"http_code\":404,\"message\":\"Token not found for invalidToken1\",\"http_status\":\"Not Found\",\"details\":[]}}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), eq(invalidRequest), ArgumentMatchers.anyMap())).thenThrow(new SkyflowException(404, mockInvalidResponse)); - - - JSONObject res = skyflowClient.detokenize(records); - } catch (SkyflowException skyflowException) { - JSONArray responseRecords = (JSONArray) skyflowException.getData().get("records"); - JSONArray errors = (JSONArray) skyflowException.getData().get("errors"); - assertEquals(1, errors.size()); - assertEquals(1, responseRecords.size()); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (ParseException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - public void testDetokenizeInvalidInput() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - records.put("invalidRecordsKey", recordsArray); - - JSONObject res = skyflowClient.detokenize(records); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidDetokenizeInput.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testDetokenizeEmptyRecords() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - records.put("records", recordsArray); - - JSONObject res = skyflowClient.detokenize(records); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.EmptyRecords.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testDetokenizeEmptyRecords2() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - records.put("records", null); - - JSONObject res = skyflowClient.detokenize(records); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.EmptyRecords.getDescription(), skyflowException.getMessage()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.TokenUtils"}) - public void testDetokenizeInvalidToken() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("token", ""); - recordsArray.add(record); - records.put("records", recordsArray); - - JSONObject res = skyflowClient.detokenize(records); - } catch (SkyflowException skyflowException) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) skyflowException.getData().get("errors")).get(0))).get("error"); - assertEquals(ErrorCode.InvalidToken.getDescription(), error.get("description")); - } - } - - @Test - public void testDetokenizeInvalidRedaction() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("token", "3423-4671-5420-2425"); - record.put("redaction", "invalid"); - recordsArray.add(record); - records.put("records", recordsArray); - - JSONObject res = skyflowClient.detokenize(records); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidDetokenizeInput.getDescription(), skyflowException.getMessage()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testDetokenizeWhenNullRedactionIsPassed() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("token", "3423-4671-5420-2425"); - record.put("redaction", null); - recordsArray.add(record); - records.put("records", recordsArray); - - JSONObject res = skyflowClient.detokenize(records); - } catch (SkyflowException skyflowException) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) skyflowException.getData().get("errors")).get(0))).get("error"); - assertEquals(ErrorCode.InvalidDetokenizeInput.getDescription(), error.get("description")); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetByIdSuccess() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - JSONArray ids = new JSONArray(); - ids.add(skyflowId); - record.put("ids", ids); - record.put("table", tableName); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - recordsArray.add(record); - - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"records\":[{\"fields\":{\"age\":10,\"skyflow_id\":\"skyflowId123\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject response = skyflowClient.getById(records); - JSONArray responseRecords = (JSONArray) response.get("records"); - - assertEquals(1, responseRecords.size()); - assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - assertNotNull(((JSONObject) responseRecords.get(0)).get("fields")); - - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetByIdError() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - JSONArray ids = new JSONArray(); - ids.add(skyflowId); - record.put("ids", ids); - record.put("table", "invalidTable"); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - recordsArray.add(record); - - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"error\":{\"grpc_code\":13,\"http_code\":500,\"message\":\"Couldn't load data\",\"http_status\":\"Internal Server Error\"}}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenThrow(new SkyflowException(500, mockResponse)); - JSONObject response = skyflowClient.getById(records); - - } catch (SkyflowException e) { - JSONArray errors = (JSONArray) e.getData().get("errors"); - assertEquals(1, errors.size()); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testGetByIdPartialError() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - JSONArray ids = new JSONArray(); - ids.add(skyflowId); - record.put("ids", ids); - record.put("table", tableName); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - recordsArray.add(record); - - JSONObject record2 = new JSONObject(); - JSONArray id2 = new JSONArray(); - id2.add("invalidId"); - record2.put("ids", id2); - record2.put("table", "invalidTable2"); - record2.put("redaction", RedactionType.PLAIN_TEXT.toString()); - recordsArray.add(record2); - - records.put("records", recordsArray); - - String validRequestUrl = "https://test.com/v1/vaults/vault123/pii_fields?skyflow_ids=skyflowId123&redaction=PLAIN_TEXT"; - String invalidRequestUrl = "https://test.com/v1/vaults/vault123/invalidTable2?skyflow_ids=invalidId&redaction=PLAIN_TEXT"; - - PowerMockito.mockStatic(HttpUtility.class); - String mockValidResponse = "{\"records\":[{\"fields\":{\"age\":10,\"skyflow_id\":\"skyflowId123\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), eq(new URL(validRequestUrl)), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockValidResponse); - - String mockInvalidResponse = "{\"error\":{\"grpc_code\":13,\"http_code\":500,\"message\":\"Couldn't load data\",\"http_status\":\"Internal Server Error\"}}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), eq(new URL(invalidRequestUrl)), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenThrow(new SkyflowException(500, mockInvalidResponse)); - - JSONObject response = skyflowClient.getById(records); - - } catch (SkyflowException e) { - JSONObject partialError = e.getData(); - assertTrue(partialError.containsKey("records")); - assertTrue(partialError.containsKey("errors")); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - public void testGetByIdInvalidInput() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - records.put("invalidRecordsKey", recordsArray); - - JSONObject response = skyflowClient.getById(records); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidGetByIdInput.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testGetByIdEmptyRecords() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - records.put("records", recordsArray); - - JSONObject response = skyflowClient.getById(records); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.EmptyRecords.getDescription(), skyflowException.getMessage()); - } - } - - - @Test - public void testGetByIdEmptyRecords2() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - records.put("records", null); - - JSONObject response = skyflowClient.getById(records); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.EmptyRecords.getDescription(), skyflowException.getMessage()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.TokenUtils"}) - public void testGetByIdEmptyTable() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - JSONArray ids = new JSONArray(); - ids.add(skyflowId); - record.put("ids", ids); - record.put("table", ""); - record.put("redaction", RedactionType.PLAIN_TEXT.toString()); - recordsArray.add(record); - - records.put("records", recordsArray); - - JSONObject response = skyflowClient.getById(records); - } catch (SkyflowException skyflowException) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) skyflowException.getData().get("errors")).get(0))).get("error"); - assertEquals(ErrorCode.InvalidTable.getDescription(), error.get("description")); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testUpdateSuccessWithToken() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - record.put("table", tableName); - record.put("id", skyflowId); - JSONObject fields = new JSONObject(); - fields.put(columnName, "name"); - record.put("fields", fields); - recordsArray.add(record); - records.put("records", recordsArray); - - UpdateOptions updateOptions = new UpdateOptions(true); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"skyflow_id\":\"skyflowId123\",\"tokens\":{\"first_name\":\"token2\"}}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - - JSONObject res = skyflowClient.update(records, updateOptions); - JSONArray responseRecords = (JSONArray) res.get("records"); - - assertEquals(1, responseRecords.size()); - assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - assertNotNull(((JSONObject) responseRecords.get(0)).get("fields")); - } catch (SkyflowException e) { - JSONArray errors = (JSONArray) e.getData().get("errors"); - assertEquals(1, errors.size()); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testUpdateSuccessWithOutToken() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - record.put("table", tableName); - record.put("id", skyflowId); - JSONObject fields = new JSONObject(); - fields.put(columnName, "name"); - record.put("fields", fields); - recordsArray.add(record); - records.put("records", recordsArray); - - UpdateOptions updateOptions = new UpdateOptions(false); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"skyflow_id\":\"skyflowId123\",\"tokens\":null}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - - JSONObject res = skyflowClient.update(records, updateOptions); - JSONArray responseRecords = (JSONArray) res.get("records"); - - assertEquals(1, responseRecords.size()); - assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - assertNull(((JSONObject) responseRecords.get(0)).get("fields")); - } catch (SkyflowException e) { - JSONArray errors = (JSONArray) e.getData().get("errors"); - assertEquals(1, errors.size()); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testUpdateSuccessWithOutUpdateOptions() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - record.put("table", tableName); - record.put("id", skyflowId); - JSONObject fields = new JSONObject(); - fields.put(columnName, "name"); - record.put("fields", fields); - recordsArray.add(record); - records.put("records", recordsArray); - - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"skyflow_id\":\"skyflowId123\",\"tokens\":{\"first_name\":\"token2\"}}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - - JSONObject res = skyflowClient.update(records); - JSONArray responseRecords = (JSONArray) res.get("records"); - - assertEquals(1, responseRecords.size()); - assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - assertNotNull(((JSONObject) responseRecords.get(0)).get("fields")); - } catch (SkyflowException e) { - JSONArray errors = (JSONArray) e.getData().get("errors"); - assertEquals(1, errors.size()); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - - } - - @Test - public void testUpdateEmptyRecords() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - records.put("records", recordsArray); - UpdateOptions updateOptions = new UpdateOptions(); - JSONObject response = skyflowClient.update(records, updateOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.EmptyRecords.getDescription(), skyflowException.getMessage()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.TokenUtils"}) - public void testUpdateEmptyFields() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - JSONObject fields = new JSONObject(); - record.put("table", tableName); - record.put("id", skyflowId); - record.put("fields", fields); - recordsArray.add(record); - - records.put("records", recordsArray); - UpdateOptions updateOptions = new UpdateOptions(); - JSONObject response = skyflowClient.update(records, updateOptions); - } catch (SkyflowException skyflowException) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) skyflowException.getData().get("error")).get(0))).get("error"); - assertEquals(ErrorCode.InvalidFields.getDescription(), error.get("description")); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.TokenUtils"}) - public void testUpdateInvalidTable() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - JSONObject fields = new JSONObject(); - record.put("table", null); - record.put("id", skyflowId); - record.put("fields", fields); - recordsArray.add(record); - - records.put("records", recordsArray); - UpdateOptions updateOptions = new UpdateOptions(); - JSONObject response = skyflowClient.update(records, updateOptions); - } catch (SkyflowException skyflowException) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) skyflowException.getData().get("error")).get(0))).get("error"); - assertEquals(ErrorCode.InvalidTable.getDescription(), error.get("description")); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.TokenUtils"}) - public void testUpdateEmptySkyflowId() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - JSONObject fields = new JSONObject(); - record.put("table", tableName); - record.put("id", ""); - record.put("fields", fields); - recordsArray.add(record); - - records.put("records", recordsArray); - UpdateOptions updateOptions = new UpdateOptions(); - JSONObject response = skyflowClient.update(records, updateOptions); - } catch (SkyflowException skyflowException) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) skyflowException.getData().get("error")).get(0))).get("error"); - assertEquals(ErrorCode.InvalidSkyflowId.getDescription(), error.get("description")); - } - } - - @Test - public void testUpdateEmptyRecords2() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - records.put("records", null); - - JSONObject response = skyflowClient.getById(records); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.EmptyRecords.getDescription(), skyflowException.getMessage()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.TokenUtils"}) - public void testUpdateEmptyTable() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - record.put("table", ""); - record.put("id", skyflowId); - JSONObject fields = new JSONObject(); - fields.put(columnName, "name"); - record.put("fields", fields); - recordsArray.add(record); - records.put("records", recordsArray); - - UpdateOptions updateOptions = new UpdateOptions(true); - - JSONObject res = skyflowClient.update(records, updateOptions); - } catch (SkyflowException e) { - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) e.getData().get("error")).get(0))).get("error"); - assertEquals(ErrorCode.InvalidTable.getDescription(), error.get("description")); - } - - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testUpdateError() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - record.put("table", "invalid_table"); - record.put("id", skyflowId); - JSONObject fields = new JSONObject(); - fields.put(columnName, "name"); - record.put("fields", fields); - recordsArray.add(record); - records.put("records", recordsArray); - - UpdateOptions updateOptions = new UpdateOptions(true); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"error\":{\"grpc_code\":3,\"http_code\":400,\"message\":\"Object Name table was not found for Vault vault123\",\"http_status\":\"Bad Request\",\"details\":[]}}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - - JSONObject res = skyflowClient.update(records, updateOptions); - - } catch (SkyflowException e) { - JSONArray errors = (JSONArray) e.getData().get("error"); - assertEquals(1, errors.size()); - JSONObject error = (JSONObject) ((JSONObject) (((JSONArray) e.getData().get("error")).get(0))).get("error"); - assertEquals(ErrorCode.InvalidTable.getDescription(), error.get("description")); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - - } - - @Test - public void testUpdateInvalidInput() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - records.put("invalidRecordsKey", recordsArray); - - UpdateOptions updateOptions = new UpdateOptions(true); - JSONObject response = skyflowClient.update(records, updateOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidUpdateInput.getDescription(), skyflowException.getMessage()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testUpdatePartialError() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - record.put("table", tableName); - record.put("id", skyflowId); - JSONObject fields = new JSONObject(); - fields.put(columnName, "name"); - record.put("fields", fields); - recordsArray.add(record); - - JSONObject record2 = new JSONObject(); - record2.put("table", "invalidTable"); - record2.put("id", "invalidId"); - JSONObject fields2 = new JSONObject(); - fields2.put(columnName, "name"); - record2.put("fields", fields2); - recordsArray.add(record2); - records.put("records", recordsArray); - - String validRequestUrl = "https://test.com/v1/vaults/vault123/pii_fields/skyflowId123"; - String invalidRequestUrl = "https://test.com/v1/vaults/vault123/invalidTable/invalidId"; - - PowerMockito.mockStatic(HttpUtility.class); - - String mockInvalidResponse = "{\"error\":{\"grpc_code\":3,\"http_code\":400,\"message\":\"Object Name table was not found for Vault vault123\",\"http_status\":\"Bad Request\",\"details\":[]}}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), eq(new URL(invalidRequestUrl)), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenThrow(new SkyflowException(400, mockInvalidResponse)); - - String mockValidResponse = "{\"skyflow_id\":\"skyflowId123\",\"tokens\":{\"first_name\":\"token2\"}}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), eq(new URL(validRequestUrl)), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockValidResponse); - - JSONObject response = skyflowClient.update(records, new UpdateOptions(true)); - - } catch (SkyflowException e) { - JSONObject partialError = e.getData(); - assertTrue(partialError.containsKey("records")); - assertTrue(partialError.containsKey("error")); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testUpdateWrongVaultError() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - record.put("table", tableName); - record.put("id", skyflowId); - JSONObject fields = new JSONObject(); - fields.put(columnName, "name"); - record.put("fields", fields); - recordsArray.add(record); - records.put("records", recordsArray); - - String invalidRequestUrl = "https://test.com/v1/vaults/vault1234/invalidTable/vault123/invalidId"; - - PowerMockito.mockStatic(HttpUtility.class); - - String mockInvalidResponse = "ThreadExecution exception"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), eq(new URL(invalidRequestUrl)), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenThrow(new SkyflowException(500, mockInvalidResponse)); - - JSONObject response = skyflowClient.update(records, new UpdateOptions(true)); - - } catch (SkyflowException e) { - String error = e.getMessage(); - assertEquals(ErrorCode.ThreadExecutionException.getDescription(), error); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testUpdateIOException() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - record.put("table", tableName); - record.put("id", skyflowId); - JSONObject fields = new JSONObject(); - fields.put(columnName, "name"); - record.put("fields", fields); - recordsArray.add(record); - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - PowerMockito.when(HttpUtility.sendRequest(anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new IOException()); - - JSONObject response = skyflowClient.update(records, new UpdateOptions(true)); - - } catch (SkyflowException e) { - String error = e.getMessage(); - assertEquals(ErrorCode.ThreadExecutionException.getDescription(), error); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testUpdateParseException() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - JSONObject record = new JSONObject(); - record.put("table", tableName); - record.put("id", skyflowId); - JSONObject fields = new JSONObject(); - fields.put(columnName, "name"); - record.put("fields", fields); - recordsArray.add(record); - records.put("records", recordsArray); - - String invalidMockResponse = "a{\"skyflow_id\":\"skyflowId123\",\"tokens\":{\"first_name\":\"token2\"}}"; - - PowerMockito.mockStatic(HttpUtility.class); - PowerMockito.when(HttpUtility.sendRequest(anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenReturn(invalidMockResponse); - - JSONObject response = skyflowClient.update(records, new UpdateOptions(true)); - - } catch (SkyflowException e) { - String error = e.getMessage(); - assertEquals(ErrorCode.ThreadExecutionException.getDescription(), error); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkEmptyTable() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertBulkOptions insertOptions = new InsertBulkOptions(false); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidTable.getDescription(), skyflowException.getMessage()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkEmptyTableCase2() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("table", null); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertBulkOptions insertOptions = new InsertBulkOptions(false); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidTable.getDescription(), skyflowException.getMessage()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkEmptyTableCase3() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("table", ""); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertBulkOptions insertOptions = new InsertBulkOptions(false); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidTable.getDescription(), skyflowException.getMessage()); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkEmptyFields() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertBulkOptions insertOptions = new InsertBulkOptions(true); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidFields.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testInsertBulkInvalidInput() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("invalidTableKey", tableName); - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertBulkOptions insertOptions = new InsertBulkOptions(true); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidInsertInput.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testInsertBulkWithEmptyArrayUpsertOptions() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - UpsertOption[] upsertOptions = new UpsertOption[]{}; - InsertBulkOptions insertOptions = new InsertBulkOptions(true, upsertOptions); - JSONObject records = new JSONObject(); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidUpsertOptionType.getDescription(), skyflowException.getMessage()); - } - - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - UpsertOption[] upsertOptions = new UpsertOption[3]; - InsertBulkOptions insertOptions = new InsertBulkOptions(true, upsertOptions); - JSONObject records = new JSONObject(); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidUpsertObjectType.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testInsertBulkWithInvalidTableInUpsertOptions() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - InsertBulkOptions insertOptions = new InsertBulkOptions(true, new UpsertOption[]{new UpsertOption(null, "column")}); - JSONObject records = new JSONObject(); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidTableInUpsertOption.getDescription(), skyflowException.getMessage()); - } - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - InsertBulkOptions insertOptions = new InsertBulkOptions(true, new UpsertOption[]{new UpsertOption("", "column")}); - JSONObject records = new JSONObject(); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidTableInUpsertOption.getDescription(), skyflowException.getMessage()); - } - } - - @Test - public void testInsertBulkWithInvalidColumnInUpsertOptions() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - InsertBulkOptions insertOptions = new InsertBulkOptions(true, new UpsertOption[]{new UpsertOption("table1", null)}); - JSONObject records = new JSONObject(); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidColumnInUpsertOption.getDescription(), skyflowException.getMessage()); - } - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - InsertBulkOptions insertOptions = new InsertBulkOptions(true, new UpsertOption[]{new UpsertOption("table2", "")}); - JSONObject records = new JSONObject(); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.InvalidColumnInUpsertOption.getDescription(), skyflowException.getMessage()); - } - } - - - @Test - public void testInvalidConfigWithEmptyVaultIDIninsertBulk() { - Configuration.setLogLevel(LogLevel.WARN); - SkyflowConfiguration testConfig = new SkyflowConfiguration("", vaultURL, new DemoTokenProvider()); - try { - Skyflow skyflow = Skyflow.init(testConfig); - skyflow.insertBulk(new JSONObject(), new InsertBulkOptions()); - } catch (SkyflowException e) { - assertEquals(e.getCode(), ErrorCode.EmptyVaultID.getCode()); - assertEquals(e.getMessage(), ErrorCode.EmptyVaultID.getDescription()); - } - } - - @Test - public void testInvalidConfigWithInvalidVaultURLIninsertBulk() { - Configuration.setLogLevel(LogLevel.OFF); - SkyflowConfiguration testConfig = new SkyflowConfiguration(vaultID, "//valid.url.com", new DemoTokenProvider()); - try { - Skyflow skyflow = Skyflow.init(testConfig); - skyflow.insertBulk(new JSONObject(), new InsertBulkOptions()); - } catch (SkyflowException e) { - assertEquals(e.getCode(), ErrorCode.InvalidVaultURL.getCode()); - assertEquals(e.getMessage(), ErrorCode.InvalidVaultURL.getDescription()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkSuccessWithUpsertOptions() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - UpsertOption upsertOption = new UpsertOption(tableName, columnName); - InsertBulkOptions insertOptions = new InsertBulkOptions(new UpsertOption[]{upsertOption}); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = - "{\"records\":[{\"skyflow_id\":\"id1\", \"tokens\":{\"first_name\":\"token1\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - JSONArray responseRecords = (JSONArray) res.get("records"); - - assertEquals(1, responseRecords.size()); - assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - assertNotNull(((JSONObject) responseRecords.get(0)).get("fields")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkSuccessWithoutTokens() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertBulkOptions insertOptions = new InsertBulkOptions(false); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = "{\"records\":[{\"skyflow_id\":\"id1\"}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - JSONArray responseRecords = (JSONArray) res.get("records"); - - assertEquals(1, responseRecords.size()); - assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - assertNotNull(((JSONObject) responseRecords.get(0)).get("skyflow_id")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - public void testInsertBulkWithInvalidSkyflowConfig() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, null); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - - JSONObject res = skyflowClient.insertBulk(records); - } catch (SkyflowException e) { - assertEquals(ErrorCode.InvalidTokenProvider.getDescription(), e.getMessage()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkSuccessWithTokens() { - try { - SkyflowConfiguration config = new SkyflowConfiguration("vaultID", "https://vaulturl.com", new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertBulkOptions insertOptions = new InsertBulkOptions(); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = - "{\"records\":[{\"skyflow_id\":\"id1\", \"tokens\":{\"first_name\":\"token1\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - JSONArray responseRecords = (JSONArray) res.get("records"); - - assertEquals(1, responseRecords.size()); - assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - assertNotNull(((JSONObject) responseRecords.get(0)).get("fields")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkErrorsWithTokens() { - try { - SkyflowConfiguration config = new SkyflowConfiguration("vaultID", "https://vaulturl.com", new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertBulkOptions insertOptions = new InsertBulkOptions(); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = - "{\"error\":{\"grpc_code\":3,\"http_code\":400,\"message\":\"Invalid field present in JSON cardholder_nam\",\"http_status\":\"Bad Request\",\"details\":[]}}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenThrow(new SkyflowException(500, mockResponse)); - - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - JSONArray errors = (JSONArray) skyflowException.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - skyflowException.printStackTrace(); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkSuccessWithoutInsertOptions() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = - "{\"records\":[{\"skyflow_id\":\"id1\", \"tokens\":{\"first_name\":\"token1\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse); - JSONObject res = skyflowClient.insertBulk(records); - JSONArray responseRecords = (JSONArray) res.get("records"); - - assertEquals(1, responseRecords.size()); - assertEquals(tableName, ((JSONObject) responseRecords.get(0)).get("table")); - assertNotNull(((JSONObject) responseRecords.get(0)).get("fields")); - } catch (SkyflowException skyflowException) { - skyflowException.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkErrorsWithTokensParseException() { - try { - SkyflowConfiguration config = new SkyflowConfiguration("vaultID", "https://vaulturl.com", new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - - InsertBulkOptions insertOptions = new InsertBulkOptions(); - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse = - "{\"grpc_code\":3,\"http_code\":400,\"message\":\"Invalid field present in JSON cardholder_nam\",\"http_status\":\"Bad Request\",\"details\":"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenThrow(new SkyflowException(500, mockResponse)); - - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - JSONArray errors = (JSONArray) skyflowException.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkPartialSuccess() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", "pii_fields"); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - JSONObject record2 = new JSONObject(); - record2.put("table", "cards"); - JSONObject fields2 = new JSONObject(); - fields.put(columnName, "first"); - record2.put("fields", fields2); - recordsArray.add(record2); - - - records.put("records", recordsArray); - String firstRequestUrl = "https://test.com/v1/vaults/vault123/pii_fields"; - String secondRequestUrl = "https://test.com/v1/vaults/vault123/cards"; - - - PowerMockito.mockStatic(HttpUtility.class); - String mockResponse2 = - "{\"records\":[{\"skyflow_id\":\"id1\", \"tokens\":{\"first_name\":\"token1\"}}]}"; - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.eq(new URL(firstRequestUrl)), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenReturn(mockResponse2); - - String mockResponse = - "{\"error\":{\"grpc_code\":3,\"http_code\":400,\"message\":\"Invalid field present in JSON cardholder_nam\",\"http_status\":\"Bad Request\",\"details\":[]}}"; - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.eq(new URL(secondRequestUrl)), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new SkyflowException(500, mockResponse - )); - - JSONObject res = skyflowClient.insertBulk(records); - - } catch (SkyflowException e) { - JSONObject partialError = e.getData(); - Assert.assertTrue(partialError.containsKey("records")); - Assert.assertTrue(partialError.containsKey("errors")); - JSONArray records = (JSONArray) e.getData().get("records"); - - Assert.assertEquals(1, records.size()); - - JSONArray errors = (JSONArray) e.getData().get("errors"); - Assert.assertEquals(1, errors.size()); - } catch (IOException e) { - e.printStackTrace(); - fail(INVALID_EXCEPTION_THROWN); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkInterruptedException() { - try { - SkyflowConfiguration config = new SkyflowConfiguration("vaultID", "https://demo.com", new DemoTokenProvider()); - Skyflow skyflowClient = Skyflow.init(config); - - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - JSONObject record = new JSONObject(); - record.put("table", tableName); - JSONObject fields = new JSONObject(); - fields.put(columnName, "first"); - record.put("fields", fields); - - recordsArray.add(record); - - records.put("records", recordsArray); - PowerMockito.mockStatic(HttpUtility.class); - - InsertBulkOptions insertOptions = new InsertBulkOptions(true); - PowerMockito.when(HttpUtility.sendRequest(ArgumentMatchers.anyString(), - ArgumentMatchers.any(), - ArgumentMatchers.any(), - ArgumentMatchers.anyMap())) - .thenThrow(new IOException("Exception occurred")); - Callable mockCallable = mock(Callable.class); - when(mockCallable.call()).thenThrow(new InterruptedException("Thread was interrupted")); - - FutureTask mockFutureTask = new FutureTask<>(mockCallable); - mockFutureTask.run(); - - when(mockFutureTask.get()).thenThrow(new InterruptedException("Thread was interrupted")); - - PowerMockito.mockStatic(HttpUtility.class); - PowerMockito.when(HttpUtility.sendRequest(anyString(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.anyMap())).thenThrow(new InterruptedException("Thread was interrupted")); - - - JSONObject response = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException e) { - String error = e.getMessage(); - assertEquals(ErrorCode.ThreadExecutionException.getDescription(), error); - } catch (IOException exception) { - exception.printStackTrace(); - Assert.fail(INVALID_EXCEPTION_THROWN); - } catch (Exception e) { - Assert.assertTrue((e.toString()).contains(ErrorCode.ThreadInterruptedException.getDescription())); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkEmptyRecords() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - JSONArray recordsArray = new JSONArray(); - - records.put("records", recordsArray); - - InsertBulkOptions insertOptions = new InsertBulkOptions(false); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.EmptyRecords.getDescription(), skyflowException.getMessage()); - } - } - @Test - @PrepareForTest(fullyQualifiedNames = {"com.skyflow.common.utils.HttpUtility", "com.skyflow.common.utils.TokenUtils"}) - public void testInsertBulkEmptyRecordsCase2() { - try { - SkyflowConfiguration config = new SkyflowConfiguration(vaultID, vaultURL, new DemoTokenProvider()); - - Skyflow skyflowClient = Skyflow.init(config); - JSONObject records = new JSONObject(); - - records.put("records", null); - - InsertBulkOptions insertOptions = new InsertBulkOptions(false); - JSONObject res = skyflowClient.insertBulk(records, insertOptions); - } catch (SkyflowException skyflowException) { - assertEquals(ErrorCode.EmptyRecords.getDescription(), skyflowException.getMessage()); - } - } -} - diff --git a/v1/src/test/resources/invalidCredentials.json b/v1/src/test/resources/invalidCredentials.json deleted file mode 100644 index 9e26dfee..00000000 --- a/v1/src/test/resources/invalidCredentials.json +++ /dev/null @@ -1 +0,0 @@ -{} \ No newline at end of file diff --git a/v1/src/test/resources/notJson.txt b/v1/src/test/resources/notJson.txt deleted file mode 100644 index e69de29b..00000000 diff --git a/v2/pom.xml b/v2/pom.xml deleted file mode 100644 index bddf1ae2..00000000 --- a/v2/pom.xml +++ /dev/null @@ -1,70 +0,0 @@ - - - 4.0.0 - - com.skyflow - skyflow-java - 1.15.0 - - - v2 - - - 8 - 8 - UTF-8 - 4.12.0 - 2.10.1 - 1.9.0 - 5.10.3 - 1.10.0 - - - - - io.github.cdimascio - dotenv-java - 3.0.0 - - - com.google.code.findbugs - jsr305 - 3.0.2 - - - io.gsonfire - gson-fire - ${gson-fire-version} - - - com.google.code.gson - gson - ${gson-version} - - - com.squareup.okhttp3 - okhttp - ${okhttp-version} - - - com.squareup.okhttp3 - logging-interceptor - ${okhttp-version} - - - - org.junit.jupiter - junit-jupiter-engine - ${junit-version} - test - - - org.junit.platform - junit-platform-runner - ${junit-platform-runner.version} - test - - - \ No newline at end of file From 60279729bc72e2bc54b05dd019aaa98895b0b738 Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Fri, 15 Nov 2024 19:18:17 +0530 Subject: [PATCH 12/18] SK-1623 Downgrade dotenv to work with java 8 --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 12533834..b719865b 100644 --- a/pom.xml +++ b/pom.xml @@ -60,7 +60,7 @@ io.github.cdimascio dotenv-java - 3.0.0 + 2.2.0 com.google.code.findbugs From f4affdf383001e4a9eb58b85e91d6a43dfb1e55b Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Mon, 18 Nov 2024 12:15:09 +0530 Subject: [PATCH 13/18] SK-1767 Fix unit tests not running in CI pipeline --- pom.xml | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/pom.xml b/pom.xml index b719865b..8b8452dc 100644 --- a/pom.xml +++ b/pom.xml @@ -39,8 +39,8 @@ 1.9.0 UTF-8 4.12.0 - 5.10.3 - 1.10.0 + 4.13.2 + 2.3.1 1.3.5 @@ -104,20 +104,18 @@ ${jakarta-annotation-version} provided - - org.junit.jupiter - junit-jupiter-engine - ${junit-version} - test + javax.xml.bind + jaxb-api + ${javax-xml-bind-version} + - org.junit.platform - junit-platform-runner - ${junit-platform-runner.version} + junit + junit + ${junit-version} test - org.powermock powermock-module-junit4 From 8fa94f7ea79c79bbd2e6ac6421aa561fb8b92ebd Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Mon, 18 Nov 2024 12:45:34 +0530 Subject: [PATCH 14/18] SK-1767 Add new secret for Java SDK v2 tests --- .github/workflows/pr.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml index c3a33dc8..3e8586a2 100644 --- a/.github/workflows/pr.yml +++ b/.github/workflows/pr.yml @@ -32,7 +32,7 @@ jobs: json: ${{ secrets.TEST_CREDENTIALS_FILE_STRING }} - name: Build & Run tests with Maven - run: mvn -B package -DTEST_EXPIRED_TOKEN=${{ secrets.TEST_EXPIRED_TOKEN }} -DTEST_DATA_CREDENTIALS_FILE=${{ secrets.TEST_DATA_CREDENTIALS_FILE }} -f pom.xml + run: mvn -B package -DTEST_EXPIRED_TOKEN=${{ secrets.TEST_EXPIRED_TOKEN }} -DTEST_DATA_CREDENTIALS_FILE=${{ secrets.TEST_DATA_CREDENTIALS_FILE }} -DSKYFLOW_CREDENTIALS=${{ secrets.SKYFLOW_CREDENTIALS }} -f pom.xml - name: Codecov uses: codecov/codecov-action@v2.1.0 From 8e9193ea9d23d9e9cfaeebd3b96e024e55dea38d Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Mon, 18 Nov 2024 15:03:23 +0530 Subject: [PATCH 15/18] SK-1767 Fix issues in CI pipeline --- .github/workflows/pr.yml | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml index 3e8586a2..a2d39562 100644 --- a/.github/workflows/pr.yml +++ b/.github/workflows/pr.yml @@ -1,6 +1,6 @@ name: PR CI Checks -on: [ pull_request ] +on: [pull_request] jobs: check-commit-message: @@ -11,18 +11,18 @@ jobs: uses: gsactions/commit-message-checker@v1 with: pattern: '\[?[A-Z]{1,5}-[1-9][0-9]*.+$' - flags: 'gm' - excludeDescription: 'true' - checkAllCommitMessages: 'true' + flags: "gm" + excludeDescription: "true" + checkAllCommitMessages: "true" accessToken: ${{ secrets.PAT_ACTIONS }} - error: 'One of your your commit messages is not matching the format with JIRA ID Ex: ( SDK-123 commit message )' + error: "One of your your commit messages is not matching the format with JIRA ID Ex: ( SDK-123 commit message )" Test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v1 - uses: actions/setup-java@v1 with: - java-version: '1.8' + java-version: "1.8" - name: create-json id: create-json @@ -31,8 +31,15 @@ jobs: name: "credentials.json" json: ${{ secrets.TEST_CREDENTIALS_FILE_STRING }} + - name: create env + id: create-env + run: | + touch .env + echo SKYFLOW_CREDENTIALS=${{ secrets.SKYFLOW_CREDENTIALS }} >> .env + echo TEST_EXPIRED_TOKEN=${{ secrets.TEST_EXPIRED_TOKEN }} >> .env + - name: Build & Run tests with Maven - run: mvn -B package -DTEST_EXPIRED_TOKEN=${{ secrets.TEST_EXPIRED_TOKEN }} -DTEST_DATA_CREDENTIALS_FILE=${{ secrets.TEST_DATA_CREDENTIALS_FILE }} -DSKYFLOW_CREDENTIALS=${{ secrets.SKYFLOW_CREDENTIALS }} -f pom.xml + run: mvn -B package -DTEST_EXPIRED_TOKEN=${{ secrets.TEST_EXPIRED_TOKEN }} -DTEST_DATA_CREDENTIALS_FILE=${{ secrets.TEST_DATA_CREDENTIALS_FILE }} -f pom.xml - name: Codecov uses: codecov/codecov-action@v2.1.0 From f63b903c2421e678a98d7800c3fd6ac9c3dc38e1 Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Mon, 18 Nov 2024 15:10:16 +0530 Subject: [PATCH 16/18] SK-1767 Fix compilation issues in CI pipeline - Excluding generating code from javadoc generation --- pom.xml | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/pom.xml b/pom.xml index 8b8452dc..ea4cbd29 100644 --- a/pom.xml +++ b/pom.xml @@ -160,6 +160,14 @@ org.apache.maven.plugins maven-javadoc-plugin 3.2.0 + + + :com.skyflow.generated.rest + :com.skyflow.generated.rest.api + :com.skyflow.generated.rest.auth + :com.skyflow.generated.rest.models + + attach-javadocs From f092e787b06badb443fe358128a165cb8802cdf7 Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Tue, 19 Nov 2024 11:37:45 +0530 Subject: [PATCH 17/18] SK-1682 Modified the structure of Skyflow error --- .../com/skyflow/errors/SkyflowException.java | 46 ++++++++++++++----- src/test/java/com/skyflow/SkyflowTests.java | 30 ++++++------ .../skyflow/config/ConnectionConfigTests.java | 12 ++--- .../com/skyflow/config/CredentialsTests.java | 20 ++++---- .../com/skyflow/config/VaultConfigTests.java | 8 ++-- .../serviceaccount/util/BearerTokenTests.java | 24 +++++----- .../util/SignedDataTokensTests.java | 20 ++++---- .../java/com/skyflow/utils/UtilsTests.java | 4 +- .../connection/InvokeConnectionTests.java | 32 ++++++------- .../controller/ConnectionControllerTests.java | 2 +- .../controller/VaultControllerTests.java | 18 +++++--- .../com/skyflow/vault/data/DeleteTests.java | 10 ++-- .../java/com/skyflow/vault/data/GetTests.java | 40 ++++++++-------- .../com/skyflow/vault/data/InsertTests.java | 34 +++++++------- .../com/skyflow/vault/data/QueryTests.java | 4 +- .../com/skyflow/vault/data/UpdateTests.java | 32 ++++++------- .../skyflow/vault/tokens/DetokenizeTests.java | 6 +-- .../skyflow/vault/tokens/TokenizeTests.java | 8 ++-- 18 files changed, 187 insertions(+), 163 deletions(-) diff --git a/src/main/java/com/skyflow/errors/SkyflowException.java b/src/main/java/com/skyflow/errors/SkyflowException.java index 625b0d2e..6cff3cdd 100644 --- a/src/main/java/com/skyflow/errors/SkyflowException.java +++ b/src/main/java/com/skyflow/errors/SkyflowException.java @@ -11,8 +11,10 @@ public class SkyflowException extends Exception { private String requestId; - private int code; + private Integer grpcCode; + private Integer httpCode; private String message; + private String httpStatus; private JsonArray details; private JsonObject responseBody; @@ -23,21 +25,23 @@ public SkyflowException(String message) { public SkyflowException(Throwable cause) { super(cause); + this.message = cause.getMessage(); } public SkyflowException(String message, Throwable cause) { super(message, cause); + this.message = message; } public SkyflowException(int code, String message) { super(message); - this.code = code; + this.httpCode = code; this.message = message; } - public SkyflowException(int code, Throwable cause, Map> responseHeaders, String responseBody) { + public SkyflowException(int httpCode, Throwable cause, Map> responseHeaders, String responseBody) { this(cause); - this.code = code; + this.httpCode = httpCode; String contentType = responseHeaders.get("content-type").get(0); setRequestId(responseHeaders); if (Objects.equals(contentType, "application/json")) { @@ -51,6 +55,8 @@ private void setResponseBody(String responseBody) { try { if (responseBody != null) { this.responseBody = JsonParser.parseString(responseBody).getAsJsonObject(); + setGrpcCode(); + setHttpStatus(); setMessage(); setDetails(); } @@ -74,12 +80,32 @@ private void setMessage() { this.message = ((JsonObject) responseBody.get("error")).get("message").getAsString(); } + private void setGrpcCode() { + this.grpcCode = ((JsonObject) responseBody.get("error")).get("grpc_code").getAsInt(); + } + + private void setHttpStatus() { + this.httpStatus = ((JsonObject) responseBody.get("error")).get("http_status").getAsString(); + } + private void setDetails() { this.details = ((JsonObject) responseBody.get("error")).get("details").getAsJsonArray(); } - public int getCode() { - return code; + public int getHttpCode() { + return httpCode; + } + + public JsonArray getDetails() { + return details; + } + + public Integer getGrpcCode() { + return grpcCode; + } + + public String getHttpStatus() { + return httpStatus; } @Override @@ -90,12 +116,8 @@ public String getMessage() { @Override public String toString() { return String.format( - "%n requestId: %s%n code: %s%n message: %s", - this.requestId, this.code, this.message + "%n requestId: %s%n grpcCode: %s%n httpCode: %s%n httpStatus: %s%n message: %s%n details: %s", + this.requestId, this.grpcCode, this.httpCode, this.httpStatus, this.message, this.details ); } - - public JsonArray getDetails() { - return details; - } } diff --git a/src/test/java/com/skyflow/SkyflowTests.java b/src/test/java/com/skyflow/SkyflowTests.java index efdc54dc..041969a7 100644 --- a/src/test/java/com/skyflow/SkyflowTests.java +++ b/src/test/java/com/skyflow/SkyflowTests.java @@ -44,7 +44,7 @@ public void testAddingInvalidVaultConfigInSkyflowBuilder() { Skyflow.builder().addVaultConfig(config).build(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyVaultId.getMessage(), e.getMessage()); } } @@ -60,7 +60,7 @@ public void testAddingInvalidVaultConfigInSkyflowClient() { skyflowClient.addVaultConfig(config); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyVaultId.getMessage(), e.getMessage()); } } @@ -90,7 +90,7 @@ public void testAddingExistingVaultConfigInSkyflowClient() { skyflowClient.addVaultConfig(config).addVaultConfig(config); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.VaultIdAlreadyInConfigList.getMessage(), e.getMessage()); } } @@ -105,7 +105,7 @@ public void testUpdatingNonExistentVaultConfigInSkyflowBuilder() { Skyflow.builder().updateVaultConfig(config).build(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.VaultIdNotInConfigList.getMessage(), e.getMessage()); } } @@ -121,7 +121,7 @@ public void testUpdatingNonExistentVaultConfigInSkyflowClient() { skyflowClient.updateVaultConfig(config); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.VaultIdNotInConfigList.getMessage(), e.getMessage()); } catch (Exception e) { Assert.assertEquals(ErrorMessage.VaultIdNotInConfigList.getMessage(), e.getMessage()); @@ -158,7 +158,7 @@ public void testRemovingNonExistentVaultConfigInSkyflowBuilder() { Skyflow.builder().removeVaultConfig(vaultID).build(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.VaultIdNotInConfigList.getMessage(), e.getMessage()); } } @@ -184,7 +184,7 @@ public void testRemovingValidVaultConfigInSkyflowClient() { skyflowClient.removeVaultConfig(vaultID); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.VaultIdNotInConfigList.getMessage(), e.getMessage()); } } @@ -210,7 +210,7 @@ public void testAddingInvalidConnectionConfigInSkyflowBuilder() { Skyflow.builder().addConnectionConfig(config).build(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyConnectionId.getMessage(), e.getMessage()); } } @@ -225,7 +225,7 @@ public void testAddingInvalidConnectionConfigInSkyflowClient() { skyflowClient.addConnectionConfig(config); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyConnectionId.getMessage(), e.getMessage()); } } @@ -253,7 +253,7 @@ public void testAddingExistingConnectionConfigInSkyflowClient() { skyflowClient.addConnectionConfig(config); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.ConnectionIdAlreadyInConfigList.getMessage(), e.getMessage()); } } @@ -267,7 +267,7 @@ public void testUpdatingNonExistentConnectionConfigInSkyflowBuilder() { Skyflow.builder().updateConnectionConfig(config).build(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.ConnectionIdNotInConfigList.getMessage(), e.getMessage()); } } @@ -282,7 +282,7 @@ public void testUpdatingNonExistentConnectionConfigInSkyflowClient() { skyflowClient.updateConnectionConfig(config); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.ConnectionIdNotInConfigList.getMessage(), e.getMessage()); } } @@ -313,7 +313,7 @@ public void testRemovingNonExistentConnectionConfigInSkyflowBuilder() { Skyflow.builder().removeConnectionConfig(connectionID).build(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.ConnectionIdNotInConfigList.getMessage(), e.getMessage()); } } @@ -325,7 +325,7 @@ public void testRemovingNonExistentConnectionConfigInSkyflowClient() { skyflowClient.removeConnectionConfig(connectionID); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.ConnectionIdNotInConfigList.getMessage(), e.getMessage()); } } @@ -361,7 +361,7 @@ public void testAddingInvalidSkyflowCredentialsInSkyflowBuilder() { Skyflow.builder().addSkyflowCredentials(credentials).build(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.NoTokenGenerationMeansPassed.getMessage(), e.getMessage()); } } diff --git a/src/test/java/com/skyflow/config/ConnectionConfigTests.java b/src/test/java/com/skyflow/config/ConnectionConfigTests.java index 03b1021e..5ff32ca5 100644 --- a/src/test/java/com/skyflow/config/ConnectionConfigTests.java +++ b/src/test/java/com/skyflow/config/ConnectionConfigTests.java @@ -1,7 +1,5 @@ package com.skyflow.config; -import com.skyflow.config.ConnectionConfig; -import com.skyflow.config.Credentials; import com.skyflow.errors.ErrorCode; import com.skyflow.errors.ErrorMessage; import com.skyflow.errors.SkyflowException; @@ -82,7 +80,7 @@ public void testNoConnectionIdInConnectionConfig() { Validations.validateConnectionConfig(connectionConfig); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidConnectionId.getMessage(), e.getMessage()); } } @@ -96,7 +94,7 @@ public void testEmptyConnectionIdInConnectionConfig() { Validations.validateConnectionConfig(connectionConfig); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyConnectionId.getMessage(), e.getMessage()); } } @@ -109,7 +107,7 @@ public void testNoConnectionURLInConnectionConfig() { Validations.validateConnectionConfig(connectionConfig); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidConnectionUrl.getMessage(), e.getMessage()); } } @@ -123,7 +121,7 @@ public void testEmptyConnectionURLInConnectionConfig() { Validations.validateConnectionConfig(connectionConfig); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyConnectionUrl.getMessage(), e.getMessage()); } } @@ -137,7 +135,7 @@ public void testInvalidConnectionURLInConnectionConfig() { Validations.validateConnectionConfig(connectionConfig); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidConnectionUrlFormat.getMessage(), e.getMessage()); } } diff --git a/src/test/java/com/skyflow/config/CredentialsTests.java b/src/test/java/com/skyflow/config/CredentialsTests.java index 1b7f6e64..cfc61de6 100644 --- a/src/test/java/com/skyflow/config/CredentialsTests.java +++ b/src/test/java/com/skyflow/config/CredentialsTests.java @@ -136,7 +136,7 @@ public void testEmptyPathInCredentials() { Validations.validateCredentials(credentials); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyCredentialFilePath.getMessage(), e.getMessage()); } } @@ -149,7 +149,7 @@ public void testEmptyCredentialsStringInCredentials() { Validations.validateCredentials(credentials); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyCredentialsString.getMessage(), e.getMessage()); } } @@ -162,7 +162,7 @@ public void testEmptyTokenInCredentials() { Validations.validateCredentials(credentials); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyToken.getMessage(), e.getMessage()); } } @@ -175,7 +175,7 @@ public void testEmptyApikeyInCredentials() { Validations.validateCredentials(credentials); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyApikey.getMessage(), e.getMessage()); } } @@ -188,7 +188,7 @@ public void testInvalidApikeyInCredentials() { Validations.validateCredentials(credentials); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidApikey.getMessage(), e.getMessage()); } } @@ -202,7 +202,7 @@ public void testBothTokenAndPathInCredentials() { Validations.validateCredentials(credentials); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.MultipleTokenGenerationMeansPassed.getMessage(), e.getMessage()); } } @@ -214,7 +214,7 @@ public void testNothingPassedInCredentials() { Validations.validateCredentials(credentials); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.NoTokenGenerationMeansPassed.getMessage(), e.getMessage()); } } @@ -228,7 +228,7 @@ public void testEmptyRolesInCredentials() { Validations.validateCredentials(credentials); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyRoles.getMessage(), e.getMessage()); } } @@ -244,7 +244,7 @@ public void testEmptyRoleInRolesInCredentials() { Validations.validateCredentials(credentials); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyRoleInRoles.getMessage(), e.getMessage()); } } @@ -258,7 +258,7 @@ public void testEmptyContextInCredentials() { Validations.validateCredentials(credentials); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyContext.getMessage(), e.getMessage()); } } diff --git a/src/test/java/com/skyflow/config/VaultConfigTests.java b/src/test/java/com/skyflow/config/VaultConfigTests.java index 478f8cf0..1a5ca703 100644 --- a/src/test/java/com/skyflow/config/VaultConfigTests.java +++ b/src/test/java/com/skyflow/config/VaultConfigTests.java @@ -121,7 +121,7 @@ public void testNoVaultIdInVaultConfigInValidations() { Validations.validateVaultConfig(vaultConfig); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidVaultId.getMessage(), e.getMessage()); } } @@ -136,7 +136,7 @@ public void testEmptyVaultIdInVaultConfigInValidations() { Validations.validateVaultConfig(vaultConfig); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyVaultId.getMessage(), e.getMessage()); } } @@ -150,7 +150,7 @@ public void testNoClusterIdInVaultConfigInValidations() { Validations.validateVaultConfig(vaultConfig); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidClusterId.getMessage(), e.getMessage()); } } @@ -165,7 +165,7 @@ public void testEmptyClusterIdInVaultConfigInValidations() { Validations.validateVaultConfig(vaultConfig); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyClusterId.getMessage(), e.getMessage()); } } diff --git a/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java b/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java index 3993e476..52272933 100644 --- a/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java +++ b/src/test/java/com/skyflow/serviceaccount/util/BearerTokenTests.java @@ -62,7 +62,7 @@ public void testEmptyCredentialsFilePath() { bearerToken.getBearerToken(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidCredentials.getMessage(), e.getMessage()); } } @@ -75,7 +75,7 @@ public void testInvalidFilePath() { bearerToken.getBearerToken(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidCredentials.getMessage(), e.getMessage()); } } @@ -88,7 +88,7 @@ public void testInvalidCredentialsFile() { bearerToken.getBearerToken(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.FileInvalidJson.getMessage(), invalidJsonFilePath), e.getMessage() @@ -103,7 +103,7 @@ public void testEmptyCredentialsString() { bearerToken.getBearerToken(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidCredentials.getMessage(), e.getMessage()); } } @@ -115,7 +115,7 @@ public void testInvalidCredentialsString() { bearerToken.getBearerToken(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.CredentialsStringInvalidJson.getMessage(), e.getMessage()); } } @@ -130,7 +130,7 @@ public void testNoPrivateKeyInCredentialsForCredentials() { bearerToken.getBearerToken(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.MissingPrivateKey.getMessage(), e.getMessage()); } } @@ -144,7 +144,7 @@ public void testNoClientIDInCredentialsForCredentials() { bearerToken.getBearerToken(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.MissingClientId.getMessage(), e.getMessage()); } } @@ -158,7 +158,7 @@ public void testNoKeyIDInCredentialsForCredentials() { bearerToken.getBearerToken(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.MissingKeyId.getMessage(), e.getMessage()); } } @@ -172,7 +172,7 @@ public void testNoTokenURIInCredentialsForCredentials() { bearerToken.getBearerToken(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.MissingTokenUri.getMessage(), e.getMessage()); } } @@ -186,7 +186,7 @@ public void testInvalidPrivateKeyInCredentialsForCredentials() { bearerToken.getBearerToken(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.JwtInvalidFormat.getMessage(), e.getMessage()); } } @@ -199,7 +199,7 @@ public void testInvalidKeySpecInCredentialsForCredentials() { bearerToken.getBearerToken(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidKeySpec.getMessage(), e.getMessage()); } } @@ -213,7 +213,7 @@ public void testInvalidTokenURIInCredentialsForCredentials() throws SkyflowExcep bearerToken.getBearerToken(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidTokenUri.getMessage(), e.getMessage()); } } diff --git a/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java b/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java index e5ce56b1..5e631995 100644 --- a/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java +++ b/src/test/java/com/skyflow/serviceaccount/util/SignedDataTokensTests.java @@ -68,7 +68,7 @@ public void testEmptyCredentialsFilePath() { signedTokens.getSignedDataTokens(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidCredentials.getMessage(), e.getMessage()); } } @@ -81,7 +81,7 @@ public void testInvalidFilePath() { signedTokens.getSignedDataTokens(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidCredentials.getMessage(), e.getMessage()); } } @@ -94,7 +94,7 @@ public void testInvalidCredentialsFile() { signedTokens.getSignedDataTokens(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.FileInvalidJson.getMessage(), invalidJsonFilePath), e.getMessage() @@ -112,7 +112,7 @@ public void testEmptyCredentialsString() { } catch (SkyflowException e) { System.out.println("caught skyflow exception"); System.out.println(e); - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.InvalidCredentials.getMessage(), invalidJsonFilePath), e.getMessage() @@ -130,7 +130,7 @@ public void testInvalidCredentialsString() { signedTokens.getSignedDataTokens(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.CredentialsStringInvalidJson.getMessage(), invalidJsonFilePath), e.getMessage() @@ -147,7 +147,7 @@ public void testNoPrivateKeyInCredentials() { signedTokens.getSignedDataTokens(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.MissingPrivateKey.getMessage(), e.getMessage()); } } @@ -161,7 +161,7 @@ public void testNoClientIDInCredentials() { signedTokens.getSignedDataTokens(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.MissingClientId.getMessage(), e.getMessage()); } } @@ -175,7 +175,7 @@ public void testNoKeyIDInCredentials() { signedTokens.getSignedDataTokens(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.MissingKeyId.getMessage(), e.getMessage()); } } @@ -189,7 +189,7 @@ public void testInvalidPrivateKeyInCredentials() { signedTokens.getSignedDataTokens(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.JwtInvalidFormat.getMessage(), e.getMessage()); } } @@ -202,7 +202,7 @@ public void testInvalidKeySpecInCredentials() { signedTokens.getSignedDataTokens(); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidKeySpec.getMessage(), e.getMessage()); } } diff --git a/src/test/java/com/skyflow/utils/UtilsTests.java b/src/test/java/com/skyflow/utils/UtilsTests.java index 5a1b9de7..79817bc5 100644 --- a/src/test/java/com/skyflow/utils/UtilsTests.java +++ b/src/test/java/com/skyflow/utils/UtilsTests.java @@ -115,7 +115,7 @@ public void testGenerateBearerTokenWithCredentialsFile() { Utils.generateBearerToken(credentials); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidCredentials.getMessage(), e.getMessage()); } } @@ -130,7 +130,7 @@ public void testGenerateBearerTokenWithCredentialsString() { Utils.generateBearerToken(credentials); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.CredentialsStringInvalidJson.getMessage(), e.getMessage()); } } diff --git a/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java b/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java index db23e010..8d950279 100644 --- a/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java +++ b/src/test/java/com/skyflow/vault/connection/InvokeConnectionTests.java @@ -76,7 +76,7 @@ public void testEmptyRequestHeadersInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyRequestHeaders.getMessage(), e.getMessage()); } } @@ -96,7 +96,7 @@ public void testNullRequestHeaderKeyInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidRequestHeaders.getMessage(), e.getMessage()); } } @@ -116,7 +116,7 @@ public void testEmptyRequestHeaderKeyInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidRequestHeaders.getMessage(), e.getMessage()); } } @@ -136,7 +136,7 @@ public void testNullRequestHeaderValueInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidRequestHeaders.getMessage(), e.getMessage()); } } @@ -156,7 +156,7 @@ public void testEmptyRequestHeaderValueInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidRequestHeaders.getMessage(), e.getMessage()); } } @@ -175,7 +175,7 @@ public void testEmptyPathParamsInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyPathParams.getMessage(), e.getMessage()); } } @@ -196,7 +196,7 @@ public void testNullPathParamKeyInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidPathParams.getMessage(), e.getMessage()); } } @@ -217,7 +217,7 @@ public void testEmptyPathParamKeyInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidPathParams.getMessage(), e.getMessage()); } } @@ -238,7 +238,7 @@ public void testNullPathParamValueInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidPathParams.getMessage(), e.getMessage()); } } @@ -259,7 +259,7 @@ public void testEmptyPathParamValueInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidPathParams.getMessage(), e.getMessage()); } } @@ -279,7 +279,7 @@ public void testEmptyQueryParamsInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyQueryParams.getMessage(), e.getMessage()); } } @@ -301,7 +301,7 @@ public void testNullQueryParamKeyInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidQueryParams.getMessage(), e.getMessage()); } } @@ -323,7 +323,7 @@ public void testEmptyQueryParamKeyInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidQueryParams.getMessage(), e.getMessage()); } } @@ -345,7 +345,7 @@ public void testNullQueryParamValueInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidQueryParams.getMessage(), e.getMessage()); } } @@ -367,7 +367,7 @@ public void testEmptyQueryParamValueInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InvalidQueryParams.getMessage(), e.getMessage()); } } @@ -388,7 +388,7 @@ public void testEmptyRequestBodyInInvokeConnectionRequestValidations() { Validations.validateInvokeConnectionRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyRequestBody.getMessage(), e.getMessage()); } } diff --git a/src/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java b/src/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java index 0b933b4a..036dfdcd 100644 --- a/src/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java +++ b/src/test/java/com/skyflow/vault/controller/ConnectionControllerTests.java @@ -42,7 +42,7 @@ public void testInvalidRequestInInvokeConnectionMethod() { skyflowClient.connection().invoke(connectionRequest); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyRequestHeaders.getMessage(), e.getMessage()); } } diff --git a/src/test/java/com/skyflow/vault/controller/VaultControllerTests.java b/src/test/java/com/skyflow/vault/controller/VaultControllerTests.java index ecfca480..ca2e85d9 100644 --- a/src/test/java/com/skyflow/vault/controller/VaultControllerTests.java +++ b/src/test/java/com/skyflow/vault/controller/VaultControllerTests.java @@ -52,7 +52,7 @@ public void testInvalidRequestInInsertMethod() { skyflowClient.vault().insert(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -68,7 +68,7 @@ public void testInvalidRequestInDetokenizeMethod() { skyflowClient.vault().detokenize(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.InvalidDataTokens.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -84,7 +84,7 @@ public void testInvalidRequestInGetMethod() { skyflowClient.vault().get(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -100,7 +100,7 @@ public void testInvalidRequestInUpdateMethod() { skyflowClient.vault().update(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -116,7 +116,7 @@ public void testInvalidRequestInDeleteMethod() { skyflowClient.vault().delete(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -132,7 +132,7 @@ public void testInvalidRequestInQueryMethod() { skyflowClient.vault().query(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.QueryKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -148,11 +148,15 @@ public void testInvalidRequestInTokenizeMethod() { skyflowClient.vault().tokenize(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.ColumnValuesKeyErrorTokenize.getMessage(), Constants.SDK_PREFIX), e.getMessage() ); + Assert.assertNull(e.getRequestId()); + Assert.assertNull(e.getGrpcCode()); + Assert.assertNull(e.getHttpStatus()); + Assert.assertNull(e.getDetails()); } } diff --git a/src/test/java/com/skyflow/vault/data/DeleteTests.java b/src/test/java/com/skyflow/vault/data/DeleteTests.java index 5f2eefc7..8cb43880 100644 --- a/src/test/java/com/skyflow/vault/data/DeleteTests.java +++ b/src/test/java/com/skyflow/vault/data/DeleteTests.java @@ -84,7 +84,7 @@ public void testNoIdsInDeleteRequestValidations() { Validations.validateDeleteRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.IdsKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -100,7 +100,7 @@ public void testEmptyIdsInDeleteRequestValidations() { Validations.validateDeleteRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyIds.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -117,7 +117,7 @@ public void testEmptyIdInIdsInDeleteRequestValidations() { Validations.validateDeleteRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyIdInIds.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -134,7 +134,7 @@ public void testNoTableInDeleteRequestValidations() { Validations.validateDeleteRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -151,7 +151,7 @@ public void testEmptyTableInDeleteRequestValidations() { Validations.validateDeleteRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyTable.getMessage(), Constants.SDK_PREFIX), e.getMessage() diff --git a/src/test/java/com/skyflow/vault/data/GetTests.java b/src/test/java/com/skyflow/vault/data/GetTests.java index 140990a7..f9fa98d9 100644 --- a/src/test/java/com/skyflow/vault/data/GetTests.java +++ b/src/test/java/com/skyflow/vault/data/GetTests.java @@ -148,7 +148,7 @@ public void testNoTableInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -164,7 +164,7 @@ public void testEmptyTableInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyTable.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -179,7 +179,7 @@ public void testEmptyIdsInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyIds.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -196,7 +196,7 @@ public void testEmptyIdInIdsInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyIdInIds.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -212,7 +212,7 @@ public void testEmptyFieldsInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyFields.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -230,7 +230,7 @@ public void testEmptyFieldInFieldsInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyFieldInFields.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -245,7 +245,7 @@ public void testNoRedactionInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.RedactionKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -262,7 +262,7 @@ public void testReturnTokensWithRedactionInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.RedactionWithTokensNotSupported.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -277,7 +277,7 @@ public void testReturnTokensWithColumnNameInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.TokensGetColumnNotSupported.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -292,7 +292,7 @@ public void testReturnTokensWithColumnValuesInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.TokensGetColumnNotSupported.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -309,7 +309,7 @@ public void testEmptyOffsetInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyOffset.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -326,7 +326,7 @@ public void testEmptyLimitInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyLimit.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -341,7 +341,7 @@ public void testNoIdsOrColumnNameInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.UniqueColumnOrIdsKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -359,7 +359,7 @@ public void testBothIdsAndColumnNameInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.BothIdsAndColumnDetailsSpecified.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -377,7 +377,7 @@ public void testBothIdsAndColumnValuesInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.BothIdsAndColumnDetailsSpecified.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -394,7 +394,7 @@ public void testColumnNameWithoutColumnValuesInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.ColumnValuesKeyErrorGet.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -411,7 +411,7 @@ public void testColumnValuesWithoutColumnNameInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.ColumnNameKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -428,7 +428,7 @@ public void testEmptyColumnNameInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyColumnName.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -445,7 +445,7 @@ public void testEmptyColumnValuesInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyColumnValues.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -464,7 +464,7 @@ public void testEmptyValueInColumnValuesInGetRequestValidations() { Validations.validateGetRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyValueInColumnValues.getMessage(), Constants.SDK_PREFIX), e.getMessage() diff --git a/src/test/java/com/skyflow/vault/data/InsertTests.java b/src/test/java/com/skyflow/vault/data/InsertTests.java index 50b1e5fc..87057d7c 100644 --- a/src/test/java/com/skyflow/vault/data/InsertTests.java +++ b/src/test/java/com/skyflow/vault/data/InsertTests.java @@ -117,7 +117,7 @@ public void testNoTableInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -132,7 +132,7 @@ public void testEmptyTableInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyTable.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -147,7 +147,7 @@ public void testNoValuesInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.ValuesKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -162,7 +162,7 @@ public void testEmptyValuesInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyValues.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -179,7 +179,7 @@ public void testEmptyKeyInValuesInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyKeyInValues.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -196,7 +196,7 @@ public void testEmptyValueInValuesInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyValueInValues.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -212,7 +212,7 @@ public void testEmptyUpsertInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyUpsert.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -230,7 +230,7 @@ public void testUpsertWithHomogenousInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.HomogenousNotSupportedWithUpsert.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -246,7 +246,7 @@ public void testTokensWithTokenStrictDisableInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.TokensPassedForByotDisable.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -264,7 +264,7 @@ public void testNoTokensWithTokenStrictEnableInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.NoTokensWithByot.getMessage(), Byot.ENABLE.toString()), e.getMessage() @@ -282,7 +282,7 @@ public void testNoTokensWithTokenStrictEnableStrictInInsertRequestValidations() Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.NoTokensWithByot.getMessage(), Byot.ENABLE_STRICT.toString()), e.getMessage() @@ -300,7 +300,7 @@ public void testEmptyTokensWithTokenStrictEnableInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyTokens.getMessage(), e.getMessage()); } } @@ -316,7 +316,7 @@ public void testInsufficientTokensWithTokenStrictEnableStrictInInsertRequestVali Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InsufficientTokensPassedForByotEnableStrict.getMessage(), e.getMessage()); } } @@ -333,7 +333,7 @@ public void testInsufficientTokensWithTokenStrictEnableStrictInInsertRequestVali Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InsufficientTokensPassedForByotEnableStrict.getMessage(), e.getMessage()); } } @@ -350,7 +350,7 @@ public void testTokenValueMismatchInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.MismatchOfFieldsAndTokens.getMessage(), e.getMessage()); } } @@ -367,7 +367,7 @@ public void testEmptyKeyInTokensInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyKeyInTokens.getMessage(), e.getMessage()); } } @@ -384,7 +384,7 @@ public void testEmptyValueInTokensInInsertRequestValidations() { Validations.validateInsertRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyValueInTokens.getMessage(), e.getMessage()); } } diff --git a/src/test/java/com/skyflow/vault/data/QueryTests.java b/src/test/java/com/skyflow/vault/data/QueryTests.java index a84c9113..82b8499a 100644 --- a/src/test/java/com/skyflow/vault/data/QueryTests.java +++ b/src/test/java/com/skyflow/vault/data/QueryTests.java @@ -77,7 +77,7 @@ public void testNoQueryInQueryRequestValidations() { Validations.validateQueryRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.QueryKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -92,7 +92,7 @@ public void testEmptyQueryInQueryRequestValidations() { Validations.validateQueryRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyQuery.getMessage(), Constants.SDK_PREFIX), e.getMessage() diff --git a/src/test/java/com/skyflow/vault/data/UpdateTests.java b/src/test/java/com/skyflow/vault/data/UpdateTests.java index 22417257..e6c41db9 100644 --- a/src/test/java/com/skyflow/vault/data/UpdateTests.java +++ b/src/test/java/com/skyflow/vault/data/UpdateTests.java @@ -98,7 +98,7 @@ public void testNoSkyflowIdInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.SkyflowIdKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -113,7 +113,7 @@ public void testEmptySkyflowIdInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptySkyflowId.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -128,7 +128,7 @@ public void testNoTableInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.TableKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -143,7 +143,7 @@ public void testEmptyTableInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyTable.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -158,7 +158,7 @@ public void testNoValuesInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.ValuesKeyError.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -173,7 +173,7 @@ public void testEmptyValuesInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyValues.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -191,7 +191,7 @@ public void testEmptyKeyInValuesInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyKeyInValues.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -209,7 +209,7 @@ public void testEmptyValueInValuesInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyValueInValues.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -229,7 +229,7 @@ public void testTokensWithTokenStrictDisableInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.TokensPassedForByotDisable.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -248,7 +248,7 @@ public void testNoTokensWithTokenStrictEnableInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.NoTokensWithByot.getMessage(), Byot.ENABLE.toString()), e.getMessage() @@ -267,7 +267,7 @@ public void testNoTokensWithTokenStrictEnableStrictInUpdateRequestValidations() Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.NoTokensWithByot.getMessage(), Byot.ENABLE_STRICT.toString()), e.getMessage() @@ -286,7 +286,7 @@ public void testEmptyTokensWithTokenStrictEnableInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyTokens.getMessage(), e.getMessage()); } } @@ -303,7 +303,7 @@ public void testInsufficientTokensWithTokenStrictEnableStrictInUpdateRequestVali Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.InsufficientTokensPassedForByotEnableStrict.getMessage(), e.getMessage()); } } @@ -321,7 +321,7 @@ public void testTokenValueMismatchInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.MismatchOfFieldsAndTokens.getMessage(), e.getMessage()); } } @@ -339,7 +339,7 @@ public void testEmptyKeyInTokensInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyKeyInTokens.getMessage(), e.getMessage()); } } @@ -357,7 +357,7 @@ public void testEmptyValueInTokensInUpdateRequestValidations() { Validations.validateUpdateRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyValueInTokens.getMessage(), e.getMessage()); } } diff --git a/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java b/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java index d569cbc9..3fe57faa 100644 --- a/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java +++ b/src/test/java/com/skyflow/vault/tokens/DetokenizeTests.java @@ -53,7 +53,7 @@ public void testNoTokensInDetokenizeRequestValidations() { Validations.validateDetokenizeRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.InvalidDataTokens.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -70,7 +70,7 @@ public void testEmptyTokensInDetokenizeRequestValidations() { Validations.validateDetokenizeRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyDataTokens.getMessage(), Constants.SDK_PREFIX), e.getMessage() @@ -89,7 +89,7 @@ public void testEmptyTokenInTokensInDetokenizeRequestValidations() { Validations.validateDetokenizeRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals( Utils.parameterizedString(ErrorMessage.EmptyTokenInDataTokens.getMessage(), Constants.SDK_PREFIX), e.getMessage() diff --git a/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java b/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java index 1f4360b2..850553f4 100644 --- a/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java +++ b/src/test/java/com/skyflow/vault/tokens/TokenizeTests.java @@ -76,7 +76,7 @@ public void testNoColumnValuesInTokenizeRequestValidations() { Validations.validateTokenizeRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.ColumnValuesKeyErrorTokenize.getMessage(), e.getMessage()); } } @@ -88,7 +88,7 @@ public void testEmptyColumnValuesInTokenizeRequestValidations() { Validations.validateTokenizeRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyColumnValues.getMessage(), e.getMessage()); } } @@ -102,7 +102,7 @@ public void testEmptyColumnValueInColumnValuesInTokenizeRequestValidations() { Validations.validateTokenizeRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyValueInColumnValues.getMessage(), e.getMessage()); } } @@ -116,7 +116,7 @@ public void testEmptyColumnGroupInColumnValuesInTokenizeRequestValidations() { Validations.validateTokenizeRequest(request); Assert.fail(EXCEPTION_NOT_THROWN); } catch (SkyflowException e) { - Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getCode()); + Assert.assertEquals(ErrorCode.INVALID_INPUT.getCode(), e.getHttpCode()); Assert.assertEquals(ErrorMessage.EmptyColumnGroupInColumnValue.getMessage(), e.getMessage()); } } From 9ec99b4b7b235f0cea6438e42598b4b7eb976eee Mon Sep 17 00:00:00 2001 From: skyflow-vivek Date: Tue, 19 Nov 2024 18:38:53 +0530 Subject: [PATCH 18/18] SK-1623 Fix minor issues in Java SDK v2 --- .../java/com/skyflow/ConnectionClient.java | 4 +- src/main/java/com/skyflow/VaultClient.java | 4 +- .../java/com/skyflow/errors/ErrorMessage.java | 191 +++++++++--------- 3 files changed, 99 insertions(+), 100 deletions(-) diff --git a/src/main/java/com/skyflow/ConnectionClient.java b/src/main/java/com/skyflow/ConnectionClient.java index 40fd741a..72a70fef 100644 --- a/src/main/java/com/skyflow/ConnectionClient.java +++ b/src/main/java/com/skyflow/ConnectionClient.java @@ -24,7 +24,6 @@ protected ConnectionClient(ConnectionConfig connectionConfig, Credentials creden super(); this.connectionConfig = connectionConfig; this.commonCredentials = credentials; - prioritiseCredentials(); } protected ConnectionConfig getConnectionConfig() { @@ -41,11 +40,12 @@ protected void updateConnectionConfig(ConnectionConfig connectionConfig) { } protected void setBearerToken() throws SkyflowException { + prioritiseCredentials(); Validations.validateCredentials(this.finalCredentials); if (this.finalCredentials.getApiKey() != null) { setApiKey(); return; - } else if (token == null || Token.isExpired(token)) { + } else if (Token.isExpired(token)) { LogUtil.printInfoLog(InfoLogs.BEARER_TOKEN_EXPIRED.getLog()); token = Utils.generateBearerToken(this.finalCredentials); } else { diff --git a/src/main/java/com/skyflow/VaultClient.java b/src/main/java/com/skyflow/VaultClient.java index b1acbdad..55a16024 100644 --- a/src/main/java/com/skyflow/VaultClient.java +++ b/src/main/java/com/skyflow/VaultClient.java @@ -48,7 +48,6 @@ protected VaultClient(VaultConfig vaultConfig, Credentials credentials) { this.tokensApi = new TokensApi(this.apiClient); this.queryApi = new QueryApi(this.apiClient); updateVaultURL(); - prioritiseCredentials(); } protected RecordsApi getRecordsApi() { @@ -168,11 +167,12 @@ protected V1TokenizePayload getTokenizePayload(TokenizeRequest request) { } protected void setBearerToken() throws SkyflowException { + prioritiseCredentials(); Validations.validateCredentials(this.finalCredentials); if (this.finalCredentials.getApiKey() != null) { setApiKey(); return; - } else if (token == null || Token.isExpired(token)) { + } else if (Token.isExpired(token)) { LogUtil.printInfoLog(InfoLogs.BEARER_TOKEN_EXPIRED.getLog()); token = Utils.generateBearerToken(this.finalCredentials); } else { diff --git a/src/main/java/com/skyflow/errors/ErrorMessage.java b/src/main/java/com/skyflow/errors/ErrorMessage.java index f44427fb..c7ac207a 100644 --- a/src/main/java/com/skyflow/errors/ErrorMessage.java +++ b/src/main/java/com/skyflow/errors/ErrorMessage.java @@ -1,132 +1,131 @@ package com.skyflow.errors; import com.skyflow.utils.Constants; -import com.skyflow.utils.Utils; public enum ErrorMessage { // client initialization - VaultIdAlreadyInConfigList("%s1 Validation error. VaultId is present in an existing config. Specify a new vaultId in config."), - VaultIdNotInConfigList("%s1 Validation error. VaultId is missing from the config. Specify the vaultIds from configs."), - ConnectionIdAlreadyInConfigList("%s1 Validation error. ConnectionId is present in an existing config. Specify a connectionId in config."), - ConnectionIdNotInConfigList("%s1 Validation error. ConnectionId is missing from the config. Specify the connectionIds from configs."), - EmptyCredentials("%s1 Validation error. Invalid credentials. Specify a valid credentials."), + VaultIdAlreadyInConfigList("%s0 Validation error. VaultId is present in an existing config. Specify a new vaultId in config."), + VaultIdNotInConfigList("%s0 Validation error. VaultId is missing from the config. Specify the vaultIds from configs."), + ConnectionIdAlreadyInConfigList("%s0 Validation error. ConnectionId is present in an existing config. Specify a connectionId in config."), + ConnectionIdNotInConfigList("%s0 Validation error. ConnectionId is missing from the config. Specify the connectionIds from configs."), + EmptyCredentials("%s0 Validation error. Invalid credentials. Specify a valid credentials."), // vault config - InvalidVaultId("%s1 Initialization failed. Invalid vault ID. Specify a valid vault ID."), - EmptyVaultId("%s1 Initialization failed. Invalid vault ID. Vault ID must not be empty."), - InvalidClusterId("%s1 Initialization failed. Invalid cluster ID. Specify cluster ID."), - EmptyClusterId("%s1 Initialization failed. Invalid cluster ID. Specify a valid cluster ID."), + InvalidVaultId("%s0 Initialization failed. Invalid vault ID. Specify a valid vault ID."), + EmptyVaultId("%s0 Initialization failed. Invalid vault ID. Vault ID must not be empty."), + InvalidClusterId("%s0 Initialization failed. Invalid cluster ID. Specify cluster ID."), + EmptyClusterId("%s0 Initialization failed. Invalid cluster ID. Specify a valid cluster ID."), // connection config - InvalidConnectionId("%s1 Initialization failed. Invalid connection ID. Specify a valid connection ID."), - EmptyConnectionId("%s1 Initialization failed. Invalid connection ID. Connection ID must not be empty."), - InvalidConnectionUrl("%s1 Initialization failed. Invalid connection URL. Specify a valid connection URL."), - EmptyConnectionUrl("%s1 Initialization failed. Invalid connection URL. Connection URL must not be empty."), - InvalidConnectionUrlFormat("%s1 Initialization failed. Connection URL is not a valid URL. Specify a valid connection URL."), + InvalidConnectionId("%s0 Initialization failed. Invalid connection ID. Specify a valid connection ID."), + EmptyConnectionId("%s0 Initialization failed. Invalid connection ID. Connection ID must not be empty."), + InvalidConnectionUrl("%s0 Initialization failed. Invalid connection URL. Specify a valid connection URL."), + EmptyConnectionUrl("%s0 Initialization failed. Invalid connection URL. Connection URL must not be empty."), + InvalidConnectionUrlFormat("%s0 Initialization failed. Connection URL is not a valid URL. Specify a valid connection URL."), // credentials - MultipleTokenGenerationMeansPassed("%s1 Initialization failed. Invalid credentials. Specify only one from 'path', 'credentialsString', 'token' or 'apiKey'."), - NoTokenGenerationMeansPassed("%s1 Initialization failed. Invalid credentials. Specify any one from 'path', 'credentialsString', 'token' or 'apiKey'."), - EmptyCredentialFilePath("%s1 Initialization failed. Invalid credentials. Credentials file path must not be empty."), - EmptyCredentialsString("%s1 Initialization failed. Invalid credentials. Credentials string must not be empty."), - EmptyToken("%s1 Initialization failed. Invalid credentials. Token mut not be empty."), - EmptyApikey("%s1 Initialization failed. Invalid credentials. Api key must not be empty."), - InvalidApikey("%s1 Initialization failed. Invalid credentials. Specify valid api key."), - EmptyRoles("%s1 Initialization failed. Invalid roles. Specify at least one role."), - EmptyRoleInRoles("%s1 Initialization failed. Invalid role. Specify a valid role."), - EmptyContext("%s1 Initialization failed. Invalid context. Specify a valid context."), + MultipleTokenGenerationMeansPassed("%s0 Initialization failed. Invalid credentials. Specify only one from 'path', 'credentialsString', 'token' or 'apiKey'."), + NoTokenGenerationMeansPassed("%s0 Initialization failed. Invalid credentials. Specify any one from 'path', 'credentialsString', 'token' or 'apiKey'."), + EmptyCredentialFilePath("%s0 Initialization failed. Invalid credentials. Credentials file path must not be empty."), + EmptyCredentialsString("%s0 Initialization failed. Invalid credentials. Credentials string must not be empty."), + EmptyToken("%s0 Initialization failed. Invalid credentials. Token mut not be empty."), + EmptyApikey("%s0 Initialization failed. Invalid credentials. Api key must not be empty."), + InvalidApikey("%s0 Initialization failed. Invalid credentials. Specify valid api key."), + EmptyRoles("%s0 Initialization failed. Invalid roles. Specify at least one role."), + EmptyRoleInRoles("%s0 Initialization failed. Invalid role. Specify a valid role."), + EmptyContext("%s0 Initialization failed. Invalid context. Specify a valid context."), // bearer token generation - FileNotFound("%s1 Initialization failed. Credential file not found at %s2. Verify the file path."), - FileInvalidJson("%s1 Initialization failed. File at %s2 is not in valid JSON format. Verify the file contents."), - CredentialsStringInvalidJson("%s1 Initialization failed. Credentials string is not in valid JSON format. Verify the credentials string contents."), - InvalidCredentials("%s1 Initialization failed. Invalid credentials provided. Specify valid credentials."), - MissingPrivateKey("%s1 Initialization failed. Unable to read private key in credentials. Verify your private key."), - MissingClientId("%s1 Initialization failed. Unable to read client ID in credentials. Verify your client ID."), - MissingKeyId("%s1 Initialization failed. Unable to read key ID in credentials. Verify your key ID."), - MissingTokenUri("%s1 Initialization failed. Unable to read token URI in credentials. Verify your token URI."), - InvalidTokenUri("%s1 Initialization failed. Token URI in not a valid URL in credentials. Verify your token URI."), - JwtInvalidFormat("%s1 Initialization failed. Invalid private key format. Verify your credentials."), - InvalidAlgorithm("%s1 Initialization failed. Invalid algorithm to parse private key. Specify valid algorithm."), - InvalidKeySpec("%s1 Initialization failed. Unable to parse RSA private key. Verify your credentials."), - JwtDecodeError("%s1 Validation error. Invalid access token. Verify your credentials."), - MissingAccessToken("%s1 Validation error. Access token not present in the response from bearer token generation. Verify your credentials."), - MissingTokenType("%s1 Validation error. Token type not present in the response from bearer token generation. Verify your credentials."), + FileNotFound("%s0 Initialization failed. Credential file not found at %s1. Verify the file path."), + FileInvalidJson("%s0 Initialization failed. File at %s1 is not in valid JSON format. Verify the file contents."), + CredentialsStringInvalidJson("%s0 Initialization failed. Credentials string is not in valid JSON format. Verify the credentials string contents."), + InvalidCredentials("%s0 Initialization failed. Invalid credentials provided. Specify valid credentials."), + MissingPrivateKey("%s0 Initialization failed. Unable to read private key in credentials. Verify your private key."), + MissingClientId("%s0 Initialization failed. Unable to read client ID in credentials. Verify your client ID."), + MissingKeyId("%s0 Initialization failed. Unable to read key ID in credentials. Verify your key ID."), + MissingTokenUri("%s0 Initialization failed. Unable to read token URI in credentials. Verify your token URI."), + InvalidTokenUri("%s0 Initialization failed. Token URI in not a valid URL in credentials. Verify your token URI."), + JwtInvalidFormat("%s0 Initialization failed. Invalid private key format. Verify your credentials."), + InvalidAlgorithm("%s0 Initialization failed. Invalid algorithm to parse private key. Specify valid algorithm."), + InvalidKeySpec("%s0 Initialization failed. Unable to parse RSA private key. Verify your credentials."), + JwtDecodeError("%s0 Validation error. Invalid access token. Verify your credentials."), + MissingAccessToken("%s0 Validation error. Access token not present in the response from bearer token generation. Verify your credentials."), + MissingTokenType("%s0 Validation error. Token type not present in the response from bearer token generation. Verify your credentials."), // insert - TableKeyError("%s1 Validation error. 'table' key is missing from the payload. Specify a 'table' key."), - EmptyTable("%s1 Validation error. 'table' can't be empty. Specify a table."), - ValuesKeyError("%s1 Validation error. 'values' key is missing from the payload. Specify a 'values' key."), - EmptyValues("%s1 Validation error. 'values' can't be empty. Specify values."), - EmptyKeyInValues("%s1 Validation error. Invalid key in values. Specify a valid key."), - EmptyValueInValues("%s1 Validation error. Invalid value in values. Specify a valid value."), - TokensKeyError("%s1 Validation error. 'tokens' key is missing from the payload. Specify a 'tokens' key."), - EmptyTokens("%s1 Validation error. The 'tokens' field is empty. Specify tokens for one or more fields."), - EmptyKeyInTokens("%s1 Validation error. Invalid key tokens. Specify a valid key."), - EmptyValueInTokens("%s1 Validation error. Invalid value in tokens. Specify a valid value."), - EmptyUpsert("%s1 Validation error. 'upsert' key can't be empty. Specify an upsert column."), - HomogenousNotSupportedWithUpsert("%s1 Validation error. 'homogenous' is not supported with 'upsert'. Specify either 'homogenous' or 'upsert'."), - TokensPassedForByotDisable("%s1 Validation error. 'tokenStrict' wasn't specified. Set 'tokenStrict' to 'ENABLE' to insert tokens."), - NoTokensWithByot("%s1 Validation error. Tokens weren't specified for records while 'tokenStrict' was %s2. Specify tokens."), - MismatchOfFieldsAndTokens("%s1 Validation error. 'fields' and 'tokens' have different columns names. Verify that 'fields' and 'tokens' columns match."), - InsufficientTokensPassedForByotEnableStrict("%s1 Validation error. 'tokenStrict' is set to 'ENABLE_STRICT', but some fields are missing tokens. Specify tokens for all fields."), - BatchInsertPartialSuccess("%s1 Insert operation completed with partial success."), - BatchInsertFailure("%s1 Insert operation failed."), + TableKeyError("%s0 Validation error. 'table' key is missing from the payload. Specify a 'table' key."), + EmptyTable("%s0 Validation error. 'table' can't be empty. Specify a table."), + ValuesKeyError("%s0 Validation error. 'values' key is missing from the payload. Specify a 'values' key."), + EmptyValues("%s0 Validation error. 'values' can't be empty. Specify values."), + EmptyKeyInValues("%s0 Validation error. Invalid key in values. Specify a valid key."), + EmptyValueInValues("%s0 Validation error. Invalid value in values. Specify a valid value."), + TokensKeyError("%s0 Validation error. 'tokens' key is missing from the payload. Specify a 'tokens' key."), + EmptyTokens("%s0 Validation error. The 'tokens' field is empty. Specify tokens for one or more fields."), + EmptyKeyInTokens("%s0 Validation error. Invalid key tokens. Specify a valid key."), + EmptyValueInTokens("%s0 Validation error. Invalid value in tokens. Specify a valid value."), + EmptyUpsert("%s0 Validation error. 'upsert' key can't be empty. Specify an upsert column."), + HomogenousNotSupportedWithUpsert("%s0 Validation error. 'homogenous' is not supported with 'upsert'. Specify either 'homogenous' or 'upsert'."), + TokensPassedForByotDisable("%s0 Validation error. 'tokenStrict' wasn't specified. Set 'tokenStrict' to 'ENABLE' to insert tokens."), + NoTokensWithByot("%s0 Validation error. Tokens weren't specified for records while 'tokenStrict' was %s1. Specify tokens."), + MismatchOfFieldsAndTokens("%s0 Validation error. 'fields' and 'tokens' have different columns names. Verify that 'fields' and 'tokens' columns match."), + InsufficientTokensPassedForByotEnableStrict("%s0 Validation error. 'tokenStrict' is set to 'ENABLE_STRICT', but some fields are missing tokens. Specify tokens for all fields."), + BatchInsertPartialSuccess("%s0 Insert operation completed with partial success."), + BatchInsertFailure("%s0 Insert operation failed."), // detokenize - InvalidDataTokens("%s1 Validation error. Invalid data tokens. Specify valid data tokens."), - EmptyDataTokens("%s1 Validation error. Invalid data tokens. Specify at least one data token."), - EmptyTokenInDataTokens("%s1 Validation error. Invalid data tokens. Specify a valid data token."), + InvalidDataTokens("%s0 Validation error. Invalid data tokens. Specify valid data tokens."), + EmptyDataTokens("%s0 Validation error. Invalid data tokens. Specify at least one data token."), + EmptyTokenInDataTokens("%s0 Validation error. Invalid data tokens. Specify a valid data token."), // get interface - IdsKeyError("%s1 Validation error. 'ids' key is missing from the payload. Specify an 'ids' key."), - EmptyIds("%s1 Validation error. 'ids' can't be empty. Specify at least one id."), - EmptyIdInIds("%s1 Validation error. Invalid id in 'ids'. Specify a valid id."), - EmptyFields("%s1 Validation error. Fields are empty in get payload. Specify at least one field."), - EmptyFieldInFields("%s1 Validation error. Invalid field in 'fields'. Specify a valid field."), - RedactionKeyError("%s1 Validation error. 'redaction' key is missing from the payload. Specify a 'redaction' key."), - RedactionWithTokensNotSupported("%s1 Validation error. 'redaction' can't be used when 'returnTokens' is specified. Remove 'redaction' from payload if 'returnTokens' is specified."), - TokensGetColumnNotSupported("%s1 Validation error. Column name and/or column values can't be used when 'returnTokens' is specified. Remove unique column values or 'returnTokens' from the payload."), - EmptyOffset("%s1 Validation error. 'offset' can't be empty. Specify an offset."), - EmptyLimit("%s1 Validation error. 'limit' can't be empty. Specify a limit."), - UniqueColumnOrIdsKeyError("%s1 Validation error. 'ids' or 'columnName' key is missing from the payload. Specify the ids or unique 'columnName' in payload."), - BothIdsAndColumnDetailsSpecified("%s1 Validation error. Both Skyflow IDs and column details can't be specified. Either specify Skyflow IDs or unique column details."), - ColumnNameKeyError("%s1 Validation error. 'columnName' isn't specified whereas 'columnValues' are specified. Either add 'columnName' or remove 'columnValues'."), - EmptyColumnName("%s1 Validation error. 'columnName' can't be empty. Specify a column name."), - ColumnValuesKeyErrorGet("%s1 Validation error. 'columnValues' aren't specified whereas 'columnName' is specified. Either add 'columnValues' or remove 'columnName'."), - EmptyColumnValues("%s1 Validation error. 'columnValues' can't be empty. Specify at least one column value"), - EmptyValueInColumnValues("%s1 Validation error. Invalid value in column values. Specify a valid column value."), - - TokenKeyError("%s1 Validation error. 'token' key is missing from the payload. Specify a 'token' key."), - PartialSuccess("%s1 Validation error. Check 'SkyflowError.data' for details."), + IdsKeyError("%s0 Validation error. 'ids' key is missing from the payload. Specify an 'ids' key."), + EmptyIds("%s0 Validation error. 'ids' can't be empty. Specify at least one id."), + EmptyIdInIds("%s0 Validation error. Invalid id in 'ids'. Specify a valid id."), + EmptyFields("%s0 Validation error. Fields are empty in get payload. Specify at least one field."), + EmptyFieldInFields("%s0 Validation error. Invalid field in 'fields'. Specify a valid field."), + RedactionKeyError("%s0 Validation error. 'redaction' key is missing from the payload. Specify a 'redaction' key."), + RedactionWithTokensNotSupported("%s0 Validation error. 'redaction' can't be used when 'returnTokens' is specified. Remove 'redaction' from payload if 'returnTokens' is specified."), + TokensGetColumnNotSupported("%s0 Validation error. Column name and/or column values can't be used when 'returnTokens' is specified. Remove unique column values or 'returnTokens' from the payload."), + EmptyOffset("%s0 Validation error. 'offset' can't be empty. Specify an offset."), + EmptyLimit("%s0 Validation error. 'limit' can't be empty. Specify a limit."), + UniqueColumnOrIdsKeyError("%s0 Validation error. 'ids' or 'columnName' key is missing from the payload. Specify the ids or unique 'columnName' in payload."), + BothIdsAndColumnDetailsSpecified("%s0 Validation error. Both Skyflow IDs and column details can't be specified. Either specify Skyflow IDs or unique column details."), + ColumnNameKeyError("%s0 Validation error. 'columnName' isn't specified whereas 'columnValues' are specified. Either add 'columnName' or remove 'columnValues'."), + EmptyColumnName("%s0 Validation error. 'columnName' can't be empty. Specify a column name."), + ColumnValuesKeyErrorGet("%s0 Validation error. 'columnValues' aren't specified whereas 'columnName' is specified. Either add 'columnValues' or remove 'columnName'."), + EmptyColumnValues("%s0 Validation error. 'columnValues' can't be empty. Specify at least one column value"), + EmptyValueInColumnValues("%s0 Validation error. Invalid value in column values. Specify a valid column value."), + + TokenKeyError("%s0 Validation error. 'token' key is missing from the payload. Specify a 'token' key."), + PartialSuccess("%s0 Validation error. Check 'SkyflowError.data' for details."), // update - SkyflowIdKeyError("%s1 Validation error. 'id' key is missing from the payload. Specify an 'id' key."), - EmptySkyflowId("%s1 Validation error. 'id' can't be empty. Specify an id."), + SkyflowIdKeyError("%s0 Validation error. 'id' key is missing from the payload. Specify an 'id' key."), + EmptySkyflowId("%s0 Validation error. 'id' can't be empty. Specify an id."), // query - QueryKeyError("%s1 Validation error. 'query' key is missing from the payload. Specify a 'query' key."), - EmptyQuery("%s1 Validation error. 'query' can't be empty. Specify a query"), + QueryKeyError("%s0 Validation error. 'query' key is missing from the payload. Specify a 'query' key."), + EmptyQuery("%s0 Validation error. 'query' can't be empty. Specify a query"), // tokenize - ColumnValuesKeyErrorTokenize("%s1 Validation error. 'columnValues' key is missing from the payload. Specify a 'columnValues' key."), - EmptyColumnGroupInColumnValue("%s1 Validation error. Invalid column group in column value. Specify a valid column group."), + ColumnValuesKeyErrorTokenize("%s0 Validation error. 'columnValues' key is missing from the payload. Specify a 'columnValues' key."), + EmptyColumnGroupInColumnValue("%s0 Validation error. Invalid column group in column value. Specify a valid column group."), // connection - InvalidRequestHeaders("%s1 Validation error. Request headers aren't valid. Specify valid request headers."), - EmptyRequestHeaders("%s1 Validation error. Request headers are empty. Specify valid ."), - InvalidPathParams("%s1 Validation error. Path parameters aren't valid. Specify valid path parameters."), - EmptyPathParams("%s1 Validation error. Path parameters are empty. Specify valid path parameters."), - InvalidQueryParams("%s1 Validation error. Query parameters aren't valid. Specify valid query parameters."), - EmptyQueryParams("%s1 Validation error. Query parameters are empty. Specify valid query parameters."), - InvalidRequestBody("%s1 Validation error. Invalid request body. Specify the request body as an object."), - EmptyRequestBody("%s1 Validation error. Request body can't be empty. Specify a valid request body."), + InvalidRequestHeaders("%s0 Validation error. Request headers aren't valid. Specify valid request headers."), + EmptyRequestHeaders("%s0 Validation error. Request headers are empty. Specify valid ."), + InvalidPathParams("%s0 Validation error. Path parameters aren't valid. Specify valid path parameters."), + EmptyPathParams("%s0 Validation error. Path parameters are empty. Specify valid path parameters."), + InvalidQueryParams("%s0 Validation error. Query parameters aren't valid. Specify valid query parameters."), + EmptyQueryParams("%s0 Validation error. Query parameters are empty. Specify valid query parameters."), + InvalidRequestBody("%s0 Validation error. Invalid request body. Specify the request body as an object."), + EmptyRequestBody("%s0 Validation error. Request body can't be empty. Specify a valid request body."), ; private final String message; ErrorMessage(String message) { - this.message = Utils.parameterizedString(message, Constants.SDK_PREFIX); + this.message = message.replace("%s0", Constants.SDK_PREFIX); } public String getMessage() {