Revised k8s schema test to generate WDT 2.0 model; renamed some helper methods

Author: rakillen

core/src/main/python/wlsdeploy/tool/extract/domain_resource_extractor.py

@@ -123,16 +123,14 @@ def _process_folder(self, model_dict, schema_folder, target_dict, schema_path):
         for key, model_value in model_dict.items():
             properties = folder_properties[key]
 
-            if wko_schema_helper.is_single_folder(properties):
-                # single object instance
+            if wko_schema_helper.is_single_object(properties):
                 next_schema_path = wko_schema_helper.append_path(schema_path, key)
                 if not wko_schema_helper.is_unsupported_folder(next_schema_path):
                     next_target_dict = PyOrderedDict()
                     target_dict[key] = next_target_dict
                     self._process_folder(model_value, properties, next_target_dict, next_schema_path)
 
-            elif wko_schema_helper.is_multiple_folder(properties):
-                # multiple object instances
+            elif wko_schema_helper.is_object_array(properties):
                 next_schema_path = wko_schema_helper.append_path(schema_path, key)
                 if not wko_schema_helper.is_unsupported_folder(next_schema_path):
                     item_info = wko_schema_helper.get_array_item_info(properties)

core/src/main/python/wlsdeploy/tool/extract/wko_schema_helper.py

@@ -62,32 +62,37 @@ def get_domain_resource_schema(exception_type=ExceptionType.DEPLOY):
     return schema
 
 
-def is_single_folder(schema_map):
+def is_single_object(schema_map):
     """
-    Return True if the schema map describes a single folder.
+    Return True if the schema map describes a single object.
     :param schema_map: the schema map to be examined
-    :return: True if the map identifies a single folder
+    :return: True if the map identifies a single object
     """
     property_type = get_type(schema_map)
     if property_type in OBJECT_TYPES:
         return get_map_element_type(schema_map) is None
     return False
 
 
-def is_multiple_folder(schema_map):
+def is_object_array(schema_map):
     """
-    Return True if the schema map identifies a multiple folder.
+    Return True if the schema map identifies an object array.
     :param schema_map: the schema map to be examined
-    :return: True if the map identifies a multiple folder
+    :return: True if the map identifies an object array
     """
     property_type = get_type(schema_map)
     if property_type == "array":
         return get_array_element_type(schema_map) in OBJECT_TYPES
     return False
 
 
-def is_folder(schema_map):
-    return is_single_folder(schema_map) or is_multiple_folder(schema_map)
+def is_object_type(schema_map):
+    """
+    Return True is the schema map identifies an object or object array.
+    :param schema_map: the schema map to be examined
+    :return: True if the map identifies an object or object array
+    """
+    return is_single_object(schema_map) or is_object_array(schema_map)
 
 
 def is_simple_map(schema_map):
@@ -114,6 +119,16 @@ def is_simple_array(schema_map):
     return False
 
 
+def is_simple_type(schema_map):
+    """
+    Return True if the schema map describes a simple type.
+    :param schema_map: the schema map to be examined
+    :return: True if the map identifies a simple type
+    """
+    property_type = get_type(schema_map)
+    return property_type in SIMPLE_TYPES
+
+
 def get_array_element_type(schema_map):
     item_info = get_array_item_info(schema_map)
     return get_type(item_info)

core/src/main/python/wlsdeploy/tool/modelhelp/model_kubernetes_printer.py

