fix: add unit tests

Author: cosmyo

packages/uipath-openai-agents/tests/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI tests for uipath-openai-agents."""

packages/uipath-openai-agents/tests/cli/conftest.py

@@ -0,0 +1,36 @@
+"""Fixtures for CLI tests."""
+
+from pathlib import Path
+
+import pytest
+
+# Get the tests directory path relative to this conftest file
+TESTS_DIR = Path(__file__).parent.parent
+MOCKS_DIR = TESTS_DIR / "mocks"
+
+
+@pytest.fixture
+def simple_agent_basic() -> str:
+    """Load simple agent with basic configuration."""
+    mock_file = MOCKS_DIR / "simple_agent_basic.py"
+    with open(mock_file, "r") as file:
+        data = file.read()
+    return data
+
+
+@pytest.fixture
+def simple_agent_translation() -> str:
+    """Load simple agent with translation configuration."""
+    mock_file = MOCKS_DIR / "simple_agent_translation.py"
+    with open(mock_file, "r") as file:
+        data = file.read()
+    return data
+
+
+@pytest.fixture
+def openai_agents_config() -> str:
+    """Load openai_agents.json configuration."""
+    mock_file = MOCKS_DIR / "openai_agents.json"
+    with open(mock_file, "r") as file:
+        data = file.read()
+    return data

packages/uipath-openai-agents/tests/cli/test_init.py

@@ -0,0 +1,146 @@
+"""Tests for uipath init command with openai-agents."""
+
+import json
+import os
+
+from click.testing import CliRunner
+from uipath._cli.cli_init import init
+
+
+class TestInit:
+    """Test init command for OpenAI agents."""
+
+    def test_init_basic_config_generation(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        simple_agent_basic: str,
+        simple_agent_translation: str,
+        openai_agents_config: str,
+    ) -> None:
+        """Test configuration file generation with basic agent."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create agent scripts (config references both)
+            with open("main.py", "w") as f:
+                f.write(simple_agent_basic)
+
+            with open("translation.py", "w") as f:
+                f.write(simple_agent_translation)
+
+            with open("openai_agents.json", "w") as f:
+                f.write(openai_agents_config)
+
+            result = runner.invoke(init)
+            assert result.exit_code == 0
+            assert os.path.exists("entry-points.json")
+
+            with open("entry-points.json", "r") as f:
+                config = json.load(f)
+
+                # Verify config structure
+                assert "entryPoints" in config
+
+                # Verify entryPoints properties
+                entry = config["entryPoints"][0]
+                assert entry["filePath"] == "basic"
+                assert entry["type"] == "agent"
+
+                # Verify input schema
+                assert "input" in entry
+                input_schema = entry["input"]
+                assert input_schema["type"] == "object"
+                assert "properties" in input_schema
+                assert "required" in input_schema
+                assert isinstance(input_schema["properties"], dict)
+                assert isinstance(input_schema["required"], list)
+
+                # OpenAI agents use default message input
+                assert "message" in input_schema["properties"]
+                assert "message" in input_schema["required"]
+
+                # Verify output schema (default since no output_type specified)
+                assert "output" in entry
+                output_schema = entry["output"]
+                assert "properties" in output_schema
+                # Default output schema has "result" field
+                assert "result" in output_schema["properties"]
+                assert "required" in output_schema
+                assert output_schema["type"] == "object"
+
+    def test_init_translation_agent_config_generation(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        simple_agent_basic: str,
+        simple_agent_translation: str,
+        openai_agents_config: str,
+    ) -> None:
+        """Test configuration file generation with translation agent."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create agent scripts
+            with open("main.py", "w") as f:
+                f.write(simple_agent_basic)
+
+            with open("translation.py", "w") as f:
+                f.write(simple_agent_translation)
+
+            with open("openai_agents.json", "w") as f:
+                f.write(openai_agents_config)
+
+            result = runner.invoke(init)
+            assert result.exit_code == 0
+            assert os.path.exists("entry-points.json")
+
+            with open("entry-points.json", "r") as f:
+                config = json.load(f)
+
+                # Verify config structure
+                assert "entryPoints" in config
+
+                # Find the translation entry point
+                translation_entry = None
+                for entry in config["entryPoints"]:
+                    if entry["filePath"] == "translation":
+                        translation_entry = entry
+                        break
+
+                assert translation_entry is not None
+                assert translation_entry["type"] == "agent"
+
+                # Verify input schema - should use default messages
+                assert "input" in translation_entry
+                input_schema = translation_entry["input"]
+                assert input_schema["type"] == "object"
+                assert "properties" in input_schema
+                assert "message" in input_schema["properties"]
+                assert "message" in input_schema["required"]
+
+                # Verify output schema from agent's output_type
+                assert "output" in translation_entry
+                output_schema = translation_entry["output"]
+                assert "properties" in output_schema
+
+                # Verify output properties from TranslationOutput
+                out_props = output_schema["properties"]
+                assert "original_text" in out_props
+                assert out_props["original_text"]["type"] == "string"
+                assert out_props["original_text"]["description"] == "The original text"
+
+                assert "translated_text" in out_props
+                assert out_props["translated_text"]["type"] == "string"
+                assert (
+                    out_props["translated_text"]["description"] == "The translated text"
+                )
+
+                assert "target_language" in out_props
+                assert out_props["target_language"]["type"] == "string"
+                assert (
+                    out_props["target_language"]["description"] == "The target language"
+                )
+
+                # Verify required fields in output
+                assert "required" in output_schema
+                assert "original_text" in output_schema["required"]
+                assert "translated_text" in output_schema["required"]
+                assert "target_language" in output_schema["required"]
+                assert output_schema["type"] == "object"

packages/uipath-openai-agents/tests/cli/test_run.py

@@ -0,0 +1,128 @@
+"""Tests for uipath run command with openai-agents.
+
+Note: These tests check CLI invocation and error handling.
+Full agent execution tests with OpenAI API calls should be marked as integration tests.
+"""
+
+import os
+
+from click.testing import CliRunner
+from uipath._cli.cli_run import run
+
+
+class TestRun:
+    """Test run command for OpenAI agents."""
+
+    def test_run_basic_agent_invocation(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        simple_agent_basic: str,
+        openai_agents_config: str,
+    ) -> None:
+        """Test basic agent invocation structure (without actual OpenAI API calls)."""
+        input_file_name = "input.json"
+        input_json_content = '{"message": "Hello, agent!"}'
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # create input file
+            input_file_path = os.path.join(temp_dir, input_file_name)
+            with open(input_file_path, "w") as f:
+                f.write(input_json_content)
+
+            # Create agent script
+            with open("main.py", "w") as f:
+                f.write(simple_agent_basic)
+
+            with open("openai_agents.json", "w") as f:
+                f.write(openai_agents_config)
+
+            # Note: This will fail without OpenAI API key, but we're testing CLI structure
+            result = runner.invoke(run, ["basic", "--file", input_file_path])
+
+            # The command should invoke without crashing from CLI parsing
+            # Actual execution may fail without API key, which is expected
+            # We're testing the CLI invocation layer here
+            assert result.exit_code in [0, 1]  # 0 = success, 1 = runtime error
+
+    def test_run_with_invalid_agent_name(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        simple_agent_basic: str,
+        openai_agents_config: str,
+    ) -> None:
+        """Test run command with non-existent agent name."""
+        input_file_name = "input.json"
+        input_json_content = '{"message": "test"}'
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            input_file_path = os.path.join(temp_dir, input_file_name)
+            with open(input_file_path, "w") as f:
+                f.write(input_json_content)
+
+            with open("main.py", "w") as f:
+                f.write(simple_agent_basic)
+
+            with open("openai_agents.json", "w") as f:
+                f.write(openai_agents_config)
+
+            # Try to run non-existent agent
+            result = runner.invoke(
+                run, ["nonexistent_agent", "--file", input_file_path]
+            )
+
+            # Should fail with non-zero exit code
+            assert result.exit_code != 0
+
+    def test_run_without_config_file(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        simple_agent_basic: str,
+    ) -> None:
+        """Test run command without openai_agents.json file."""
+        input_file_name = "input.json"
+        input_json_content = '{"message": "test"}'
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            input_file_path = os.path.join(temp_dir, input_file_name)
+            with open(input_file_path, "w") as f:
+                f.write(input_json_content)
+
+            with open("main.py", "w") as f:
+                f.write(simple_agent_basic)
+
+            # No openai_agents.json file
+
+            result = runner.invoke(run, ["basic", "--file", input_file_path])
+
+            # Should fail without config file
+            assert result.exit_code != 0
+
+    def test_run_with_malformed_input_json(
+        self,
+        runner: CliRunner,
+        temp_dir: str,
+        simple_agent_basic: str,
+        openai_agents_config: str,
+    ) -> None:
+        """Test run command with malformed JSON input."""
+        input_file_name = "input.json"
+        input_json_content = '{"message": invalid json}'  # Malformed
+
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            input_file_path = os.path.join(temp_dir, input_file_name)
+            with open(input_file_path, "w") as f:
+                f.write(input_json_content)
+
+            with open("main.py", "w") as f:
+                f.write(simple_agent_basic)
+
+            with open("openai_agents.json", "w") as f:
+                f.write(openai_agents_config)
+
+            result = runner.invoke(run, ["basic", "--file", input_file_path])
+
+            # Should fail due to malformed JSON
+            assert result.exit_code != 0

packages/uipath-openai-agents/tests/conftest.py

@@ -0,0 +1,20 @@
+"""Root conftest for uipath-openai-agents tests."""
+
+import tempfile
+from typing import Generator
+
+import pytest
+from click.testing import CliRunner
+
+
+@pytest.fixture
+def runner() -> CliRunner:
+    """Provide a Click CLI test runner."""
+    return CliRunner()
+
+
+@pytest.fixture
+def temp_dir() -> Generator[str, None, None]:
+    """Provide a temporary directory for test files."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        yield tmp_dir

