pygeai 0.1.6__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/tests/integration/lab/processes/test_list_processes.py

@@ -0,0 +1,138 @@
+from unittest import TestCase
+import unittest
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import FilterSettings, AgenticProcessList
+import copy
+
+ai_lab_manager: AILabManager
+
+class TestAILabListProcessesIntegration(TestCase):    
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        self.filter_settings = FilterSettings(
+            start=0,
+            count=100,
+            allow_drafts=False
+        )
+
+    
+    def __list_processes(self, filter_settings: FilterSettings = None):
+        return self.ai_lab_manager.list_processes(
+            filter_settings if filter_settings is not None else self.filter_settings
+        )
+    
+    
+    def test_default_list_processes(self):
+        processes = self.__list_processes()
+        self.assertIsInstance(processes, AgenticProcessList, "Expected a list of processes")
+
+
+    def test_list_processes_with_id_filter(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.id = "7e28e9ab-b9a2-417e-9e87-ed7f6ec9534b"
+        result = self.__list_processes(filter_settings=filter_settings)
+        print(result)
+
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        if result.processes:
+            for process in result.processes:
+                self.assertEqual(
+                    process.id, filter_settings.id,
+                    f"Expected process ID to match filter value: {filter_settings.id}"
+                )
+
+
+    def test_list_processes_with_name_filter(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.name = "ArithmeticProcess"
+        result = self.__list_processes(filter_settings=filter_settings)
+        print(result)
+
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        if result.processes:
+            for process in result.processes:
+                self.assertEqual(
+                    "ArithmeticProcess",
+                    process.name,
+                    "Expected process name to contain filter value"
+                )
+
+
+    def test_list_processes_with_status_filter_active(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.status = "active"
+        result = self.__list_processes(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        if result.processes:
+            for process in result.processes:
+                self.assertEqual(
+                    process.status.lower(), "active",
+                    "Expected all processes to have active status"
+                )
+
+
+    def test_list_processes_with_status_filter_inactive(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.status = "inactive"
+        result = self.__list_processes(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        if result.processes:
+            for process in result.processes:
+                self.assertEqual(
+                    process.status.lower(), "inactive",
+                    "Expected all processes to have inactive status"
+                )
+
+
+    def test_list_processes_small_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 2
+        result = self.__list_processes(filter_settings=filter_settings)
+        
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        self.assertLessEqual(
+            len(result.processes), 2,
+            "Expected list of processes returned to be 2 or less"
+        )
+
+
+    def test_list_processes_big_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 500
+        result = self.__list_processes(filter_settings=filter_settings)
+        
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        self.assertLessEqual(
+            len(result.processes), 500,
+            "Expected list of processes returned to be 500 or less"
+        )
+
+    @unittest.skip("Method is not returning drafts")
+    def test_list_processes_allow_drafts_true(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.allow_drafts = True
+        result = self.__list_processes(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        # Note: This test verifies that draft processes are included when allow_drafts=True
+        has_draft = any(p.is_draft for p in result.processes)
+        self.assertTrue(has_draft, "Expected at least one draft process")
+
+
+    def test_list_processes_allow_drafts_false(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.allow_drafts = False
+        result = self.__list_processes(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        # Note: This test verifies that draft processes are excluded when allow_drafts=False
+        has_draft = any(p.is_draft == False for p in result.processes)
+        self.assertTrue(has_draft, "Expected at least one draft process")
+
+
+    def test_list_processes_none_filter_settings(self):
+        result = self.__list_processes(filter_settings=None)
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")

pygeai/tests/integration/lab/processes/test_publish_process_revision.py

@@ -0,0 +1,232 @@
+from unittest import TestCase
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import AgenticProcess, KnowledgeBase, AgenticActivity, ArtifactSignal, UserSignal, Event, SequenceFlow
+from pygeai.core.common.exceptions import InvalidAPIResponseException, MissingRequirementException, APIError
+
+ai_lab_manager: AILabManager
+
+class TestAILabPublishProcessRevisionIntegration(TestCase):  
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        # Using a known process ID that should have revisions for testing
+        self.process_id = "7e28e9ab-b9a2-417e-9e87-ed7f6ec9534b"
+        self.process_name = "Test Process For Sdk Project"
+        self.revision = "1"
+        
+
+    def __create_process(self):
+        """
+        Helper to create a process for testing publish revision functionality.
+        """
+        unique_key = str(uuid.uuid4())
+        process = AgenticProcess(
+            key="test_publish_key",
+            name=f"Test Publish Process {unique_key[:8]}",
+            description="Test process for publish revision testing",
+            kb=KnowledgeBase(name="basic-sample", artifact_type_name=["sample-artifact"]),
+            agentic_activities=[
+                AgenticActivity(
+                    key="activityOne", 
+                    name="First Step", 
+                    task_name="basic-task", 
+                    agent_name="GoogleSummarizer2", 
+                    agent_revision_id=0
+                )
+            ],
+            artifact_signals=[
+                ArtifactSignal(
+                    key="artifact.upload.1", 
+                    name="artifact.upload", 
+                    handling_type="C", 
+                    artifact_type_name=["sample-artifact"]
+                )
+            ],
+            user_signals=[
+                UserSignal(key="signal_done", name="process-completed")
+            ],
+            start_event=Event(key="artifact.upload.1", name="artifact.upload"),
+            end_event=Event(key="end", name="Done"),
+            sequence_flows=[
+                SequenceFlow(key="step1", source_key="artifact.upload.1", target_key="activityOne"),
+                SequenceFlow(key="step2", source_key="activityOne", target_key="signal_done"),
+                SequenceFlow(key="stepEnd", source_key="signal_done", target_key="end")
+            ]
+        )
+
+        return self.ai_lab_manager.create_process(
+            process=process,
+            automatic_publish=False
+        )
+
+
+    def __publish_process_revision(self, process_id: str = None, process_name: str = None, revision: str = None):
+        return self.ai_lab_manager.publish_process_revision(
+            process_id=process_id,
+            process_name=process_name,
+            revision=revision if revision is not None else self.revision
+        )
+    
+
+    def test_publish_process_revision_by_id(self):
+        """Test publishing a process revision using process_id."""
+        published_process = self.__publish_process_revision(process_id=self.process_id)
+
+        self.assertIsInstance(published_process, AgenticProcess, "Expected AgenticProcess instance")
+        self.assertEqual(published_process.id, self.process_id, "Expected process ID to match")
+        self.assertIsNotNone(published_process.revision, "Expected revision to be set")
+
+
+    def test_publish_process_revision_by_name(self):
+        """Test publishing a process revision using process_name."""
+        published_process = self.__publish_process_revision(process_name=self.process_name)
+
+        self.assertIsInstance(published_process, AgenticProcess, "Expected AgenticProcess instance")
+        self.assertEqual(published_process.name, self.process_name, "Expected process name to match")
+        self.assertIsNotNone(published_process.revision, "Expected revision to be set")
+
+
+    def test_publish_process_revision_specific_revision(self):
+        """Test publishing a specific revision number."""
+        specific_revision = "2"
+        published_process = self.__publish_process_revision(
+            process_id=self.process_id, 
+            revision=specific_revision
+        )
+
+        self.assertIsInstance(published_process, AgenticProcess, "Expected AgenticProcess instance")
+        self.assertEqual(published_process.id, self.process_id, "Expected process ID to match")
+
+
+    def test_publish_process_revision_no_parameters(self):
+        """Test error when neither process_id nor process_name is provided."""
+        with self.assertRaises(MissingRequirementException) as exception:
+            self.__publish_process_revision()
+
+        self.assertIn(
+            "Either process_id or process_name and revision must be provided",
+            str(exception.exception),
+            "Expected error message for missing parameters"
+        )
+
+
+    def test_publish_process_revision_empty_process_id(self):
+        """Test error when process_id is empty."""
+        with self.assertRaises(MissingRequirementException) as exception:
+            self.__publish_process_revision(process_id="")
+
+        self.assertIn(
+            "Either process_id or process_name and revision must be provided",
+            str(exception.exception),
+            "Expected error message for empty process_id"
+        )
+
+
+    def test_publish_process_revision_empty_process_name(self):
+        """Test error when process_name is empty."""
+        with self.assertRaises(MissingRequirementException) as exception:
+            self.__publish_process_revision(process_name="")
+
+        self.assertIn(
+            "Either process_id or process_name and revision must be provided",
+            str(exception.exception),
+            "Expected error message for empty process_name"
+        )
+
+
+    def test_publish_process_revision_no_revision(self):
+        """Test error when revision is not provided."""
+        with self.assertRaises(MissingRequirementException) as exception:
+            self.__publish_process_revision(process_id=self.process_id, revision="")
+
+        self.assertIn(
+            "Either process_id or process_name and revision must be provided",
+            str(exception.exception),
+            "Expected error message for missing revision"
+        )
+
+
+    def test_publish_process_revision_none_revision(self):
+        """Test error when revision is None."""
+        with self.assertRaises(MissingRequirementException) as exception:
+            self.__publish_process_revision(process_id=self.process_id, revision=None)
+
+        self.assertIn(
+            "Either process_id or process_name and revision must be provided",
+            str(exception.exception),
+            "Expected error message for None revision"
+        )
+
+
+    def test_publish_process_revision_invalid_process_id(self):
+        """Test error with invalid process_id."""
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        with self.assertRaises((APIError, InvalidAPIResponseException)) as exception:
+            self.__publish_process_revision(process_id=invalid_id)
+
+        self.assertTrue(
+            f"Unable to publish revision {self.revision} for process {invalid_id}" in str(exception.exception) or
+            "Error received while publishing process revision" in str(exception.exception),
+            "Expected error message for invalid process id"
+        )
+
+
+    def test_publish_process_revision_invalid_process_name(self):
+        """Test error with invalid process_name."""
+        invalid_name = "NonExistentProcessName123"
+        with self.assertRaises((APIError, InvalidAPIResponseException)) as exception:
+            self.__publish_process_revision(process_name=invalid_name)
+
+        self.assertTrue(
+            f"Unable to publish revision {self.revision} for process {invalid_name}" in str(exception.exception) or
+            "Error received while publishing process revision" in str(exception.exception),
+            "Expected error message for invalid process name"
+        )
+
+
+    def test_publish_process_revision_nonexistent_process_id(self):
+        """Test error with nonexistent process_id."""
+        nonexistent_id = "99999999-9999-9999-9999-999999999999"
+        with self.assertRaises((APIError, InvalidAPIResponseException)) as exception:
+            self.__publish_process_revision(process_id=nonexistent_id)
+
+        self.assertTrue(
+            f"Unable to publish revision {self.revision} for process {nonexistent_id}" in str(exception.exception) or
+            "Error received while publishing process revision" in str(exception.exception),
+            "Expected error message for nonexistent process id"
+        )
+
+
+    def test_publish_process_revision_invalid_revision(self):
+        """Test error with invalid revision number."""
+        invalid_revision = "999"
+        with self.assertRaises((APIError, InvalidAPIResponseException)) as exception:
+            self.__publish_process_revision(process_id=self.process_id, revision=invalid_revision)
+
+        self.assertTrue(
+            f"Unable to publish revision {invalid_revision} for process {self.process_id}" in str(exception.exception) or
+            "Error received while publishing process revision" in str(exception.exception),
+            "Expected error message for invalid revision"
+        )
+
+
+    def test_publish_process_revision_with_created_process(self):
+        """Test publishing revision with a newly created process."""
+        # Create a fresh process
+        created_process = self.__create_process()
+        
+        # Note: A newly created process might not have additional revisions to publish
+        # This test verifies the process creation worked and we can attempt to publish
+        self.assertIsNotNone(created_process.id, "Expected created process to have an ID")
+        
+        # Attempt to publish revision 0 (initial revision)
+        try:
+            published_process = self.__publish_process_revision(
+                process_id=created_process.id, 
+                revision="0"
+            )
+            self.assertIsInstance(published_process, AgenticProcess, "Expected AgenticProcess instance")
+        except (APIError, InvalidAPIResponseException):
+            # This is expected for a new process that may not have publishable revisions yet
+            pass

pygeai/tests/integration/lab/processes/test_update_process.py

@@ -0,0 +1,289 @@
+from unittest import TestCase
+import uuid
+
+from pydantic import ValidationError
+from pygeai.core.common.exceptions import APIResponseError, APIError
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import (
+    AgenticProcess, KnowledgeBase, AgenticActivity, ArtifactSignal, Task, 
+    UserSignal, Event, SequenceFlow, Variable
+)
+
+
+class TestAILabUpdateProcessIntegration(TestCase):  
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.ai_lab_manager = AILabManager()
+        self.process_to_update = self.__load_process()
+        self.created_process: AgenticProcess = None
+        self.updated_process: AgenticProcess = None
+
+
+    def tearDown(self):
+        """
+        Clean up after each test if necessary.
+        This can be used to delete the created process
+        """
+        if isinstance(self.created_process, AgenticProcess):
+            self.ai_lab_manager.delete_process(self.created_process.id)
+
+    
+    def __load_process(self):
+        """
+        Helper to load a complete process configuration for testing.
+        """
+        self.random_str = str(uuid.uuid4())
+        return AgenticProcess(
+            id="3c071d2f-a044-4513-b2c0-6d27d9420693",
+            key=f"sdk_project_updated_process_{self.random_str[:8]}",
+            name=f"Updated Agentic Process {self.random_str[:8]}",
+            description=f"Process updated for SDK testing purposes {self.random_str[:8]}",
+            kb=KnowledgeBase(name="basic-sample", artifact_type_name=["sample-artifact"]),
+            agentic_activities=[
+                AgenticActivity(key="activityOne", name="First Step Updated", task_name="basic-task", agent_name="GoogleSummarizer2", agent_revision_id=0)
+            ],
+            artifact_signals=[
+                ArtifactSignal(key="artifact.upload.1", name="artifact.upload.updated", handling_type="C", artifact_type_name=["sample-artifact"])
+            ],
+            user_signals=[
+                UserSignal(key="signal_done", name="process-completed-updated")
+            ],
+            start_event=Event(key="artifact.upload.1", name="artifact.upload.updated"),
+            end_event=Event(key="end", name="Done Updated"),
+            sequence_flows=[
+                SequenceFlow(key="step1", source_key="artifact.upload.1", target_key="activityOne"),
+                SequenceFlow(key="step2", source_key="activityOne", target_key="signal_done"),
+                SequenceFlow(key="stepEnd", source_key="signal_done", target_key="end")
+            ]
+        )
+    
+
+    def __update_process(self, process: AgenticProcess = None, automatic_publish: bool = False, upsert: bool = False):
+        """
+        Helper method to update a process.
+        """
+        return self.ai_lab_manager.update_process(
+            process=self.process_to_update if process is None else process,
+            automatic_publish=automatic_publish,
+            upsert=upsert
+        )
+
+
+    def test_update_process_all_fields_success(self):
+        """
+        Test updating a process with all available fields populated.
+        """
+        self.updated_process = self.__update_process()
+        
+        # Assertions
+        self.assertEqual(self.updated_process.name, self.process_to_update.name)
+        self.assertEqual(self.updated_process.description, self.process_to_update.description)
+        
+        # Assert knowledge base
+        self.assertIsNotNone(self.updated_process.kb)
+        self.assertEqual(self.updated_process.kb.name, self.process_to_update.kb.name)
+        
+        # Assert agentic activities
+        self.assertIsNotNone(self.updated_process.agentic_activities)
+        updated_activity = self.updated_process.agentic_activities[0]
+        original_activity = self.process_to_update.agentic_activities[0]
+        self.assertEqual(updated_activity.name, original_activity.name)
+
+        # Assert artifact signals
+        updated_signal = self.updated_process.artifact_signals[0]
+        original_signal = self.process_to_update.artifact_signals[0]
+        self.assertTrue(isinstance(updated_signal, ArtifactSignal))        
+        self.assertEqual(updated_signal.key.lower(), original_signal.key.lower())
+        self.assertEqual(updated_signal.name, original_signal.name)
+        self.assertEqual(updated_signal.handling_type, original_signal.handling_type)
+        
+        # Assert that the process is in draft state after update
+        self.assertTrue(self.updated_process.is_draft, "Expected process to be in draft state after update")
+
+
+    def test_update_process_minimum_fields_success(self):
+        """
+        Test updating a process with minimum required fields (only name).
+        """
+        # Update with minimal data
+        minimal_update = AgenticProcess(
+            id=self.process_to_update.id,
+            name=f"Minimal Updated Process {str(uuid.uuid4())[:8]}"
+        )
+        
+        self.updated_process = self.__update_process(process=minimal_update)
+        self.assertEqual(self.updated_process.name, minimal_update.name)
+
+
+    def test_update_process_invalid_name(self):
+        """
+        Test updating a process with invalid characters in name.
+        """
+        test_params = [True, False]
+        
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):                
+                # Test invalid characters
+                invalid_names = [
+                    f"{self.process_to_update.name}:invalid",
+                    f"{self.process_to_update.name}/invalid"
+                ]
+
+                for invalid_name in invalid_names:
+                    with self.assertRaises(APIError) as exception:
+                        self.process_to_update.name = invalid_name
+                        self.__update_process(automatic_publish=auto_publish)
+                    
+                    self.assertIn(
+                        f"Invalid character in name ({':' if ":" in invalid_name else "/"} is not allowed).",
+                        str(exception.exception),                    
+                        f"Expected an error about invalid character in process name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                    )
+
+
+    def test_update_process_duplicated_name(self):
+        """
+        Test updating a process with a name that already exists.
+        """
+        test_params = [True, False]
+        
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                self.process_to_update.name = "Test Process For Sdk Project"
+                
+                with self.assertRaises(APIError) as exception:
+                    self.__update_process(automatic_publish=auto_publish)
+                
+                self.assertIn(
+                    "A process with this name already exists",
+                    str(exception.exception),                    
+                    f"Expected an error about duplicated process name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+    
+
+    def test_update_process_no_name(self):
+        """
+        Test updating a process without providing a name.
+        """
+        test_params = [True, False]
+        
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                self.process_to_update.name = ""
+                
+                with self.assertRaises(APIError) as exception:
+                    self.__update_process(automatic_publish=auto_publish)
+                
+                self.assertIn(
+                    "Process name cannot be empty",
+                    str(exception.exception),                    
+                    f"Expected an error when process name is empty with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_update_process_invalid_id(self):
+        """
+        Test updating a process with an invalid ID.
+        """
+        test_params = [True, False]
+        
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+                self.process_to_update.id = invalid_id
+                
+                with self.assertRaises(APIError) as exception:
+                    self.__update_process(automatic_publish=auto_publish)
+                
+                self.assertIn(
+                    f"Process-Definition not found [IdOrName= {invalid_id}]",
+                    str(exception.exception),                    
+                    f"Expected an error when process id is invalid and autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_update_process_no_id_invalid_name(self):
+        """
+        Test updating a process without ID.
+        """
+        test_params = [True, False]
+        
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                self.process_to_update.id = ""
+                
+                with self.assertRaises(APIError) as exception:
+                    self.__update_process(automatic_publish=auto_publish)
+                
+                self.assertIn(
+                    f"Process-Definition not found [IdOrName= {self.process_to_update.name}]",
+                    str(exception.exception),                    
+                    f"Expected an error when process id is invalid and autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_update_process_knowledge_base(self):
+        """
+        Test updating a process with different knowledge base configurations.
+        """
+        
+        # Update with different KB
+        self.process_to_update.kb = KnowledgeBase(name="updated-kb", artifact_type_name=["updated-artifact"])
+        
+        self.updated_process = self.__update_process()
+        self.assertEqual(self.updated_process.kb.name, "updated-kb")
+        self.assertEqual(self.updated_process.kb.artifact_type_name, ["updated-artifact"])
+
+
+    def test_update_process_automatic_publish(self):
+        """
+        Test updating a process with automatic publish enabled.
+        """        
+        # Create a task for publishing
+        unique_key = str(uuid.uuid4())
+        task = Task(name=unique_key, description="Basic task for process", title_template="Basic Task")
+        self.ai_lab_manager.create_task(task=task, automatic_publish=True)
+        
+        # Update process with task reference
+        self.process_to_update.agentic_activities[0].task_name = unique_key
+        
+        self.updated_process = self.__update_process(automatic_publish=True)
+        self.assertFalse(self.updated_process.is_draft, "Expected process to be published after update with automatic_publish=True")    
+
+
+    def test_update_process_upsert_existing(self):
+        """
+        Test updating a process with upsert=True when process exists.
+        """
+        # Update existing process with upsert
+        self.updated_process = self.__update_process(upsert=True)
+        self.assertEqual(self.updated_process.name, self.process_to_update.name)
+        self.assertEqual(self.updated_process.id, self.process_to_update.id)
+
+
+    def test_update_process_upsert_new(self):
+        """
+        Test updating a process with upsert=True when process doesn't exist (should create new).
+        """
+        new_id = str(uuid.uuid4())
+        self.process_to_update.id = new_id
+        
+        self.created_process = self.__update_process(upsert=True)
+        self.assertEqual(self.created_process.name, self.process_to_update.name)
+        self.assertIsNotNone(self.created_process.id)
+
+
+    def test_update_process_by_name_instead_of_id(self):
+        """
+        Test updating a process by name instead of ID.
+        """
+        self.process = self.ai_lab_manager.get_process(self.process_to_update.id)
+        self.process_to_update.id = None
+        self.process_to_update.name = self.process.name
+        self.process_to_update.description = "Updated via name instead of ID"
+        
+        
+        self.updated_process = self.__update_process()
+        self.assertEqual(self.updated_process.description, "Updated via name instead of ID")