tests: rename DecodeSample in DecodeTestSample

Author: dabrain34

tests/README.md

@@ -82,7 +82,7 @@ pytest tests/unit_tests/ -v -k "skip"
 | `test_cli.py` | CLI argument parsing and option handling |
 | `test_skip_list.py` | Skip list pattern matching and filtering |
 | `test_filter_suite.py` | Test suite filtering by codec, pattern, and skip rules |
-| `test_sample_configs.py` | Sample configuration classes (DecodeSample, EncodeTestSample) |
+| `test_sample_configs.py` | Sample configuration classes (DecodeTestSample, EncodeTestSample) |
 | `test_status_determination.py` | Return code to test status mapping |
 | `test_utils.py` | Utility functions (file hashing, checksum verification) |
 

tests/unit_tests/test_sample_configs.py

@@ -1,7 +1,7 @@
 """
 Unit tests for sample configuration classes.
 
-Tests DecodeSample, EncodeTestSample, and CodecType.
+Tests DecodeTestSample, EncodeTestSample, and CodecType.
 
 Copyright 2025 Igalia S.L.
 
@@ -21,7 +21,7 @@
 import pytest
 
 from tests.libs.video_test_config_base import CodecType, BaseTestConfig
-from tests.video_test_framework_decode import DecodeSample
+from tests.video_test_framework_decode import DecodeTestSample
 from tests.video_test_framework_encode import EncodeTestSample
 
 
@@ -48,11 +48,11 @@ def test_codec_type_invalid_string(self):
             CodecType("invalid")
 
 
-class TestDecodeSample:
-    """Tests for DecodeSample class"""
+class TestDecodeTestSample:
+    """Tests for DecodeTestSample class"""
 
     def test_from_dict_valid(self):
-        """Test creating DecodeSample from valid dictionary"""
+        """Test creating DecodeTestSample from valid dictionary"""
         data = {
             "name": "h264_test",
             "codec": "h264",
@@ -63,7 +63,7 @@ def test_from_dict_valid(self):
             "expected_output_md5": "def456",
         }
 
-        sample = DecodeSample.from_dict(data)
+        sample = DecodeTestSample.from_dict(data)
 
         assert sample.name == "h264_test"
         assert sample.codec == CodecType.H264
@@ -74,7 +74,7 @@ def test_from_dict_valid(self):
         assert sample.expected_output_md5 == "def456"
 
     def test_from_dict_optional_fields(self):
-        """Test creating DecodeSample with missing optional fields"""
+        """Test creating DecodeTestSample with missing optional fields"""
         data = {
             "name": "minimal_test",
             "codec": "av1",
@@ -83,7 +83,7 @@ def test_from_dict_optional_fields(self):
             "source_filepath": "video/test.ivf",
         }
 
-        sample = DecodeSample.from_dict(data)
+        sample = DecodeTestSample.from_dict(data)
 
         assert sample.name == "minimal_test"
         assert sample.codec == CodecType.AV1
@@ -102,11 +102,11 @@ def test_from_dict_missing_required_field(self):
         }
 
         with pytest.raises(KeyError):
-            DecodeSample.from_dict(data)
+            DecodeTestSample.from_dict(data)
 
     def test_display_name_prefix(self):
         """Test that display_name adds decode_ prefix"""
-        sample = DecodeSample(
+        sample = DecodeTestSample(
             name="h264_test",
             codec=CodecType.H264,
             source_url="",
@@ -119,12 +119,15 @@ def test_display_name_prefix(self):
     def test_display_name_different_codecs(self):
         """Test display_name with different codecs"""
         samples = [
-            DecodeSample(name="test", codec=CodecType.H264, source_url="",
-                         source_checksum="", source_filepath=""),
-            DecodeSample(name="test", codec=CodecType.H265, source_url="",
-                         source_checksum="", source_filepath=""),
-            DecodeSample(name="test", codec=CodecType.AV1, source_url="",
-                         source_checksum="", source_filepath=""),
+            DecodeTestSample(name="test", codec=CodecType.H264,
+                             source_url="", source_checksum="",
+                             source_filepath=""),
+            DecodeTestSample(name="test", codec=CodecType.H265,
+                             source_url="", source_checksum="",
+                             source_filepath=""),
+            DecodeTestSample(name="test", codec=CodecType.AV1,
+                             source_url="", source_checksum="",
+                             source_filepath=""),
         ]
 
         # All should have same display_name regardless of codec

tests/video_test_framework_decode.py

@@ -58,7 +58,7 @@
 
 @dataclass(init=False)
 # pylint: disable=too-many-instance-attributes
-class DecodeSample(BaseTestConfig):
+class DecodeTestSample(BaseTestConfig):
     """Configuration for decoder test cases with download capability"""
     expected_output_md5: str = ""  # Expected MD5 of decoded YUV output
 
@@ -76,7 +76,7 @@ def __init__(
         source_filepath: str = "",
         expected_output_md5: str = "",
     ):
-        """Initialize DecodeSample with all fields from base and child"""
+        """Initialize DecodeTestSample with all fields from base and child"""
         super().__init__(
             name=name,
             codec=codec,
@@ -91,8 +91,8 @@ def __init__(
         self.expected_output_md5 = expected_output_md5
 
     @classmethod
-    def from_dict(cls, data: dict) -> 'DecodeSample':
-        """Create a DecodeSample from a dictionary"""
+    def from_dict(cls, data: dict) -> 'DecodeTestSample':
+        """Create a DecodeTestSample from a dictionary"""
         return cls(
             name=data["name"],
             codec=CodecType(data["codec"]),
@@ -144,14 +144,14 @@ class VulkanVideoDecodeTestFramework(VulkanVideoTestFrameworkBase):
 
     def _load_decode_samples(
             self, json_file: str = "decode_samples.json"
-    ) -> List[DecodeSample]:
+    ) -> List[DecodeTestSample]:
         """Load decode samples from JSON configuration"""
         samples_data = load_samples_from_json(json_file, test_type="decode")
         samples = []
 
         for sample_data in samples_data:
             try:
-                sample = DecodeSample.from_dict(sample_data)
+                sample = DecodeTestSample.from_dict(sample_data)
                 samples.append(sample)
             except (KeyError, ValueError, TypeError) as e:
                 msg = (
@@ -182,7 +182,7 @@ def __init__(self, decoder_path: str = None, **options):
                 f"Decoder not found: {self.executable_path}")
 
     def check_resources(self, auto_download: bool = True,
-                        test_configs: List[DecodeSample] = None) -> bool:
+                        test_configs: List[DecodeTestSample] = None) -> bool:
         """Check if required resource files are available and have correct
         checksums
 
