feat: addressed __hash__ methods in a number of model classes and added tests #153

Signed-off-by: Paul Horton <[email protected]>

Author: madpah

cyclonedx/model/__init__.py

@@ -292,6 +292,14 @@ def get_algorithm(self) -> HashAlgorithm:
     def get_hash_value(self) -> str:
         return self._content
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, HashType):
+            return hash(other) == hash(self)
+        return False
+
+    def __hash__(self) -> int:
+        return hash((self._alg, self._content))
+
     def __repr__(self) -> str:
         return f'<Hash {self._alg.value}:{self._content}>'
 
@@ -351,7 +359,7 @@ def __hash__(self) -> int:
         return hash(self._uri)
 
     def __repr__(self) -> str:
-        return f'<XsUri uri={self._uri}>'
+        return self._uri
 
 
 class ExternalReference:
@@ -416,8 +424,19 @@ def get_url(self) -> str:
         """
         return self._url
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, ExternalReference):
+            return hash(other) == hash(self)
+        return False
+
+    def __hash__(self) -> int:
+        return hash((
+            self._type, self._url, self._comment,
+            tuple([hash(hash_) for hash_ in set(self._hashes)]) if self._hashes else None
+        ))
+
     def __repr__(self) -> str:
-        return f'<ExternalReference {self._type.name}, {self._url}> {self._hashes}'
+        return f'<ExternalReference {self._type.name}, {self._url}>'
 
 
 class License:
@@ -503,6 +522,17 @@ def url(self) -> Optional[XsUri]:
     def url(self, url: Optional[XsUri]) -> None:
         self._url = url
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, License):
+            return hash(other) == hash(self)
+        return False
+
+    def __hash__(self) -> int:
+        return hash((self.id, self.name, self.text, self.url))
+
+    def __repr__(self) -> str:
+        return f'<License id={self.id}, name={self.name}>'
+
 
 class LicenseChoice:
     """
@@ -559,6 +589,17 @@ def expression(self) -> Optional[str]:
     def expression(self, expression: Optional[str]) -> None:
         self._expression = expression
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, LicenseChoice):
+            return hash(other) == hash(self)
+        return False
+
+    def __hash__(self) -> int:
+        return hash((self.license, self.expression))
+
+    def __repr__(self) -> str:
+        return f'<LicenseChoice license={self.license}, expression={self.expression}>'
+
 
 class Property:
     """

cyclonedx/model/component.py

@@ -26,8 +26,8 @@
 # See https://github.com/package-url/packageurl-python/issues/65
 from packageurl import PackageURL  # type: ignore
 
-from . import AttachedText, ExternalReference, HashAlgorithm, HashType, LicenseChoice, OrganizationalEntity, Property, \
-    sha1sum, XsUri, IdentifiableAction, Copyright
+from . import AttachedText, Copyright, ExternalReference, HashAlgorithm, HashType, IdentifiableAction, LicenseChoice, \
+    OrganizationalEntity, Property, sha1sum, XsUri
 from .issue import IssueType
 from .release_note import ReleaseNotes
 from .vulnerability import Vulnerability
@@ -151,6 +151,11 @@ class ComponentEvidence:
 
     def __init__(self, licenses: Optional[List[LicenseChoice]] = None,
                  copyright_: Optional[List[Copyright]] = None) -> None:
+        if not licenses and not copyright_:
+            raise NoPropertiesProvidedException(
+                'At least one of `licenses` or `copyright_` must be supplied for a `ComponentEvidence`.'
+            )
+
         self.licenses = licenses
         self.copyright = copyright_
 
@@ -372,7 +377,10 @@ def __eq__(self, other: object) -> bool:
         return False
 
     def __hash__(self) -> int:
-        return hash((hash(self.type), hash(self.diff), str(self.resolves)))
+        return hash((
+            hash(self.type), hash(self.diff),
+            tuple([hash(issue) for issue in set(self.resolves)]) if self.resolves else None
+        ))
 
     def __repr__(self) -> str:
         return f'<Patch type={self.type}, id={id(self)}>'
@@ -559,7 +567,11 @@ def __eq__(self, other: object) -> bool:
 
     def __hash__(self) -> int:
         return hash((
-            str(self.ancestors), str(self.descendants), str(self.variants), str(self.commits), str(self.patches),
+            tuple([hash(ancestor) for ancestor in set(self.ancestors)]) if self.ancestors else None,
+            tuple([hash(descendant) for descendant in set(self.descendants)]) if self.descendants else None,
+            tuple([hash(variant) for variant in set(self.variants)]) if self.variants else None,
+            tuple([hash(commit) for commit in set(self.commits)]) if self.commits else None,
+            tuple([hash(patch) for patch in set(self.patches)]) if self.patches else None,
             self.notes
         ))
 
@@ -1220,9 +1232,15 @@ def __eq__(self, other: object) -> bool:
 
     def __hash__(self) -> int:
         return hash((
-            self.author, self.copyright, self.description, str(self.external_references), self.group,
-            str(self.hashes), str(self.licenses), self.mime_type, self.name, str(self.properties), self.publisher,
-            self.purl, self.release_notes, self.scope, self.supplier, self.type, self.version, self.cpe
+            self.type, self.mime_type, self.supplier, self.author, self.publisher, self.group, self.name,
+            self.version, self.description, self.scope,
+            tuple([hash(hash_) for hash_ in set(self.hashes)]) if self.hashes else None,
+            tuple([hash(license_) for license_ in set(self.licenses)]) if self.licenses else None,
+            self.copyright, self.cpe, self.purl, self.swid, self.pedigree,
+            tuple([hash(ref) for ref in set(self.external_references)]) if self.external_references else None,
+            tuple([hash(prop) for prop in set(self.properties)]) if self.properties else None,
+            tuple([hash(component) for component in set(self.components)]) if self.components else None,
+            self.evidence, self.release_notes
         ))
 
     def __repr__(self) -> str:

cyclonedx/model/issue.py

@@ -78,6 +78,17 @@ def url(self) -> Optional[XsUri]:
     def url(self, url: Optional[XsUri]) -> None:
         self._url = url
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, IssueTypeSource):
+            return hash(other) == hash(self)
+        return False
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.url))
+
+    def __repr__(self) -> str:
+        return f'<IssueTypeSource name={self._name}, url={self.url}>'
+
 
 class IssueType:
     """
@@ -263,3 +274,17 @@ def set_source_url(self, source_url: XsUri) -> None:
             self._source.url = source_url
         else:
             self._source = IssueTypeSource(url=source_url)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, IssueType):
+            return hash(other) == hash(self)
+        return False
+
+    def __hash__(self) -> int:
+        return hash((
+            self._type, self._id, self._name, self._description, self._source,
+            tuple([hash(ref) for ref in set(self._references)]) if self._references else None
+        ))
+
+    def __repr__(self) -> str:
+        return f'<IssueType type={self._type}, id={self._id}, name={self._name}>'