packages/uipath-openai-agents/tests/mocks/openai_agents.json

@@ -0,0 +1,6 @@
+{
+  "agents": {
+    "basic": "main.py:agent",
+    "translation": "translation.py:agent"
+  }
+}

packages/uipath-openai-agents/tests/mocks/simple_agent_basic.py

@@ -0,0 +1,9 @@
+"""Simple OpenAI agent for testing - basic configuration."""
+
+from agents import Agent
+
+# Simple agent without output type (uses default behavior)
+agent = Agent(
+    name="echo_agent",
+    instructions="You are a helpful assistant. Respond to the user's message.",
+)

packages/uipath-openai-agents/tests/mocks/simple_agent_translation.py

@@ -0,0 +1,20 @@
+"""Simple OpenAI agent for testing - translation agent with custom output."""
+
+from agents import Agent
+from pydantic import BaseModel, Field
+
+
+class TranslationOutput(BaseModel):
+    """Output model for translation."""
+
+    original_text: str = Field(description="The original text")
+    translated_text: str = Field(description="The translated text")
+    target_language: str = Field(description="The target language")
+
+
+# Agent with custom output type (direct Pydantic model)
+agent = Agent(
+    name="translation_agent",
+    instructions="You are a translation agent. Translate the given text to the target language specified in the message.",
+    output_type=TranslationOutput,
+)