pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/tests/cli/commands/test_rag.py

@@ -0,0 +1,266 @@
+import unittest
+from unittest.mock import patch, Mock
+from pygeai.cli.commands.rag import (
+    show_help,
+    get_assistants_from_project,
+    get_assistant_detail,
+    create_assistant,
+    update_assistant,
+    delete_assistant,
+    list_documents,
+    delete_all_documents,
+    get_document_data,
+    upload_document,
+    delete_document,
+    Option
+)
+from pygeai.core.common.exceptions import MissingRequirementException, WrongArgumentError
+
+
+class TestRagCommands(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.cli.commands.test_rag.TestRagCommands
+    """
+    def setUp(self):
+        # Helper to create Option objects for testing
+        self.mock_option = lambda name, value: (Option(name, [f"--{name}"], f"Description for {name}", True), value)
+
+    @patch('pygeai.cli.commands.rag.Console.write_stdout')
+    @patch('pygeai.cli.commands.rag.build_help_text')
+    def test_show_help(self, mock_build_help, mock_write_stdout):
+        mock_help_text = "Mocked help text"
+        mock_build_help.return_value = mock_help_text
+
+        show_help()
+
+        mock_build_help.assert_called_once()
+        mock_write_stdout.assert_called_once_with(mock_help_text)
+
+    @patch('pygeai.cli.commands.rag.Console.write_stdout')
+    @patch('pygeai.cli.commands.rag.RAGAssistantClient')
+    def test_get_assistants_from_project(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.get_assistants_from_project.return_value = {"assistants": ["assistant1", "assistant2"]}
+
+        get_assistants_from_project()
+
+        mock_instance.get_assistants_from_project.assert_called_once()
+        mock_write_stdout.assert_called_once_with("RAG Assistants in project: \n{'assistants': ['assistant1', 'assistant2']}")
+
+    @patch('pygeai.cli.commands.rag.Console.write_stdout')
+    @patch('pygeai.cli.commands.rag.RAGAssistantClient')
+    def test_get_assistant_detail_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.get_assistant_data.return_value = {"name": "test_assistant"}
+        option_list = [self.mock_option("name", "test_assistant")]
+
+        get_assistant_detail(option_list)
+
+        mock_instance.get_assistant_data.assert_called_once_with("test_assistant")
+        mock_write_stdout.assert_called_once_with("Assistant detail: \n{'name': 'test_assistant'}")
+
+    def test_get_assistant_detail_missing_name(self):
+        option_list = []
+
+        with self.assertRaises(MissingRequirementException) as context:
+            get_assistant_detail(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot retrieve assistant detail without name")
+
+    @patch('pygeai.cli.commands.rag.Console.write_stdout')
+    @patch('pygeai.cli.commands.rag.RAGAssistantClient')
+    @patch('pygeai.cli.commands.rag.get_search_options')
+    @patch('pygeai.cli.commands.rag.get_index_options')
+    @patch('pygeai.cli.commands.rag.get_welcome_data')
+    @patch('pygeai.cli.commands.rag.get_boolean_value')
+    @patch('pygeai.cli.commands.rag.get_welcome_data_feature_list')
+    @patch('pygeai.cli.commands.rag.get_welcome_data_example_prompt')
+    def test_create_assistant_success(self, mock_example_prompt, mock_feature_list, mock_boolean, mock_welcome, mock_index, mock_search, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.create_assistant.return_value = {"name": "new_assistant"}
+        mock_search.return_value = {"search": "options"}
+        mock_index.return_value = {"index": "options"}
+        mock_welcome.return_value = {"welcome": "data"}
+        mock_boolean.return_value = True
+        mock_feature_list.return_value = []
+        mock_example_prompt.return_value = []
+        option_list = [
+            self.mock_option("name", "new_assistant"),
+            self.mock_option("description", "A test assistant"),
+            self.mock_option("llm_cache", "true"),
+            self.mock_option("chunk_size", "1000"),
+            self.mock_option("welcome_data_title", "Welcome Title")
+        ]
+
+        create_assistant(option_list)
+
+        mock_instance.create_assistant.assert_called_once_with(
+            name="new_assistant",
+            description="A test assistant",
+            template=None,
+            search_options={"search": "options"},
+            index_options={"index": "options"},
+            welcome_data={"welcome": "data"}
+        )
+        mock_write_stdout.assert_called_once_with("New RAG Assistant: \n{'name': 'new_assistant'}")
+
+    def test_create_assistant_missing_name(self):
+        option_list = []
+
+        with self.assertRaises(MissingRequirementException) as context:
+            create_assistant(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot create RAG assistant without name")
+
+    @patch('pygeai.cli.commands.rag.get_boolean_value')
+    def test_create_assistant_invalid_mmr_options(self, mock_boolean):
+        mock_boolean.return_value = True
+        option_list = [
+            self.mock_option("name", "test_assistant"),
+            self.mock_option("search_type", "similarity"),
+            self.mock_option("search_fetch_k", "5")
+        ]
+
+        with self.assertRaises(WrongArgumentError) as context:
+            create_assistant(option_list)
+
+        self.assertEqual(str(context.exception), "--fetch-k and --lambda are only valid for --search-type 'mmr'")
+
+    @patch('pygeai.cli.commands.rag.Console.write_stdout')
+    @patch('pygeai.cli.commands.rag.RAGAssistantClient')
+    @patch('pygeai.cli.commands.rag.get_search_options')
+    @patch('pygeai.cli.commands.rag.get_welcome_data')
+    @patch('pygeai.cli.commands.rag.get_boolean_value')
+    @patch('pygeai.cli.commands.rag.get_welcome_data_feature_list')
+    @patch('pygeai.cli.commands.rag.get_welcome_data_example_prompt')
+    def test_update_assistant_success(self, mock_example_prompt, mock_feature_list, mock_boolean, mock_welcome, mock_search, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.update_assistant.return_value = {"name": "updated_assistant"}
+        mock_search.return_value = {"search": "options"}
+        mock_welcome.return_value = {"welcome": "data"}
+        mock_boolean.return_value = True
+        mock_feature_list.return_value = []
+        mock_example_prompt.return_value = []
+        option_list = [
+            self.mock_option("name", "updated_assistant"),
+            self.mock_option("status", "1"),
+            self.mock_option("llm_cache", "true"),
+            self.mock_option("welcome_data_title", "Welcome Title")
+        ]
+
+        update_assistant(option_list)
+
+        mock_instance.update_assistant.assert_called_once_with(
+            name="updated_assistant",
+            status="1",
+            description=None,
+            template=None,
+            search_options={"search": "options"},
+            welcome_data={"welcome": "data"}
+        )
+        mock_write_stdout.assert_called_once_with("Updated RAG Assistant: \n{'name': 'updated_assistant'}")
+
+    @patch('pygeai.cli.commands.rag.Console.write_stdout')
+    @patch('pygeai.cli.commands.rag.RAGAssistantClient')
+    def test_delete_assistant_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.delete_assistant.return_value = {"status": "deleted"}
+        option_list = [self.mock_option("name", "test_assistant")]
+
+        delete_assistant(option_list)
+
+        mock_instance.delete_assistant.assert_called_once_with("test_assistant")
+        mock_write_stdout.assert_called_once_with("Deleted assistant: \n{'status': 'deleted'}")
+
+    @patch('pygeai.cli.commands.rag.Console.write_stdout')
+    @patch('pygeai.cli.commands.rag.RAGAssistantClient')
+    def test_list_documents_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.get_documents.return_value = {"documents": ["doc1", "doc2"]}
+        option_list = [
+            self.mock_option("name", "test_assistant"),
+            self.mock_option("skip", "5"),
+            self.mock_option("count", "20")
+        ]
+
+        list_documents(option_list)
+
+        mock_instance.get_documents.assert_called_once_with(name="test_assistant", skip=5, count=20)
+        mock_write_stdout.assert_called_once_with("Assistant's documents: \n{'documents': ['doc1', 'doc2']}")
+
+    @patch('pygeai.cli.commands.rag.Console.write_stdout')
+    @patch('pygeai.cli.commands.rag.RAGAssistantClient')
+    def test_delete_all_documents_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.delete_all_documents.return_value = {"status": "deleted"}
+        option_list = [self.mock_option("name", "test_assistant")]
+
+        delete_all_documents(option_list)
+
+        mock_instance.delete_all_documents.assert_called_once_with(name="test_assistant")
+        mock_write_stdout.assert_called_once_with("Deleted documents: \n{'status': 'deleted'}")
+
+    @patch('pygeai.cli.commands.rag.Console.write_stdout')
+    @patch('pygeai.cli.commands.rag.RAGAssistantClient')
+    def test_get_document_data_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.retrieve_document.return_value = {"id": "doc123"}
+        option_list = [
+            self.mock_option("name", "test_assistant"),
+            self.mock_option("document_id", "doc123")
+        ]
+
+        get_document_data(option_list)
+
+        mock_instance.retrieve_document.assert_called_once_with(name="test_assistant", document_id="doc123")
+        mock_write_stdout.assert_called_once_with("Document detail: \n{'id': 'doc123'}")
+
+    @patch('pygeai.cli.commands.rag.Console.write_stdout')
+    @patch('pygeai.cli.commands.rag.RAGAssistantClient')
+    @patch('pathlib.Path.is_file')
+    def test_upload_document_success(self, mock_is_file, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.upload_document.return_value = {"status": "uploaded"}
+        mock_is_file.return_value = False
+        option_list = [
+            self.mock_option("name", "test_assistant"),
+            self.mock_option("file_path", "/path/to/file"),
+            self.mock_option("upload_type", "multipart")
+        ]
+
+        upload_document(option_list)
+
+        mock_instance.upload_document.assert_called_once_with(
+            name="test_assistant",
+            file_path="/path/to/file",
+            upload_type="multipart",
+            metadata={},
+            content_type=None
+        )
+        mock_write_stdout.assert_called_once_with("Uploaded: \n{'status': 'uploaded'}")
+
+    @patch('pygeai.cli.commands.rag.Console.write_stdout')
+    @patch('pygeai.cli.commands.rag.RAGAssistantClient')
+    def test_delete_document_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.delete_document.return_value = {"status": "deleted"}
+        option_list = [
+            self.mock_option("name", "test_assistant"),
+            self.mock_option("document_id", "doc123")
+        ]
+
+        delete_document(option_list)
+
+        mock_instance.delete_document.assert_called_once_with(name="test_assistant", document_id="doc123")
+        mock_write_stdout.assert_called_once_with("Deleted document: \n{'status': 'deleted'}")
+

pygeai/tests/cli/commands/test_rerank.py

@@ -0,0 +1,110 @@
+import unittest
+from unittest import TestCase
+from unittest.mock import patch, MagicMock
+from pygeai.cli.commands.rerank import show_help, rerank_chunks, rerank_commands, rerank_chunks_options
+from pygeai.core.common.exceptions import MissingRequirementException, WrongArgumentError
+from pygeai.cli.commands import Option
+
+
+class TestRerankCommands(TestCase):
+    """
+    python -m unittest pygeai.tests.cli.commands.test_rerank.TestRerankCommands
+    """
+
+    def setUp(self):
+        # Mock Console to avoid actual stdout writes
+        self.console_patch = patch('pygeai.cli.commands.rerank.Console')
+        self.mock_console = self.console_patch.start()
+        self.mock_console.write_stdout = MagicMock()
+
+    def tearDown(self):
+        self.console_patch.stop()
+
+    def test_show_help(self):
+        show_help()
+        self.mock_console.write_stdout.assert_called_once()
+        self.assertTrue(isinstance(self.mock_console.write_stdout.call_args[0][0], str))
+
+    def test_rerank_chunks_valid_input(self):
+        mock_client = MagicMock()
+        mock_result = {"results": [{"index": 0, "relevance_score": 0.95}]}
+        mock_client.rerank_chunks.return_value = mock_result
+
+        with patch('pygeai.cli.commands.rerank.RerankClient', return_value=mock_client):
+            option_list = [
+                (Option("query", ["--query"], "string", True), "test query"),
+                (Option("model", ["--model"], "string", True), "cohere/rerank-v3.5"),
+                (Option("documents", ["--documents"], "string or array", True), '["doc1", "doc2"]'),
+                (Option("top_n", ["--top-n"], "string", True), 2)
+            ]
+            rerank_chunks(option_list)
+            mock_client.rerank_chunks.assert_called_once_with(
+                query="test query",
+                model="cohere/rerank-v3.5",
+                documents=["doc1", "doc2"],
+                top_n=2
+            )
+            self.mock_console.write_stdout.assert_called_once()
+            self.assertIn("Rerank details", str(self.mock_console.write_stdout.call_args[0][0]))
+
+    def test_rerank_chunks_valid_single_document(self):
+        mock_client = MagicMock()
+        mock_result = {"results": [{"index": 0, "relevance_score": 0.95}]}
+        mock_client.rerank_chunks.return_value = mock_result
+
+        with patch('pygeai.cli.commands.rerank.RerankClient', return_value=mock_client):
+            option_list = [
+                (Option("query", ["--query"], "string", True), "test query"),
+                (Option("model", ["--model"], "string", True), "cohere/rerank-v3.5"),
+                (Option("documents", ["--documents"], "string or array", True), "single doc"),
+                (Option("top_n", ["--top-n"], "string", True), 1)
+            ]
+            rerank_chunks(option_list)
+            mock_client.rerank_chunks.assert_called_once_with(
+                query="test query",
+                model="cohere/rerank-v3.5",
+                documents=["single doc"],
+                top_n=1
+            )
+            self.mock_console.write_stdout.assert_called_once()
+
+    def test_rerank_chunks_missing_requirements(self):
+        option_list = [
+            (Option("query", ["--query"], "string", True), "test query")
+            # Missing model and documents
+        ]
+        with self.assertRaises(MissingRequirementException) as context:
+            rerank_chunks(option_list)
+        self.assertIn("Cannot rerank chunks without model, query and documents", str(context.exception))
+
+    def test_rerank_chunks_invalid_documents_json(self):
+        option_list = [
+            (Option("query", ["--query"], "string", True), "test query"),
+            (Option("model", ["--model"], "string", True), "cohere/rerank-v3.5"),
+            (Option("documents", ["--documents"], "string or array", True), "[{\"not\": \"a list}\"]"),  # Invalid JSON list
+            (Option("top_n", ["--top-n"], "string", True), 3)
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            rerank_chunks(option_list)
+        self.assertIn("Documents must be a list of strings", str(context.exception))
+
+    def test_rerank_chunks_invalid_documents_format(self):
+        option_list = [
+            (Option("query", ["--query"], "string", True), "test query"),
+            (Option("model", ["--model"], "string", True), "cohere/rerank-v3.5"),
+            (Option("documents", ["--documents"], "string or array", True), '[{"1": "a"}'),
+            (Option("top_n", ["--top-n"], "string", True), 3)
+        ]
+        with self.assertRaises(WrongArgumentError) as context:
+            rerank_chunks(option_list)
+        self.assertIn("Documents must be a list of strings", str(context.exception))
+
+    def test_rerank_commands_structure(self):
+        self.assertEqual(len(rerank_commands), 2)
+        self.assertEqual(rerank_commands[0].name, "help")
+        self.assertEqual(rerank_commands[1].name, "rerank")
+        self.assertEqual(len(rerank_commands[1].options), len(rerank_chunks_options))
+        self.assertEqual(rerank_commands[1].options[0].name, "query")
+        self.assertEqual(rerank_commands[1].options[1].name, "model")
+        self.assertEqual(rerank_commands[1].options[2].name, "documents")
+        self.assertEqual(rerank_commands[1].options[3].name, "top_n")

pygeai/tests/cli/commands/test_secrets.py

@@ -0,0 +1,171 @@
+import unittest
+from unittest.mock import patch, Mock
+
+from pygeai.cli.commands.secrets import (
+    show_help,
+    get_secret,
+    create_secret,
+    update_secret,
+    list_secrets,
+    set_secret_accesses,
+    get_secret_accesses
+)
+from pygeai.core.common.exceptions import MissingRequirementException, WrongArgumentError
+
+
+class TestSecretsCommands(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.cli.commands.test_secrets.TestSecretsCommands
+    """
+
+    def test_show_help(self):
+        with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+            show_help()
+            mock_stdout.assert_called_once()
+
+    def test_get_secret_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="secret_id"), "secret-123")
+        ]
+        option_list[0][0].name = "secret_id"
+
+        with patch('pygeai.core.secrets.clients.SecretClient.get_secret', return_value="Secret data") as mock_get:
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                get_secret(option_list)
+                mock_get.assert_called_once_with(secret_id="secret-123")
+                mock_stdout.assert_called_once_with("Get secret result: \nSecret data")
+
+    def test_get_secret_missing_id(self):
+        option_list = []
+        with self.assertRaises(MissingRequirementException) as context:
+            get_secret(option_list)
+        self.assertEqual(str(context.exception), "Cannot retrieve secret without specifying secret-id")
+
+    def test_create_secret_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="name"), "MySecret"),
+            (Mock(spec=['name'], name="secret_string"), "secret-value"),
+            (Mock(spec=['name'], name="description"), "Test description")
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+
+        with patch('pygeai.core.secrets.clients.SecretClient.create_secret', return_value="Created secret") as mock_create:
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                create_secret(option_list)
+                mock_create.assert_called_once_with(
+                    name="MySecret",
+                    secret_string="secret-value",
+                    description="Test description"
+                )
+                mock_stdout.assert_called_once_with("Create secret result: \nCreated secret")
+
+    def test_create_secret_missing_name(self):
+        option_list = [
+            (Mock(spec=['name'], name="secret_string"), "secret-value")
+        ]
+        option_list[0][0].name = "secret_string"
+
+        with self.assertRaises(MissingRequirementException) as context:
+            create_secret(option_list)
+        self.assertEqual(str(context.exception), "Cannot create secret without specifying name and secret-string")
+
+    def test_create_secret_missing_secret_string(self):
+        option_list = [
+            (Mock(spec=['name'], name="name"), "MySecret")
+        ]
+        option_list[0][0].name = "name"
+
+        with self.assertRaises(MissingRequirementException) as context:
+            create_secret(option_list)
+        self.assertEqual(str(context.exception), "Cannot create secret without specifying name and secret-string")
+
+    def test_update_secret_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="secret_id"), "secret-123"),
+            (Mock(spec=['name'], name="name"), "UpdatedSecret"),
+            (Mock(spec=['name'], name="secret_string"), "updated-value")
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+
+        with patch('pygeai.core.secrets.clients.SecretClient.update_secret', return_value="Updated secret") as mock_update:
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                update_secret(option_list)
+                mock_update.assert_called_once()
+                mock_stdout.assert_called_once_with("Update secret result: \nUpdated secret")
+
+    def test_update_secret_missing_id(self):
+        option_list = [
+            (Mock(spec=['name'], name="name"), "UpdatedSecret")
+        ]
+        option_list[0][0].name = "name"
+
+        with self.assertRaises(MissingRequirementException) as context:
+            update_secret(option_list)
+        self.assertEqual(str(context.exception), "Cannot update secret without specifying secret-id, name, and secret-string")
+
+    def test_list_secrets_success(self):
+        option_list = []
+
+        with patch('pygeai.core.secrets.clients.SecretClient.list_secrets', return_value="Secrets list") as mock_list:
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                list_secrets(option_list)
+                mock_list.assert_called_once_with(name=None, id=None, start=0, count=10)
+                mock_stdout.assert_called_once_with("List secrets result: \nSecrets list")
+
+    def test_set_secret_accesses_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="secret_id"), "secret-123"),
+            (Mock(spec=['name'], name="access_list"), '[{"project_id": "project-456"}]')
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+
+        with patch('pygeai.core.secrets.clients.SecretClient.set_secret_accesses', return_value="Access set") as mock_set:
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                set_secret_accesses(option_list)
+                mock_set.assert_called_once()
+                mock_stdout.assert_called_once_with("Set secret accesses result: \nAccess set")
+
+    def test_set_secret_accesses_missing_secret_id(self):
+        option_list = [
+            (Mock(spec=['name'], name="project_id"), "project-456")
+        ]
+        option_list[0][0].name = "project_id"
+
+        with self.assertRaises(MissingRequirementException) as context:
+            set_secret_accesses(option_list)
+        self.assertEqual(str(context.exception), "Cannot set secret accesses without specifying secret-id and access-list")
+
+    def test_set_secret_accesses_missing_project_id(self):
+        option_list = [
+            (Mock(spec=['name'], name="secret_id"), "secret-123")
+        ]
+        option_list[0][0].name = "secret_id"
+
+        with self.assertRaises(MissingRequirementException) as context:
+            set_secret_accesses(option_list)
+        self.assertEqual(str(context.exception), "Cannot set secret accesses without specifying secret-id and access-list")
+
+    def test_get_secret_accesses_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="secret_id"), "secret-123")
+        ]
+        option_list[0][0].name = "secret_id"
+
+        with patch('pygeai.core.secrets.clients.SecretClient.get_secret_accesses', return_value="Access list") as mock_get:
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                get_secret_accesses(option_list)
+                mock_get.assert_called_once_with(secret_id="secret-123")
+                mock_stdout.assert_called_once_with("Get secret accesses result: \nAccess list")
+
+    def test_get_secret_accesses_missing_id(self):
+        option_list = []
+        with self.assertRaises(MissingRequirementException) as context:
+            get_secret_accesses(option_list)
+        self.assertEqual(str(context.exception), "Cannot retrieve secret accesses without specifying secret-id")
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/cli/commands/test_show_help.py

