New API: Comprehensive serialization testing

The idea of this commit is to separate (de)serialization testing outside
test_api.py and make sure we are testing from_dict/to_dict for all
possible valid data for all classes.

As a result of this commit, there will be a single place where
one can have a quick look at what use-cases are we testing for
(de)serialization.

Signed-off-by: Martin Vrachev <mvrachev@vmware.com>

Author: MVrachev

tests/test_api.py

@@ -260,27 +260,6 @@ def test_metafile_class(self):
         self.assertEqual(metafile_obj.to_dict(), data)
 
 
-    def test_targetfile_class(self):
-        # Test from_dict and to_dict with all attributes.
-        data = {
-            "custom": {
-                "file_permissions": "0644"
-            },
-            "hashes": {
-                "sha256": "65b8c67f51c993d898250f40aa57a317d854900b3a04895464313e48785440da",
-                "sha512": "467430a68afae8e9f9c0771ea5d78bf0b3a0d79a2d3d3b40c69fde4dd42c461448aef76fcef4f5284931a1ffd0ac096d138ba3a0d6ca83fa8d7285a47a296f77"
-            },
-            "length": 31
-        }
-        targetfile_obj = TargetFile.from_dict(copy.copy(data))
-        self.assertEqual(targetfile_obj.to_dict(), data)
-
-        # Test from_dict and to_dict without custom.
-        del data["custom"]
-        targetfile_obj = TargetFile.from_dict(copy.copy(data))
-        self.assertEqual(targetfile_obj.to_dict(), data)
-
-
     def test_metadata_snapshot(self):
         snapshot_path = os.path.join(
                 self.repo_dir, 'metadata', 'snapshot.json')
@@ -299,13 +278,6 @@ def test_metadata_snapshot(self):
             snapshot.signed.meta['role1.json'].to_dict(), fileinfo.to_dict()
         )
 
-        # Test from_dict and to_dict without hashes and length.
-        snapshot_dict = snapshot.to_dict()
-        del snapshot_dict['signed']['meta']['role1.json']['length']
-        del snapshot_dict['signed']['meta']['role1.json']['hashes']
-        test_dict = copy.deepcopy(snapshot_dict['signed'])
-        snapshot = Snapshot.from_dict(test_dict)
-        self.assertEqual(snapshot_dict['signed'], snapshot.to_dict())
 
     def test_metadata_timestamp(self):
         timestamp_path = os.path.join(
@@ -344,13 +316,6 @@ def test_metadata_timestamp(self):
             timestamp.signed.meta['snapshot.json'].to_dict(), fileinfo.to_dict()
         )
 
-        # Test from_dict and to_dict without hashes and length.
-        timestamp_dict = timestamp.to_dict()
-        del timestamp_dict['signed']['meta']['snapshot.json']['length']
-        del timestamp_dict['signed']['meta']['snapshot.json']['hashes']
-        test_dict = copy.deepcopy(timestamp_dict['signed'])
-        timestamp_test = Timestamp.from_dict(test_dict)
-        self.assertEqual(timestamp_dict['signed'], timestamp_test.to_dict())
 
     def test_key_class(self):
         keys = {
@@ -363,21 +328,12 @@ def test_key_class(self):
             },
         }
         for key_dict in keys.values():
-            # Testing that the workflow of deserializing and serializing
-            # a key dictionary doesn't change the content.
-            test_key_dict = key_dict.copy()
-            key_obj = Key.from_dict("id", test_key_dict)
-            self.assertEqual(key_dict, key_obj.to_dict())
             # Test creating an instance without a required attribute.
             for key in key_dict.keys():
                 test_key_dict = key_dict.copy()
                 del test_key_dict[key]
                 with self.assertRaises(KeyError):
-                    Key.from_dict("id", test_key_dict)
-            # Test creating a Key instance with wrong keyval format.
-            key_dict["keyval"] = {}
-            with self.assertRaises(ValueError):
-                Key.from_dict("id", key_dict)
+                    Key.from_dict(test_key_dict)
 
 
     def test_role_class(self):
@@ -396,23 +352,12 @@ def test_role_class(self):
             },
         }
         for role_dict in roles.values():
