Convert yaml schema into tree structure

Issue-ID: VNFSDK-594
Signed-off-by: Bartosz Gardziejewski <bartosz.gardziejewski@nokia.com>
Change-Id: I071095347fbdf824205e63ab9771cdf47d2ad29d

4 files changed, 336 insertions, 11 deletions

diff --git a/csarvalidation/src/test/java/org/onap/validation/yaml/YamlLoaderTest.java b/csarvalidation/src/test/java/org/onap/validation/yaml/YamlLoaderTest.java
index 853d558..1680a40 100644
--- a/csarvalidation/src/test/java/org/onap/validation/yaml/YamlLoaderTest.java
+++ b/csarvalidation/src/test/java/org/onap/validation/yaml/YamlLoaderTest.java
@@ -29,23 +29,13 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 public class YamlLoaderTest {
 
-    private static final String PATH_TO_VALID_YAML = "yaml_schema/PM_Dictionary.yaml";
-
-
     @Test
     public void shouldLoadAllDocumentsFromYamlFile() throws YamlDocumentFactory.YamlDocumentParsingException {
-        // given
-        YamlLoader loader = new YamlLoader();
-        URL urlOfValidYaml = getUrlForGivenPath(PATH_TO_VALID_YAML);
-
         // when
-        List<YamlDocument> documents = loader.loadMultiDocumentYamlFile(urlOfValidYaml);
+        List<YamlDocument> documents = YamlLoadingUtils.loadValidMultiDocumentYamlFile();
 
         // then
         assertThat(documents.size()).isEqualTo(4);
     }
 
-    private URL getUrlForGivenPath(String path) {
-        return this.getClass().getClassLoader().getResource(path);
-    }
 }
diff --git a/csarvalidation/src/test/java/org/onap/validation/yaml/YamlLoadingUtils.java b/csarvalidation/src/test/java/org/onap/validation/yaml/YamlLoadingUtils.java
new file mode 100644
index 0000000..1e3618b
--- /dev/null
+++ b/csarvalidation/src/test/java/org/onap/validation/yaml/YamlLoadingUtils.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2020 Nokia
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.onap.validation.yaml;
+
+import org.onap.validation.yaml.model.YamlDocument;
+
+import java.net.URL;
+import java.util.List;
+
+import static org.onap.validation.yaml.model.YamlDocumentFactory.YamlDocumentParsingException;
+
+public final class YamlLoadingUtils {
+
+    private YamlLoadingUtils() {}
+
+    private static final String PATH_TO_VALID_YAML = "yaml_schema/PM_Dictionary.yaml";
+    private static final String PATH_TO_SIMPLE_VALID_SCHEMA = "yaml_schema/Simple_Valid_Schema.yaml";
+    private static final String PATH_TO_SIMPLE_VALID_SCHEMA_MULTI_ROOT = "yaml_schema/Simple_Valid_Schema_Multi_Root.yaml";
+    private static final String PATH_TO_SIMPLE_INVALID_SCHEMA = "yaml_schema/Simple_Invalid_Schema_Construction.yaml";
+    private static final String PATH_TO_SIMPLE_INVALID_SCHEMA_FOR_LAZY_LOADING = "yaml_schema/Simple_Invalid_Schema_LazyLoading.yaml";
+
+    public static List<YamlDocument> loadValidMultiDocumentYamlFile() throws YamlDocumentParsingException {
+        return new YamlLoader().loadMultiDocumentYamlFile(getUrlForGivenPath(PATH_TO_VALID_YAML));
+    }
+
+    public static YamlDocument loadSimpleValidYamlSchemaFile() throws YamlDocumentParsingException {
+        return new YamlLoader().loadMultiDocumentYamlFile(getUrlForGivenPath(PATH_TO_SIMPLE_VALID_SCHEMA)).get(0);
+    }
+
+    public static YamlDocument loadSimpleInvalidYamlSchemaFile() throws YamlDocumentParsingException {
+        return new YamlLoader().loadMultiDocumentYamlFile(getUrlForGivenPath(PATH_TO_SIMPLE_INVALID_SCHEMA)).get(0);
+    }
+
+    public static YamlDocument loadSimpleInvalidYamlSchemaForLazyLoadingFile() throws YamlDocumentParsingException {
+        return new YamlLoader().loadMultiDocumentYamlFile(getUrlForGivenPath(PATH_TO_SIMPLE_INVALID_SCHEMA_FOR_LAZY_LOADING)).get(0);
+    }
+
+    public static YamlDocument loadSimpleValidYamlSchemaWithMultiRootFile() throws YamlDocumentParsingException {
+        return new YamlLoader().loadMultiDocumentYamlFile(getUrlForGivenPath(PATH_TO_SIMPLE_VALID_SCHEMA_MULTI_ROOT)).get(0);
+    }
+
+    private static URL getUrlForGivenPath(String path) {
+        return YamlLoadingUtils.class.getClassLoader().getResource(path);
+    }
+}
diff --git a/csarvalidation/src/test/java/org/onap/validation/yaml/schema/YamlSchemaFactoryTest.java b/csarvalidation/src/test/java/org/onap/validation/yaml/schema/YamlSchemaFactoryTest.java
new file mode 100644
index 0000000..4c05d71
--- /dev/null
+++ b/csarvalidation/src/test/java/org/onap/validation/yaml/schema/YamlSchemaFactoryTest.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2020 Nokia
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.onap.validation.yaml.schema;
+
+import org.junit.Test;
+import org.onap.validation.yaml.YamlLoadingUtils;
+import org.onap.validation.yaml.exception.YamlProcessingException;
+import org.onap.validation.yaml.model.YamlDocument;
+import org.onap.validation.yaml.schema.node.YamlSchemaNode;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.onap.validation.yaml.model.YamlDocumentFactory.YamlDocumentParsingException;
+import static org.onap.validation.yaml.schema.node.YamlSchemaNodeFactory.EMPTY_COMMENT;
+import static org.onap.validation.yaml.schema.node.YamlSchemaNodeFactoryTest.assertThatBranchNodeIsValid;
+import static org.onap.validation.yaml.schema.node.YamlSchemaNodeFactoryTest.assertThatLeafNodeIsValid;
+
+
+public class YamlSchemaFactoryTest {
+
+    @Test
+    public void shouldCreateYamlSchemaFromYamlDocumentWithMultipleRoots()
+        throws YamlProcessingException {
+
+        // given
+        YamlDocument documents = YamlLoadingUtils.loadSimpleValidYamlSchemaWithMultiRootFile();
+
+        // when
+        YamlSchema schema = new YamlSchemaFactory().createTreeStructuredYamlSchema(documents);
+
+        // then
+        assertThat(schema).isNotNull();
+        assertThat(schema.getRootNodes()).hasSize(3);
+        assertThat(schema.getRootNodes().get(0).getName()).isEqualTo("root1");
+        assertThat(schema.getRootNodes().get(1).getName()).isEqualTo("root2");
+        assertThat(schema.getRootNodes().get(2).getName()).isEqualTo("root3");
+    }
+
+
+    @Test
+    public void shouldCreateYamlSchemaFromYamlDocument()
+        throws YamlProcessingException {
+
+        // given
+        YamlDocument documents = YamlLoadingUtils.loadSimpleValidYamlSchemaFile();
+
+        // when
+        YamlSchema schema = new YamlSchemaFactory().createTreeStructuredYamlSchema(documents);
+
+        // then
+        assertThat(schema).isNotNull();
+        assertThat(schema.getRootNodes()).hasSize(1);
+        YamlSchemaNode pmMetaData = schema.getRootNodes().get(0);
+        assertThatBranchNodeIsValid(pmMetaData, "pmMetaData","/", true, EMPTY_COMMENT,
+            2);
+
+        YamlSchemaNode pmHeader = pmMetaData.getNextNodes().get(1);
+        assertThatBranchNodeIsValid(pmHeader, "pmHeader","/pmMetaData/", true, EMPTY_COMMENT,
+            1);
+
+        YamlSchemaNode nfType = pmHeader.getNextNodes().get(0);
+        assertThatLeafNodeIsValid(nfType, "nfType", "/pmMetaData/pmHeader/", true, "nfType comment");
+
+        YamlSchemaNode pmFields = pmMetaData.getNextNodes().get(0);
+        assertThatBranchNodeIsValid(pmFields, "pmFields", "/pmMetaData/", true, EMPTY_COMMENT,
+            2);
+
+        YamlSchemaNode measChangeType = pmFields.getNextNodes().get(1);
+        assertThatLeafNodeIsValid(measChangeType, "measChangeType", "/pmMetaData/pmFields/",
+            true, "measChangeType comment",
+            "added", "modified", "deleted");
+
+        YamlSchemaNode measAdditionalFields = pmFields.getNextNodes().get(0);
+        assertThatBranchNodeIsValid(measAdditionalFields, "measAdditionalFields", "/pmMetaData/pmFields/",
+            true, "measAdditionalFields comment",
+            2);
+
+        YamlSchemaNode vendorField1 = measAdditionalFields.getNextNodes().get(0);
+        assertThatLeafNodeIsValid(vendorField1, "vendorField1", "/pmMetaData/pmFields/measAdditionalFields/",
+            true, "vendorField1 comment",
+            "X", "Y", "Z");
+        YamlSchemaNode vendorField2 = measAdditionalFields.getNextNodes().get(1);
+        assertThatLeafNodeIsValid(vendorField2, "vendorField2", "/pmMetaData/pmFields/measAdditionalFields/",
+            false, "vendorField2 comment",
+            "A", "B");
+    }
+
+    @Test
+    public void shouldThrowYamlParsingExceptionWhenLoadedSchemaIsInvalid()
+        throws YamlDocumentParsingException {
+
+        // given
+        YamlDocument documents = YamlLoadingUtils.loadSimpleInvalidYamlSchemaFile();
+
+        // when/then
+        assertThatThrownBy(() ->
+            new YamlSchemaFactory().createTreeStructuredYamlSchema(documents)
+        ).isInstanceOf(YamlDocumentParsingException.class)
+            .hasMessageContaining(
+                String.format(
+                    "Fail to parse given objects: %s as yaml document",
+                    documents.getSubStructure("pmMetaData").getYaml().get("structure")
+                )
+            );
+    }
+
+}
diff --git a/csarvalidation/src/test/java/org/onap/validation/yaml/schema/node/YamlSchemaNodeFactoryTest.java b/csarvalidation/src/test/java/org/onap/validation/yaml/schema/node/YamlSchemaNodeFactoryTest.java
new file mode 100644
index 0000000..d35e3b2
--- /dev/null
+++ b/csarvalidation/src/test/java/org/onap/validation/yaml/schema/node/YamlSchemaNodeFactoryTest.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright 2020 Nokia
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.onap.validation.yaml.schema.node;
+
+import org.assertj.core.util.Lists;
+import org.junit.Test;
+import org.onap.validation.yaml.YamlLoadingUtils;
+import org.onap.validation.yaml.exception.YamlProcessingException;
+import org.onap.validation.yaml.model.YamlDocument;
+import org.onap.validation.yaml.model.YamlDocumentFactory;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.onap.validation.yaml.schema.node.YamlSchemaNodeFactory.EMPTY_COMMENT;
+
+public class YamlSchemaNodeFactoryTest {
+
+    private static final String ROOT_PATH = "/";
+
+    @Test
+    public void shouldThrowExceptionDuringLazyLoadingWhenLoadedSchemaHaveInvalidSubStructure()
+        throws YamlProcessingException {
+        // given
+        String nodeName = "pmMetaData";
+
+        YamlDocument document = YamlLoadingUtils.loadSimpleInvalidYamlSchemaForLazyLoadingFile();
+        YamlSchemaNode node = new YamlSchemaNodeFactory()
+            .createNode(nodeName, ROOT_PATH, document.getSubStructure(nodeName));
+
+        // when/then
+        assertThatThrownBy(node::getNextNodes
+        ).isInstanceOf(YamlSchemaNode.YamlSchemaProcessingException.class)
+            .hasMessageContaining(
+                "Lazy loading failed, due to yaml parsing exception."
+            );
+    }
+
+    @Test
+    public void shouldCreateLeafNodeIfGivenYamlDocumentHaveNoSubStructure()
+        throws YamlProcessingException {
+        // given
+        String nodeName = "leaf_test";
+        String comment = "test leaf node";
+        List<String> acceptedValues = Lists.list("val1", "val2");
+        Map<Object, Object> nodeInYamlFormat = new HashMap<>();
+        nodeInYamlFormat.put(YamlSchemaNodeFactory.PRESENCE_KEY, YamlSchemaNodeFactory.PRESENCE_REQUIRED_KEY);
+        nodeInYamlFormat.put(YamlSchemaNodeFactory.COMMENT_KEY, comment);
+        nodeInYamlFormat.put(YamlSchemaNodeFactory.VALUE_KET, acceptedValues);
+        YamlDocument document = new YamlDocumentFactory().createYamlDocument(
+            nodeInYamlFormat
+        );
+
+        // when
+        YamlSchemaNode yamlSchemaNode = new YamlSchemaNodeFactory().createNode(nodeName, ROOT_PATH, document);
+
+        // then
+        assertThatLeafNodeIsValid(
+            yamlSchemaNode, nodeName, ROOT_PATH, true, comment,
+            acceptedValues.toArray(new String[acceptedValues.size()])
+        );
+    }
+
+    @Test
+    public void shouldCreateBranchNodeIfGivenYamlDocumentHaveSubStructure()
+        throws YamlProcessingException {
+        // given
+        String nodeName = "branch_test";
+        String comment = "test branch node";
+
+        Map<Object, Object> subStructure = new HashMap<>();
+        String subNode1Name = "branch_test_node1";
+        String subNode2Name = "branch_test_node2";
+        subStructure.put(subNode1Name, new HashMap<>());
+        subStructure.put(subNode2Name, new HashMap<>());
+
+        Map<Object, Object> nodeInYamlFormat = new HashMap<>();
+        nodeInYamlFormat.put(YamlSchemaNodeFactory.PRESENCE_KEY, YamlSchemaNodeFactory.PRESENCE_REQUIRED_KEY);
+        nodeInYamlFormat.put(YamlSchemaNodeFactory.COMMENT_KEY, comment);
+        nodeInYamlFormat.put(YamlSchemaNodeFactory.STRUCTURE_KEY, subStructure);
+        YamlDocument document = new YamlDocumentFactory().createYamlDocument(
+            nodeInYamlFormat
+        );
+
+        // when
+        YamlSchemaNode yamlSchemaNode = new YamlSchemaNodeFactory().createNode(nodeName, ROOT_PATH, document);
+
+        // then
+        assertThatBranchNodeIsValid(
+            yamlSchemaNode, nodeName, ROOT_PATH, true, comment, 2);
+
+        List<YamlSchemaNode> subNodes = yamlSchemaNode.getNextNodes();
+        assertThat(subNodes).hasSize(2);
+        assertThatLeafNodeIsValid(
+            subNodes.get(1), subNode1Name, ROOT_PATH + nodeName + "/", false, EMPTY_COMMENT);
+        assertThatLeafNodeIsValid(
+            subNodes.get(0), subNode2Name, ROOT_PATH + nodeName + "/", false, EMPTY_COMMENT);
+    }
+
+    public static void assertThatBranchNodeIsValid(
+        YamlSchemaNode yamlSchemaNode, String name, String path, boolean isRequired, String comment,
+        int numberOfSubNodes
+    ) throws YamlSchemaNode.YamlSchemaProcessingException {
+        assertThatNodeIsValid(yamlSchemaNode, name, path, isRequired, comment);
+
+        assertThat(yamlSchemaNode.getClass()).isEqualTo(YamlSchemaBranchNode.class);
+        assertThat(yamlSchemaNode.isContainingSubStructure()).isTrue();
+        assertThat(yamlSchemaNode.getNextNodes()).hasSize(numberOfSubNodes);
+        assertThat(yamlSchemaNode.getAcceptedValues()).isEmpty();
+    }
+
+    public static void assertThatLeafNodeIsValid(
+        YamlSchemaNode yamlSchemaNode, String name, String path, boolean isRequired, String comment,
+        String... acceptedValues
+    ) throws YamlSchemaNode.YamlSchemaProcessingException {
+        assertThatNodeIsValid(yamlSchemaNode, name, path, isRequired, comment);
+
+        assertThat(yamlSchemaNode.getClass()).isEqualTo(YamlSchemaLeafNode.class);
+        assertThat(yamlSchemaNode.isContainingSubStructure()).isFalse();
+        assertThat(yamlSchemaNode.getAcceptedValues()).containsExactly(acceptedValues);
+        assertThat(yamlSchemaNode.getNextNodes()).isEmpty();
+    }
+
+    private static void assertThatNodeIsValid(YamlSchemaNode yamlSchemaNode, String name, String path, boolean isRequired, String comment) {
+        assertThat(yamlSchemaNode).isNotNull();
+        assertThat(yamlSchemaNode.getName()).isEqualTo(name);
+        assertThat(yamlSchemaNode.getPath()).isEqualTo(path);
+        if (comment.isEmpty()) {
+            assertThat(yamlSchemaNode.getComment()).isNotEmpty();
+        } else {
+            assertThat(yamlSchemaNode.getComment()).isEqualTo(comment);
+        }
+        assertThat(yamlSchemaNode.isRequired()).isEqualTo(isRequired);
+    }
+}