Adjust test structure

Signed-off-by: Tushar Goel <[email protected]>

Author: TG1999

spec

@@ -538,7 +538,7 @@ def validate(self, strict: bool = False) -> list[str]:
                 return [f"Given type: {self.type} can not be validated"]
 
     @classmethod
-    def from_string(cls, purl: str) -> Self:
+    def from_string(cls, purl: str, normalize_purl: bool = True) -> Self:
         """
         Return a PackageURL object parsed from a string.
         Raise ValueError on errors.
@@ -622,14 +622,18 @@ def from_string(cls, purl: str) -> Self:
         if not name:
             raise ValueError(f"purl is missing the required name component: {purl!r}")
 
-        type_, namespace, name, version, qualifiers, subpath = normalize(
-            type_,
-            namespace,
-            name,
-            version,
-            qualifiers_str,
-            subpath,
-            encode=False,
+        if normalize_purl:
+            type_, namespace, name, version, qualifiers, subpath = normalize(
+                type_,
+                namespace,
+                name,
+                version,
+                qualifiers_str,
+                subpath,
+                encode=False,
+            )
+        else:
+            qualifiers = normalize_qualifiers(qualifiers_str, encode=False) or {}
+        return cls(
+            type_, namespace, name, version, qualifiers, subpath, normalize_purl=normalize_purl
         )
-
-        return cls(type_, namespace, name, version, qualifiers, subpath)

src/packageurl/__init__.py

@@ -26,6 +26,21 @@
 Validate each type according to the PURL spec type definitions
 """
 
+from enum import Enum
+from dataclasses import dataclass
+
+
+class ValidationSeverity(Enum):
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"
+
+
+@dataclass
+class ValidationMessage:
+    severity: ValidationSeverity
+    message: str
+
 
 class TypeValidator:
     @classmethod
@@ -34,26 +49,45 @@ def validate(cls, purl, strict=False):
             purl = cls.normalize(purl)
 
         if cls.namespace_requirement == "prohibited" and purl.namespace:
-            yield f"Namespace is prohibited for purl type: {cls.type!r}"
+            yield ValidationMessage(
+                severity=ValidationSeverity.ERROR,
+                message=f"Namespace is prohibited for purl type: {cls.type!r}",
+            )
 
         elif cls.namespace_requirement == "required" and not purl.namespace:
-            yield f"Namespace is required for purl type: {cls.type!r}"
+            yield ValidationMessage(
+                severity=ValidationSeverity.ERROR,
+                message=f"Namespace is required for purl type: {cls.type!r}",
+            )
 
         if purl.type == "cpan":
             if purl.namespace and purl.namespace != purl.namespace.upper():
-                yield f"Namespace must be uppercase for purl type: {cls.type!r}"
+                yield ValidationMessage(
+                    severity=ValidationSeverity.WARNING,
+                    message=f"Namespace must be uppercase for purl type: {cls.type!r}",
+                )
+        # TODO: Check pending CPAN PR and decide if we want to upgrade the type definition schema
         elif (
             not cls.namespace_case_sensitive
             and purl.namespace
             and purl.namespace.lower() != purl.namespace
         ):
-            yield f"Namespace is not lowercased for purl type: {cls.type!r}"
+            yield ValidationMessage(
+                severity=ValidationSeverity.WARNING,
+                message=f"Namespace is not lowercased for purl type: {cls.type!r}",
+            )
 
         if not cls.name_case_sensitive and purl.name and purl.name.lower() != purl.name:
-            yield f"Name is not lowercased for purl type: {cls.type!r}"
+            yield ValidationMessage(
+                severity=ValidationSeverity.WARNING,
+                message=f"Name is not lowercased for purl type: {cls.type!r}",
+            )
 
         if not cls.version_case_sensitive and purl.version and purl.version.lower() != purl.version:
-            yield f"Version is not lowercased for purl type: {cls.type!r}"
+            yield ValidationMessage(
+                severity=ValidationSeverity.WARNING,
+                message=f"Version is not lowercased for purl type: {cls.type!r}",
+            )
 
         messages = cls.validate_type(purl, strict=strict)
         if messages:
@@ -87,7 +121,8 @@ def normalize(cls, purl):
 
     @classmethod
     def validate_type(cls, purl, strict=False):
-        return
+        if strict:
+            yield from cls.validate_qualifiers(purl)
 
     @classmethod
     def validate_qualifiers(cls, purl):
@@ -100,9 +135,12 @@ def validate_qualifiers(cls, purl):
         disallowed = purl_qualifiers_keys - allowed_qualifiers_set
 
         if disallowed:
