Fixed error

Author: sujata-m

src/example.py

@@ -11,26 +11,29 @@
 
 def valid_test_with_provided_schema():
     validator = OSWValidation(zipfile_path=VALID_ZIP_FILE, schema_file_path=SCHEMA_FILE_PATH)
-    validation = validator.validate()
-    print(f'Valid Test With Provided Schema: {"Passed" if validation.is_valid else "Failed"}')
+    result = validator.validate()
+    print(f'Valid Test With Provided Schema: {"Passed" if result.is_valid else "Failed"}')
 
 
 def valid_test_without_provided_schema():
     validator = OSWValidation(zipfile_path=VALID_ZIP_FILE)
-    validation = validator.validate()
-    print(f'Valid Test Without Schema: {"Passed" if validation.is_valid else "Failed"}')
+    result = validator.validate()
+    print(f'Valid Test Without Schema: {"Passed" if result.is_valid else "Failed"}')
 
 
 def invalid_test_with_provided_schema():
     validator = OSWValidation(zipfile_path=INVALID_ZIP_FILE, schema_file_path=SCHEMA_FILE_PATH)
-    validation = validator.validate()
-    print(f'Invalid Test With Provided Schema: {"Failed" if validation.is_valid else "Passed"}')
+    result = validator.validate()
+    if not result.is_valid:
+        for error in result.errors:
+            print(error)
+    print(f'Invalid Test With Provided Schema: {"Failed" if result.is_valid else "Passed"}')
 
 
 def invalid_test_without_provided_schema():
     validator = OSWValidation(zipfile_path=INVALID_ZIP_FILE)
-    validation = validator.validate()
-    print(f'Invalid Test Without Schema: {"Failed" if validation.is_valid else "Passed"}')
+    result = validator.validate()
+    print(f'Invalid Test Without Schema: {"Failed" if result.is_valid else "Passed"}')
 
 
 if __name__ == '__main__':

src/python_lib_osw_validation/__init__.py

@@ -1,17 +1,17 @@
 import os
 import json
 import jsonschema
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
 from .zipfile_handler import ZipFileHandler
 from .extracted_data_validator import ExtractedDataValidator
 
 SCHEMA_PATH = os.path.join(os.path.dirname(__file__), 'schema')
 
 
 class ValidationResult:
-    def __init__(self, is_valid: bool, error: Optional[str] = None):
+    def __init__(self, is_valid: bool, errors: Optional[List[str]] = None):
         self.is_valid = is_valid
-        self.error = error
+        self.errors = errors
 
 
 class OSWValidation:
@@ -20,21 +20,19 @@ class OSWValidation:
     def __init__(self, zipfile_path: str, schema_file_path=None):
         self.zipfile_path = zipfile_path
         self.extracted_dir = None
+        self.errors = []
         if schema_file_path is None:
-            self.schema = self.load_osw_schema(OSWValidation.default_schema_file_path)
+            self.schema_file_path = OSWValidation.default_schema_file_path
         else:
-            self.schema = self.load_osw_schema(schema_file_path)
-
-        self.error = None
+            self.schema_file_path = schema_file_path
 
     def load_osw_schema(self, schema_path: str) -> Dict[str, Any]:
         '''Load OSW Schema'''
         try:
             with open(schema_path, 'r') as file:
-                schema = json.load(file)
-            return schema
+                return json.load(file)
         except Exception as e:
-            self.error = e
+            self.errors.append(f'Invalid or missing schema file: {e}')
             raise Exception(f'Invalid or missing schema file: {e}')
 
     def validate(self) -> ValidationResult:
@@ -44,40 +42,39 @@ def validate(self) -> ValidationResult:
             self.extracted_dir = zip_handler.extract_zip()
 
             if not self.extracted_dir:
-                self.error = zip_handler.error
-                return ValidationResult(False, self.error)
+                self.errors.append(zip_handler.error)
+                return ValidationResult(False, self.errors)
 
             # Validate the folder structure
             validator = ExtractedDataValidator(self.extracted_dir)
             if not validator.is_valid():
-                self.error = validator.error
-                return ValidationResult(False, self.error)
+                self.errors.append(validator.error)
+                return ValidationResult(False, self.errors)
 
             for file in validator.files:
                 file_path = os.path.join(file)
                 is_valid = self.validate_osw_errors(self.load_osw_file(file_path))
                 if not is_valid:
                     zip_handler.remove_extracted_files()
-                    return ValidationResult(False, self.error)
+                    return ValidationResult(False, self.errors)
 
-            return ValidationResult(True, None)
+            return ValidationResult(True)
         except Exception as e:
-            self.error = f'Unable to validate: {e}'
-            return ValidationResult(False, self.error)
+            self.errors.append(f'Unable to validate: {e}')
+            return ValidationResult(False, self.errors)
 
     def load_osw_file(self, graph_geojson_path: str) -> Dict[str, Any]:
         '''Load OSW Data'''
-
         with open(graph_geojson_path, 'r') as file:
-            data = json.load(file)
-        return data
+            return json.load(file)
 
     def validate_osw_errors(self, geojson_data: Dict[str, Any]) -> bool:
         '''Validate OSW Data against the schema and process all errors'''
-        validator = jsonschema.Draft7Validator(self.schema)
+        validator = jsonschema.Draft7Validator(self.load_osw_schema(self.schema_file_path))
         errors = list(validator.iter_errors(geojson_data))
 
         if errors:
-            self.error = errors[0]
+            for error in errors:
+                self.errors.append(f'Validation error: {error.message}')
             return False
         return True