@@ -86,7 +86,7 @@ def _print_model_folder_sample(self, section_name, model_path_tokens, control_op
             _print_indent(token + ":", indent)
             indent += 1
 
-            if wko_schema_helper.is_multiple_folder(current_folder):
+            if wko_schema_helper.is_object_array(current_folder):
                 name = token + '-1'
                 _print_indent(name + ":", indent)
                 indent += 1
@@ -119,10 +119,10 @@ def _print_subfolders_sample(self, schema_folder, control_option, indent_level,
             property_map = folder_info[key]
 
             if property_map is not None:
-                if wko_schema_helper.is_single_folder(property_map):
+                if wko_schema_helper.is_single_object(property_map):
                     folder_map[key] = property_map
 
-                elif wko_schema_helper.is_multiple_folder(property_map):
+                elif wko_schema_helper.is_object_array(property_map):
                     folder_map[key] = wko_schema_helper.get_array_item_info(property_map)
                     multi_folders.append(key)
 
@@ -173,7 +173,7 @@ def _print_attributes_sample(self, schema_folder, indent_level):
                     # array of simple type
                     attribute_map[key] = 'list of ' + wko_schema_helper.get_array_element_type(property_map)
 
-                elif not wko_schema_helper.is_folder(property_map):
+                elif not wko_schema_helper.is_object_type(property_map):
                     type_text = wko_schema_helper.get_type(property_map)
                     enum_values = wko_schema_helper.get_enum_values(property_map)
                     if enum_values:
@@ -199,7 +199,7 @@ def _print_attributes_sample(self, schema_folder, indent_level):
 
 def _get_properties(schema_folder):
     # in array elements, the properties are under "items"
-    if wko_schema_helper.is_multiple_folder(schema_folder):
+    if wko_schema_helper.is_object_array(schema_folder):
         item_info = wko_schema_helper.get_array_item_info(schema_folder)
         return wko_schema_helper.get_properties(item_info)
     else:
@@ -216,7 +216,7 @@ def _get_folder_names(schema_properties):
     for key in schema_properties:
         property_map = schema_properties[key]
         if property_map is not None:
-            if wko_schema_helper.is_single_folder(property_map) or wko_schema_helper.is_multiple_folder(property_map):
+            if wko_schema_helper.is_object_type(property_map):
                 folder_names.append(key)
     return folder_names
 

core/src/main/python/wlsdeploy/tool/validate/kubernetes_validator.py

@@ -61,16 +61,15 @@ def validate_folder(self, model_folder, schema_folder, schema_path, model_path):
 
             if properties is not None:
 
-                if wko_schema_helper.is_single_folder(properties):
+                if wko_schema_helper.is_single_object(properties):
                     # single object instance
                     self._log_debug('  ' + key + ': folder')
                     next_schema_path = wko_schema_helper.append_path(schema_path, key)
                     next_model_path = model_path + "/" + key
                     if self._check_folder_path(next_schema_path, next_model_path):
                         self.validate_folder(model_value, properties, next_schema_path, next_model_path)
 
-                elif wko_schema_helper.is_multiple_folder(properties):
-                    # multiple object instances
+                elif wko_schema_helper.is_object_array(properties):
                     self._log_debug('  ' + key + ': multiple folder')
                     next_schema_path = wko_schema_helper.append_path(schema_path, key)
                     next_model_path = model_path + "/" + key

core/src/test/python/wlsdeploy/tool/extract/kubernetes_schema_test.py

@@ -8,9 +8,7 @@
 from oracle.weblogic.deploy.util import PyOrderedDict
 
 from wlsdeploy.aliases.model_constants import KUBERNETES
-from wlsdeploy.tool.extract import domain_resource_extractor
 from wlsdeploy.tool.extract import wko_schema_helper
-from wlsdeploy.util import dictionary_utils
 
 
 class KubernetesSchemaTest(unittest.TestCase):
@@ -31,93 +29,78 @@ def tearDown(self):
     def testKubernetesSchema(self):
         # create a model with every element.
         # verify that there are no unknown types or structures.
-        self._write_folder(self.schema_map, "", False, "", "")
-
-    def _write_folder(self, folder, name, is_multiple, path, indent):
-        label = name
-        if not label:
-            label = KUBERNETES
-
-        if wko_schema_helper.is_unsupported_folder(path):
-            self._write_line("\n" + indent + "# " + label + ": (unsupported folder)")
-            return
-
-        self._write_line("\n" + indent + label + ":")
-        indent = indent + "  "
-
-        properties = wko_schema_helper.get_properties(folder)
-
-        multi_key = None
+        self._write_line(KUBERNETES + ":")
+        self._write_folder(self.schema_map, False, "", "  ")
+
+    def _write_folder(self, folder, is_multiple, path, indent):
+        # for a multiple (object list) type, the first field is prefixed with a hyphen
+        plain_indent = indent
+        hyphen_indent = indent[:-2] + "- "
+        this_indent = plain_indent
         if is_multiple:
-            mapped_key = domain_resource_extractor.get_mapped_key(path)
-            multi_property = dictionary_utils.get_element(properties, mapped_key)
-            if multi_property:
-                multi_key = mapped_key
-                comment = 'maps to ' + multi_key
-            else:
-                comment = 'unique key for each'
-
-            self._write_line(indent + "'" + name + "-1':  # " + comment)
-            indent = indent + "  "
+            this_indent = hyphen_indent
 
+        properties = wko_schema_helper.get_properties(folder)
         property_names = list(properties.keys())
         property_names.sort()
 
         sub_folders = PyOrderedDict()
         multi_sub_folders = []
         for property_name in property_names:
             property_map = properties[property_name]
-
-            property_type = dictionary_utils.get_element(property_map, "type")
-
-            if property_type in wko_schema_helper.OBJECT_TYPES:
-                additional = dictionary_utils.get_dictionary_element(property_map, "additionalProperties")
-                additional_type = dictionary_utils.get_element(additional, "type")
-                if additional_type:
-                    if additional_type not in wko_schema_helper.SIMPLE_TYPES:
-                        self.fail('Unknown map type ' + additional_type + ' for ' + path + ' ' + property_name)
-                    nest_indent = indent + "  "
-                    self._write_line(indent + property_name + ":")
-                    self._write_line(nest_indent + "'key-1': " + _get_sample_value(additional_type))
-                    self._write_line(nest_indent + "'key-2': " + _get_sample_value(additional_type))
-                else:
-                    # single object instance
-                    sub_folders[property_name] = property_map
-
-            elif property_type == "array":
-                array_items = dictionary_utils.get_dictionary_element(property_map, "items")
-                array_type = dictionary_utils.get_element(array_items, "type")
-                if array_type in wko_schema_helper.OBJECT_TYPES:
-                    # multiple object instances
-                    sub_folders[property_name] = array_items
-                    multi_sub_folders.append(property_name)
-                elif array_type in wko_schema_helper.SIMPLE_TYPES:
-                    nest_indent = indent + "  "
-                    self._write_line(indent + property_name + ": [")
-                    self._write_line(nest_indent + _get_sample_value(array_type) + ",")
-                    self._write_line(nest_indent + _get_sample_value(array_type))
-                    self._write_line(indent + "]")
-                else:
-                    self.fail('Unknown array type ' + array_type + ' for ' + path + ' ' + property_name)
-
-            elif property_type in wko_schema_helper.SIMPLE_TYPES:
-                if property_name != multi_key:
-                    value = _get_sample_value(property_type)
-                    enum_values = wko_schema_helper.get_enum_values(property_map)
-                    if enum_values:
-                        value = "'" + enum_values[0] + "'  # " + ', '.join(enum_values)
-                    self._write_line(indent + str(property_name) + ": " + value)
+            property_type = wko_schema_helper.get_type(property_map)
+
+            if wko_schema_helper.is_simple_map(property_map):
+                additional_type = wko_schema_helper.get_map_element_type(property_map)
+                if additional_type not in wko_schema_helper.SIMPLE_TYPES:
+                    self.fail('Unknown map type ' + additional_type + ' for ' + path + ' ' + property_name)
+                self._write_line(this_indent + property_name + ":")
+                this_indent = plain_indent
+                nest_indent = this_indent + "  "
+                self._write_line(nest_indent + "'key-1': " + _get_sample_value(additional_type))
+                self._write_line(nest_indent + "'key-2': " + _get_sample_value(additional_type))
+
+            elif wko_schema_helper.is_single_object(property_map):
+                # single object instance
+                sub_folders[property_name] = property_map
+
+            elif wko_schema_helper.is_object_array(property_map):
+                array_items = wko_schema_helper.get_array_item_info(property_map)
+                sub_folders[property_name] = array_items
+                multi_sub_folders.append(property_name)
+
+            elif wko_schema_helper.is_simple_array(property_map):
+                array_type = wko_schema_helper.get_array_element_type(property_map)
+                self._write_line(this_indent + property_name + ":")
+                this_indent = plain_indent
+                each_indent = this_indent + "- "
+                self._write_line(each_indent + _get_sample_value(array_type))
+                self._write_line(each_indent + _get_sample_value(array_type))
+
+            elif wko_schema_helper.is_simple_type(property_map):
+                value = _get_sample_value(property_type)
+                enum_values = wko_schema_helper.get_enum_values(property_map)
+                if enum_values:
+                    value = "'" + enum_values[0] + "'  # " + ', '.join(enum_values)
+                self._write_line(this_indent + str(property_name) + ": " + value)
+                this_indent = plain_indent
 
             else:
                 self.fail('Unknown property type ' + str(property_type) + ' for ' + str(path) + ' '
                           + str(property_name))
 
         # process sub-folders after attributes for clarity
         for property_name in sub_folders:
-            subfolder = sub_folders[property_name]
-            is_multiple = property_name in multi_sub_folders
             next_path = wko_schema_helper.append_path(path, property_name)
-            self._write_folder(subfolder, property_name, is_multiple, next_path, indent)
+            if wko_schema_helper.is_unsupported_folder(next_path):
+                self._write_line(indent + "# " + property_name + ": (unsupported folder)")
+            else:
+                self._write_line(this_indent + property_name + ":")
+                this_indent = plain_indent
+                subfolder = sub_folders[property_name]
+                is_multiple = property_name in multi_sub_folders
+                child_indent = this_indent + "  "
+                self._write_folder(subfolder, is_multiple, next_path, child_indent)
 
     def _write_line(self, text):
         self.out_file.write(text + "\n")