Add Detach and Duplicate Prefab basic workflow auto test (#4506)

- Add a new automated test PrefabBasicWorkflow_CreateReparentAndDetachPrefab for verifying prefab detachment basic workflow.
- Add a new automated test PrefabBasicWorkflow_CreateAndDuplicatePrefab for verifying prefab detachment basic workflow.
- Fix a bug related to sets of entity ids in Reparent helper function .

AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/prefab_utils.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 from collections import Counter
 from collections import deque
 from os import path
+from pathlib import Path
 
 from PySide2 import QtWidgets
 
@@ -20,6 +21,10 @@ from editor_python_test_tools.utils import Report
 
 import azlmbr.entity as entity
 import azlmbr.bus as bus
+import azlmbr.components as components
+import azlmbr.editor as editor
+import azlmbr.globals
+import azlmbr.math as math
 import azlmbr.prefab as prefab
 import editor_python_test_tools.pyside_utils as pyside_utils
 
@@ -57,26 +62,46 @@ class PrefabInstance:
     def __hash__(self):
         return hash(self.container_entity.id)
 
-    """
-    See if this instance is valid to be used with other prefab operations. 
-    :return: Whether the target instance is valid or not.
-    """
     def is_valid(self) -> bool:
+        """
+        See if this instance is valid to be used with other prefab operations. 
+        :return: Whether the target instance is valid or not.
+        """
         return self.container_entity.id.IsValid() and self.prefab_file_name in Prefab.existing_prefabs
 
-    """
-    Reparent this instance to target parent entity. 
-    The function will also check pop up dialog ui in editor to see if there's prefab cyclical dependency error while reparenting prefabs.
-    :param parent_entity_id: The id of the entity this instance should be a child of in the transform hierarchy next.
-    """
+    def has_editor_prefab_component(self) -> bool:
+        """
+        Check if the instance's container entity contains EditorPrefabComponent. 
+        :return: Whether the container entity of target instance has EditorPrefabComponent in it or not.
+        """
+        return editor.EditorComponentAPIBus(bus.Broadcast, "HasComponentOfType", self.container_entity.id, azlmbr.globals.property.EditorPrefabComponentTypeId)
+
+    def is_at_position(self, expected_position):
+        """
+        Check if the instance's container entity is at expected position given. 
+        :return: Whether the container entity of target instance is at expected position or not.
+        """
+        actual_position = components.TransformBus(bus.Event, "GetWorldTranslation", self.container_entity.id)
+        is_at_position = actual_position.IsClose(expected_position)
+
+        if not is_at_position:
+            Report.info(f"Prefab Instance Container Entity '{self.container_entity.id.ToString()}'\'s expected position: {expected_position.ToString()}, actual position: {actual_position.ToString()}")
+        
+        return is_at_position
+
     async def ui_reparent_prefab_instance(self, parent_entity_id: EntityId):
+        """
+        Reparent this instance to target parent entity. 
+        The function will also check pop up dialog ui in editor to see if there's prefab cyclical dependency error while reparenting prefabs.
+        :param parent_entity_id: The id of the entity this instance should be a child of in the transform hierarchy next.
+        """
         container_entity_id_before_reparent = self.container_entity.id
 
         original_parent = EditorEntity(self.container_entity.get_parent_id())
-        original_parent_before_reparent_children_ids = set(original_parent.get_children_ids())
+        original_parent_before_reparent_children_ids = {child_id.ToString(): child_id for child_id in original_parent.get_children_ids()}
 
         new_parent = EditorEntity(parent_entity_id)
-        new_parent_before_reparent_children_ids = set(new_parent.get_children_ids())
+        new_parent_before_reparent_children_ids = {child_id.ToString(): child_id for child_id in new_parent.get_children_ids()}
 
         pyside_utils.run_soon(lambda: self.container_entity.set_parent_entity(parent_entity_id))
         pyside_utils.run_soon(lambda: wait_for_propagation())
@@ -90,23 +115,28 @@ class PrefabInstance:
         except pyside_utils.EventLoopTimeoutException:
             pass
 
-        original_parent_after_reparent_children_ids = set(original_parent.get_children_ids())
+        original_parent_after_reparent_children_ids = {child_id.ToString(): child_id for child_id in original_parent.get_children_ids()}
         assert len(original_parent_after_reparent_children_ids) == len(original_parent_before_reparent_children_ids) - 1, \
             "The children count of the Prefab Instance's original parent should be decreased by 1."
         assert not container_entity_id_before_reparent in original_parent_after_reparent_children_ids, \
             "This Prefab Instance is still a child entity of its original parent entity."
        
-        new_parent_after_reparent_children_ids = set(new_parent.get_children_ids())
+        new_parent_after_reparent_children_ids = {child_id.ToString(): child_id for child_id in new_parent.get_children_ids()}
         assert len(new_parent_after_reparent_children_ids) == len(new_parent_before_reparent_children_ids) + 1, \
             "The children count of the Prefab Instance's new parent should be increased by 1."
 
-        container_entity_id_after_reparent = set(new_parent_after_reparent_children_ids).difference(new_parent_before_reparent_children_ids).pop()
+        after_before_diff = set(new_parent_after_reparent_children_ids.keys()).difference(set(new_parent_before_reparent_children_ids.keys()))
+        container_entity_id_after_reparent = new_parent_after_reparent_children_ids[after_before_diff.pop()]
         reparented_container_entity = EditorEntity(container_entity_id_after_reparent)
         reparented_container_entity_parent_id = reparented_container_entity.get_parent_id()
         has_correct_parent = reparented_container_entity_parent_id.ToString() == parent_entity_id.ToString()
         assert has_correct_parent, "Prefab Instance reparented is *not* under the expected parent entity"
 
+        current_instance_prefab = Prefab.get_prefab(self.prefab_file_name)
+        current_instance_prefab.instances.remove(self)
+
         self.container_entity = reparented_container_entity
+        current_instance_prefab.instances.add(self)
 
 # This is a helper class which contains some of the useful information about a prefab template.
 class Prefab:
@@ -117,31 +147,32 @@ class Prefab:
         self.file_path: str = get_prefab_file_path(file_path)
         self.instances: set[PrefabInstance] = set()
 
-    """
-    Check if a prefab is ready to be used to generate its instances.
-    :param file_path: A unique file path of the target prefab.
-    :return: Whether the target prefab is loaded or not.
-    """
     @classmethod
     def is_prefab_loaded(cls, file_path: str) -> bool:
+        """
+        Check if a prefab is ready to be used to generate its instances.
+        :param file_path: A unique file path of the target prefab.
+        :return: Whether the target prefab is loaded or not.
+        """
         return file_path in Prefab.existing_prefabs
 
-    """
-    Check if a prefab exists in the directory for files of prefab tests.
-    :param file_name: A unique file name of the target prefab.
-    :return: Whether the target prefab exists or not.
-    """
+    
     @classmethod
     def prefab_exists(cls, file_path: str) -> bool:
+        """
+        Check if a prefab exists in the directory for files of prefab tests.
+        :param file_name: A unique file name of the target prefab.
+        :return: Whether the target prefab exists or not.
+        """
         return path.exists(get_prefab_file_path(file_path))
 
-    """
-    Return a prefab which can be used immediately.
-    :param file_name: A unique file name of the target prefab.
-    :return: The prefab with given file name.
-    """
     @classmethod
     def get_prefab(cls, file_name: str) -> Prefab:
+        """
+        Return a prefab which can be used immediately.
+        :param file_name: A unique file name of the target prefab.
+        :return: The prefab with given file name.
+        """
         assert file_name, "Received an empty file_name"
         if Prefab.is_prefab_loaded(file_name):
             return Prefab.existing_prefabs[file_name]
@@ -151,15 +182,15 @@ class Prefab:
             Prefab.existing_prefabs[file_name] = Prefab(file_name)
             return new_prefab
 
-    """
-    Create a prefab in memory and return it. The very first instance of this prefab will also be created.
-    :param entities: The entities that should form the new prefab (along with their descendants).
-    :param file_name: A unique file name of new prefab.
-    :param prefab_instance_name: A name for the very first instance generated while prefab creation. The default instance name is the same as file_name.
-    :return: Created Prefab object and the very first PrefabInstance object owned by the prefab.
-    """
     @classmethod
     def create_prefab(cls, entities: list[EditorEntity], file_name: str, prefab_instance_name: str=None) -> tuple(Prefab, PrefabInstance):
+        """
+        Create a prefab in memory and return it. The very first instance of this prefab will also be created.
+        :param entities: The entities that should form the new prefab (along with their descendants).
+        :param file_name: A unique file name of new prefab.
+        :param prefab_instance_name: A name for the very first instance generated while prefab creation. The default instance name is the same as file_name.
+        :return: Created Prefab object and the very first PrefabInstance object owned by the prefab.
+        """
         assert not Prefab.is_prefab_loaded(file_name), f"Can't create Prefab '{file_name}' since the prefab already exists"
 
         new_prefab = Prefab(file_name)
@@ -169,6 +200,9 @@ class Prefab:
 
         container_entity_id = create_prefab_result.GetValue()
         container_entity = EditorEntity(container_entity_id)
+        children_entity_ids = container_entity.get_children_ids()
+
+        assert len(children_entity_ids) == len(entities), f"Entity count of created prefab instance does *not* match the count of given entities."
 
         if prefab_instance_name:
             container_entity.set_name(prefab_instance_name)
@@ -180,12 +214,12 @@ class Prefab:
         Prefab.existing_prefabs[file_name] = new_prefab
         return new_prefab, new_prefab_instance
 
-    """
-    Remove target prefab instances.
-    :param prefab_instances: Instances to be removed.
-    """
     @classmethod
     def remove_prefabs(cls, prefab_instances: list[PrefabInstance]):
+        """
+        Remove target prefab instances.
+        :param prefab_instances: Instances to be removed.
+        """
         entity_ids_to_remove = []
         entity_id_queue = [prefab_instance.container_entity for prefab_instance in prefab_instances]
         while entity_id_queue:
@@ -212,15 +246,89 @@ class Prefab:
             instance_deleted_prefab = Prefab.get_prefab(instance.prefab_file_name)
             instance_deleted_prefab.instances.remove(instance)
             instance = PrefabInstance()
-        
-    """
-    Instantiate an instance of this prefab.
-    :param parent_entity: The entity the prefab should be a child of in the transform hierarchy.
-    :param name: A name for newly instantiated prefab instance. The default instance name is the same as this prefab's file name.
-    :param prefab_position: The position in world space the prefab should be instantiated in.
-    :return: Instantiated PrefabInstance object owned by this prefab.
-    """
+
+    @classmethod
+    def duplicate_prefabs(cls, prefab_instances: list[PrefabInstance]):
+        """
+        Duplicate target prefab instances.
+        :param prefab_instances: Instances to be duplicated.
+        :return: PrefabInstance objects of given prefab instances' duplicates.
+        """
+        assert prefab_instances, "Input list of prefab instances should *not* be empty."
+
+        common_parent = EditorEntity(prefab_instances[0].container_entity.get_parent_id())
+        common_parent_children_ids_before_duplicate = set([child_id.ToString() for child_id in common_parent.get_children_ids()])
+
+        container_entity_ids = [prefab_instance.container_entity.id for prefab_instance in prefab_instances]
+
+        duplicate_prefab_result = prefab.PrefabPublicRequestBus(bus.Broadcast, 'DuplicateEntitiesInInstance', container_entity_ids)
+        assert duplicate_prefab_result.IsSuccess(), f"Prefab operation 'DuplicateEntitiesInInstance' failed. Error: {duplicate_prefab_result.GetError()}"
+
+        wait_for_propagation()
+
+        duplicate_container_entity_ids = duplicate_prefab_result.GetValue()
+        common_parent_children_ids_after_duplicate = set([child_id.ToString() for child_id in common_parent.get_children_ids()])
+
+        assert set([container_entity_id.ToString() for container_entity_id in container_entity_ids]).issubset(common_parent_children_ids_after_duplicate), \
+            "Provided prefab instances are *not* the children of their common parent anymore after duplication."
+        assert common_parent_children_ids_before_duplicate.issubset(common_parent_children_ids_after_duplicate), \
+            "Some children of provided entities' common parent before duplication are *not* the children of the common parent anymore after duplication."
+        assert len(common_parent_children_ids_after_duplicate) == len(common_parent_children_ids_before_duplicate) + len(prefab_instances), \
+            "The children count of the given prefab instances' common parent entity is *not* increased to the expected number."
+        assert EditorEntity(duplicate_container_entity_ids[0]).get_parent_id().ToString() == common_parent.id.ToString(), \
+            "Provided prefab instances' parent should be the same as duplicates' parent."
+
+        duplicate_instances = []
+        for duplicate_container_entity_id in duplicate_container_entity_ids:
+            prefab_file_path = prefab.PrefabPublicRequestBus(bus.Broadcast, 'GetOwningInstancePrefabPath', duplicate_container_entity_id)
+            assert prefab_file_path, "Returned file path should *not* be empty."
+
+            prefab_file_name =  Path(prefab_file_path).stem
+            duplicate_instance_prefab = Prefab.get_prefab(prefab_file_name)
+            duplicate_instance = PrefabInstance(prefab_file_path, EditorEntity(duplicate_container_entity_id))
+            duplicate_instance_prefab.instances.add(duplicate_instance)
+            duplicate_instances.append(duplicate_instance)
+
+        return duplicate_instances
+
+    @classmethod
+    def detach_prefab(cls, prefab_instance: PrefabInstance):
+        """
+        Detach target prefab instance.
+        :param prefab_instances: Instance to be detached.
+        """
+        parent = EditorEntity(prefab_instance.container_entity.get_parent_id())
+        parent_children_ids_before_detach = set([child_id.ToString() for child_id in parent.get_children_ids()])
+
+        assert prefab_instance.has_editor_prefab_component(), f"Container entity should have EditorPrefabComponent before detachment."
+
+        detach_prefab_result = prefab.PrefabPublicRequestBus(bus.Broadcast, 'DetachPrefab', prefab_instance.container_entity.id)
+        assert detach_prefab_result.IsSuccess(), f"Prefab operation 'DetachPrefab' failed. Error: {detach_prefab_result.GetError()}"
+
+        assert not prefab_instance.has_editor_prefab_component(), f"Container entity should *not* have EditorPrefabComponent after detachment."
+
+        parent_children_ids_after_detach = set([child_id.ToString() for child_id in parent.get_children_ids()])
+
+        assert prefab_instance.container_entity.id.ToString() in parent_children_ids_after_detach, \
+            "Target prefab instance's container entity id should still exists after the detachment and before the propagation."
+
+        assert len(parent_children_ids_after_detach) == len(parent_children_ids_before_detach), \
+            "Parent entity should still keep the same amount of children entities."
+
+        wait_for_propagation()
+
+        instance_owner_prefab = Prefab.get_prefab(prefab_instance.prefab_file_name)
+        instance_owner_prefab.instances.remove(prefab_instance)
+        prefab_instance = PrefabInstance()
+
     def instantiate(self, parent_entity: EditorEntity=None, name: str=None, prefab_position: Vector3=Vector3()) -> PrefabInstance:
+        """
+        Instantiate an instance of this prefab.
+        :param parent_entity: The entity the prefab should be a child of in the transform hierarchy.
+        :param name: A name for newly instantiated prefab instance. The default instance name is the same as this prefab's file name.
+        :param prefab_position: The position in world space the prefab should be instantiated in.
+        :return: Instantiated PrefabInstance object owned by this prefab.
+        """
         parent_entity_id = parent_entity.id if parent_entity is not None else EntityId()
 
         instantiate_prefab_result = prefab.PrefabPublicRequestBus(
@@ -240,4 +348,6 @@ class Prefab:
         assert not new_prefab_instance in self.instances, "This prefab instance is already existed before this instantiation."
         self.instances.add(new_prefab_instance)
 
+        assert new_prefab_instance.is_at_position(prefab_position), "This prefab instance is *not* at expected position."
+
         return new_prefab_instance

AutomatedTesting/Gem/PythonTests/Prefab/TestSuite_Main.py

@@ -47,3 +47,11 @@ class TestAutomation(TestAutomationBase):
     def test_PrefabBasicWorkflow_CreateAndReparentPrefab(self, request, workspace, editor, launcher_platform):
         from .tests import PrefabBasicWorkflow_CreateAndReparentPrefab as test_module
         self._run_prefab_test(request, workspace, editor, test_module, autotest_mode=False)
+
+    def test_PrefabBasicWorkflow_CreateReparentAndDetachPrefab(self, request, workspace, editor, launcher_platform):
+        from .tests import PrefabBasicWorkflow_CreateReparentAndDetachPrefab as test_module
+        self._run_prefab_test(request, workspace, editor, test_module, autotest_mode=False)
+
+    def test_PrefabBasicWorkflow_CreateAndDuplicatePrefab(self, request, workspace, editor, launcher_platform):
+        from .tests import PrefabBasicWorkflow_CreateAndDuplicatePrefab as test_module
+        self._run_prefab_test(request, workspace, editor, test_module)

AutomatedTesting/Gem/PythonTests/Prefab/tests/PrefabBasicWorkflow_CreateAndDeletePrefab.py

@@ -16,16 +16,15 @@ def PrefabBasicWorkflow_CreateAndDeletePrefab():
 
     prefab_test_utils.open_base_tests_level()
 
-    # Creates a new Entity at the root level
-    # Asserts if creation didn't succeed
+    # Creates a new entity at the root level
     car_entity = EditorEntity.create_editor_entity()
     car_prefab_entities = [car_entity]
 
-    # Asserts if prefab creation doesn't succeeds 
+    # Creates a prefab from the new entity
     _, car = Prefab.create_prefab(
         car_prefab_entities, CAR_PREFAB_FILE_NAME)
 
-    # Asserts if prefab deletion fails
+    # Deletes the prefab instance
     Prefab.remove_prefabs([car])
 
 if __name__ == "__main__":

AutomatedTesting/Gem/PythonTests/Prefab/tests/PrefabBasicWorkflow_CreateAndDuplicatePrefab.py

@@ -0,0 +1,32 @@
+"""
+Copyright (c) Contributors to the Open 3D Engine Project.
+For complete copyright and license terms please see the LICENSE at the root of this distribution.
+
+SPDX-License-Identifier: Apache-2.0 OR MIT
+"""
+
+def PrefabBasicWorkflow_CreateAndDuplicatePrefab():
+
+    CAR_PREFAB_FILE_NAME = 'car_prefab'
+
+    from editor_python_test_tools.editor_entity_utils import EditorEntity
+    from editor_python_test_tools.prefab_utils import Prefab
+
+    import PrefabTestUtils as prefab_test_utils
+
+    prefab_test_utils.open_base_tests_level()
+
+    # Creates a new entity at the root level
+    car_entity = EditorEntity.create_editor_entity()
+    car_prefab_entities = [car_entity]
+
+    # Creates a prefab from the new entity
+    _, car = Prefab.create_prefab(
+        car_prefab_entities, CAR_PREFAB_FILE_NAME)
+
+    # Duplicates the prefab instance
+    Prefab.duplicate_prefabs([car])
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(PrefabBasicWorkflow_CreateAndDuplicatePrefab)

AutomatedTesting/Gem/PythonTests/Prefab/tests/PrefabBasicWorkflow_CreateAndReparentPrefab.py

@@ -22,24 +22,23 @@ def PrefabBasicWorkflow_CreateAndReparentPrefab():
 
         prefab_test_utils.open_base_tests_level()
 
-        # Creates a new Entity at the root level
-        # Asserts if creation didn't succeed
+        # Creates a new car entity at the root level
         car_entity = EditorEntity.create_editor_entity()
         car_prefab_entities = [car_entity]
 
-        # Checks for prefab creation passed or not 
+        # Creates a prefab from the car entity
         _, car = Prefab.create_prefab(
             car_prefab_entities, CAR_PREFAB_FILE_NAME)
 
-        # Creates another new Entity at the root level
+        # Creates another new wheel entity at the root level
         wheel_entity = EditorEntity.create_editor_entity()
         wheel_prefab_entities = [wheel_entity]
 
-        # Checks for wheel prefab creation passed or not 
+        # Creates another prefab from the wheel entity
         _, wheel = Prefab.create_prefab(
             wheel_prefab_entities, WHEEL_PREFAB_FILE_NAME)
 
-        # Checks for prefab reparenting passed or not 
+        # Reparents the wheel prefab instance to the container entity of the car prefab instance
         await wheel.ui_reparent_prefab_instance(car.container_entity.id)
 
     run_test()

AutomatedTesting/Gem/PythonTests/Prefab/tests/PrefabBasicWorkflow_CreatePrefab.py

@@ -17,12 +17,11 @@ def PrefabBasicWorkflow_CreatePrefab():
 
     prefab_test_utils.open_base_tests_level()
 
-    # Creates a new Entity at the root level
-    # Asserts if creation didn't succeed
+    # Creates a new entity at the root level
     car_entity = EditorEntity.create_editor_entity()
     car_prefab_entities = [car_entity]
 
-    # Checks for prefab creation passed or not
+    # Creates a prefab from the new entity
     Prefab.create_prefab(car_prefab_entities, CAR_PREFAB_FILE_NAME)
 
 if __name__ == "__main__":

AutomatedTesting/Gem/PythonTests/Prefab/tests/PrefabBasicWorkflow_CreateReparentAndDetachPrefab.py

@@ -0,0 +1,51 @@
+"""
+Copyright (c) Contributors to the Open 3D Engine Project.
+For complete copyright and license terms please see the LICENSE at the root of this distribution.
+
+SPDX-License-Identifier: Apache-2.0 OR MIT
+"""
+
+def PrefabBasicWorkflow_CreateReparentAndDetachPrefab():
+
+    CAR_PREFAB_FILE_NAME = 'car_prefab'
+    WHEEL_PREFAB_FILE_NAME = 'wheel_prefab'
+
+    import editor_python_test_tools.pyside_utils as pyside_utils
+
+    @pyside_utils.wrap_async
+    async def run_test():
+
+        from editor_python_test_tools.editor_entity_utils import EditorEntity
+        from editor_python_test_tools.prefab_utils import Prefab
+
+        import PrefabTestUtils as prefab_test_utils
+
+        prefab_test_utils.open_base_tests_level()
+
+        # Creates a new car entity at the root level
+        car_entity = EditorEntity.create_editor_entity()
+        car_prefab_entities = [car_entity]
+
+        # Creates a prefab from the car entity
+        _, car = Prefab.create_prefab(
+            car_prefab_entities, CAR_PREFAB_FILE_NAME)
+
+        # Creates another new wheel entity at the root level
+        wheel_entity = EditorEntity.create_editor_entity()
+        wheel_prefab_entities = [wheel_entity]
+
+        # Creates another prefab from the wheel entity
+        _, wheel = Prefab.create_prefab(
+            wheel_prefab_entities, WHEEL_PREFAB_FILE_NAME)
+
+        # Reparents the wheel prefab instance to the container entity of the car prefab instance
+        await wheel.ui_reparent_prefab_instance(car.container_entity.id)
+
+        # Detaches the wheel prefab instance
+        Prefab.detach_prefab(wheel)
+
+    run_test()
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(PrefabBasicWorkflow_CreateReparentAndDetachPrefab)

AutomatedTesting/Gem/PythonTests/Prefab/tests/PrefabBasicWorkflow_InstantiatePrefab.py

@@ -19,9 +19,8 @@ def PrefabBasicWorkflow_InstantiatePrefab():
 
     prefab_test_utils.open_base_tests_level()
 
-    # Checks for prefab instantiation passed or not 
+    # Instantiates a new car prefab instance
     test_prefab = Prefab.get_prefab(EXISTING_TEST_PREFAB_FILE_NAME)
-
     test_instance = test_prefab.instantiate( 
         prefab_position=INSTANTIATED_TEST_PREFAB_POSITION)
     

AutomatedTesting/Gem/PythonTests/Prefab/tests/PrefabTestUtils.py

@@ -18,20 +18,6 @@ import azlmbr.components as components
 import azlmbr.entity as entity
 import azlmbr.legacy.general as general
 
-def check_entity_at_position(entity_id, expected_entity_position):
-    entity_at_expected_position_result = (
-        "entity is at expected position",
-        "entity is *not* at expected position")
-
-    actual_entity_position = components.TransformBus(bus.Event, "GetWorldTranslation", entity_id)
-    is_at_position = actual_entity_position.IsClose(expected_entity_position)
-    Report.result(entity_at_expected_position_result, is_at_position)
-
-    if not is_at_position:
-        Report.info(f"Entity '{entity_id.ToString()}'\'s expected position: {expected_entity_position.ToString()}, actual position: {actual_entity_position.ToString()}")
-    
-    return is_at_position
-
 def check_entity_children_count(entity_id, expected_children_count):
     entity_children_count_matched_result = (
         "Entity with a unique name found",
@@ -47,19 +33,6 @@ def check_entity_children_count(entity_id, expected_children_count):
 
     return entity_children_count_matched
 
-def get_children_ids_by_name(entity_id, entity_name):
-    entity = EditorEntity(entity_id)
-    children_entity_ids = entity.get_children_ids()
-    
-    result = []
-    for child_entity_id in children_entity_ids:
-        child_entity = EditorEntity(child_entity_id)
-        child_entity_name = child_entity.get_name()
-        if child_entity_name == entity_name:
-            result.append(child_entity_id)
-
-    return result
-
 def open_base_tests_level():
     helper.init_idle()
     helper.open_level("Prefab", "Base")

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/EditorPrefabComponent.cpp

@@ -9,6 +9,8 @@
 #include <AzToolsFramework/Prefab/EditorPrefabComponent.h>
 
 #include <AzCore/Interface/Interface.h>
+#include <AzCore/Math/Uuid.h>
+#include <AzCore/RTTI/BehaviorContext.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/Serialization/SerializeContext.h>
 #include <AzToolsFramework/Prefab/PrefabPublicInterface.h>
@@ -38,6 +40,13 @@ namespace AzToolsFramework
                                 AZ::Edit::SliceFlags::DontGatherReference);
                 }
             }
+
+            if (auto behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+            {
+                behaviorContext->ConstantProperty(
+                    "EditorPrefabComponentTypeId", BehaviorConstant(AZ::Uuid(EditorPrefabComponent::EditorPrefabComponentTypeId)))
+                    ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Automation);
+            }
         }
 
         void EditorPrefabComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services)

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/EditorPrefabComponent.h

@@ -16,7 +16,9 @@ namespace AzToolsFramework
         class EditorPrefabComponent : public AzToolsFramework::Components::EditorComponentBase
         {
         public:
-            AZ_COMPONENT(EditorPrefabComponent, "{756E5F9C-3E08-4F8D-855C-A5AEEFB6FCDD}", EditorComponentBase);
+            static constexpr const char* const EditorPrefabComponentTypeId = "{756E5F9C-3E08-4F8D-855C-A5AEEFB6FCDD}";
+
+            AZ_COMPONENT(EditorPrefabComponent, EditorPrefabComponentTypeId, EditorComponentBase);
 
             static void Reflect(AZ::ReflectContext* context);
             static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services);

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp

@@ -974,7 +974,7 @@ namespace AzToolsFramework
             return DeleteFromInstance(entityIds, true);
         }
 
-        PrefabOperationResult PrefabPublicHandler::DuplicateEntitiesInInstance(const EntityIdList& entityIds)
+        DuplicatePrefabResult PrefabPublicHandler::DuplicateEntitiesInInstance(const EntityIdList& entityIds)
         {
             if (entityIds.empty())
             {
@@ -1021,6 +1021,7 @@ namespace AzToolsFramework
 
             ScopedUndoBatch undoBatch("Duplicate Entities");
 
+            EntityIdList duplicatedEntityAndInstanceIds;
             {
                 AZ_PROFILE_SCOPE(AzToolsFramework, "DuplicateEntitiesInInstance::UndoCaptureAndDuplicateEntities");
 
@@ -1033,7 +1034,7 @@ namespace AzToolsFramework
 
                 if (!retrieveEntitiesAndInstancesOutcome.IsSuccess())
                 {
-                    return AZStd::move(retrieveEntitiesAndInstancesOutcome);
+                    return AZ::Failure(retrieveEntitiesAndInstancesOutcome.TakeError());
                 }
 
                 // Take a snapshot of the instance DOM before we manipulate it
@@ -1044,8 +1045,6 @@ namespace AzToolsFramework
                 PrefabDom instanceDomAfter;
                 instanceDomAfter.CopyFrom(instanceDomBefore, instanceDomAfter.GetAllocator());
 
-                EntityIdList duplicatedEntityAndInstanceIds;
-
                 // Duplicate any nested entities and instances as requested
                 AZStd::unordered_map<InstanceAlias, Instance*> newInstanceAliasToOldInstanceMap;
                 AZStd::unordered_map<EntityAlias, EntityAlias> duplicateEntityAliasMap;
@@ -1114,7 +1113,7 @@ namespace AzToolsFramework
                 ToolsApplicationRequestBus::Broadcast(&ToolsApplicationRequestBus::Events::SetSelectedEntities, duplicatedEntityAndInstanceIds);
             }
 
-            return AZ::Success();
+            return AZ::Success(AZStd::move(duplicatedEntityAndInstanceIds));
         }
 
         PrefabOperationResult PrefabPublicHandler::DeleteFromInstance(const EntityIdList& entityIds, bool deleteDescendants)

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.h

@@ -63,7 +63,7 @@ namespace AzToolsFramework
 
             PrefabOperationResult DeleteEntitiesInInstance(const EntityIdList& entityIds) override;
             PrefabOperationResult DeleteEntitiesAndAllDescendantsInInstance(const EntityIdList& entityIds) override;
-            PrefabOperationResult DuplicateEntitiesInInstance(const EntityIdList& entityIds) override;
+            DuplicatePrefabResult DuplicateEntitiesInInstance(const EntityIdList& entityIds) override;
 
             PrefabOperationResult DetachPrefab(const AZ::EntityId& containerEntityId) override;
 

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicInterface.h

@@ -26,6 +26,7 @@ namespace AzToolsFramework
     {
         typedef AZ::Outcome<AZ::EntityId, AZStd::string> CreatePrefabResult;
         typedef AZ::Outcome<AZ::EntityId, AZStd::string> InstantiatePrefabResult;
+        typedef AZ::Outcome<EntityIdList, AZStd::string> DuplicatePrefabResult;
         typedef AZ::Outcome<void, AZStd::string> PrefabOperationResult;
         typedef AZ::Outcome<bool, AZStd::string> PrefabRequestResult;
         typedef AZ::Outcome<AZ::EntityId, AZStd::string> PrefabEntityResult;
@@ -160,14 +161,15 @@ namespace AzToolsFramework
             /**
               * Duplicates all entities in the owning instance. Bails if the entities don't all belong to the same instance.
               * @param entities The entities to duplicate.
-              * @return An outcome object; on failure, it comes with an error message detailing the cause of the error.
+              * @return An outcome object with a list of ids of target entities' duplicates if duplication succeeded;
+              *  on failure, it comes with an error message detailing the cause of the error.
               */
-            virtual PrefabOperationResult DuplicateEntitiesInInstance(const EntityIdList& entityIds) = 0;
+            virtual DuplicatePrefabResult DuplicateEntitiesInInstance(const EntityIdList& entityIds) = 0;
 
             /**
               * If the entity id is a container entity id, detaches the prefab instance corresponding to it. This includes converting
               * the container entity into a regular entity and putting it under the parent prefab, removing the link between this
-              * instance and the parent, removing links between this instance and it's nested instances, adding entities directly 
+              * instance and the parent, removing links between this instance and its nested instances, and adding entities directly 
               * owned by this instance under the parent instance.
               * Bails if the entity is not a container entity or belongs to the level prefab instance.
               * @param containerEntityId The container entity id of the instance to detach.

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestBus.h

@@ -25,6 +25,7 @@ namespace AzToolsFramework
     {
         using CreatePrefabResult = AZ::Outcome<AZ::EntityId, AZStd::string>;
         using InstantiatePrefabResult = AZ::Outcome<AZ::EntityId, AZStd::string>;
+        using DuplicatePrefabResult = AZ::Outcome<EntityIdList, AZStd::string>;
         using PrefabOperationResult = AZ::Outcome<void, AZStd::string>;
 
         /**
@@ -69,6 +70,29 @@ namespace AzToolsFramework
              * Return an outcome object; on failure, it comes with an error message detailing the cause of the error.
              */
             virtual PrefabOperationResult DeleteEntitiesAndAllDescendantsInInstance(const EntityIdList& entityIds) = 0;
+
+            /**
+              * If the entity id is a container entity id, detaches the prefab instance corresponding to it. This includes converting
+              * the container entity into a regular entity and putting it under the parent prefab, removing the link between this
+              * instance and the parent, removing links between this instance and its nested instances, and adding entities directly
+              * owned by this instance under the parent instance.
+              * Bails if the entity is not a container entity or belongs to the level prefab instance.
+              * Return an outcome object; on failure, it comes with an error message detailing the cause of the error.
+              */
+            virtual PrefabOperationResult DetachPrefab(const AZ::EntityId& containerEntityId) = 0;
+
+            /**
+              * Duplicates all entities in the owning instance. Bails if the entities don't all belong to the same instance.
+              * Return an outcome object with a list of ids of given entities' duplicates if duplication succeeded;
+              * on failure, it comes with an error message detailing the cause of the error.
+              */
+            virtual DuplicatePrefabResult DuplicateEntitiesInInstance(const EntityIdList& entityIds) = 0;
+
+            /**
+             * Get the file path to the prefab file for the prefab instance owning the entity provided.
+             * Returns the path to the prefab, or an empty path if the entity is owned by the level.
+             */
+            virtual AZStd::string GetOwningInstancePrefabPath(AZ::EntityId entityId) const = 0;
         };
 
         using PrefabPublicRequestBus = AZ::EBus<PrefabPublicRequests>;

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestHandler.cpp

@@ -28,6 +28,9 @@ namespace AzToolsFramework
                     ->Event("CreatePrefabInMemory", &PrefabPublicRequests::CreatePrefabInMemory)
                     ->Event("InstantiatePrefab", &PrefabPublicRequests::InstantiatePrefab)
                     ->Event("DeleteEntitiesAndAllDescendantsInInstance", &PrefabPublicRequests::DeleteEntitiesAndAllDescendantsInInstance)
+                    ->Event("DetachPrefab", &PrefabPublicRequests::DetachPrefab)
+                    ->Event("DuplicateEntitiesInInstance", &PrefabPublicRequests::DuplicateEntitiesInInstance)
+                    ->Event("GetOwningInstancePrefabPath", &PrefabPublicRequests::GetOwningInstancePrefabPath)
                     ;
             }
         }
@@ -62,5 +65,19 @@ namespace AzToolsFramework
             return m_prefabPublicInterface->DeleteEntitiesAndAllDescendantsInInstance(entityIds);
         }
 
+        PrefabOperationResult PrefabPublicRequestHandler::DetachPrefab(const AZ::EntityId& containerEntityId)
+        {
+            return m_prefabPublicInterface->DetachPrefab(containerEntityId);
+        }
+
+        DuplicatePrefabResult PrefabPublicRequestHandler::DuplicateEntitiesInInstance(const EntityIdList& entityIds)
+        {
+            return m_prefabPublicInterface->DuplicateEntitiesInInstance(entityIds);
+        }
+
+        AZStd::string PrefabPublicRequestHandler::GetOwningInstancePrefabPath(AZ::EntityId entityId) const
+        {
+            return m_prefabPublicInterface->GetOwningInstancePrefabPath(entityId).Native();
+        }
     } // namespace Prefab
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestHandler.h

@@ -34,6 +34,9 @@ namespace AzToolsFramework
             CreatePrefabResult CreatePrefabInMemory(const EntityIdList& entityIds, AZStd::string_view filePath) override;
             InstantiatePrefabResult InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position) override;
             PrefabOperationResult DeleteEntitiesAndAllDescendantsInInstance(const EntityIdList& entityIds) override;
+            PrefabOperationResult DetachPrefab(const AZ::EntityId& containerEntityId) override;
+            DuplicatePrefabResult DuplicateEntitiesInInstance(const EntityIdList& entityIds) override;
+            AZStd::string GetOwningInstancePrefabPath(AZ::EntityId entityId) const override;
 
         private:
             PrefabPublicInterface* m_prefabPublicInterface = nullptr;

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabUndo.cpp

@@ -23,7 +23,7 @@ namespace AzToolsFramework
         }
 
         //PrefabInstanceUndo
-        PrefabUndoInstance::PrefabUndoInstance(const AZStd::string& undoOperationName, const bool useImmediatePropagation)
+        PrefabUndoInstance::PrefabUndoInstance(const AZStd::string& undoOperationName, bool useImmediatePropagation)
             : PrefabUndoBase(undoOperationName)
         {
             m_useImmediatePropagation = useImmediatePropagation;

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabUndo.h

@@ -45,7 +45,7 @@ namespace AzToolsFramework
             : public PrefabUndoBase
         {
         public:
-            explicit PrefabUndoInstance(const AZStd::string& undoOperationName, const bool useImmediatePropagation = true);
+            explicit PrefabUndoInstance(const AZStd::string& undoOperationName, bool useImmediatePropagation = true);
 
             void Capture(
                 const PrefabDom& initialState,