refactor: Rename helpers for validation module (#167)

Author: pankajagrawal16

.github/workflows/build.yml

@@ -9,6 +9,8 @@ on:
       - 'powertools-logging/**'
       - 'powertools-sqs/**'
       - 'powertools-tracing/**'
+      - 'powertools-validation/**'
+      - 'powertools-parameters/**'
       - 'pom.xml'
   push:
     branches:

docs/content/utilities/validation.mdx

@@ -101,7 +101,7 @@ Validate standalone function is used within the Lambda handler, or any other met
 You can also gracefully handle schema validation errors by catching `ValidationException`.
 
 ```java
-import static software.amazon.lambda.powertools.validation.Validator.*;
+import static software.amazon.lambda.powertools.validation.ValidationUtils.*;
 
 public class MyFunctionHandler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
 
@@ -289,7 +289,7 @@ public class XMLFunction extends BaseFunction {
 Once your function is created, you need to add it to powertools:
 
 ```java
-ValidatorConfig.get().addFunction(new XMLFunction());
+ValidationConfig.get().addFunction(new XMLFunction());
 ```
 
 You can then use it to do your validation:
@@ -317,16 +317,16 @@ public class MyXMLEventHandler implements RequestHandler<MyEventWithXML, String>
 
 ## Change the schema version
 By default, powertools-validation is configured with [V7](https://json-schema.org/draft-07/json-schema-release-notes.html).
-You can use the `ValidatorConfig` to change that behaviour:
+You can use the `ValidationConfig` to change that behaviour:
 
 ```java
-ValidatorConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V4);
+ValidationConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V4);
 ```
 
 ## Advanced ObjectMapper settings
-If you need to configure the Jackson ObjectMapper, you can use the `ValidatorConfig`:
+If you need to configure the Jackson ObjectMapper, you can use the `ValidationConfig`:
 
 ```java