-            # Testing that the workflow of deserializing and serializing
-            # a role dictionary doesn't change the content.
-            test_role_dict = role_dict.copy()
-            role_obj = Role.from_dict(test_role_dict)
-            self.assertEqual(role_dict, role_obj.to_dict())
             # Test creating an instance without a required attribute.
             for role_attr in role_dict.keys():
                 test_role_dict = role_dict.copy()
                 del test_role_dict[role_attr]
                 with self.assertRaises(KeyError):
-                    Key.from_dict("id", test_role_dict)
-            # Test creating a Role instance with keyid dublicates.
-            # for keyid in role_dict["keyids"]:
-            role_dict["keyids"].append(role_dict["keyids"][0])
-            test_role_dict = role_dict.copy()
-            with self.assertRaises(ValueError):
-                Role.from_dict(test_role_dict)
+                    Key.from_dict(test_role_dict)
 
 
     def test_metadata_root(self):
@@ -459,84 +404,8 @@ def test_metadata_root(self):
         with self.assertRaises(KeyError):
             root.signed.remove_key('root', 'nosuchkey')
 
-        # Test serializing and deserializing without consistent_snapshot.
-        root_dict = root.to_dict()
-        del root_dict["signed"]["consistent_snapshot"]
-        root = Root.from_dict(copy.deepcopy(root_dict["signed"]))
-        self.assertEqual(root_dict["signed"], root.to_dict())
-
-    def test_delegated_role_class(self):
-        roles = [
-            {
-                "keyids": [
-                    "c8022fa1e9b9cb239a6b362bbdffa9649e61ad2cb699d2e4bc4fdf7930a0e64a"
-                ],
-                "name": "role1",
-                "paths": [
-                    "file3.txt"
-                ],
-                "terminating": False,
-                "threshold": 1
-            }
-        ]
-        for role in roles:
-            # Testing that the workflow of deserializing and serializing
-            # a delegation role dictionary doesn't change the content.
-            key_obj = DelegatedRole.from_dict(role.copy())
-            self.assertEqual(role, key_obj.to_dict())
-
-            # Test creating a DelegatedRole object with both "paths" and
-            # "path_hash_prefixes" set.
-            role["path_hash_prefixes"] = "foo"
-            with self.assertRaises(ValueError):
-                DelegatedRole.from_dict(role.copy())
-
-            # Test creating DelegatedRole only with "path_hash_prefixes" (an empty one)
-            del role["paths"]
-            role["path_hash_prefixes"] = []
-            role_obj = DelegatedRole.from_dict(role.copy())
-            self.assertEqual(role_obj.to_dict(), role)
-
-            # Test creating DelegatedRole only with "paths" (now an empty one)
-            del role["path_hash_prefixes"]
-            role["paths"] = []
-            role_obj = DelegatedRole.from_dict(role.copy())
-            self.assertEqual(role_obj.to_dict(), role)
-
-            # Test creating DelegatedRole without "paths" and
-            # "path_hash_prefixes" set
-            del role["paths"]
-            role_obj = DelegatedRole.from_dict(role.copy())
-            self.assertEqual(role_obj.to_dict(), role)
-
 
     def test_delegation_class(self):
-        roles = [
-                {
-                    "keyids": [
-                        "c8022fa1e9b9cb239a6b362bbdffa9649e61ad2cb699d2e4bc4fdf7930a0e64a"
-                    ],
-                    "name": "role1",
-                    "paths": [
-                        "file3.txt"
-                    ],
-                    "terminating": False,
-                    "threshold": 1
-                }
-            ]
-        keys = {
-                "59a4df8af818e9ed7abe0764c0b47b4240952aa0d179b5b78346c470ac30278d":{
-                    "keytype": "ed25519",
-                    "keyval": {
-                        "public": "edcd0a32a07dce33f7c7873aaffbff36d20ea30787574ead335eefd337e4dacd"
-                    },
-                    "scheme": "ed25519"
-                },
-            }
-        delegations_dict = {"keys": keys, "roles": roles}
-        delegations = Delegations.from_dict(copy.deepcopy(delegations_dict))
-        self.assertEqual(delegations_dict, delegations.to_dict())
-
         # empty keys and roles
         delegations_dict = {"keys":{}, "roles":[]}
         delegations = Delegations.from_dict(delegations_dict.copy())