fix: refactor

Author: tmathern

tests/test_unit_tests_threaded.py

@@ -1818,203 +1818,6 @@ async def run_async_tests():
         # Verify all readers completed
         self.assertEqual(active_readers, 0, "Not all readers completed")
 
-    def test_builder_sign_with_multiple_ingredients_from_stream(self):
-        """Test Builder class operations with multiple ingredients using streams."""
-        # Test creating builder from JSON
-        builder = Builder.from_json(self.manifestDefinition)
-        assert builder._handle is not None
-
-        # Thread synchronization
-        add_errors = []
-        add_lock = threading.Lock()
-        completed_threads = 0
-        completion_lock = threading.Lock()
-
-        def add_ingredient_from_stream(ingredient_json, file_path, thread_id):
-            nonlocal completed_threads
-            try:
-                with open(file_path, 'rb') as f:
-                    builder.add_ingredient_from_stream(
-                        ingredient_json, "image/jpeg", f)
-                with add_lock:
-                    add_errors.append(None)  # Success case
-            except Exception as e:
-                with add_lock:
-                    add_errors.append(f"Thread {thread_id} error: {str(e)}")
-            finally:
-                with completion_lock:
-                    completed_threads += 1
-
-        # Create and start two threads for parallel ingredient addition
-        thread1 = threading.Thread(
-            target=add_ingredient_from_stream,
-            args=('{"title": "Test Ingredient Stream 1"}', self.testPath3, 1)
-        )
-        thread2 = threading.Thread(
-            target=add_ingredient_from_stream,
-            args=('{"title": "Test Ingredient Stream 2"}', self.testPath4, 2)
-        )
-
-        # Start both threads
-        thread1.start()
-        thread2.start()
-
-        # Wait for both threads to complete
-        thread1.join()
-        thread2.join()
-
-        # Check for errors during ingredient addition
-        if any(error for error in add_errors if error is not None):
-            self.fail(
-                "\n".join(
-                    error for error in add_errors if error is not None))
-
-        # Verify both ingredients were added successfully
-        self.assertEqual(
-            completed_threads,
-            2,
-            "Both threads should have completed")
-        self.assertEqual(
-            len(add_errors),
-            2,
-            "Both threads should have completed without errors")
-
-        # Now sign the manifest with the added ingredients
-        with open(self.testPath2, "rb") as file:
-            output = io.BytesIO(bytearray())
-            builder.sign(self.signer, "image/jpeg", file, output)
-            output.seek(0)
-            reader = Reader("image/jpeg", output)
-            json_data = reader.json()
-            manifest_data = json.loads(json_data)
-
-            # Verify active manifest exists
-            self.assertIn("active_manifest", manifest_data)
-            active_manifest_id = manifest_data["active_manifest"]
-
-            # Verify active manifest object exists
-            self.assertIn("manifests", manifest_data)
-            self.assertIn(active_manifest_id, manifest_data["manifests"])
-            active_manifest = manifest_data["manifests"][active_manifest_id]
-
-            # Verify ingredients array exists in active manifest
-            self.assertIn("ingredients", active_manifest)
-            self.assertIsInstance(active_manifest["ingredients"], list)
-            self.assertEqual(len(active_manifest["ingredients"]), 2)
-
-            # Verify both ingredients exist in the array (order doesn't matter)
-            ingredient_titles = [ing["title"]
-                                 for ing in active_manifest["ingredients"]]
-            self.assertIn("Test Ingredient Stream 1", ingredient_titles)
-            self.assertIn("Test Ingredient Stream 2", ingredient_titles)
-
-        builder.close()
-
-    def test_builder_sign_with_same_ingredient_multiple_times(self):
-        """Test Builder class operations with the same ingredient added multiple times from different threads."""
-        # Test creating builder from JSON
-        builder = Builder.from_json(self.manifestDefinition)
-        assert builder._handle is not None
-
-        # Thread synchronization
-        add_errors = []
-        add_lock = threading.Lock()
-        completed_threads = 0
-        completion_lock = threading.Lock()
-
-        def add_ingredient(ingredient_json, thread_id):
-            nonlocal completed_threads
-            try:
-                with open(self.testPath3, 'rb') as f:
-                    builder.add_ingredient(ingredient_json, "image/jpeg", f)
-                with add_lock:
-                    add_errors.append(None)  # Success case
-            except Exception as e:
-                with add_lock:
-                    add_errors.append(f"Thread {thread_id} error: {str(e)}")
-            finally:
-                with completion_lock:
-                    completed_threads += 1
-
-        # Create and start 5 threads for parallel ingredient addition
-        threads = []
-        for i in range(1, 6):
-            # Create unique manifest JSON for each thread
-            ingredient_json = json.dumps({
-                "title": f"Test Ingredient Thread {i}"
-            })
-
-            thread = threading.Thread(
-                target=add_ingredient,
-                args=(ingredient_json, i)
-            )
-            threads.append(thread)
-            thread.start()
-
-        # Wait for all threads to complete
-        for thread in threads:
-            thread.join()
-
-        # Check for errors during ingredient addition
-        if any(error for error in add_errors if error is not None):
-            self.fail(
-                "\n".join(
-                    error for error in add_errors if error is not None))
-
-        # Verify all ingredients were added successfully
-        self.assertEqual(
-            completed_threads,
-            5,
-            "All 5 threads should have completed")
-        self.assertEqual(
-            len(add_errors),
-            5,
-            "All 5 threads should have completed without errors")
-
-        # Now sign the manifest with the added ingredients
-        with open(self.testPath2, "rb") as file:
-            output = io.BytesIO(bytearray())
-            builder.sign(self.signer, "image/jpeg", file, output)
-            output.seek(0)
-            reader = Reader("image/jpeg", output)
-            json_data = reader.json()
-            manifest_data = json.loads(json_data)
-
-            # Verify active manifest exists
-            self.assertIn("active_manifest", manifest_data)
-            active_manifest_id = manifest_data["active_manifest"]
-
-            # Verify active manifest object exists
-            self.assertIn("manifests", manifest_data)
-            self.assertIn(active_manifest_id, manifest_data["manifests"])
-            active_manifest = manifest_data["manifests"][active_manifest_id]
-
-            # Verify ingredients array exists in active manifest
-            self.assertIn("ingredients", active_manifest)
-            self.assertIsInstance(active_manifest["ingredients"], list)
-            self.assertEqual(len(active_manifest["ingredients"]), 5)
-
-            # Verify all ingredients exist in the array with correct thread IDs
-            # and unique metadata
-            ingredient_titles = [ing["title"]
-                                 for ing in active_manifest["ingredients"]]
-
-            # Check that we have 5 unique titles
-            self.assertEqual(len(set(ingredient_titles)), 5,
-                             "Should have 5 unique ingredient titles")
-
-            # Verify each thread's ingredient exists with correct metadata
-            for i in range(1, 6):
-                # Find ingredients with this thread ID
-                thread_ingredients = [ing for ing in active_manifest["ingredients"]
-                                      if ing["title"] == f"Test Ingredient Thread {i}"]
-                self.assertEqual(
-                    len(thread_ingredients),
-                    1,
-                    f"Should find exactly one ingredient for thread {i}")
-
-        builder.close()
-
     def test_builder_sign_with_multiple_ingredient_random_many_threads(self):
         """Test Builder class operations with 12 threads, each adding 3 specific ingredients and signing a file."""
         # Number of threads to use in the test
