New API: add TargetFile class

Add a new TargetFile class to tuf.api.metadata module make Targets
class to use it.
This class will contain information about the "targets" field
from targets.json

Also, update the tests for that change.

Signed-off-by: Martin Vrachev <[email protected]>

Author: MVrachev

tests/test_api.py

@@ -37,7 +37,8 @@ def setUpModule():
         Root,
         Snapshot,
         Timestamp,
-        Targets
+        Targets,
+        TargetFile
     )
 
     from securesystemslib.interface import (
@@ -333,8 +334,9 @@ def test_metadata_targets(self):
         self.assertNotEqual(targets.signed.targets[filename], fileinfo)
         # Update an already existing fileinfo
         targets.signed.update(filename, fileinfo)
+        expected_target_file = TargetFile(length=28, hashes=hashes)
         # Verify that data is updated
-        self.assertEqual(targets.signed.targets[filename], fileinfo)
+        self.assertEqual(targets.signed.targets[filename], expected_target_file)
 
 # Run unit test.
 if __name__ == '__main__':

tuf/api/metadata.py

@@ -566,22 +566,74 @@ def update(
         self.meta[metadata_fn] = MetaFile(version, length, hashes)
 
 
+class TargetFile:
+    """A container with information about a particilur target file.
+    Instances of TargetFile are used as values in a dictionary
+    called "targets" in Targets.
+
+        targets: A dictionary that contains information about target files::
+            {
+                'target_file_path_1': <TargetFile INSTANCE_1>,
+                'target_file_path_2': <TargetFile INSTANCE_2>,
+                ...
+            }
+    Attributes:
+        length: An integer indicating the length of the target file.
+        hashes: An dictionary containing hash algorithms and the
+            hashes resulted from applying them over the target file::
+                'hashes': {
+                    '<HASH ALGO 1>': '<TARGET FILE HASH 1>',
+                    '<HASH ALGO 2>': '<TARGET FILE HASH 2>',
+                    ...
+                }
+        custom: An optional dictionary which may include version numbers,
+            dependencies, or any other data that the application wants
+            to include to describe the target file::
+                'custom': {
+                    'type': 'metadata',
+                    'file_permissions': '0644',
+                    ...
+                } // optional
+
+    """
+
+    def __init__(self, length: int, hashes: JsonDict,
+            custom: Optional[JsonDict] = None) -> None:
+        self.length = length
+        self.hashes = hashes
+        self.custom = custom
+
+
+    def __eq__(self, other: Any) -> bool:
+        """Used to compare objects by their values instead of by their
+        addresses."""
+        if not isinstance(other, TargetFile):
+            # don't attempt to compare against unrelated types
+            return NotImplemented
+
+        return self.length == other.length and \
+            self.hashes == other.hashes and \
+            self.custom == other.custom
+
+
+    def to_dict(self) -> JsonDict:
+        """Returns the JSON-serializable dictionary representation of self. """
+        json_dict = {'length': self.length, 'hashes': self.hashes}
+
+        if self.custom is not None:
+            json_dict['custom'] = self.custom
+
+        return json_dict
+
+
 class Targets(Signed):
     """A container for the signed part of targets metadata.
 
     Attributes:
         targets: A dictionary that contains information about target files::
 
             {
-                '<TARGET FILE NAME>': {
-                    'length': <TARGET FILE SIZE>,
-                    'hashes': {
-                        '<HASH ALGO 1>': '<TARGET FILE HASH 1>',
-                        '<HASH ALGO 2>': '<TARGETS FILE HASH 2>',
-                        ...
-                    },
-                    'custom': <CUSTOM OPAQUE DICT> // optional
-                },
+                '<TARGET FILE NAME>': <TargetFile INSTANCE>,
                 ...
             }
 
@@ -628,22 +680,32 @@ def __init__(
             expires: datetime, targets: JsonDict, delegations: JsonDict
             ) -> None:
         super().__init__(_type, version, spec_version, expires)
-        # TODO: Add class for meta
-        self.targets = targets
+
+        self.targets = {}
+        for target_path, target_dict in targets.items():
+            self.targets[target_path] = TargetFile(target_dict['length'],
+                target_dict['hashes'], target_dict.get('custom'))
+
+        # TO DO: Add Key and Role classes
         self.delegations = delegations
 
 
     # Serialization.
     def to_dict(self) -> JsonDict:
         """Returns the JSON-serializable dictionary representation of self. """
         json_dict = super().to_dict()
+        target_dict = {}
+        for target_path, target_file_obj in self.targets.items():
+            target_dict[target_path] = target_file_obj.to_dict()
+
         json_dict.update({
-            'targets': self.targets,
+            'targets': target_dict,
             'delegations': self.delegations,
         })
         return json_dict
 
     # Modification.
     def update(self, filename: str, fileinfo: JsonDict) -> None:
         """Assigns passed target file info to meta dict. """
-        self.targets[filename] = fileinfo
+        self.targets[filename] = TargetFile(fileinfo['length'],
+            fileinfo['hashes'], fileinfo.get('custom'))