pygeai 0.4.0b3__py3-none-any.whl → 0.5.0__py3-none-any.whl

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(alias="beta")
+        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")

pygeai/tests/integration/lab/reasoning_strategies/test_get_reasoning_strategy.py

@@ -0,0 +1,70 @@
+from unittest import TestCase
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import ReasoningStrategy
+from pygeai.core.common.exceptions import APIError
+
+ai_lab_manager: AILabManager
+
+class TestAILabGetReasoningStrategyIntegration(TestCase):   
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.strategy_id = "0a3b039e-25bd-4cf9-ad67-7af2b654874b"
+        self.strategy_name = "Chain of Thought"
+
+    def __get_reasoning_strategy(self, strategy_id = None, strategy_name = None):
+        return self.ai_lab_manager.get_reasoning_strategy(
+            reasoning_strategy_id= strategy_id if strategy_id is not None else self.strategy_id,
+            reasoning_strategy_name=strategy_name if strategy_name is not None else self.strategy_name
+        )
+
+    def test_get_reasoning_strategy_by_id(self):
+        strategy = self.__get_reasoning_strategy(strategy_name="")
+
+        self.assertIsInstance(strategy, ReasoningStrategy, "Expected a reasoning strategy")
+        self.assertEqual(strategy.id, self.strategy_id, "Expected reasoning strategy ID to match")
+
+
+    def test_get_reasoning_strategy_by_name(self):
+        strategy = self.__get_reasoning_strategy(strategy_id="")
+        
+        self.assertIsInstance(strategy, ReasoningStrategy, "Expected a reasoning strategy")
+        self.assertEqual(
+            strategy.name, 
+            self.strategy_name,
+            "Expected reasoning strategy name to match"
+        )
+
+
+    def test_get_reasoning_strategy_no_id_or_name(self):
+        with self.assertRaises(Exception) as context:
+            self.__get_reasoning_strategy(strategy_id="", strategy_name="")
+
+        self.assertIn(
+            "Either reasoning_strategy_id or reasoning_strategy_name must be provided.",
+            str(context.exception),
+            "Expected error message for missing id and name"
+        )
+
+
+    def test_get_reasoning_strategy_invalid_id(self):
+        invalid_id = "invalid-id-1234"
+        with self.assertRaises(APIError) as context:
+            self.__get_reasoning_strategy(strategy_id=invalid_id)
+        self.assertIn(
+            f"Reasoning-Strategy not found (idOrName={invalid_id}",
+            str(context.exception),
+            "Expected an error for invalid reasoning strategy id"
+        )
+
+
+    def test_get_reasoning_strategy_invalid_name(self):
+        invalid_name = "Nonexistent Strategy"
+        with self.assertRaises(APIError) as context:
+            self.__get_reasoning_strategy(strategy_id="", strategy_name=invalid_name)
+
+        self.assertIn(
+            f"Reasoning-Strategy not found (idOrName={invalid_name})",
+            str(context.exception),
+            "Expected an error for invalid reasoning strategy name"
+        )

pygeai/tests/integration/lab/reasoning_strategies/test_list_reasoning_strategies.py

