Use decorator in test_updater_with_simulator

Reuse the decorator defined in tests/utils.py in order
to receive more helpful messages when an assertion
fails in test_tragets().

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

Author: MVrachev

tests/test_updater_with_simulator.py

@@ -10,7 +10,7 @@
 import os
 import sys
 import tempfile
-from typing import Optional
+from typing import Dict, NamedTuple, Optional, Tuple
 from tuf.exceptions import UnsignedMetadataError
 import unittest
 
@@ -19,6 +19,13 @@
 from tests import utils
 from tests.repository_simulator import RepositorySimulator
 
+class TargetData(NamedTuple):
+    targetpath: str
+    content: str
+    encoded_path: str
+
+DataSet = Dict[str, TargetData]
+
 class TestUpdater(unittest.TestCase):
     # set dump_dir to trigger repository state dumps
     dump_dir:Optional[str] = None
@@ -79,43 +86,45 @@ def test_refresh(self):
 
         self._run_refresh()
 
-    def test_targets(self):
-        targets = {
-            "targetpath": b"content",
-            "åäö": b"more content",
-            "dir/targetpath": b"dir target content"
-        }
+    targets: DataSet = {
+        "standard case": ("targetpath", b"content", "targetpath"),
+        "non-asci case": ("åäö", b"more content", "%C3%A5%C3%A4%C3%B6"),
+        "subdirectory case": ("a/b/c/targetpath", b"dir target content", "a%2Fb%2Fc%2Ftargetpath"),
+    }
+
+    @utils.run_sub_tests_with_dataset(targets)
+    def test_targets(self, test_case_data: TargetData):
+        targetpath, content, encoded_path = test_case_data
+        # target does not exist yet
+        updater = self._run_refresh()
+        self.assertIsNone(updater.get_one_valid_targetinfo(targetpath))
 
         # Add targets to repository
         self.sim.targets.version += 1
-        for targetpath, content in targets.items():
-            self.sim.add_target("targets", content, targetpath)
+        self.sim.add_target("targets", content, targetpath)
         self.sim.update_snapshot()
 
         updater = self._run_refresh()
-        for targetpath, content in targets.items():
-            # target now exists, is not in cache yet
-            file_info = updater.get_one_valid_targetinfo(targetpath)
-            self.assertIsNotNone(file_info)
-            self.assertEqual(
-                updater.updated_targets([file_info], self.targets_dir),
-                [file_info]
-            )
-
-            # download target, assert it is in cache and content is correct
-            local_path = updater.download_target(file_info, self.targets_dir)
-            self.assertEqual(
-                updater.updated_targets([file_info], self.targets_dir), []
-            )
-            self.assertTrue(local_path.startswith(self.targets_dir))
-            with open(local_path, "rb") as f:
-                self.assertEqual(f.read(), content)
-
-            if "/" in targetpath:
-                # assert local_path != targetpath because of the URL encoding
-                # make target_path absolute as local_path
-                target_path = os.path.join(self.targets_dir, targetpath)
-                self.assertNotEqual(target_path, local_path)
+        # target now exists, is not in cache yet
+        file_info = updater.get_one_valid_targetinfo(targetpath)
+        self.assertIsNotNone(file_info)
+        self.assertEqual(
+            updater.updated_targets([file_info], self.targets_dir),
+            [file_info]
+        )
+
+        # download target, assert it is in cache and content is correct
+        local_path = updater.download_target(file_info, self.targets_dir)
+        self.assertEqual(
+            updater.updated_targets([file_info], self.targets_dir), []
+        )
+        self.assertTrue(local_path.startswith(self.targets_dir))
+        with open(local_path, "rb") as f:
+            self.assertEqual(f.read(), content)
+
+        # Assert that the targetpath was URL encoded as expected.
+        encoded_absolute_path = os.path.join(self.targets_dir, encoded_path)
+        self.assertEqual(local_path, encoded_absolute_path)
 
 
 

tests/utils.py

@@ -49,8 +49,8 @@
 # (where N is number of items in dataset), feeding the actual test
 # function one test case at a time
 def run_sub_tests_with_dataset(dataset: DataSet):
-    def real_decorator(function: Callable[["unittest.TestCase", Any], None]):
-        def wrapper(test_cls: "unittest.TestCase"):
+    def real_decorator(function: Callable[[unittest.TestCase, Any], None]):
+        def wrapper(test_cls: unittest.TestCase):
             for case, data in dataset.items():
                 with test_cls.subTest(case=case):
                     function(test_cls, data)