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

pygeai/tests/integration/lab/agents/test_create_agent.py

@@ -0,0 +1,319 @@
+from unittest import TestCase
+import unittest
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Agent, AgentData, Prompt, LlmConfig, Model, Sampling, PromptExample, PromptOutput
+from pydantic import ValidationError
+from pygeai.core.common.exceptions import APIError, InvalidAPIResponseException 
+
+
+class TestAILabCreateAgentIntegration(TestCase):    
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.ai_lab_manager = AILabManager()
+        self.new_agent = self.__load_agent()
+        self.created_agent: Agent = None
+
+
+    def tearDown(self):
+        """
+        Clean up after each test if necessary.
+        This can be used to delete the created agent or reset the state.
+        """
+        if isinstance(self.created_agent, Agent):
+            self.ai_lab_manager.delete_agent(self.created_agent.id)
+
+
+    def __load_agent(self):
+        random_str = str(uuid.uuid4())
+        return Agent(
+            name=random_str,
+            access_scope="public",
+            public_name=f"public_{random_str}",
+            job_description="Translator",
+            description="Agent that translates from any language to english.",
+            agent_data=AgentData(
+                prompt=Prompt(
+                    instructions="the user will provide a text, you must return the same text translated to english",
+                    inputs=["text", "avoid slang indicator"],
+                    outputs=[
+                        PromptOutput(key="translated_text", description="translated text, with slang or not depending on the indication. in plain text.")
+                    ],
+                    examples=[
+                        PromptExample(input_data="hola mundo [no-slang]", output='{"translated_text":"hello world"}'),
+                        PromptExample(input_data="esto es una prueba pincheguey [keep-slang]", output='{"translated_text":"this is a test pal"}')
+                    ]
+                ),
+                llm_config=LlmConfig(
+                    max_tokens=1800,
+                    timeout=0,
+                    sampling=Sampling(temperature=0.3, top_k=0, top_p=0)
+                ),
+                models=[Model(name="gpt-4o")]
+            )
+        )
+
+
+    def __create_agent(self, agent=None, automatic_publish=False):
+        """
+        Helper to create an agent with the current project_id and ai_lab_manager.
+        If automatic_publish is None, do not pass it (useful for tests that omit it).
+        """
+        return self.ai_lab_manager.create_agent(
+            agent=self.new_agent if agent is None else agent,
+            automatic_publish=automatic_publish
+        )
+
+
+    def test_create_agent_full_data(self):
+        self.created_agent = self.__create_agent()
+        created_agent = self.created_agent
+        agent = self.new_agent
+
+        self.assertTrue(isinstance(created_agent, Agent), "Expected a created agent")
+
+        # Assert the main fields of the created agent
+        self.assertIsNotNone(created_agent.id)
+        self.assertEqual(created_agent.name, agent.name)
+        self.assertEqual(created_agent.access_scope, agent.access_scope)
+        self.assertEqual(created_agent.public_name, agent.public_name)
+        self.assertEqual(created_agent.avatar_image, agent.avatar_image)
+        self.assertEqual(created_agent.description, agent.description)
+        self.assertEqual(created_agent.job_description, agent.job_description)
+
+        # Assert agentData fields
+        agent_data = created_agent.agent_data
+        self.assertIsNotNone(agent_data)
+        self.assertEqual(agent_data.llm_config.max_tokens, agent.agent_data.llm_config.max_tokens)
+        self.assertEqual(agent_data.llm_config.timeout, agent.agent_data.llm_config.timeout)
+        self.assertEqual(agent_data.llm_config.sampling.temperature, agent.agent_data.llm_config.sampling.temperature)
+        self.assertEqual(agent_data.llm_config.sampling.top_k, agent.agent_data.llm_config.sampling.top_k)
+        self.assertEqual(agent_data.llm_config.sampling.top_p, agent.agent_data.llm_config.sampling.top_p)
+        self.assertEqual(agent_data.models[0].name, agent.agent_data.models[0].name)
+
+        # Assert prompt fields
+        prompt = agent_data.prompt
+        self.assertEqual(prompt.instructions, agent.agent_data.prompt.instructions)
+        self.assertEqual(prompt.inputs, agent.agent_data.prompt.inputs)
+        self.assertEqual(prompt.outputs[0].key, agent.agent_data.prompt.outputs[0].key)
+        self.assertEqual(prompt.outputs[0].description, agent.agent_data.prompt.outputs[0].description)
+
+        # Assert prompt examples
+        self.assertEqual(prompt.examples[0].input_data, agent.agent_data.prompt.examples[0].input_data)
+        self.assertEqual(prompt.examples[0].output, agent.agent_data.prompt.examples[0].output)
+
+
+    def test_create_agent_minimum_required_data(self):
+        self.new_agent = Agent(
+            name=str(uuid.uuid4()),
+            description="Agent that translates from any language to english.",
+            agent_data=AgentData(
+                prompt=Prompt(
+                    instructions="the user will provide a text, you must return the same text translated to english",
+                    inputs=["text", "avoid slang indicator"]
+                ),
+                llm_config=LlmConfig(
+                    max_tokens=1800,
+                    timeout=0
+                ),
+                models=[Model(name="gpt-4o")]
+            )
+        )
+        self.created_agent = self.__create_agent()
+        agent = self.new_agent
+
+        self.assertIsNotNone(self.created_agent.id)
+        self.assertEqual(self.created_agent.name, agent.name)
+        self.assertEqual(self.created_agent.description, agent.description)
+
+         # Assert agentData fields
+        agent_data = self.created_agent.agent_data
+        self.assertIsNotNone(agent_data)
+        self.assertEqual(agent_data.llm_config.max_tokens, agent.agent_data.llm_config.max_tokens)
+        self.assertEqual(agent_data.llm_config.timeout, agent.agent_data.llm_config.timeout)
+        self.assertEqual(agent_data.models[0].name, agent.agent_data.models[0].name)
+
+        # Assert prompt fields
+        prompt = agent_data.prompt
+        self.assertEqual(prompt.instructions, agent.agent_data.prompt.instructions)
+        self.assertEqual(prompt.inputs, agent.agent_data.prompt.inputs)
+
+
+    def test_create_agent_without_required_data(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+            
+            with self.subTest(input=auto_publish):
+                self.new_agent = Agent(
+                    name=str(uuid.uuid4())
+                )
+                if auto_publish:
+                    
+                    with self.assertRaises(APIError) as exception:
+                        self.__create_agent(automatic_publish=auto_publish)
+
+                    #TODO: Change validation error to a more specific one
+                    self.assertIn(
+                        "A valid prompt is required. To be valid, it must provide clear instructions to the model",
+                        str(exception.exception)
+                    )   
+                else:
+                    created_agent = self.__create_agent(automatic_publish=auto_publish)
+                    self.assertTrue(isinstance(created_agent, Agent), "Expected a created agent")
+
+
+    def test_create_agent_no_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                self.new_agent.name = ""
+                with self.assertRaises(APIError) as exception:
+                    self.__create_agent(automatic_publish=auto_publish)
+
+                self.assertIn(
+                    "Agent name cannot be empty.",
+                    str(exception.exception),
+                    f"Expected an error about the missing agent name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_create_agent_duplicated_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+
+            with self.subTest(input=auto_publish):
+                self.new_agent.name = "AritmeticaExpert"
+                with self.assertRaises(APIError) as exception:
+                    self.__create_agent(automatic_publish=auto_publish)
+                self.assertIn(
+                    "Agent cannot be created as it already exists [name=AritmeticaExpert].",
+                    str(exception.exception),                    
+                    f"Expected an error about duplicated agent name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_create_agent_invalid_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                new_agent = self.__load_agent()
+                new_agent2 = self.__load_agent()
+
+                with self.assertRaises(APIError) as exception:
+                    new_agent.name = f"{new_agent.name}:invalid"
+                    self.__create_agent(agent=new_agent, automatic_publish=auto_publish)
+                self.assertIn(
+                    "Invalid character in name (: is not allowed).",
+                    str(exception.exception),                    
+                    f"Expected an error about invalid character (:) in agent name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+                with self.assertRaises(APIError) as exception:
+                    new_agent2.name = f"{new_agent2.name}/invalid"
+                    self.__create_agent(agent=new_agent2, automatic_publish=auto_publish)
+                self.assertIn(
+                    "Invalid character in name (/ is not allowed).",
+                    str(exception.exception),                    
+                    f"Expected an error about invalid character (/) in agent name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+        
+
+    def test_create_agent_invalid_scope(self):
+        self.new_agent.access_scope = "project" 
+        with self.assertRaises(ValueError) as exc:
+            self.__create_agent()
+        self.assertEqual(
+            str(exc.exception),
+            "Access scope must be one of public, private.",
+            "Expected a ValueError exception for invalid access scope"
+        )
+
+
+    def test_create_agent_default_scope(self):
+        self.new_agent.access_scope = None
+        self.created_agent = self.__create_agent()
+
+        self.assertEqual(self.created_agent.access_scope, "private", "Expected the default access scope to be 'private' when not specified")
+
+
+    def test_create_agent_no_public_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+
+            with self.subTest(input=auto_publish):
+                self.new_agent.public_name = None
+                with self.assertRaises(APIError) as exception:
+                    self.__create_agent(automatic_publish=auto_publish)
+                self.assertIn(
+                    "Agent publicName is required for agents with accessScope=public.",
+                    str(exception.exception),                    
+                    f"Expected an error about missing publicName for public access scope with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+    
+    def test_create_agent_invalid_public_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish): 
+                self.new_agent.public_name = self.new_agent.public_name.replace("_", "#")  # Add invalid character to public name
+                with self.assertRaises(APIError) as exception:
+                    self.__create_agent(automatic_publish=auto_publish)
+
+                self.assertIn(
+                    "Invalid public name, it can only contain lowercase letters, numbers, periods (.), dashes (-), and underscores (_). Please remove any other characters.",
+                    str(exception.exception),                    
+                    f"The expected error about invalid publicName was not returned when autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+
+    
+    def test_create_agent_duplicated_public_name(self):
+        test_params = [ True, False ]
+        self.created_agent = self.__create_agent()
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                duplicated_pn_agent = self.__load_agent()
+                duplicated_pn_agent.public_name = self.created_agent.public_name
+
+                with self.assertRaises(APIError) as exception:
+                    self.__create_agent(agent=duplicated_pn_agent, automatic_publish=auto_publish)
+                self.assertIn(
+                    f"Agent already exists [publicName={self.created_agent.public_name}].",
+                    str(exception.exception),                   
+                    f"Expected an error about the duplicated public name when autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+
+    
+    def test_create_agent_no_prompt_instructions(self):
+        self.new_agent.agent_data.prompt.instructions = ""
+        self.created_agent = self.__create_agent()
+
+        self.assertTrue(
+            isinstance(self.created_agent, Agent),
+            "Expected a created agent"
+        )
+        
+        self.assertIsNone(
+            self.created_agent.agent_data.prompt.instructions,
+            "Expected the created agent to not have prompt instructions"
+        )
+
+    
+    def test_create_agent_autopublish(self): 
+        self.created_agent = self.__create_agent(automatic_publish=True)
+        self.assertFalse(self.created_agent.is_draft, "Expected the agent to be published automatically")
+    
+    
+    def test_create_agent_autopublish_private_scope(self):
+        self.new_agent.access_scope = "private"
+
+        self.created_agent = self.__create_agent(automatic_publish=True)
+        self.assertFalse(self.created_agent.is_draft, "Expected the agent to be published automatically even with private scope")

pygeai/tests/integration/lab/agents/test_create_sharing_link.py

@@ -0,0 +1,70 @@
+from unittest import TestCase
+import unittest
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import SharingLink
+from pygeai.core.common.exceptions import APIError, MissingRequirementException
+
+ai_lab_manager: AILabManager
+
+class TestAILabCreateSharingLinkIntegration(TestCase):  
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        self.agent_id = "0026e53d-ea78-4cac-af9f-12650e5bb6d9" 
+
+    def __create_sharing_link(self, agent_id=None):
+        return self.ai_lab_manager.create_sharing_link(
+            agent_id=self.agent_id if agent_id is None else agent_id
+        )
+    
+    @unittest.skip("Endpoint is not found. Validate if it was deleted")
+    def test_create_sharing_link(self):    
+        shared_link = self.__create_sharing_link()        
+        self.assertIsInstance(shared_link, SharingLink, "Expected response to be an instance of SharingLink")
+       
+        self.assertEqual(
+            shared_link.agent_id,
+            self.agent_id,
+            "Returned agentId should match the requested agent_id"
+        )
+        self.assertTrue(
+            shared_link.api_token.startswith("shared-"),
+            "apiToken should start with 'shared-'"
+        )
+        self.assertTrue(
+            shared_link.shared_link.startswith("https://"),
+            "sharedLink should be a valid URL"
+        )
+        self.assertIn(
+            f"agentId={self.agent_id}",
+            shared_link.shared_link,
+            "sharedLink should contain the agentId as a query parameter"
+        )
+        self.assertIn(
+            f"sharedToken={shared_link.api_token}",
+            shared_link.shared_link,
+            "sharedLink should contain the apiToken as sharedToken"
+        )
+
+
+    @unittest.skip("Endpoint is not found. Validate if it was deleted")
+    def test_create_sharing_link_no_agent_id(self):
+        with self.assertRaises(MissingRequirementException) as context:
+            self.__create_sharing_link(agent_id="")
+        self.assertEqual(
+            str(context.exception),
+            "agent_id must be specified in order to create sharing link",
+            "Expected exception for missing agent_id"
+        )
+
+
+    @unittest.skip("Endpoint is not found. Validate if it was deleted")
+    def test_create_sharing_link_invalid_agent_id(self):
+        with self.assertRaises(APIError) as exception:
+            invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+            self.__create_sharing_link(agent_id=invalid_id)
+        self.assertIn(
+            f"Agent not found [IdOrName= {invalid_id}].",
+            str(exception.exception),
+            "Expected error message for invalid agent id"
+        )

pygeai/tests/integration/lab/agents/test_delete_agent.py

@@ -0,0 +1,75 @@
+from unittest import TestCase
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Agent, AgentData, Prompt, LlmConfig, Model
+from pygeai.core.common.exceptions import InvalidAPIResponseException
+
+ai_lab_manager: AILabManager
+
+class TestAILabDeleteAgentIntegration(TestCase):  
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        
+
+    def __create_agent(self):
+        """
+        Helper to create an agent with the current project_id and ai_lab_manager.
+        If automatic_publish is None, do not pass it (useful for tests that omit it).
+        """
+        agent = Agent(
+            name=str(uuid.uuid4()),
+            description="Agent that translates from any language to english.",
+            agent_data=AgentData(
+                prompt=Prompt(
+                    instructions="the user will provide a text, you must return the same text translated to english",
+                    inputs=["text", "avoid slang indicator"]
+                ),
+                llm_config=LlmConfig(
+                    max_tokens=1800,
+                    timeout=0
+                ),
+                models=[Model(name="gpt-4o")]
+            )
+        )
+
+
+        return self.ai_lab_manager.create_agent(
+            agent=agent
+        )
+
+    def __delete_agent(self, agent_id: str):
+        return self.ai_lab_manager.delete_agent(
+            agent_id=agent_id
+        )
+    
+
+    def test_delete_agent(self):         
+        create_agent = self.__create_agent()     
+        deleted_agent = self.__delete_agent(agent_id=create_agent.id)
+
+        self.assertEqual(
+            deleted_agent.content,
+            "Agent deleted successfully",
+            "Expected confirmation message after deletion"            
+        )
+
+
+    def test_delete_agent_no_agent_id(self):
+        with self.assertRaises(InvalidAPIResponseException) as exception:
+            self.__delete_agent(agent_id="")
+
+        self.assertIn("405",str(exception.exception))    
+        self.assertIn("Method Not Allowed",str(exception.exception))
+
+
+    def test_delete_agent_invalid_agent_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        with self.assertRaises(InvalidAPIResponseException) as exception:
+            self.__delete_agent(agent_id=invalid_id)
+
+        self.assertIn(
+            f"Agent not found [IdOrName= {invalid_id}].",
+            str(exception.exception),
+            "Expected error message for invalid agent id"
+        )

pygeai/tests/integration/lab/agents/test_get_agent.py

@@ -0,0 +1,94 @@
+from unittest import TestCase
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Agent, FilterSettings
+from pygeai.core.common.exceptions import MissingRequirementException, APIError
+import copy
+
+ai_lab_manager: AILabManager
+
+class TestAILabGetAgentIntegration(TestCase):    
+    __required_attrs = [
+        'id', 'status', 'name', 'access_scope', 'public_name',
+        'avatar_image', 'description', 'job_description',
+        'is_draft', 'is_readonly', 'revision', 'version', 'agent_data'
+    ]
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        self.agent_id = "0026e53d-ea78-4cac-af9f-12650e5bb6d9"
+        self.filter_settings = FilterSettings(
+            revision="0",
+            version="0"
+        )
+
+    def __get_agent(self, agent_id=None, filter_settings: FilterSettings = None):
+        return self.ai_lab_manager.get_agent(
+            agent_id=self.agent_id if agent_id is None else agent_id,
+            filter_settings=self.filter_settings if filter_settings is None else filter_settings
+        )
+
+    def test_get_agent(self):
+        agent = self.__get_agent()
+
+        self.assertIsInstance(agent, Agent, "Expected an agent") 
+        for attr in self.__required_attrs:
+                self.assertTrue(
+                    hasattr(agent, attr),
+                    f"Agent should have an '{attr}' attribute"
+                )
+ 
+
+    def test_get_agent_no_agent_id(self):
+        with self.assertRaises(Exception) as context:
+            self.__get_agent(agent_id="")
+        self.assertIn(
+            "agent_id must be specified in order to retrieve the agent",
+            str(context.exception),
+            "Expected exception for missing agent_id"
+        )
+
+
+    def test_get_agent_invalid_agent_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        with self.assertRaises(APIError) as context:
+            self.__get_agent(agent_id=invalid_id)
+        self.assertIn(
+            f"Agent not found [IdOrName= {invalid_id}].",
+            str(context.exception),
+            "Expected an error for invalid agent id"
+        )
+
+
+    def test_get_agent_no_revision(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.revision = None
+        agent = self.__get_agent(filter_settings=filter_settings)
+
+        self.assertIsInstance(agent, Agent, "Expected an agent")
+        self.assertGreater(agent.revision, 1, "Expected agent revision to be the latest")
+
+    
+    def test_get_agent_by_revision(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.revision = "5"
+        agent = self.__get_agent(filter_settings=filter_settings)
+
+        self.assertEqual(5, agent.revision, "Expected agent revision to be 5")
+        self.assertIn("Version 2", agent.description, "Expected agent description to match the one in revision 5")
+
+
+    def test_get_agent_no_version(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.version = None
+        agent = self.__get_agent(filter_settings=filter_settings)
+
+        self.assertGreater(agent.version, 1, "Expected agent version to be the latest")
+        self.assertIn("Latest version", agent.description, "Expected agent description to contain 'Latest version'")
+
+
+    def test_get_agent_by_version(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.version = "1"
+        agent = self.__get_agent(filter_settings=filter_settings)
+
+        self.assertNotIn("Latest version", agent.description, "Expected agent description to not contain 'Latest version'")

pygeai/tests/integration/lab/agents/test_publish_agent_revision.py

@@ -0,0 +1,127 @@
+from unittest import TestCase
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Agent, AgentData, Prompt, PromptOutput, PromptExample, LlmConfig, Sampling, Model
+from pygeai.core.common.exceptions import APIError
+
+ai_lab_manager: AILabManager
+
+class TestAILabPublishAgentRevisionIntegration(TestCase):  
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        self.agent_id = "b4b09935-2ad2-42c0-bd55-1ee6fa4b6034"
+
+    
+    def __publish_agent_revision(self,  revision: str, agent_id=None):
+        return self.ai_lab_manager.publish_agent_revision(
+            agent_id=self.agent_id if agent_id is None else agent_id,
+            revision=revision
+        )
+    
+
+    def __load_agent(self):
+        random_str = str(uuid.uuid4())
+        agent = Agent(
+            id="b4b09935-2ad2-42c0-bd55-1ee6fa4b6034",
+            name=f"UpdatedAgent{random_str}",
+            access_scope="public",
+            public_name=f"public_{random_str}",
+            job_description=f"SummarizerAgent{random_str}",
+            description=f"Agent that summarized documents. {random_str}",
+            agent_data=AgentData(
+                prompt=Prompt(
+                    instructions="the user will provide a document, you must return a summary of the document.",
+                    inputs=["text", "avoid slang indicator"],
+                    outputs=[
+                        PromptOutput(key="translated_text", description="translated text, with slang or not depending on the indication. in plain text.")
+                    ],
+                    examples=[
+                        PromptExample(input_data="hola mundo [no-slang]", output='{"translated_text":"hello world"}'),
+                        PromptExample(input_data="esto es una prueba pincheguey [keep-slang]", output='{"translated_text":"this is a test pal"}')
+                    ]
+                ),
+                llm_config=LlmConfig(
+                    max_tokens=1800,
+                    timeout=0,
+                    sampling=Sampling(temperature=0.3, top_k=0, top_p=0)
+                ),
+                models=[Model(name="openai/gpt-4o")]
+            )
+        )
+
+        return agent
+
+
+    def __update_agent(self):
+        """
+        Helper method to update agent and generate a new revision of it
+        """
+        agent = self.__load_agent()
+        return self.ai_lab_manager.update_agent(
+            agent=agent,
+            automatic_publish=False, 
+            upsert=False
+        )    
+
+
+    def test_publish_agent_revision(self):
+        new_revision = (self.__update_agent()).revision
+        published_agent = self.__publish_agent_revision(revision=new_revision)
+
+        self.assertFalse(published_agent.is_draft, "Expected draft to be false after publishing the revision") 
+        self.assertEqual(published_agent.revision, new_revision, "Expected last revision to be published") 
+
+    
+    def test_publish_agent_earlier_revision_with_newer_revision_published(self):
+        with self.assertRaises(APIError) as exception:
+            self.__publish_agent_revision(revision="1")
+        self.assertIn(
+            "There are newer published revisions.",
+            str(exception.exception),
+            "Expected error when trying to send a earlier revision"
+        )
+
+
+    def test_publish_agent_earlier_revision(self):
+        earlier_revision = (self.__update_agent()).revision
+        self.__update_agent()
+        published_agent = self.__publish_agent_revision(revision=earlier_revision)
+
+        self.assertFalse(published_agent.is_draft, "Expected draft to be false after publishing the revision") 
+        self.assertEqual(published_agent.revision, earlier_revision, "Expected last revision to be published") 
+
+
+    def test_publish_agent_invalid_revision(self):
+        with self.assertRaises(APIError) as exception:
+            self.__publish_agent_revision(revision="10000000")
+        self.assertIn(
+            "Invalid revision [rev=10000000]",
+            str(exception.exception),
+            "Expected error when trying to send a revision that does not exist"
+        )
+
+
+    def test_publish_agent_string_revision(self):
+        with self.assertRaises(APIError) as exception:
+            self.__publish_agent_revision(revision="revision")
+        self.assertIn("Bad Request", str(exception.exception))
+        self.assertIn("400", str(exception.exception))
+
+
+    def test_publish_agent_invalid_agent_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        with self.assertRaises(APIError) as exception:
+            self.__publish_agent_revision(revision="103", agent_id=invalid_id)
+        self.assertIn(
+            f"Agent not found [IdOrName= {invalid_id}].",
+            str(exception.exception),
+            "Expected error when sending and invalid agent id"
+        )
+
+    
+    def test_publish_agent_no_agent_id(self):
+        with self.assertRaises(APIError) as exception:
+            self.__publish_agent_revision(revision="103", agent_id="")
+        self.assertIn("Not Found", str(exception.exception))
+        self.assertIn("404", str(exception.exception))