@@ -0,0 +1,41 @@
+import unittest
+import importlib
+import io
+import contextlib
+from unittest import TestCase
+
+
+class TestShowHelp(TestCase):
+    """
+    python -m unittest pygeai.tests.cli.commands.test_show_help.TestShowHelp
+    """
+    command_files = [
+        'admin', 'assistant', 'base', 'chat',
+        'embeddings', 'evaluation', 'feedback', 'files',
+        'gam', 'llm', 'migrate', 'organization', 'rag',
+        'rerank', 'secrets', 'usage_limits'
+    ]
+
+    def test_show_help(self):
+        """
+        Test that show_help() in each command module runs without errors and produces output.
+        """
+        for command_file in self.command_files:
+            with self.subTest(command_file=command_file):
+                try:
+                    module = importlib.import_module(f'pygeai.cli.commands.{command_file}')
+
+                    self.assertTrue(hasattr(module, 'show_help'), f"show_help not found in {command_file}")
+                    self.assertTrue(callable(module.show_help), f"show_help is not callable in {command_file}")
+
+                    output = io.StringIO()
+                    with contextlib.redirect_stdout(output):
+                        module.show_help()
+
+                    output_text = output.getvalue()
+                    self.assertGreater(len(output_text.strip()), 0, f"show_help in {command_file} produced empty output")
+
+                except ImportError as e:
+                    self.fail(f"Failed to import {command_file}: {str(e)}")
+                except Exception as e:
+                    self.fail(f"show_help in {command_file} raised an exception: {str(e)}")