@@ -2857,118 +2660,6 @@ async def run_async_tests():
             self.fail("\n".join(read_errors))
         self.assertEqual(active_readers, 0)
 
-    def test_builder_sign_with_multiple_ingredients_from_stream(self):
-        """Test Builder with multiple ingredients from streams using context APIs"""
-        ctx = Context()
-        builder = Builder.from_json(self.manifestDefinition, context=ctx)
-        assert builder._handle is not None
-        add_errors = []
-        add_lock = threading.Lock()
-        completed_threads = 0
-        completion_lock = threading.Lock()
-
-        def add_ingredient_from_stream(ingredient_json, file_path, thread_id):
-            nonlocal completed_threads
-            try:
-                with open(file_path, 'rb') as f:
-                    builder.add_ingredient_from_stream(ingredient_json, "image/jpeg", f)
-                with add_lock:
-                    add_errors.append(None)
-            except Exception as e:
-                with add_lock:
-                    add_errors.append(f"Thread {thread_id} error: {str(e)}")
-            finally:
-                with completion_lock:
-                    completed_threads += 1
-
-        thread1 = threading.Thread(target=add_ingredient_from_stream, args=('{"title": "Test Ingredient Stream 1"}', self.testPath3, 1))
-        thread2 = threading.Thread(target=add_ingredient_from_stream, args=('{"title": "Test Ingredient Stream 2"}', self.testPath4, 2))
-        thread1.start()
-        thread2.start()
-        thread1.join()
-        thread2.join()
-        if any(e for e in add_errors if e is not None):
-            self.fail("\n".join(e for e in add_errors if e is not None))
-        self.assertEqual(completed_threads, 2)
-        self.assertEqual(len(add_errors), 2)
-        with open(self.testPath2, "rb") as file:
-            output = io.BytesIO(bytearray())
-            builder.sign(self.signer, "image/jpeg", file, output)
-            output.seek(0)
-            read_ctx = Context()
-            reader = Reader("image/jpeg", output, context=read_ctx)
-            json_data = reader.json()
-            manifest_data = json.loads(json_data)
-            self.assertIn("active_manifest", manifest_data)
-            active_manifest_id = manifest_data["active_manifest"]
-            self.assertIn("manifests", manifest_data)
-            self.assertIn(active_manifest_id, manifest_data["manifests"])
-            active_manifest = manifest_data["manifests"][active_manifest_id]
-            self.assertIn("ingredients", active_manifest)
-            self.assertEqual(len(active_manifest["ingredients"]), 2)
-            ingredient_titles = [ing["title"] for ing in active_manifest["ingredients"]]
-            self.assertIn("Test Ingredient Stream 1", ingredient_titles)
-            self.assertIn("Test Ingredient Stream 2", ingredient_titles)
-        builder.close()
-
-    def test_builder_sign_with_same_ingredient_multiple_times(self):
-        """Test Builder with same ingredient added multiple times from different threads using context APIs"""
-        ctx = Context()
-        builder = Builder.from_json(self.manifestDefinition, context=ctx)
-        assert builder._handle is not None
-        add_errors = []
-        add_lock = threading.Lock()
-        completed_threads = 0
-        completion_lock = threading.Lock()
-
-        def add_ingredient(ingredient_json, thread_id):
-            nonlocal completed_threads
-            try:
-                with open(self.testPath3, 'rb') as f:
-                    builder.add_ingredient(ingredient_json, "image/jpeg", f)
-                with add_lock:
-                    add_errors.append(None)
-            except Exception as e:
-                with add_lock:
-                    add_errors.append(f"Thread {thread_id} error: {str(e)}")
-            finally:
-                with completion_lock:
-                    completed_threads += 1
-
-        threads = []
-        for i in range(1, 6):
-            ingredient_json = json.dumps({"title": f"Test Ingredient Thread {i}"})
-            thread = threading.Thread(target=add_ingredient, args=(ingredient_json, i))
-            threads.append(thread)
-            thread.start()
-        for thread in threads:
-            thread.join()
-        if any(e for e in add_errors if e is not None):
-            self.fail("\n".join(e for e in add_errors if e is not None))
-        self.assertEqual(completed_threads, 5)
-        self.assertEqual(len(add_errors), 5)
-        with open(self.testPath2, "rb") as file:
-            output = io.BytesIO(bytearray())
-            builder.sign(self.signer, "image/jpeg", file, output)
-            output.seek(0)
-            read_ctx = Context()
-            reader = Reader("image/jpeg", output, context=read_ctx)
-            json_data = reader.json()
-            manifest_data = json.loads(json_data)
-            self.assertIn("active_manifest", manifest_data)
-            active_manifest_id = manifest_data["active_manifest"]
-            self.assertIn("manifests", manifest_data)
-            self.assertIn(active_manifest_id, manifest_data["manifests"])
-            active_manifest = manifest_data["manifests"][active_manifest_id]
-            self.assertIn("ingredients", active_manifest)
-            self.assertEqual(len(active_manifest["ingredients"]), 5)
-            ingredient_titles = [ing["title"] for ing in active_manifest["ingredients"]]
-            self.assertEqual(len(set(ingredient_titles)), 5)
-            for i in range(1, 6):
-                thread_ingredients = [ing for ing in active_manifest["ingredients"] if ing["title"] == f"Test Ingredient Thread {i}"]
-                self.assertEqual(len(thread_ingredients), 1)
-        builder.close()
-
     def test_builder_sign_with_multiple_ingredient_random_many_threads(self):
         """Test Builder with 12 threads adding ingredients and signing using context APIs"""
         TOTAL_THREADS_USED = 12