@@ -197,13 +197,13 @@ def check_resources(self, auto_download: bool = True,
                                       "decoder resource",
                                       auto_download)
 
-    def _run_decoder_test(self, config: DecodeSample) -> TestResult:
+    def _run_decoder_test(self, config: DecodeTestSample) -> TestResult:
         """Run decoder test for specified codec"""
         if not self.decoder_path:
             return create_error_result(config, "Decoder path not specified")
 
         # Use the sample file directly from the config
-        # (since DecodeSample now contains everything)
+        # (since DecodeTestSample now contains everything)
         input_file = config.full_path
 
         if not input_file.exists():
@@ -269,22 +269,22 @@ def create_test_suite(
         self,
         codec_filter: Optional[str] = None,
         test_pattern: Optional[str] = None,
-    ) -> List[DecodeSample]:
+    ) -> List[DecodeTestSample]:
         """Create test suite from samples with optional filtering"""
         # Use base class filtering method with skip list
         return self.filter_test_suite(
             self.decode_samples, codec_filter, test_pattern,
             self.skip_filter, test_format="vvs", test_type="decode"
         )
 
-    def run_single_test(self, config: DecodeSample) -> TestResult:
+    def run_single_test(self, config: DecodeTestSample) -> TestResult:
         """Run a single test case - implementation for base class"""
         result = self._run_decoder_test(config)
         self._validate_test_result(result)
         return result
 
     def run_test_suite(
-        self, test_configs: List[DecodeSample] = None
+        self, test_configs: List[DecodeTestSample] = None
     ) -> List[TestResult]:
         """Run complete test suite using base class implementation"""
         return self.run_test_suite_base(test_configs, test_type="decode")