-            yield (
-                f"Invalid qualifiers found: {', '.join(sorted(disallowed))}. "
-                f"Allowed qualifiers are: {', '.join(sorted(allowed_qualifiers_set))}"
+            yield ValidationMessage(
+                severity=ValidationSeverity.INFO,
+                message=(
+                    f"Invalid qualifiers found: {', '.join(sorted(disallowed))}. "
+                    f"Allowed qualifiers are: {', '.join(sorted(allowed_qualifiers_set))}"
+                ),
             )
 
 
@@ -248,9 +286,15 @@ class CpanTypeValidator(TypeValidator):
     @classmethod
     def validate_type(cls, purl, strict=False):
         if purl.namespace and "::" in purl.name:
-            yield f"Name must not contain '::' when Namespace is absent for purl type: {cls.type!r}"
+            yield ValidationMessage(
+                severity=ValidationSeverity.ERROR,
+                message=f"Name must not contain '::' when Namespace is present for purl type: {cls.type!r}",
+            )
         if not purl.namespace and "-" in purl.name:
-            yield f"Name must not contain '-' when Namespace is absent for purl type: {cls.type!r}"
+            yield ValidationMessage(
+                severity=ValidationSeverity.ERROR,
+                message=f"Name must not contain '-' when Namespace is absent for purl type: {cls.type!r}",
+            )
         messages = super().validate_type(purl, strict)
         if messages:
             yield from messages
@@ -370,7 +414,10 @@ class HackageTypeValidator(TypeValidator):
     @classmethod
     def validate_type(cls, purl, strict=False):
         if "_" in purl.name:
-            yield f"Name contains underscores but should be kebab-case for purl type: {cls.type!r}"
+            yield ValidationMessage(
+                severity=ValidationSeverity.WARNING,
+                message=f"Name cannot contain underscores for purl type:{cls.type!r}",
+            )
         messages = super().validate_type(purl, strict)
         if messages:
             yield from messages
@@ -503,10 +550,17 @@ class PubTypeValidator(TypeValidator):
 
     @classmethod
     def validate_type(cls, purl, strict=False):
-        if any(not (c.islower() or c.isdigit() or c == "_") for c in purl.name):
-            yield f"Name contains invalid characters but should only contain lowercase letters, digits, or underscores for purl type: {cls.type!r}"
+        if not all(c.isalnum() or c == "_" for c in purl.name):
+            yield ValidationMessage(
+                severity=ValidationSeverity.ERROR,
+                message=f"Name contains invalid characters but should only contain letters, digits, or underscores for purl type: {cls.type!r}",
+            )
+
         if " " in purl.name:
-            yield f"Name contains spaces but should use underscores instead for purl type: {cls.type!r}"
+            yield ValidationMessage(
+                severity=ValidationSeverity.ERROR,
+                message=f"Name contains spaces but should use underscores instead for purl type: {cls.type!r}",
+            )
         messages = super().validate_type(purl, strict)
         if messages:
             yield from messages
@@ -528,7 +582,10 @@ class PypiTypeValidator(TypeValidator):
     @classmethod
     def validate_type(cls, purl, strict=False):
         if "_" in purl.name:
-            yield f"Name cannot contain `_` for purl type:{cls.type!r}"
+            yield ValidationMessage(
+                severity=ValidationSeverity.WARNING,
+                message=f"Name cannot contain underscores for purl type:{cls.type!r}",
+            )
         messages = super().validate_type(purl, strict)
         if messages:
             yield from messages

src/packageurl/validate.py

@@ -160,17 +160,18 @@ def run_test_case(case, test_type, desc):
         strict = True
         if test_group == "advanced":
             strict = False
-        purl = PackageURL(
-            type=input_data["type"],
-            namespace=input_data["namespace"],
-            name=input_data["name"],
-            version=input_data["version"],
-            qualifiers=input_data.get("qualifiers"),
-            subpath=input_data.get("subpath"),
-            normalize_purl=not strict,
-        )
+        purl = PackageURL.from_string(input_data, normalize_purl=False)
         messages = purl.validate(strict=strict)
-        if case.get("expected_messages"):
-            assert messages == case["expected_messages"]
+        messages = list(change_messages_to_json(messages))
+        if case.get("expected_output"):
+            assert messages == case["expected_output"]
         else:
             assert not messages
+
+
+def change_messages_to_json(messages):
+    for message in messages:
+        yield {
+            "severity": message.severity.value,
+            "message": message.message,
+        }