import org.onap.dcaegen2.services.sdk.services.external.schema.manager.service.SchemaReferenceResolver;
+/**
+ * A SchemaReference model contains information about schema URL which will be used to validate json content.
+ */
public class SchemaReference {
public static final String URL_SEPARATOR = "#";
private final String url;
private final String internalReference;
+ /**
+ * Constructor
+ * @param schemaReferenceResolver to resolve schema reference
+ */
public SchemaReference(SchemaReferenceResolver schemaReferenceResolver) {
- this.url = schemaReferenceResolver.resolveUrl();
- this.internalReference = schemaReferenceResolver.resolveInternalReference();
+ this(schemaReferenceResolver.resolveUrl(), schemaReferenceResolver.resolveInternalReference());
}
public SchemaReference(String url, String internalReference) {
this.internalReference = internalReference;
}
+ /**
+ * @return url to schema reference
+ */
public String getUrl() {
return url;
}
+ /**
+ * @return internal schema reference path
+ */
public String getInternalReference() {
return internalReference;
}
import java.nio.file.Files;
import java.nio.file.Paths;
+/**
+ * A FileReader is used to load a file content.
+ */
class FileReader {
private static final Logger logger = LoggerFactory.getLogger(FileReader.class);
private final String filename;
- FileReader(String filename) {
- this.filename = filename;
+ /**
+ * Constructor
+ * @param filePath path to file which will be read
+ */
+ FileReader(String filePath) {
+ this.filename = filePath;
}
- String readFile() {
+ /**
+ * @return all file content
+ */
+ String getContent() {
String fileContent = "";
try {
fileContent = getFileContent();
return fileContent;
}
+ /**
+ * @return true if file exists; otherwise false
+ */
boolean doesFileExists() {
return new File(filename).exists();
}
private byte[] readBytes() throws IOException {
return Files.readAllBytes(Paths.get(filename));
}
-}
\ No newline at end of file
+}
import org.onap.dcaegen2.services.sdk.services.external.schema.manager.model.SchemaReference;
-
+/**
+ * A SchemaReferenceResolver is used to resolve a schema reference which will be used to validate json data.
+ */
public class SchemaReferenceResolver {
private static final String ROOT_REFERENCE = "/";
private final String schemaReference;
+ /**
+ * Constructor
+ * @param schemaReference is represented by an URL with optional internal reference path (for example: http://someExternalUrl/external#schemaName)
+ */
public SchemaReferenceResolver(String schemaReference) {
this.schemaReference = schemaReference;
}
import java.io.File;
import java.io.IOException;
+/**
+ * A StndDefinedValidator is used to validate a JsonNode objects.
+ */
public class StndDefinedValidator {
private static final Logger logger = LoggerFactory.getLogger(StndDefinedValidator.class);
private final String schemaRefPath;
private final String stndDefinedDataPath;
private final ValidatorCache validatorCache;
+ /**
+ * Constructor
+ *
+ * @param schemaRefPath path to schema reference in json
+ * @param stndDefinedDataPath path to data in json which is described by schemaRefPath
+ * @param validatorCache contains cached validators
+ */
private StndDefinedValidator(String schemaRefPath, String stndDefinedDataPath, ValidatorCache validatorCache) {
this.schemaRefPath = schemaRefPath;
this.stndDefinedDataPath = stndDefinedDataPath;
this.validatorCache = validatorCache;
}
+ /**
+ * @return cached validators
+ */
ValidatorCache getValidatorCache() {
return validatorCache;
}
return validationResult;
}
+ /**
+ * An event validator builder.
+ */
public static final class ValidatorBuilder {
public static final String DEFAULT_MAPPING_FILE_PATH = "etc/externalRepo/schema-map.json";
import org.onap.dcaegen2.services.sdk.services.external.schema.manager.exception.NoLocalReferenceException;
import java.util.Map;
-
+/**
+ * An UrlMapper contains mapping between public urls received in events and schemas stored locally in the system.
+ * */
final class UrlMapper {
private final Map<String, String> mappingsCache;
+ /**
+ * Constructor
+ * @param mappings contain mapping public urls to local schema file
+ */
UrlMapper(Map<String, String> mappings) {
this.mappingsCache = Map.copyOf(mappings);
}
+ /**
+ * @return cached mapping of public urls to local schemas
+ */
Map<String, String> getMappingsCache() {
return Map.copyOf(mappingsCache);
}
+ /**
+ * Map public url received in the event to url of local schema file
+ * @param publicUrl public url
+ * @return Urt to local schema file
+ * @throws NoLocalReferenceException when local schema file doesn't exist for selected public url
+ */
String mapToLocalUrl(String publicUrl) throws NoLocalReferenceException {
String externalUrl = mappingsCache.get(publicUrl);
if (externalUrl == null) {
}
-}
\ No newline at end of file
+}
import java.util.HashMap;
import java.util.Map;
+/**
+ * An UrlMapperFactory is used to produced {@link UrlMapper}.
+ */
public class UrlMapperFactory {
private static final Logger logger = LoggerFactory.getLogger(UrlMapperFactory.class);
+ /**
+ * Returns UrlMapper instance
+ * @param mappingFilePath path to file with mappings
+ * @param schemasPath path to local schemas repository
+ * @return {@link UrlMapper}
+ */
UrlMapper getUrlMapper(String mappingFilePath, String schemasPath) {
Map<String, String> mappings = new HashMap<>();
try {
FileReader fileReader = new FileReader(mappingFilePath);
Map<String, String> mappings = new HashMap<>();
- for (JsonNode mapping : objectMapper.readTree(fileReader.readFile())) {
+ for (JsonNode mapping : objectMapper.readTree(fileReader.getContent())) {
String localURL = mapping.get("localURL").asText();
if (isMappingValid(schemasPath, localURL)) {
mappings.put(mapping.get("publicURL").asText(), localURL);
}
private boolean isFileValidSchema(String schemaRelativePath) throws IOException {
- String schemaContent = new FileReader(schemaRelativePath).readFile();
+ String schemaContent = new FileReader(schemaRelativePath).getContent();
return isNotEmpty(schemaContent, schemaRelativePath) && isYaml(schemaContent, schemaRelativePath);
}
class FileReaderTest {
public static final String TEST_RESOURCES = "src/main/test/resources/";
+ public static final String DUMMY_FILE_PATH = "dummyFileName";
@Test
void shouldReturnEmptyStringWhenFileNotFound() {
//given
String expectedContent = "";
- String fileName = "dummyFileName";
//when
- String actualContent = new FileReader(fileName).readFile();
+ String actualContent = new FileReader(DUMMY_FILE_PATH).getContent();
//then
assertEquals(expectedContent, actualContent);
String expectedContent = "{\n" +
" \"someObject\": \"dummyValue\"\n" +
"}";
- String filename = TEST_RESOURCES + "file_with_one_line.json";
+ String filePath = TEST_RESOURCES + "file_with_one_line.json";
//when
- String actualContent = new FileReader(filename).readFile();
+ String actualContent = new FileReader(filePath).getContent();
//then
assertEquals(expectedContent, actualContent);
@Test
void shouldReturnFalseWhenFileDoesNotExist() {
//when
- boolean doesFileExists = new FileReader("dummyFileName").doesFileExists();
+ boolean doesFileExists = new FileReader(DUMMY_FILE_PATH).doesFileExists();
//then
assertFalse(doesFileExists);
//then
assertTrue(doesFileExists);
}
-}
\ No newline at end of file
+}
.getUrlMapper()
.getMappingsCache();
}
-}
\ No newline at end of file
+}
throws IOException {
//given
FileReader fileReader = new FileReader(VALID_EVENT_PATH);
- JsonNode validEventNode = objectMapper.readTree(fileReader.readFile());
+ JsonNode validEventNode = objectMapper.readTree(fileReader.getContent());
//when
boolean validationResult = validator.validate(validEventNode);
throws IOException {
//given
FileReader fileReader = new FileReader(INVALID_EVENT_PATH);
- JsonNode invalidEventNode = objectMapper.readTree(fileReader.readFile());
+ JsonNode invalidEventNode = objectMapper.readTree(fileReader.getContent());
//when
boolean validationResult = validator.validate(invalidEventNode);
throws IOException {
//given
FileReader fileReader = new FileReader(VALID_NO_HASH_EVENT_PATH);
- JsonNode validEventNode = objectMapper.readTree(fileReader.readFile());
+ JsonNode validEventNode = objectMapper.readTree(fileReader.getContent());
//when
boolean validationResult = validator.validate(validEventNode);
String noLocalResourceMappingFilePath = TEST_RESOURCES + "externalRepo/schema-map-no-local-resource.json";
StndDefinedValidator validator = getValidator(noLocalResourceMappingFilePath);
FileReader fileReader = new FileReader(VALID_EVENT_PATH);
- JsonNode validEventNode = objectMapper.readTree(fileReader.readFile());
+ JsonNode validEventNode = objectMapper.readTree(fileReader.getContent());
//when
//then
String noLocalResourceMappingFilePath = TEST_RESOURCES + "externalRepo/schema-map-empty-content.json";
StndDefinedValidator validator = getValidator(noLocalResourceMappingFilePath);
FileReader fileReader = new FileReader(VALID_EVENT_PATH);
- JsonNode validEventNode = objectMapper.readTree(fileReader.readFile());
+ JsonNode validEventNode = objectMapper.readTree(fileReader.getContent());
//when
//then
//given
String noLocalResourceMappingFilePath = TEST_RESOURCES + "externalRepo/schema-map-incorrect-yaml-format.json";
StndDefinedValidator validator = getValidator(noLocalResourceMappingFilePath);
- JsonNode validEventNode = objectMapper.readTree(new FileReader(VALID_EVENT_PATH).readFile());
+ JsonNode validEventNode = objectMapper.readTree(new FileReader(VALID_EVENT_PATH).getContent());
//when
//then
void shouldValidateStndDefinedFieldsInEventAndReturnExceptionWhenEventReferToIncorrectInternalFileReference()
throws IOException {
//given
- JsonNode validEventNode = objectMapper.readTree(new FileReader(INCORRECT_INTERNAL_REF_EVENT_PATH).readFile());
+ JsonNode validEventNode = objectMapper.readTree(new FileReader(INCORRECT_INTERNAL_REF_EVENT_PATH).getContent());
//when
//then
.schemasPath(SCHEMAS_PATH)
.build();
}
-}
\ No newline at end of file
+}
Code Review / dcaegen2 / services / sdk.git / commitdiff