Enhance image editing tests and functionality

- Added parameterized tests for image edit replacement to ensure alpha mode preservation.
- Refactored existing tests to utilize new image editing methods and improve clarity.
- Introduced new tests for image target functionality, ensuring proper handling of shared textures and context.
- Updated various tests to validate alpha mode handling across different scenarios.
- Improved undo/redo functionality in image operators to maintain state consistency.
- Added support for texture node actions, enhancing integration with Blender's node system.
- Ensured that image properties are preserved during operations and that invalid contexts are handled gracefully.

tests/anyimage/operators/test_ai_image_operators.py

@@ -21,7 +21,7 @@ class AiImageOperatorsTest(BlenderTestCase):
         self.assertEqual(operator_type.bl_options, {"UNDO"})
         operator = operator_type()
         operator.input_path = "input.png"
-        operator.source_object_name = "Source"
+        operator._image_target = SimpleNamespace(start_frame=4)
         operator.model = "SAFMN_REAL_X4"
         operator.max_input_size = 1024
         context = SimpleNamespace(
@@ -34,7 +34,6 @@ class AiImageOperatorsTest(BlenderTestCase):
                 self.upscale, "require_input_path", return_value=Path("input.png")
             ),
             patch.object(self.upscale, "production_device", return_value="CUDA"),
-            patch.object(self.upscale, "source_start_frame", return_value=4),
         ):
             request = operator.request(context)
 
@@ -89,63 +88,37 @@ class AiImageOperatorsTest(BlenderTestCase):
 
 
     def test_remove_background_loads_a_plain_image_edit_result(self):
-        source = SimpleNamespace()
-        result_image = SimpleNamespace()
         result = SimpleNamespace(directory=Path("result"))
+        operator = self.remove_background.RunBackgroundRemoval()
+        operator._image_target = Mock()
         ops = SimpleNamespace(
             ed=SimpleNamespace(undo_push=Mock(return_value={"FINISHED"}))
         )
         with (
-            patch.object(self.image_data, "require_image_empty", return_value=source),
-            patch.object(
-                self.image_data,
-                "load_image_edit_result",
-                return_value=result_image,
-            ) as load,
-            patch.object(self.image_data, "replace_empty_image") as replace,
             patch.object(self.remove_background.bpy, "ops", ops, create=True),
         ):
-            self.remove_background.apply_background_response(result, "Source")
+            operator.response(None, result)
 
-        load.assert_called_once_with(source, Path("result"))
-        replace.assert_called_once_with(source, result_image)
+        operator._image_target.apply.assert_called_once_with(Path("result"))
+        ops.ed.undo_push.assert_called_once_with(message="Remove Background")
 
 
     def test_upscale_loads_a_plain_image_edit_result(self):
-        source_image = SimpleNamespace()
-        source = SimpleNamespace(data=source_image)
-        result_image = SimpleNamespace()
         result = SimpleNamespace(directory=Path("result"))
         operator = self.upscale.UpscaleImage()
-        operator.source_object_name = "Source"
-        operator.source_image_name = "Poster.png"
+        operator._image_target = Mock()
         operator.model = "SAFMN_REAL_X4"
-        images = SimpleNamespace(get=lambda name: source_image if name == "Poster.png" else None)
         with (
-            patch.object(self.upscale, "require_image_empty", return_value=source),
-            patch.object(
-                self.upscale,
-                "load_image_edit_result",
-                return_value=result_image,
-            ) as load,
-            patch.object(self.upscale, "replace_empty_image") as replace,
             patch.object(
                 self.upscale,
                 "upscale_model_label",
                 return_value="SAFMN Real x4",
             ),
-            patch.object(
-                self.upscale.bpy,
-                "data",
-                SimpleNamespace(images=images),
-            ),
         ):
             message = operator.response(None, result)
 
-        load.assert_called_once_with(
-            source,
+        operator._image_target.apply.assert_called_once_with(
             Path("result"),
             frame_prefix="upscale.",
         )
-        replace.assert_called_once_with(source, result_image)
         self.assertEqual(message, "Image is upscaled with SAFMN Real x4")