Validate that zowe.config.json file matches schema

CHANGELOG.md

@@ -4,4 +4,5 @@ All notable changes to the Zowe Client Python SDK will be documented in this fil
 
 ## Recent Changes
 
-- Feature: Added method to load profile properties from environment variables
+- BugFix: Validation of zowe.config.json file matching the schema [#192](https://github.com/zowe/zowe-client-python-sdk/issues/192)
+- Feature: Added method to load profile properties from environment variables

requirements.txt

@@ -6,7 +6,7 @@ coverage==5.4
 flake8==3.8.4
 idna==2.10
 importlib-metadata==3.6.0
-jsonschema==4.14.0
+jsonschema==4.19.0
 keyring
 lxml==4.9.3
 mccabe==0.6.1

src/core/zowe/core_for_zowe_sdk/config_file.py

@@ -23,6 +23,7 @@
 import commentjson
 
 from .constants import constants
+from .validators import validate_config_json
 from .custom_warnings import (
     ProfileNotFoundWarning,
     ProfileParsingWarning,
@@ -80,6 +81,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
     schema_property: Optional[dict] = None
     _missing_secure_props: list = field(default_factory=list)
@@ -104,10 +106,10 @@ def filepath(self) -> Optional[str]:
     @property
     def location(self) -> Optional[str]:
         return self._location
-
+    
     @property
     def schema_path(self) -> Optional[str]:
-        self.schema_property
+        return self.schema_property
 
     @location.setter
     def location(self, dirname: str) -> None:
@@ -116,7 +118,12 @@ 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, 
+        validate_schema: Optional[bool] = False,
+        verify: Optional[bool] = False,
+    ) -> None:
         """
         Initializes the class variable after
         setting filepath (or if not set, autodiscover the file)
@@ -128,14 +135,46 @@ 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", {})
         self.schema_property = profile_jsonc.get("$schema", None)
 
+        if self.schema_property:
+            self.validate_schema(config_type, validate_schema, verify=verify)
         # 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,
+        validate_schema: Optional[bool] = False,
+        verify: Optional[bool] = False,
+    ) -> 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:
+            path_config_json = f"./{self.filename}"
+
+        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 validate_schema:
+            validate_config_json(path_config_json, path_schema_json, cwd = self.location, verify=verify)
+
     def schema_list(
         self,
     ) -> list:
@@ -184,6 +223,9 @@ def get_profile(
         self,
         profile_name: Optional[str] = None,
         profile_type: Optional[str] = None,
+        config_type: Optional[str] = None,
+        validate_schema: Optional[bool] = False,
+        verify: Optional[bool] = False,
     ) -> Profile:
         """
         Load given profile including secure properties and excluding values from base profile
@@ -193,7 +235,7 @@ def get_profile(
             Returns a namedtuple called Profile
         """
         if self.profiles is None:
-            self.init_from_file()
+            self.init_from_file(config_type, validate_schema, verify)
 
         if profile_name is None and profile_type is None:
             raise ProfileNotFound(

src/core/zowe/core_for_zowe_sdk/profile_manager.py

@@ -13,6 +13,7 @@
 import os.path
 import os
 import warnings
+import jsonschema
 from typing import Optional
 
 from .config_file import ConfigFile, Profile
@@ -160,6 +161,8 @@ def get_profile(
         profile_name: Optional[str],
         profile_type: Optional[str],
         config_type: str,
+        validate_schema: Optional[bool] = True,
+        verify: Optional[bool] = False,
     ) -> Profile:
         """
         Get just the profile from the config file (overriden with base props in the config file)
@@ -174,7 +177,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, validate_schema=validate_schema
+            )
+        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.exceptions.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:
@@ -207,20 +230,23 @@ def get_profile(
                     SecurePropsNotFoundWarning,
                 )
         except Exception as exc:
+            print("hi", exc)
             warnings.warn(
                 f"Could not load {config_type} '{cfg.filename}' at '{cfg.filepath}'"
                 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,
+        validate_schema: Optional[bool] = False,
         override_with_env: Optional[bool] = False,
+        verify: Optional[bool] = False,
     ) -> dict:
         """Load connection details from a team config profile.
         Returns
@@ -255,13 +281,14 @@ def load(
             "Global Config": self.global_config,
         }
         profile_props: dict = {}
+        schema_path = None
         env_var: dict = {}
 
         missing_secure_props = []  # track which secure props were not loaded
 
         for i, (config_type, cfg) in enumerate(config_layers.items()):
             profile_loaded = self.get_profile(
-                cfg, profile_name, profile_type, config_type
+                cfg, profile_name, profile_type, config_type, validate_schema, verify
             )
             # TODO Why don't user and password show up here for Project User Config?
             # Probably need to update load_profile_properties method in config_file.py
@@ -270,7 +297,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 override_with_env:

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, Optional
+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, cwd: str, verify: Optional[bool] = False):
     """
     Function validating that zowe.config.json file matches zowe.schema.json.
 
@@ -31,10 +34,29 @@ 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, verify = verify).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)
+
+    # checks if the path_schema_json is absolute
+    elif not os.path.isabs(path_schema_json):
+        path_schema_json = os.path.join(cwd, 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)

tests/unit/fixtures/invalid.zowe.config.json

@@ -1,5 +1,5 @@
 {
-    "$schema": "./zowe.schema.json",
+    "$schema": "./invalid.zowe.schema.json",
     "profiles": {
         "zosmf": {
             "type": "zosmf",

tests/unit/fixtures/invalidUri.zowe.config.json

@@ -0,0 +1,55 @@
+{
+    "$schema": "./invalidUri.zowe.schema.json",
+    "profiles": {
+        "zosmf": {
+            "type": "zosmf",
+            "properties": {
+                "port": 10443
+            },
+            "secure": []
+        },
+        "tso": {
+            "type": "tso",
+            "properties": {
+                "account": "",
+                "codePage": "1047",
+                "logonProcedure": "IZUFPROC"
+            },
+            "secure": []
+        },
+        "ssh": {
+            "type": "ssh",
+            "properties": {
+                "port": 22
+            },
+            "secure": ["user"]
+        },
+        "zftp": {
+            "type": "zftp",
+            "properties": {
+                "port": 21,
+                "secureFtp": true
+            },
+            "secure": []
+        },
+        "base": {
+            "type": "base",
+            "properties": {
+                "host": "zowe.test.cloud",
+                "rejectUnauthorized": false
+            },
+            "secure": [
+                "user",
+                "password"
+            ]
+        }
+    },
+    "defaults": {
+        "zosmf": "zosmf",
+        "tso": "tso",
+        "ssh": "ssh",
+        "zftp": "zftp",
+        "base": "base"
+    },
+    "autoStore": true
+}