Merge "Convert yaml schema into tree structure"

17 files changed, 893 insertions, 15 deletions

diff --git a/csarvalidation/src/main/java/org/onap/validation/yaml/exception/YamlProcessingException.java b/csarvalidation/src/main/java/org/onap/validation/yaml/exception/YamlProcessingException.java
new file mode 100644
index 0000000..edfdbb8
--- /dev/null
+++ b/csarvalidation/src/main/java/org/onap/validation/yaml/exception/YamlProcessingException.java
@@ -0,0 +1,29 @@
+/*
+ * 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.exception;
+
+public class YamlProcessingException extends Exception {
+
+    public YamlProcessingException(String message, Throwable throwable) {
+        super(message, throwable);
+    }
+
+    public YamlProcessingException(Throwable throwable) {
+        super(throwable);
+    }
+}
diff --git a/csarvalidation/src/main/java/org/onap/validation/yaml/model/YamlDocumentFactory.java b/csarvalidation/src/main/java/org/onap/validation/yaml/model/YamlDocumentFactory.java
index 1cda34b..16d94a2 100644
--- a/csarvalidation/src/main/java/org/onap/validation/yaml/model/YamlDocumentFactory.java
+++ b/csarvalidation/src/main/java/org/onap/validation/yaml/model/YamlDocumentFactory.java
@@ -17,6 +17,8 @@
 
 package org.onap.validation.yaml.model;
 
+import org.onap.validation.yaml.exception.YamlProcessingException;
+
 import java.util.HashMap;
 import java.util.Map;
 
@@ -41,8 +43,7 @@ public class YamlDocumentFactory {
         return parsedYaml;
     }
 
-    public static class YamlDocumentParsingException extends Exception {
-
+    public static class YamlDocumentParsingException extends YamlProcessingException {
         YamlDocumentParsingException(String message, Throwable throwable) {
             super(message, throwable);
         }
diff --git a/csarvalidation/src/main/java/org/onap/validation/yaml/model/YamlParameterListFactory.java b/csarvalidation/src/main/java/org/onap/validation/yaml/model/YamlParameterListFactory.java
index b85ec7c..4ea5ca2 100644
--- a/csarvalidation/src/main/java/org/onap/validation/yaml/model/YamlParameterListFactory.java
+++ b/csarvalidation/src/main/java/org/onap/validation/yaml/model/YamlParameterListFactory.java
@@ -17,6 +17,8 @@
 
 package org.onap.validation.yaml.model;
 
+import org.onap.validation.yaml.exception.YamlProcessingException;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -51,8 +53,7 @@ public class YamlParameterListFactory {
     }
 
 
-    public static class YamlParameterListParsingException extends Exception {
-
+    public static class YamlParameterListParsingException extends YamlProcessingException {
         YamlParameterListParsingException(String message, Throwable throwable) {
             super(message, throwable);
         }
diff --git a/csarvalidation/src/main/java/org/onap/validation/yaml/schema/YamlSchema.java b/csarvalidation/src/main/java/org/onap/validation/yaml/schema/YamlSchema.java
new file mode 100644
index 0000000..19e6af8
--- /dev/null
+++ b/csarvalidation/src/main/java/org/onap/validation/yaml/schema/YamlSchema.java
@@ -0,0 +1,38 @@
+/*
+ * 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.onap.validation.yaml.schema.node.YamlSchemaNode;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class YamlSchema {
+
+    private final List<YamlSchemaNode> rootNodes;
+
+    public List<YamlSchemaNode> getRootNodes() {
+        return Collections.unmodifiableList(rootNodes);
+    }
+
+    YamlSchema(List<YamlSchemaNode> rootNodes) {
+        this.rootNodes = new ArrayList<>(rootNodes);
+    }
+}
diff --git a/csarvalidation/src/main/java/org/onap/validation/yaml/schema/YamlSchemaFactory.java b/csarvalidation/src/main/java/org/onap/validation/yaml/schema/YamlSchemaFactory.java
new file mode 100644
index 0000000..df7d673
--- /dev/null
+++ b/csarvalidation/src/main/java/org/onap/validation/yaml/schema/YamlSchemaFactory.java
@@ -0,0 +1,59 @@
+/*
+ * 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.onap.validation.yaml.exception.YamlProcessingException;
+import org.onap.validation.yaml.model.YamlDocument;
+import org.onap.validation.yaml.model.YamlDocumentFactory;
+import org.onap.validation.yaml.schema.node.YamlSchemaNode;
+import org.onap.validation.yaml.schema.node.YamlSchemaNodeFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class YamlSchemaFactory {
+
+
+    private static final String ROOT_PATH = "/";
+
+    public YamlSchema createTreeStructuredYamlSchema(YamlDocument schema)
+        throws YamlProcessingException {
+
+        return new YamlSchema(getRootNodes(schema));
+    }
+
+    private List<YamlSchemaNode> getRootNodes(YamlDocument yamlDocument)
+        throws YamlProcessingException {
+
+        List<YamlSchemaNode> nextNodes = new ArrayList<>();
+        for(String nodeName: yamlDocument.getYaml().keySet()) {
+            nextNodes.add(
+                new YamlSchemaNodeFactory().createNode(
+                    nodeName,
+                    ROOT_PATH,
+                    new YamlDocumentFactory().createYamlDocument(
+                        yamlDocument.getYaml().get(nodeName)
+                    )
+                )
+            );
+        }
+        return nextNodes;
+    }
+
+}
diff --git a/csarvalidation/src/main/java/org/onap/validation/yaml/schema/node/YamlSchemaBranchNode.java b/csarvalidation/src/main/java/org/onap/validation/yaml/schema/node/YamlSchemaBranchNode.java
new file mode 100644
index 0000000..8ff3569
--- /dev/null
+++ b/csarvalidation/src/main/java/org/onap/validation/yaml/schema/node/YamlSchemaBranchNode.java
@@ -0,0 +1,83 @@
+/*
+ * 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.onap.validation.yaml.exception.YamlProcessingException;
+import org.onap.validation.yaml.model.YamlDocument;
+import org.onap.validation.yaml.model.YamlDocumentFactory;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+import static org.onap.validation.yaml.model.YamlDocumentFactory.YamlDocumentParsingException;
+import static org.onap.validation.yaml.model.YamlParameterListFactory.YamlParameterListParsingException;
+
+public class YamlSchemaBranchNode extends YamlSchemaNode {
+
+    private final YamlDocument nextNodesInLazyForm;
+    private Optional<List<YamlSchemaNode>> nextNodes;
+
+    YamlSchemaBranchNode(String name, String path, boolean required, String comment,
+                         YamlDocument nextNodesInLazyForm) {
+        super(name, path, required, comment);
+        this.nextNodesInLazyForm = nextNodesInLazyForm;
+        this.nextNodes = Optional.empty();
+    }
+
+    @Override
+    public boolean isContainingSubStructure() {
+        return true;
+    }
+
+    @Override
+    public List<String> getAcceptedValues() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public synchronized List<YamlSchemaNode> getNextNodes() throws YamlSchemaProcessingException {
+        try {
+            return nextNodes.orElseGet(this::loadNextNodes);
+        } catch (YamlSchemaLazyLoadingException lazyLoadingException) {
+            throw new YamlSchemaProcessingException(lazyLoadingException);
+        }
+    }
+
+    private List<YamlSchemaNode> loadNextNodes() {
+        try {
+            List<YamlSchemaNode> loadedNextNodes = new ArrayList<>();
+            for (String key : nextNodesInLazyForm.getYaml().keySet()) {
+                YamlDocument substructure = new YamlDocumentFactory()
+                    .createYamlDocument(nextNodesInLazyForm.getYaml().get(key));
+                loadedNextNodes.add(new YamlSchemaNodeFactory().createNode(key, getPath() + getName() + "/", substructure));
+            }
+            nextNodes = Optional.of(loadedNextNodes);
+            return loadedNextNodes;
+        } catch (YamlProcessingException e) {
+            throw new YamlSchemaLazyLoadingException("Lazy loading failed, due to yaml parsing exception.",e);
+        }
+    }
+
+    static class YamlSchemaLazyLoadingException extends RuntimeException {
+        YamlSchemaLazyLoadingException(String message, Throwable throwable) {
+            super(message, throwable);
+        }
+    }
+}
diff --git a/csarvalidation/src/main/java/org/onap/validation/yaml/schema/node/YamlSchemaLeafNode.java b/csarvalidation/src/main/java/org/onap/validation/yaml/schema/node/YamlSchemaLeafNode.java
new file mode 100644
index 0000000..73470d4
--- /dev/null
+++ b/csarvalidation/src/main/java/org/onap/validation/yaml/schema/node/YamlSchemaLeafNode.java
@@ -0,0 +1,50 @@
+/*
+ * 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.onap.validation.yaml.model.YamlParametersList;
+
+import java.util.Collections;
+import java.util.List;
+
+public class YamlSchemaLeafNode extends YamlSchemaNode {
+
+    private YamlParametersList acceptedValues;
+
+    YamlSchemaLeafNode(String name, String path, boolean required, String comment,
+                       YamlParametersList acceptedValues) {
+        super(name, path, required, comment);
+        this.acceptedValues = acceptedValues;
+    }
+
+    @Override
+    public List<String> getAcceptedValues() {
+        return acceptedValues.getParameters();
+    }
+
+    @Override
+    public List<YamlSchemaNode> getNextNodes() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public boolean isContainingSubStructure() {
+        return false;
+    }
+
+}
diff --git a/csarvalidation/src/main/java/org/onap/validation/yaml/schema/node/YamlSchemaNode.java b/csarvalidation/src/main/java/org/onap/validation/yaml/schema/node/YamlSchemaNode.java
new file mode 100644
index 0000000..28913a2
--- /dev/null
+++ b/csarvalidation/src/main/java/org/onap/validation/yaml/schema/node/YamlSchemaNode.java
@@ -0,0 +1,66 @@
+/*
+ * 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.onap.validation.yaml.exception.YamlProcessingException;
+
+import java.util.List;
+
+public abstract class YamlSchemaNode {
+
+    private final String path;
+    private final String name;
+    private final boolean required;
+    private final String comment;
+
+
+    public String getName() {
+        return name;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public boolean isRequired() {
+        return required;
+    }
+
+    public abstract List<String> getAcceptedValues();
+
+    public abstract List<YamlSchemaNode> getNextNodes() throws YamlSchemaProcessingException;
+
+    public abstract boolean isContainingSubStructure();
+
+    public String getComment() {
+        return comment;
+    }
+
+    YamlSchemaNode(String name, String path, boolean required, String comment) {
+        this.name = name;
+        this.path = path;
+        this.required = required;
+        this.comment = comment;
+    }
+
+    static class YamlSchemaProcessingException extends YamlProcessingException {
+        YamlSchemaProcessingException(Throwable throwable) {
+            super(throwable);
+        }
+    }
+}
diff --git a/csarvalidation/src/main/java/org/onap/validation/yaml/schema/node/YamlSchemaNodeFactory.java b/csarvalidation/src/main/java/org/onap/validation/yaml/schema/node/YamlSchemaNodeFactory.java
new file mode 100644
index 0000000..a07935a
--- /dev/null
+++ b/csarvalidation/src/main/java/org/onap/validation/yaml/schema/node/YamlSchemaNodeFactory.java
@@ -0,0 +1,86 @@
+/*
+ * 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.onap.validation.yaml.exception.YamlProcessingException;
+import org.onap.validation.yaml.model.YamlDocument;
+import org.onap.validation.yaml.model.YamlDocumentFactory;
+import org.onap.validation.yaml.model.YamlParameterListFactory;
+import org.onap.validation.yaml.model.YamlParametersList;
+
+import static org.onap.validation.yaml.model.YamlDocumentFactory.YamlDocumentParsingException;
+import static org.onap.validation.yaml.model.YamlParameterListFactory.YamlParameterListParsingException;
+
+public class YamlSchemaNodeFactory {
+
+    public static final String EMPTY_COMMENT = "no comment available";
+    static final String STRUCTURE_KEY = "structure";
+    static final String COMMENT_KEY = "comment";
+    static final String VALUE_KET = "value";
+    static final String PRESENCE_KEY = "presence";
+    static final String PRESENCE_REQUIRED_KEY = "required";
+
+    public YamlSchemaNode createNode(String nodeName, String path, YamlDocument yamlDocument)
+        throws YamlProcessingException {
+
+        YamlSchemaNode yamlSchemaNode;
+        if(isYamlContainingKey(yamlDocument, STRUCTURE_KEY)) {
+            yamlSchemaNode = new YamlSchemaBranchNode(
+                nodeName, path, getIsPresenceRequired(yamlDocument), getComment(yamlDocument),
+                getNextNodes(yamlDocument)
+            );
+        } else {
+            yamlSchemaNode = new YamlSchemaLeafNode(
+                nodeName, path, getIsPresenceRequired(yamlDocument), getComment(yamlDocument),
+                getAcceptedValues(yamlDocument)
+            );
+        }
+        return  yamlSchemaNode;
+    }
+
+    private YamlDocument getNextNodes(YamlDocument yamlDocument)
+        throws YamlDocumentParsingException {
+        return new YamlDocumentFactory().createYamlDocument(yamlDocument.getYaml().get(STRUCTURE_KEY));
+    }
+
+    private String getComment(YamlDocument yamlDocument) {
+
+        return isYamlContainingKey(yamlDocument, COMMENT_KEY)
+            ? yamlDocument.getYaml().get(COMMENT_KEY).toString()
+            : EMPTY_COMMENT;
+    }
+
+    private YamlParametersList getAcceptedValues(YamlDocument yamlDocument)
+        throws YamlParameterListParsingException {
+
+        return isYamlContainingKey(yamlDocument, VALUE_KET)
+            ? new YamlParameterListFactory().createYamlParameterList(yamlDocument.getYaml().get(VALUE_KET))
+            : new YamlParameterListFactory().createEmptyYamlParameterList();
+    }
+
+    private boolean getIsPresenceRequired(YamlDocument yamlDocument) {
+
+        return isYamlContainingKey(yamlDocument, PRESENCE_KEY)
+            && yamlDocument.getYaml().get(PRESENCE_KEY).equals(PRESENCE_REQUIRED_KEY);
+    }
+
+    private boolean isYamlContainingKey(YamlDocument yamlDocument, String structureKey) {
+        return yamlDocument.getYaml().containsKey(structureKey);
+    }
+
+}
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);
+    }
+}
diff --git a/csarvalidation/src/test/resources/yaml_schema/Simple_Invalid_Schema_Construction.yaml b/csarvalidation/src/test/resources/yaml_schema/Simple_Invalid_Schema_Construction.yaml
new file mode 100644
index 0000000..c5e7b7c
--- /dev/null
+++ b/csarvalidation/src/test/resources/yaml_schema/Simple_Invalid_Schema_Construction.yaml
@@ -0,0 +1,39 @@
+---
+pmMetaData: { presence: required, structure: [
+  -pmHeader: {
+    presence: required,
+    structure: {
+      nfType: {
+        presence: required,
+        comment: "nfType comment"
+      }
+    }
+  },
+  -pmFields: {
+    presence: required,
+    structure: {
+      measChangeType: {
+        presence: required,
+        value: [added, modified, deleted],
+        comment: "measChangeType comment"
+      },
+      measAdditionalFields: {
+        presence: required,
+        comment: "measAdditionalFields comment",
+        structure: {
+          vendorField1: {
+            presence: required,
+            value: [X, Y, Z],
+            comment: "vendorField1 comment"
+          },
+          vendorField2: {
+            presence: optional,
+            value: [A, B],
+            comment: "vendorField2 comment"
+          }
+        }
+      }
+    }
+  }
+]}
+...
diff --git a/csarvalidation/src/test/resources/yaml_schema/Simple_Invalid_Schema_LazyLoading.yaml b/csarvalidation/src/test/resources/yaml_schema/Simple_Invalid_Schema_LazyLoading.yaml
new file mode 100644
index 0000000..7f9f946
--- /dev/null
+++ b/csarvalidation/src/test/resources/yaml_schema/Simple_Invalid_Schema_LazyLoading.yaml
@@ -0,0 +1,39 @@
+---
+pmMetaData: { presence: required, structure: {
+  pmHeader: {
+    presence: required,
+    structure: {
+      nfType: {
+        presence: required,
+        comment: "nfType comment"
+      }
+    }
+  },
+  pmFields: {
+    presence: required,
+    structure: [
+      -measChangeType: {
+        presence: required,
+        value: [added, modified, deleted],
+        comment: "measChangeType comment"
+      },
+      -measAdditionalFields: {
+        presence: required,
+        comment: "measAdditionalFields comment",
+        structure: {
+          vendorField1: {
+            presence: required,
+            value: [X, Y, Z],
+            comment: "vendorField1 comment"
+          },
+          vendorField2: {
+            presence: optional,
+            value: [A, B],
+            comment: "vendorField2 comment"
+          }
+        }
+      }
+    ]
+  }
+}}
+...
diff --git a/csarvalidation/src/test/resources/yaml_schema/Simple_Valid_Schema.yaml b/csarvalidation/src/test/resources/yaml_schema/Simple_Valid_Schema.yaml
new file mode 100644
index 0000000..a125b13
--- /dev/null
+++ b/csarvalidation/src/test/resources/yaml_schema/Simple_Valid_Schema.yaml
@@ -0,0 +1,39 @@
+---
+pmMetaData: { presence: required, structure: {
+  pmHeader: {
+    presence: required,
+    structure: {
+      nfType: {
+        presence: required,
+        comment: "nfType comment"
+      }
+    }
+  },
+  pmFields: {
+    presence: required,
+    structure: {
+      measChangeType: {
+        presence: required,
+        value: [added, modified, deleted],
+        comment: "measChangeType comment"
+      },
+      measAdditionalFields: {
+        presence: required,
+        comment: "measAdditionalFields comment",
+        structure: {
+          vendorField1: {
+            presence: required,
+            value: [X, Y, Z],
+            comment: "vendorField1 comment"
+          },
+          vendorField2: {
+            presence: optional,
+            value: [A, B],
+            comment: "vendorField2 comment"
+          }
+        }
+      }
+    }
+  }
+}}
+...
diff --git a/csarvalidation/src/test/resources/yaml_schema/Simple_Valid_Schema_Multi_Root.yaml b/csarvalidation/src/test/resources/yaml_schema/Simple_Valid_Schema_Multi_Root.yaml
new file mode 100644
index 0000000..d73ca4f
--- /dev/null
+++ b/csarvalidation/src/test/resources/yaml_schema/Simple_Valid_Schema_Multi_Root.yaml
@@ -0,0 +1,23 @@
+---
+root1: { presence: required, structure: {
+  field1: {
+    presence: required,
+    value: [X, Y, Z],
+    comment: "field 1 description"
+  }
+}}
+root2: { presence: required, structure: {
+  field2: {
+    presence: required,
+    value: [X, Y, Z],
+    comment: "field 1 description"
+  }
+}}
+root3: { presence: required, structure: {
+  field3: {
+    presence: required,
+    value: [X, Y, Z],
+    comment: "field 1 description"
+  }
+}}
+...