Validate that zowe.config.json file matches schema

CHANGELOG.md

@@ -2,3 +2,6 @@
 
 All notable changes to the Zowe Client Python SDK will be documented in this file.
 
+## Recent Changes
+
+- BugFix: Validation of zowe.config.json file matching the schema [#192](https://github.com/zowe/zowe-client-python-sdk/issues/192)

src/core/zowe/core_for_zowe_sdk/config_file.py

@@ -21,6 +21,7 @@
 import commentjson
 
 from .constants import constants
+from .validators import validate_config_json
 from .custom_warnings import (
     ProfileNotFoundWarning,
     ProfileParsingWarning,
@@ -69,6 +70,7 @@ class ConfigFile:
     4. Contents of the file.
     4.1 Profiles
     4.2 Defaults
+    4.3 Schema Property
     5. Secure Properties associated with the file.
     """
 
@@ -77,6 +79,7 @@ class ConfigFile:
     _location: Optional[str] = None
     profiles: Optional[dict] = None
     defaults: Optional[dict] = None
+    schema_property: Optional[dict] = None
     secure_props: Optional[dict] = None
     _missing_secure_props: list = field(default_factory=list)
 
@@ -100,6 +103,10 @@ def filepath(self) -> Optional[str]:
     @property
     def location(self) -> Optional[str]:
         return self._location
+
+    @property
+    def schema_path(self) -> Optional[str]:
+        return self.schema_property
 
     @location.setter
     def location(self, dirname: str) -> None:
@@ -108,7 +115,11 @@ def location(self, dirname: str) -> None:
         else:
             raise FileNotFoundError(f"given path {dirname} is not valid")
 
-    def init_from_file(self) -> None:
+    def init_from_file(
+        self, 
+        config_type: str, 
+        opt_in: Optional[bool] = True
+    ) -> None:
         """
         Initializes the class variable after
         setting filepath (or if not set, autodiscover the file)
@@ -120,17 +131,53 @@ def init_from_file(self) -> None:
             profile_jsonc = commentjson.load(fileobj)
 
         self.profiles = profile_jsonc.get("profiles", {})
+        self.schema_property = profile_jsonc.get("$schema", None)
         self.defaults = profile_jsonc.get("defaults", {})
 
+        if self.schema_property:
+            self.validate_schema(config_type, opt_in)
         # loading secure props is done in load_profile_properties
         # since we want to try loading secure properties only when
         # we know that the profile has saved properties
         # self.load_secure_props()
 
+    def validate_schema(
+        self,
+        config_type: str,
+        opt_in: Optional[bool] = True,
+    ) -> None:
+        """
+        Get the $schema_property from the config and load the schema
+
+        Returns
+        -------
+        file_path to the $schema property
+        """
+
+        path_schema_json, path_config_json = None, ""
+
+        if self._location and config_type in ("Project Config", "Global Config"):
+            path_config_json = "./zowe.config.json"
+        elif self._location and config_type in ("Project User Config", "Global User Config"):
+            path_config_json = "./zowe.config.user.json"
+
+        path_schema_json = self.schema_path
+        if path_schema_json is None:    # check if the $schema property is not defined
+            warnings.warn(
+                f"$schema property could not found"
+            )
+
+        # validate the $schema property 
+        if path_schema_json and opt_in:
+            validate_config_json(path_config_json, path_schema_json)
+
+
     def get_profile(
         self,
         profile_name: Optional[str] = None,
         profile_type: Optional[str] = None,
+        config_type: Optional[str] = None,
+        opt_in: Optional[bool] = True,
     ) -> Profile:
         """
         Load given profile including secure properties and excluding values from base profile
@@ -140,7 +187,7 @@ def get_profile(
             Returns a namedtuple called Profile
         """
         if self.profiles is None:
-            self.init_from_file()
+            self.init_from_file(config_type, opt_in)
 
         if profile_name is None and profile_type is None:
             raise ProfileNotFound(

src/core/zowe/core_for_zowe_sdk/profile_manager.py

@@ -12,6 +12,7 @@
 
 import os.path
 import warnings
+import jsonschema
 from typing import Optional
 
 from .config_file import ConfigFile, Profile
@@ -129,7 +130,27 @@ def get_profile(
         cfg_profile = Profile()
         try:
             cfg_profile = cfg.get_profile(
-                profile_name=profile_name, profile_type=profile_type
+                profile_name=profile_name, profile_type=profile_type, config_type=config_type
+            )
+        except jsonschema.exceptions.ValidationError as exc:
+            raise jsonschema.exceptions.ValidationError(
+                f"Instance was invalid under the provided $schema property, {exc}"
+            )
+        except jsonschema.exceptions.SchemaError as exc:
+            raise jsonschema.exception.SchemaError(
+                f"The provided schema is invalid, {exc}"
+            )
+        except jsonschema.exceptions.UndefinedTypeCheck as exc:
+            raise jsonschema.exceptions.UndefinedTypeCheck(
+                f"A type checker was asked to check a type it did not have registered, {exc}"
+            )
+        except jsonschema.exceptions.UnknownType as exc:
+            raise jsonschema.exceptions.UnknownType(
+                f"Unknown type is found in schema_json, exc"
+            )
+        except jsonschema.exceptions.FormatError as exc:
+            raise jsonschema.exceptions.FormatError(
+                f"Validating a format config_json failed for schema_json, {exc}"
             )
         except ProfileNotFound:
             if profile_name:
@@ -167,14 +188,15 @@ def get_profile(
                 f"because {type(exc).__name__}'{exc}'.",
                 ConfigNotFoundWarning,
             )
-        finally:
-            return cfg_profile
+
+        return cfg_profile
 
     def load(
         self,
         profile_name: Optional[str] = None,
         profile_type: Optional[str] = None,
         check_missing_props: bool = True,
+        opt_in: Optional[bool] = True,
     ) -> dict:
         """Load connection details from a team config profile.
         Returns
@@ -209,6 +231,7 @@ def load(
             "Global Config": self.global_config,
         }
         profile_props: dict = {}
+        schema_path = None
 
         missing_secure_props = []  # track which secure props were not loaded
 
@@ -223,7 +246,7 @@ def load(
                     profile_loaded.name
                 )  # Define profile name that will be merged from other layers
             profile_props = {**profile_loaded.data, **profile_props}
-
+            
             missing_secure_props.extend(profile_loaded.missing_secure_props)
 
             if i == 1 and profile_props:

src/core/zowe/core_for_zowe_sdk/validators.py

@@ -12,9 +12,12 @@
 
 import commentjson
 from jsonschema import validate
+import os
+from typing import Union
+import requests
 
 
-def validate_config_json(path_config_json: str, path_schema_json: str):
+def validate_config_json(path_config_json: Union[str, dict], path_schema_json: str):
     """
     Function validating that zowe.config.json file matches zowe.schema.json.
 
@@ -31,10 +34,23 @@ def validate_config_json(path_config_json: str, path_schema_json: str):
         Provides details if config.json doesn't match schema.json, otherwise it returns None.
     """
 
-    with open(path_config_json) as file:
-        config_json = commentjson.load(file)
-
-    with open(path_schema_json) as file:
-        schema_json = commentjson.load(file)
+    # checks if the path_schema_json point to an internet URI and download the schema using the URI
+    if path_schema_json.startswith("https://") or path_schema_json.startswith("http://"):
+        schema_json = requests.get(path_schema_json).json()
+
+    # checks if the path_schema_json is a file
+    elif os.path.isfile(path_schema_json):
+        with open(path_schema_json) as file:
+            schema_json = commentjson.load(file)
+
+    # if there is no path_schema_json it will return None
+    else: 
+        return None
+
+    if isinstance(path_config_json, str):
+        with open(path_config_json) as file:
+            config_json = commentjson.load(file)
+    else:
+        config_json = path_config_json
 
     return validate(instance=config_json, schema=schema_json)