-ObjectMapper objectMapper= ValidatorConfig.get().getObjectMapper();
+ObjectMapper objectMapper= ValidationConfig.get().getObjectMapper();
 // update (de)serializationConfig or other properties
 ```

example/HelloWorldFunction/src/main/java/helloworld/AppValidation.java

@@ -5,7 +5,6 @@
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
 import software.amazon.lambda.powertools.validation.Validation;
-import software.amazon.lambda.powertools.validation.Validator;
 
 import java.io.BufferedReader;
 import java.io.IOException;

powertools-validation/src/main/java/software/amazon/lambda/powertools/validation/ValidatorConfig.java renamed to powertools-validation/src/main/java/software/amazon/lambda/powertools/validation/ValidationConfig.java

@@ -31,15 +31,15 @@
  * Use this if you need to customize some part of the JSON Schema validation
  * (eg. specification version, Jackson ObjectMapper, or adding functions to JMESPath)
  */
-public class ValidatorConfig {
-    private ValidatorConfig() {
+public class ValidationConfig {
+    private ValidationConfig() {
     }
 
     private static class ConfigHolder {
-        private final static ValidatorConfig instance = new ValidatorConfig();
+        private final static ValidationConfig instance = new ValidationConfig();
     }
 
-    public static ValidatorConfig get() {
+    public static ValidationConfig get() {
         return ConfigHolder.instance;
     }
 

powertools-validation/src/main/java/software/amazon/lambda/powertools/validation/Validator.java renamed to powertools-validation/src/main/java/software/amazon/lambda/powertools/validation/ValidationUtils.java

@@ -30,11 +30,14 @@
 /**
  * Validation utility, used to manually validate Json against Json Schema
  */
-public class Validator {
+public class ValidationUtils {
     private static final String CLASSPATH = "classpath:";
 
     private static final ConcurrentHashMap<String, JsonSchema> schemas = new ConcurrentHashMap<>();
 
+    private ValidationUtils() {
+    }
+
     /**
      * Validate part of a json object against a json schema
      *
@@ -60,8 +63,8 @@ public static void validate(Object obj, JsonSchema jsonSchema, String envelope)
         }
         JsonNode subNode;
         try {
-            JsonNode jsonNode = ValidatorConfig.get().getObjectMapper().valueToTree(obj);
-            Expression<JsonNode> expression = ValidatorConfig.get().getJmesPath().compile(envelope);
+            JsonNode jsonNode = ValidationConfig.get().getObjectMapper().valueToTree(obj);
+            Expression<JsonNode> expression = ValidationConfig.get().getJmesPath().compile(envelope);
             subNode = expression.search(jsonNode);
         } catch (Exception e) {
             throw new ValidationException("Cannot find envelope <"+envelope+"> in the object <"+obj+">", e);
@@ -103,7 +106,7 @@ public static void validate(Object obj, String jsonSchema) throws ValidationExce
     public static void validate(Object obj, JsonSchema jsonSchema) throws ValidationException {
         JsonNode jsonNode;
         try {
-            jsonNode = ValidatorConfig.get().getObjectMapper().valueToTree(obj);
+            jsonNode = ValidationConfig.get().getObjectMapper().valueToTree(obj);
         } catch (Exception e) {
             throw new ValidationException("Object <"+obj+"> is not valid against the schema provided", e);
         }
@@ -132,7 +135,7 @@ public static void validate(String json, String jsonSchema) throws ValidationExc
     public static void validate(String json, JsonSchema jsonSchema) throws ValidationException {
         JsonNode jsonNode;
         try {
-            jsonNode = ValidatorConfig.get().getObjectMapper().readTree(json);
+            jsonNode = ValidationConfig.get().getObjectMapper().readTree(json);
         } catch (Exception e) {
             throw new ValidationException("Json <"+json+"> is not valid against the schema provided", e);
         }
@@ -161,7 +164,7 @@ public static void validate(Map<String, Object> map, String jsonSchema) throws V
     public static void validate(Map<String, Object> map, JsonSchema jsonSchema) throws ValidationException {
         JsonNode jsonNode;
         try {
-            jsonNode = ValidatorConfig.get().getObjectMapper().valueToTree(map);
+            jsonNode = ValidationConfig.get().getObjectMapper().valueToTree(map);
         } catch (Exception e) {
             throw new ValidationException("Map <"+map+"> cannot be converted to json for validation", e);
         }
@@ -194,7 +197,7 @@ public static void validate(JsonNode jsonNode, JsonSchema jsonSchema) throws Val
         if (!validationMessages.isEmpty()) {
             String message;
             try {
-                message = ValidatorConfig.get().getObjectMapper().writeValueAsString(new ValidationErrors(validationMessages));
+                message = ValidationConfig.get().getObjectMapper().writeValueAsString(new ValidationErrors(validationMessages));
             } catch (JsonProcessingException e) {
                 message = validationMessages.stream().map(ValidationMessage::getMessage).collect(Collectors.joining(", "));
             }
@@ -233,13 +236,13 @@ public static JsonSchema getJsonSchema(String schema, boolean validateSchema) {
                 if (schemaStream == null) {
                     throw new IllegalArgumentException("'" + schema + "' is invalid, verify '" + filePath + "' is in your classpath");
                 }
-                jsonSchema = ValidatorConfig.get().getFactory().getSchema(schemaStream);
+                jsonSchema = ValidationConfig.get().getFactory().getSchema(schemaStream);
             } else {
-                jsonSchema = ValidatorConfig.get().getFactory().getSchema(schema);
+                jsonSchema = ValidationConfig.get().getFactory().getSchema(schema);
             }
 
             if (validateSchema) {
-                String version = ValidatorConfig.get().getSchemaVersion().toString();
+                String version = ValidationConfig.get().getSchemaVersion().toString();
                 try {
                     validate(jsonSchema.getSchemaNode(),
                             getJsonSchema("classpath:/schemas/meta_schema_" + version));

powertools-validation/src/main/java/software/amazon/lambda/powertools/validation/internal/ValidationAspect.java

@@ -20,14 +20,14 @@
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.annotation.Pointcut;
 import software.amazon.lambda.powertools.validation.Validation;
-import software.amazon.lambda.powertools.validation.ValidatorConfig;
+import software.amazon.lambda.powertools.validation.ValidationConfig;
 
 import static com.networknt.schema.SpecVersion.VersionFlag.V201909;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static software.amazon.lambda.powertools.core.internal.LambdaHandlerProcessor.isHandlerMethod;
 import static software.amazon.lambda.powertools.core.internal.LambdaHandlerProcessor.placedOnRequestHandler;
-import static software.amazon.lambda.powertools.validation.Validator.getJsonSchema;
-import static software.amazon.lambda.powertools.validation.Validator.validate;
+import static software.amazon.lambda.powertools.validation.ValidationUtils.getJsonSchema;
+import static software.amazon.lambda.powertools.validation.ValidationUtils.validate;
 import static software.amazon.lambda.powertools.validation.jmespath.Base64Function.decode;
 import static software.amazon.lambda.powertools.validation.jmespath.Base64GZipFunction.decompress;
 
@@ -48,7 +48,7 @@ public Object around(ProceedingJoinPoint pjp,
         boolean validationNeeded = false;
 
         if (validation.schemaVersion() != V201909) {
-            ValidatorConfig.get().setSchemaVersion(validation.schemaVersion());
+            ValidationConfig.get().setSchemaVersion(validation.schemaVersion());
         }
 
         if (isHandlerMethod(pjp)

powertools-validation/src/test/java/software/amazon/lambda/powertools/validation/Base64FunctionTest.java

@@ -26,8 +26,8 @@ public class Base64FunctionTest {
 
     @Test
     public void testPowertoolsBase64() throws IOException {
-        JsonNode event = ValidatorConfig.get().getObjectMapper().readTree(this.getClass().getResourceAsStream("/custom_event.json"));
-        Expression<JsonNode> expression = ValidatorConfig.get().getJmesPath().compile("basket.powertools_base64(hiddenProduct)");
+        JsonNode event = ValidationConfig.get().getObjectMapper().readTree(this.getClass().getResourceAsStream("/custom_event.json"));
+        Expression<JsonNode> expression = ValidationConfig.get().getJmesPath().compile("basket.powertools_base64(hiddenProduct)");
         JsonNode result = expression.search(event);
         assertThat(result.getNodeType()).isEqualTo(JsonNodeType.STRING);
         assertThat(result.asText()).isEqualTo("{\n" +

powertools-validation/src/test/java/software/amazon/lambda/powertools/validation/Base64GZipFunctionTest.java

@@ -26,8 +26,8 @@ public class Base64GZipFunctionTest {
 
     @Test
     public void testPowertoolsGzip() throws IOException {
-        JsonNode event = ValidatorConfig.get().getObjectMapper().readTree(this.getClass().getResourceAsStream("/custom_event_gzip.json"));
-        Expression<JsonNode> expression = ValidatorConfig.get().getJmesPath().compile("basket.powertools_base64_gzip(hiddenProduct)");
+        JsonNode event = ValidationConfig.get().getObjectMapper().readTree(this.getClass().getResourceAsStream("/custom_event_gzip.json"));
+        Expression<JsonNode> expression = ValidationConfig.get().getJmesPath().compile("basket.powertools_base64_gzip(hiddenProduct)");
         JsonNode result = expression.search(event);
         assertThat(result.getNodeType()).isEqualTo(JsonNodeType.STRING);
         assertThat(result.asText()).isEqualTo("{  \"id\": 43242,  \"name\": \"FooBar XY\",  \"price\": 258}");

powertools-validation/src/test/java/software/amazon/lambda/powertools/validation/ValidatorTest.java renamed to powertools-validation/src/test/java/software/amazon/lambda/powertools/validation/ValidationUtilsTest.java

@@ -14,71 +14,71 @@
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.*;
-import static software.amazon.lambda.powertools.validation.Validator.getJsonSchema;
-import static software.amazon.lambda.powertools.validation.Validator.validate;
+import static software.amazon.lambda.powertools.validation.ValidationUtils.getJsonSchema;
+import static software.amazon.lambda.powertools.validation.ValidationUtils.validate;
 
-public class ValidatorTest {
+public class ValidationUtilsTest {
 
     private JsonSchema schema = getJsonSchema("classpath:/schema_v7.json");
 
     @BeforeEach
     public void setup() {
-        ValidatorConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V7);
+        ValidationConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V7);
     }
 
     @Test
     public void testLoadSchemaV7OK() {
-        ValidatorConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V7);
+        ValidationConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V7);
         JsonSchema jsonSchema = getJsonSchema("classpath:/schema_v7.json", true);
         assertThat(jsonSchema).isNotNull();
         assertThat(jsonSchema.getCurrentUri()).asString().isEqualTo("http://example.com/product.json");
     }
 
     @Test
     public void testLoadSchemaV7KO() {
-        ValidatorConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V7);
+        ValidationConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V7);
         assertThatThrownBy(() -> getJsonSchema("classpath:/schema_v7_ko.json", true))
                 .isInstanceOf(IllegalArgumentException.class)
                 .hasMessage("The schema classpath:/schema_v7_ko.json is not valid, it does not respect the specification V7");
     }
 
     @Test
     public void testLoadMetaSchema_NoValidation() {
-        ValidatorConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V201909);
+        ValidationConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V201909);
         getJsonSchema("classpath:/schemas/meta_schema_V201909", false);
     }
 
     @Test
     public void testLoadMetaSchemaV2019() {
-        ValidatorConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V201909);
+        ValidationConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V201909);
         JsonSchema jsonSchema = getJsonSchema("classpath:/schemas/meta_schema_V201909", true);
         assertThat(jsonSchema).isNotNull();
     }
 
     @Test
     public void testLoadMetaSchemaV7() {
-        ValidatorConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V7);
+        ValidationConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V7);
         JsonSchema jsonSchema = getJsonSchema("classpath:/schemas/meta_schema_V7", true);
         assertThat(jsonSchema).isNotNull();
     }
 
     @Test
     public void testLoadMetaSchemaV6() {
-        ValidatorConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V6);
+        ValidationConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V6);
         JsonSchema jsonSchema = getJsonSchema("classpath:/schemas/meta_schema_V6", true);
         assertThat(jsonSchema).isNotNull();
     }
 
     @Test
     public void testLoadMetaSchemaV4() {
-        ValidatorConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V4);
+        ValidationConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V4);
         JsonSchema jsonSchema = getJsonSchema("classpath:/schemas/meta_schema_V4", true);
         assertThat(jsonSchema).isNotNull();
     }
 
     @Test
     public void testLoadSchemaV4OK() {
-        ValidatorConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V4);
+        ValidationConfig.get().setSchemaVersion(SpecVersion.VersionFlag.V4);
         JsonSchema jsonSchema = getJsonSchema("classpath:/schema_v4.json", true);
         assertThat(jsonSchema).isNotNull();
     }
@@ -92,14 +92,14 @@ public void testLoadSchemaNotFound() {
 
     @Test
     public void testValidateJsonNodeOK() throws IOException {
-        JsonNode node = ValidatorConfig.get().getObjectMapper().readTree(this.getClass().getResourceAsStream("/json_ok.json"));
+        JsonNode node = ValidationConfig.get().getObjectMapper().readTree(this.getClass().getResourceAsStream("/json_ok.json"));
 
         validate(node, schema);
     }
 
     @Test
     public void testValidateJsonNodeKO() throws IOException {
-        JsonNode node = ValidatorConfig.get().getObjectMapper().readTree(this.getClass().getResourceAsStream("/json_ko.json"));
+        JsonNode node = ValidationConfig.get().getObjectMapper().readTree(this.getClass().getResourceAsStream("/json_ko.json"));
 
         assertThatExceptionOfType(ValidationException.class).isThrownBy(() -> validate(node, schema));
     }

powertools-validation/src/test/java/software/amazon/lambda/powertools/validation/internal/ValidationAspectTest.java

@@ -23,7 +23,7 @@
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import software.amazon.lambda.powertools.validation.ValidationException;
-import software.amazon.lambda.powertools.validation.ValidatorConfig;
+import software.amazon.lambda.powertools.validation.ValidationConfig;
 import software.amazon.lambda.powertools.validation.handlers.*;
 import software.amazon.lambda.powertools.validation.model.MyCustomEvent;
 
@@ -92,23 +92,23 @@ public void validate_inputKO_schemaInString_shouldThrowValidationException() {
 
     @Test
     public void validate_SQS() throws IOException {
-        SQSEvent event = ValidatorConfig.get().getObjectMapper().readValue(this.getClass().getResourceAsStream("/sqs.json"), SQSEvent.class);
+        SQSEvent event = ValidationConfig.get().getObjectMapper().readValue(this.getClass().getResourceAsStream("/sqs.json"), SQSEvent.class);
 
         SQSHandler handler = new SQSHandler();
         assertThat(handler.handleRequest(event, context)).isEqualTo("OK");
     }
 
     @Test
     public void validate_Kinesis() throws IOException {
-        KinesisEvent event = ValidatorConfig.get().getObjectMapper().readValue(this.getClass().getResourceAsStream("/kinesis.json"), KinesisEvent.class);
+        KinesisEvent event = ValidationConfig.get().getObjectMapper().readValue(this.getClass().getResourceAsStream("/kinesis.json"), KinesisEvent.class);
 
         KinesisHandler handler = new KinesisHandler();
         assertThat(handler.handleRequest(event, context)).isEqualTo("OK");
     }
 
     @Test
     public void validate_CustomObject() throws IOException {
-        MyCustomEvent event = ValidatorConfig.get().getObjectMapper().readValue(this.getClass().getResourceAsStream("/custom_event.json"), MyCustomEvent.class);
+        MyCustomEvent event = ValidationConfig.get().getObjectMapper().readValue(this.getClass().getResourceAsStream("/custom_event.json"), MyCustomEvent.class);
 
         MyCustomEventHandler handler = new MyCustomEventHandler();
         assertThat(handler.handleRequest(event, context)).isEqualTo("OK");