@@ -0,0 +1,93 @@
+from unittest import TestCase
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import FilterSettings, ReasoningStrategyList
+import copy
+
+ai_lab_manager: AILabManager
+
+class TestAILabListReasoningStrategiesIntegration(TestCase):    
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.filter_settings = FilterSettings(
+            name="",
+            start=0,
+            count=100,
+            allow_external=True,
+            access_scope="public"
+        )
+
+    
+    def __list_reasoning_strategies(self, filter_settings: FilterSettings = None):
+        filter_settings = filter_settings if filter_settings is not None else self.filter_settings
+        return self.ai_lab_manager.list_reasoning_strategies(filter_settings=filter_settings)
+    
+    
+    def test_public_list_reasoning_strategies(self):
+        result = self.__list_reasoning_strategies()
+
+        self.assertIsInstance(result, ReasoningStrategyList, "Expected a list of reasoning strategies")
+        for strategy in result.strategies:
+            self.assertTrue(
+                strategy.access_scope == "public",
+                "Expected all reasoning strategies to be public"
+            )
+
+
+    def test_private_list_reasoning_strategies(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.access_scope = "private"
+        result = self.__list_reasoning_strategies(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, ReasoningStrategyList, "Expected a list of reasoning strategies")
+        for strategy in result.strategies:
+            self.assertTrue(
+                strategy.access_scope == "private",
+                "Expected all reasoning strategies to be private"
+            )
+
+
+    def test_list_reasoning_strategies_small_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 2
+        result = self.__list_reasoning_strategies(filter_settings=filter_settings)
+        self.assertEqual(
+            len(result), 2,
+            "Expected list of reasoning strategies returned to be 2"
+        )
+
+
+    def test_list_reasoning_strategies_big_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 500
+        result = self.__list_reasoning_strategies(filter_settings=filter_settings)
+        self.assertLessEqual(
+            len(result), 500,
+            "Expected list of reasoning strategies returned to be 500 or less"
+        )
+
+
+    def test_list_reasoning_strategies_name_filter(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.name = "Chain of Thought"
+        result = self.__list_reasoning_strategies(filter_settings=filter_settings)
+
+        for strategy in result.strategies:
+            self.assertIn(
+                "Chain of Thought",
+                strategy.name,
+                "Expected reasoning strategy name to contain filter value"
+            )
+
+   
+    def test_list_reasoning_strategies_invalid_scope(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.access_scope = "project"
+
+        with self.assertRaises(ValueError) as exception:
+            self.__list_reasoning_strategies(filter_settings=filter_settings)
+        self.assertIn(
+            "Access scope must be either 'public' or 'private'.",
+            str(exception.exception),
+            "The expected error about invalid scope was not returned"
+        )

pygeai/tests/integration/lab/reasoning_strategies/test_update_reasoning_strategy.py

@@ -0,0 +1,149 @@
+from unittest import TestCase
+import unittest
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import LocalizedDescription, ReasoningStrategy
+from pydantic import ValidationError
+from pygeai.core.common.exceptions import APIError, APIResponseError
+
+class TestAILabCreateReasoningStrategyIntegration(TestCase):    
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.strategy_to_update = self.__load_strategy()
+
+    
+    def __load_strategy(self):
+        self.random_str = str(uuid.uuid4())
+        return ReasoningStrategy(
+            id="323f5f94-5a3d-4717-89f3-3554a33c093f",
+            name=f"UpdatedStrategy_{self.random_str}",
+            system_prompt=f"Let's think step by step. {self.random_str}",
+            access_scope="private",
+            type="addendum",
+            localized_descriptions=[
+                LocalizedDescription(language="spanish", description=f"RSName spanish description {self.random_str}"),
+                LocalizedDescription(language="english", description=f"RSName english description {self.random_str}"),
+                LocalizedDescription(language="japanese", description=f"RSName japanese description {self.random_str}")
+            ]
+        )
+    
+
+    def __update_strategy(self, strategy=None, upsert = False):
+        """
+        Helper to create a reasoning strategy using ai_lab_manager.
+        """
+        return self.ai_lab_manager.update_reasoning_strategy(
+            strategy=self.strategy_to_update if strategy is None else strategy,
+            upsert=upsert
+        )
+    
+
+    def test_update_strategy_full_data(self):
+        self.updated_strategy = self.__update_strategy()
+
+        self.assertEqual(self.updated_strategy.name, self.strategy_to_update.name)
+        self.assertEqual(self.updated_strategy.system_prompt, self.strategy_to_update.system_prompt)
+
+        for locale in self.updated_strategy.localized_descriptions:
+            self.assertIn(
+                self.random_str, 
+                locale.description,
+                "Expected the localized description to be updated correctly"
+            )
+
+
+    def test_update_strategy_no_name(self):  
+        self.strategy_to_update.name = None
+
+        with self.assertRaises(APIError) as exception:
+            self.__update_strategy()
+        self.assertIn(
+            "ReasoningStrategy name cannot be empty",
+            str(exception.exception),
+            "The expected error about empty name was not returned"
+        )
+    
+
+    def test_update_strategy_no_system_prompt(self):
+        self.strategy_to_update.system_prompt = None
+        
+        with self.assertRaises(APIError) as exception:
+            self.__update_strategy()
+        self.assertIn(
+            "ReasoningStrategy template or systemPrompt are required.",
+            str(exception.exception),
+            "The expected error about empty system_prompt was not returned"
+        )
+
+
+    def test_update_strategy_no_public_name(self):
+        self.strategy_to_update.access_scope = "public"
+        with self.assertRaises(APIError) as exception:
+            self.__update_strategy()
+        self.assertIn(
+            "ReasoningStrategy publicName is required for public strategies",
+            str(exception.exception),
+            "The expected error about missing public name was not returned"
+        )
+
+
+    def test_update_strategy_no_access_scope(self):
+        self.strategy_to_update.access_scope = ""
+        with self.assertRaises(ValueError) as exception:
+            self.__update_strategy()
+        self.assertIn(
+            "Access scope must be either 'public' or 'private'",
+            str(exception.exception),
+            "The expected error about missing access scope was not returned"
+        )
+
+    
+    def test_update_strategy_no_type(self):
+        self.strategy_to_update.type = ""
+        with self.assertRaises(ValueError) as exception:
+            self.__update_strategy()
+        self.assertIn(
+            "Type must be 'addendum'",
+            str(exception.exception),
+            "The expected error about missing type was not returned"
+        )
+
+
+    def test_update_strategy_invalid_type(self):
+        self.strategy_to_update.type = "strategy_type"
+        
+        with self.assertRaises(ValueError) as exception:
+            self.__update_strategy()
+        self.assertIn(
+            "Type must be 'addendum'",
+            str(exception.exception),
+            "The expected error about missing type was not returned"
+        )
+
+    
+    def test_update_strategy_no_localized_descriptions(self):
+        self.strategy_to_update.localized_descriptions = []    
+        updated_strategy = self.__update_strategy()
+        self.assertIsNone(
+            updated_strategy.localized_descriptions,
+            "Expected no localized descriptions after update"
+        )    
+
+    @unittest.skip("Skipping upsert test to avoid creating new strategies during routine testing before having a cleanup mechanism.")
+    def test_update_strategy_upsert(self):			
+        new_id = str(uuid.uuid4())
+        new_strategy = ReasoningStrategy(
+            id=new_id,
+            name=f"UpsertStrategy_{self.random_str}",
+            system_prompt=f"Upsert system prompt {self.random_str}",
+            access_scope="private",
+            type="addendum",
+            localized_descriptions=[
+                LocalizedDescription(language="english", description=f"Upsert description {self.random_str}")
+            ]
+        )
+        upserted_strategy = self.__update_strategy(strategy=new_strategy, upsert=True)
+        self.assertEqual(upserted_strategy.id, new_id, "Expected the reasoning strategy to be created via upsert")