Made the dicts being serialized ordered.

Signed-off-by: KOLANICH <[email protected]>

Author: KOLANICH

tuf/api/metadata.py

@@ -138,7 +138,9 @@ def __init__(
         if unrecognized_fields is None:
             unrecognized_fields = {}
 
-        self.unrecognized_fields = unrecognized_fields
+        self.unrecognized_fields = type(unrecognized_fields)(
+            sorted(unrecognized_fields.items(), key=lambda x: x[0])
+        )
 
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, Metadata):
@@ -293,7 +295,7 @@ def to_bytes(
 
         return serializer.serialize(self)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> Mapping[str, Any]:
         """Returns the dict representation of self."""
 
         signatures = [sig.to_dict() for sig in self.signatures.values()]
@@ -582,7 +584,7 @@ def _common_fields_from_dict(
 
         return version, spec_version, expires
 
-    def _common_fields_to_dict(self) -> Dict[str, Any]:
+    def _common_fields_to_dict(self) -> Mapping[str, Any]:
         """Returns dict representation of common fields of ``Signed`` instances.
 
         See ``{Root, Timestamp, Snapshot, Targets}.to_dict`` methods for usage.
@@ -682,7 +684,7 @@ def from_dict(cls, keyid: str, key_dict: Dict[str, Any]) -> "Key":
         # All fields left in the key_dict are unrecognized.
         return cls(keyid, keytype, scheme, keyval, key_dict)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> Mapping[str, Any]:
         """Returns the dictionary representation of self."""
         return {
             "keytype": self.keytype,
@@ -840,7 +842,7 @@ def from_dict(cls, role_dict: Dict[str, Any]) -> "Role":
         # All fields left in the role_dict are unrecognized.
         return cls(keyids, threshold, role_dict)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> Mapping[str, Any]:
         """Returns the dictionary representation of self."""
         return {
             "keyids": self.keyids,
@@ -927,12 +929,15 @@ def from_dict(cls, signed_dict: Dict[str, Any]) -> "Root":
         # All fields left in the signed_dict are unrecognized.
         return cls(*common_args, keys, roles, consistent_snapshot, signed_dict)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> Mapping[str, Any]:
         """Returns the dict representation of self."""
         root_dict = self._common_fields_to_dict()
-        keys = {keyid: key.to_dict() for (keyid, key) in self.keys.items()}
+        keys = {
+            keyid: key.to_dict()
+            for (keyid, key) in sorted(self.keys.items(), key=lambda x: x[0])
+        }
         roles = {}
-        for role_name, role in self.roles.items():
+        for role_name, role in sorted(self.roles.items(), key=lambda x: x[0]):
             roles[role_name] = role.to_dict()
         if self.consistent_snapshot is not None:
             root_dict["consistent_snapshot"] = self.consistent_snapshot
@@ -1274,11 +1279,13 @@ def from_dict(cls, signed_dict: Dict[str, Any]) -> "Snapshot":
         # All fields left in the snapshot_dict are unrecognized.
         return cls(*common_args, meta, signed_dict)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> Mapping[str, Any]:
         """Returns the dict representation of self."""
         snapshot_dict = self._common_fields_to_dict()
         meta_dict = {}
-        for meta_path, meta_info in self.meta.items():
+        for meta_path, meta_info in sorted(
+            self.meta.items(), key=lambda x: x[0]
+        ):
             meta_dict[meta_path] = meta_info.to_dict()
 
         snapshot_dict["meta"] = meta_dict
@@ -1695,9 +1702,12 @@ def from_dict(cls, delegations_dict: Dict[str, Any]) -> "Delegations":
         # All fields left in the delegations_dict are unrecognized.
         return cls(keys_res, roles_res, succinct_roles_info, delegations_dict)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> Mapping[str, Any]:
         """Returns the dict representation of self."""
-        keys = {keyid: key.to_dict() for keyid, key in self.keys.items()}
+        keys = {
+            keyid: key.to_dict()
+            for keyid, key in sorted(self.keys.items(), key=lambda x: x[0])
+        }
         res_dict: Dict[str, Any] = {
             "keys": keys,
             **self.unrecognized_fields,
@@ -1967,11 +1977,13 @@ def from_dict(cls, signed_dict: Dict[str, Any]) -> "Targets":
         # All fields left in the targets_dict are unrecognized.
         return cls(*common_args, res_targets, delegations, signed_dict)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> Mapping[str, Any]:
         """Returns the dict representation of self."""
         targets_dict = self._common_fields_to_dict()
         targets = {}
-        for target_path, target_file_obj in self.targets.items():
+        for target_path, target_file_obj in sorted(
+            self.targets.items(), key=lambda x: x[0]
+        ):
             targets[target_path] = target_file_obj.to_dict()
         targets_dict[_TARGETS] = targets
         if self.delegations is not None: