feat(canvas): add name param and auto_stop to update_processor

- update_processor now accepts name param for renaming processors
- add auto_stop param (default False) to handle running processors
- revert_flow_ver now refreshes revision internally to prevent stale errors

Author: Chaffelson

nipyapi/canvas.py

@@ -735,36 +735,80 @@ def update_process_group(pg, update, refresh=True):
         )
 
 
-def update_processor(processor, update, refresh=True):
+def update_processor(processor, update=None, name=None, refresh=True, auto_stop=False):
     """
-    Updates configuration parameters for a given Processor.
+    Updates a Processor's configuration and/or name.
 
-    An example update would be:
-    nifi.ProcessorConfigDTO(scheduling_period='3s')
+    For configuration changes, pass a ProcessorConfigDTO:
+        nifi.ProcessorConfigDTO(scheduling_period='3s')
+
+    For renaming, pass the new name. Both can be provided together.
+
+    Processors must be stopped for certain updates (including renaming).
+    If auto_stop is True (default), the processor will be stopped before
+    updating and restarted afterward if it was originally running.
 
     Args:
         processor (ProcessorEntity): The Processor to target for update
-        update (ProcessorConfigDTO): The new configuration parameters
+        update (ProcessorConfigDTO, optional): Configuration parameters to update
+        name (str, optional): New name for the processor
         refresh (bool): Whether to refresh the Processor object state
-          before applying the update
+            before applying the update. Default True.
+        auto_stop (bool): If True, automatically stop the processor before
+            updating and restart afterward if it was running. Default False.
 
     Returns:
         :class:`~nipyapi.nifi.models.ProcessorEntity`: The updated ProcessorEntity
 
+    Raises:
+        ValueError: If neither update nor name is provided, or if update is not
+            a ProcessorConfigDTO, or if processor is running and auto_stop=False.
     """
-    if not isinstance(update, nipyapi.nifi.ProcessorConfigDTO):
+    if update is None and name is None:
+        raise ValueError("Must provide 'update' (ProcessorConfigDTO) and/or 'name'")
+    if update is not None and not isinstance(update, nipyapi.nifi.ProcessorConfigDTO):
         raise ValueError("update param is not an instance of nifi.ProcessorConfigDTO")
+
     with nipyapi.utils.rest_exceptions():
         if refresh:
             processor = get_processor(processor.id, "id")
-        return nipyapi.nifi.ProcessorsApi().update_processor(
+
+        was_running = processor.component.state == "RUNNING"
+
+        if was_running and not auto_stop:
+            raise ValueError(
+                f"Processor '{processor.component.name}' is running. "
+                "Stop it first or set auto_stop=True."
+            )
+
+        # Stop if running
+        if was_running:
+            schedule_processor(processor, scheduled=False, refresh=True)
+            processor = get_processor(processor.id, "id")
+
+        # Build the update DTO with whatever fields are provided
+        dto_kwargs = {"id": processor.component.id}
+        if name is not None:
+            dto_kwargs["name"] = name
+        if update is not None:
+            dto_kwargs["config"] = update
+
+        result = nipyapi.nifi.ProcessorsApi().update_processor(
             id=processor.id,
             body=nipyapi.nifi.ProcessorEntity(
-                component=nipyapi.nifi.ProcessorDTO(config=update, id=processor.id),
+                id=processor.id,
                 revision=processor.revision,
+                component=nipyapi.nifi.ProcessorDTO(**dto_kwargs),
             ),
         )
 
+        # Restart if it was running
+        if was_running:
+            schedule_processor(result, scheduled=True, refresh=True)
+            result = get_processor(result.id, "id")
+
+        return result
+
 
 def get_variable_registry(process_group, ancestors=True):
     """

nipyapi/versioning.py

@@ -1059,9 +1059,15 @@ def revert_flow_ver(process_group, wait=False):
     assert isinstance(process_group, nipyapi.nifi.ProcessGroupEntity)
 
     with nipyapi.utils.rest_exceptions():
+        # Refresh version control info to get current revision
+        vci = nipyapi.nifi.VersionsApi().get_version_information(process_group.id)
+        # Also get fresh process group revision
+        fresh_pg = nipyapi.canvas.get_process_group(process_group.id, "id")
+        vci.process_group_revision = fresh_pg.revision
+
         revert_request = nipyapi.nifi.VersionsApi().initiate_revert_flow_version(
             id=process_group.id,
-            body=nipyapi.nifi.VersionsApi().get_version_information(process_group.id),
+            body=vci,
         )
 
         if not wait:

tests/test_canvas.py

@@ -287,14 +287,39 @@ def test_delete_processor(fix_proc):
 
 
 def test_update_processor(fix_proc):
-    # TODO: Add way more tests to this
+    """Test update_processor with config, name, and both."""
     f_p1 = fix_proc.generate()
-    update = nifi.ProcessorConfigDTO(
-        scheduling_period='3s'
-    )
-    r1 = canvas.update_processor(f_p1, update)
+    original_name = f_p1.component.name
+
+    # Test config update (processor is stopped, no auto_stop needed)
+    update = nifi.ProcessorConfigDTO(scheduling_period='3s')
+    r1 = canvas.update_processor(f_p1, update=update)
+    assert r1 is not None
+
+    # Test invalid update type
     with pytest.raises(ValueError, match='update param is not an instance'):
-        _ = canvas.update_processor(f_p1, 'FakeNews')
+        canvas.update_processor(f_p1, update='FakeNews')
+
+    # Test rename (processor is stopped, no auto_stop needed)
+    new_name = original_name + '_RENAMED'
+    r2 = canvas.update_processor(r1, name=new_name)
+    assert r2.component.name == new_name
+
+    # Test rename back
+    r3 = canvas.update_processor(r2, name=original_name)
+    assert r3.component.name == original_name
+
+    # Test both config and name together
+    update2 = nifi.ProcessorConfigDTO(scheduling_period='5s')
+    r4 = canvas.update_processor(r3, update=update2, name=original_name + '_BOTH')
+    assert r4.component.name == original_name + '_BOTH'
+
+    # Restore name
+    canvas.update_processor(r4, name=original_name)
+
+    # Test error when neither update nor name provided
+    with pytest.raises(ValueError, match="Must provide"):
+        canvas.update_processor(f_p1)
 
 
 def test_purge_connection():

tests/test_versioning.py

@@ -617,7 +617,7 @@ def test_revert_flow_ver_wait_false(fix_deployed_git_flow):
 
 def test_revert_flow_ver_already_up_to_date(fix_deployed_git_flow):
     """Test revert on flow that's already UP_TO_DATE."""
-    # Ensure flow is UP_TO_DATE
+    # Ensure flow is UP_TO_DATE (function refreshes revision internally)
     vci = versioning.get_version_info(fix_deployed_git_flow.pg)
     assert vci.version_control_information.state == 'UP_TO_DATE'