fix: Update corrupted file (#120)

* fix: Add a test

* fix: Add a debug test for CAWG

* fix: Fix corrupted file

* fix: Cleaning up

* fix: Fix non-threaded tests

* fix: unrandomize test

* fix: Improve test sensitivity

* fix: Improve comment

Author: tmathern

tests/fixtures/files-for-reading-tests/C_with_CAWG_data.jpg

@@ -212,6 +212,30 @@ def test_read_all_files_using_extension(self):
             except Exception as e:
                 self.fail(f"Failed to read metadata from {filename}: {str(e)}")
 
+    def test_read_cawg_data_file(self):
+        """Test reading C2PA metadata from C_with_CAWG_data.jpg file."""
+        file_path = os.path.join(self.data_dir, "files-for-reading-tests", "C_with_CAWG_data.jpg")
+
+        with open(file_path, "rb") as file:
+            reader = Reader("image/jpeg", file)
+            json_data = reader.json()
+            self.assertIsInstance(json_data, str)
+
+            # Parse the JSON and verify specific fields
+            manifest_data = json.loads(json_data)
+
+            # Verify basic manifest structure
+            self.assertIn("manifests", manifest_data)
+            self.assertIn("active_manifest", manifest_data)
+
+            # Get the active manifest
+            active_manifest_id = manifest_data["active_manifest"]
+            active_manifest = manifest_data["manifests"][active_manifest_id]
+
+            # Verify manifest is not null or empty
+            assert active_manifest is not None, "Active manifest should not be null"
+            assert len(active_manifest) > 0, "Active manifest should not be empty"
+
 
 class TestBuilder(unittest.TestCase):
     def setUp(self):

tests/test_unit_tests.py

@@ -2096,57 +2096,40 @@ def add_ingredient(ingredient_json, thread_id):
         builder.close()
 
     def test_builder_sign_with_multiple_ingredient_random_many_threads(self):
-        """Test Builder class operations with 10 threads, each adding 3 random ingredients and signing a random file."""
+        """Test Builder class operations with 12 threads, each adding 3 specific ingredients and signing a file."""
         # Number of threads to use in the test
-        # We are pushing it here, as we want to test with thread count one to two orders of magnitude
-        # higher than "usual" max numbers of cores on (server) machines may be.
-
         TOTAL_THREADS_USED = 12
 
-        # Get list of files from files-for-reading-tests directory
-        reading_dir = os.path.join(self.data_dir, "files-for-reading-tests")
-
-        # Filter for JPG and PNG files only
-        all_files = [
-            f for f in os.listdir(reading_dir)
-            if os.path.isfile(os.path.join(reading_dir, f))
-            and os.path.splitext(f)[1].lower() in {'.jpg', '.jpeg', '.png'}
+        # Define the specific files to use as ingredients
+        # THose files should be valid to use as ingredient
+        ingredient_files = [
+            os.path.join(self.data_dir, "A_thumbnail.jpg"),
+            os.path.join(self.data_dir, "C.jpg"),
+            os.path.join(self.data_dir, "cloud.jpg")
         ]
 
-        # Ensure we have enough files
-        self.assertGreaterEqual(
-            len(all_files),
-            3,
-            "Need at least 3 JPG/PNG files for testing")
-
         # Thread synchronization
         thread_results = {}
         completed_threads = 0
+        thread_lock = threading.Lock()  # Lock for thread-safe access to shared data
 
         def thread_work(thread_id):
             nonlocal completed_threads
             try:
                 # Create a new builder for this thread
                 builder = Builder.from_json(self.manifestDefinition)
 
-                # Select 3 random files for ingredients
-                # Use thread_id as seed for reproducibility
-                random.seed(thread_id)
-                ingredient_files = random.sample(all_files, 3)
-
                 # Add each ingredient
-                for i, file_name in enumerate(ingredient_files, 1):
-                    file_path = os.path.join(reading_dir, file_name)
+                for i, file_path in enumerate(ingredient_files, 1):
                     ingredient_json = json.dumps({
-                        "title": f"Thread {thread_id} Ingredient {i} - {file_name}"
+                        "title": f"Thread {thread_id} Ingredient {i} - {os.path.basename(file_path)}"
                     })
 
                     with open(file_path, 'rb') as f:
                         builder.add_ingredient(ingredient_json, "image/jpeg", f)
 
-                # Select a random file for signing
-                sign_file = random.choice(all_files)
-                sign_file_path = os.path.join(reading_dir, sign_file)
+                # Use A.jpg as the file to sign
+                sign_file_path = os.path.join(self.data_dir, "A.jpg")
 
                 # Sign the file
                 with open(sign_file_path, "rb") as file:
@@ -2168,11 +2151,13 @@ def thread_work(thread_id):
                     manifest_data = json.loads(json_data)
 
                     # Store results for verification
-                    thread_results[thread_id] = {
-                        'manifest': manifest_data,
-                        'ingredient_files': ingredient_files,
-                        'sign_file': sign_file
-                    }
+                    with thread_lock:
+                        thread_results[thread_id] = {
+                            'manifest': manifest_data,
+                            'ingredient_files': [os.path.basename(f) for f in ingredient_files],
+                            'sign_file': os.path.basename(sign_file_path),
+                            'manifest_hash': hash(json.dumps(manifest_data, sort_keys=True))  # Add hash for comparison
+                        }
 
                     # Clean up streams
                     output.close()
@@ -2181,11 +2166,13 @@ def thread_work(thread_id):
                 builder.close()
 
             except Exception as e:
-                thread_results[thread_id] = {
-                    'error': str(e)
-                }
+                with thread_lock:
+                    thread_results[thread_id] = {
+                        'error': str(e)
+                    }
             finally:
-                completed_threads += 1
+                with thread_lock:
+                    completed_threads += 1
 
         # Create and start threads
         threads = []
@@ -2199,26 +2186,31 @@ def thread_work(thread_id):
             thread.join()
 
         # Verify all threads completed
-        self.assertEqual(completed_threads, TOTAL_THREADS_USED, f"All {
-                         TOTAL_THREADS_USED} threads should have completed")
+        self.assertEqual(completed_threads, TOTAL_THREADS_USED, f"All {TOTAL_THREADS_USED} threads should have completed")
         self.assertEqual(
             len(thread_results),
             TOTAL_THREADS_USED,
             f"Should have results from all {TOTAL_THREADS_USED} threads")
 
+        # Collect all manifest hashes for comparison
+        manifest_hashes = set()
+        thread_manifest_data = {}
+
         # Verify results for each thread
         for thread_id in range(1, TOTAL_THREADS_USED + 1):
             result = thread_results[thread_id]
 
             # Check if thread encountered an error
             if 'error' in result:
-                self.fail(
-                    f"Thread {thread_id} failed with error: {
-                        result['error']}")
+                self.fail(f"Thread {thread_id} failed with error: {result['error']}")
 
             manifest_data = result['manifest']
             ingredient_files = result['ingredient_files']
-            sign_file = result['sign_file']
+            manifest_hash = result['manifest_hash']
+
+            # Store manifest data for cross-thread comparison
+            thread_manifest_data[thread_id] = manifest_data
+            manifest_hashes.add(manifest_hash)
 
             # Verify active manifest exists
             self.assertIn("active_manifest", manifest_data)
@@ -2234,16 +2226,44 @@ def thread_work(thread_id):
             self.assertIsInstance(active_manifest["ingredients"], list)
             self.assertEqual(len(active_manifest["ingredients"]), 3)
 
-            # Verify all ingredients exist with correct thread ID and file
-            # names
-            ingredient_titles = [ing["title"]
-                                 for ing in active_manifest["ingredients"]]
+            # Verify all ingredients exist with correct thread ID and file names
+            ingredient_titles = [ing["title"] for ing in active_manifest["ingredients"]]
             for i, file_name in enumerate(ingredient_files, 1):
-                expected_title = f"Thread {
-                    thread_id} Ingredient {i} - {file_name}"
-                self.assertIn(expected_title, ingredient_titles, f"Thread {
-                              thread_id} should have ingredient with title {expected_title}")
+                expected_title = f"Thread {thread_id} Ingredient {i} - {file_name}"
+                self.assertIn(expected_title, ingredient_titles, f"Thread {thread_id} should have ingredient with title {expected_title}")
+
+            # Verify no cross-thread contamination in ingredient titles
+            for other_thread_id in range(1, TOTAL_THREADS_USED + 1):
+                if other_thread_id != thread_id:
+                    for title in ingredient_titles:
+                        # Check for exact thread ID pattern to avoid false positives
+                        self.assertNotIn(
+                            f"Thread {other_thread_id} Ingredient",
+                            title,
+                            f"Thread {thread_id}'s manifest contains ingredient data from thread {other_thread_id}")
+
+        # Verify all manifests are unique (no data scrambling between threads)
+        self.assertEqual(
+            len(manifest_hashes),
+            TOTAL_THREADS_USED,
+            "Each thread should have a unique manifest (no data scrambling)")
 
+        # Additional verification: Compare manifest structures between threads
+        for thread_id in range(1, TOTAL_THREADS_USED + 1):
+            current_manifest = thread_manifest_data[thread_id]
+
+            # Verify manifest structure is consistent
+            self.assertIn("active_manifest", current_manifest)
+            self.assertIn("manifests", current_manifest)
+
+            # Verify no cross-thread contamination in manifest data
+            for other_thread_id in range(1, TOTAL_THREADS_USED + 1):
+                if other_thread_id != thread_id:
+                    other_manifest = thread_manifest_data[other_thread_id]
+                    self.assertNotEqual(
+                        current_manifest["active_manifest"],
+                        other_manifest["active_manifest"],
+                        f"Thread {thread_id} and {other_thread_id} share the same active manifest ID")
 
 if __name__ == '__main__':
     unittest.main()