composiohq__composio/python/tests/test_toolkit_version.py

"""Test toolkit version utilities."""

import pytest

from composio.core.types import ToolkitVersionParam
from composio.utils.toolkit_version import get_toolkit_version, get_toolkit_versions


class TestToolkitVersion:
    """Test cases for toolkit version utilities."""

    def test_get_toolkit_version_with_string(self):
        """Test get_toolkit_version with string parameter."""
        result = get_toolkit_version("github", "v1.0.0")
        assert result == "v1.0.0"

    def test_get_toolkit_version_with_dict(self):
        """Test get_toolkit_version with dict parameter."""
        versions = {"github": "v1.0.0", "slack": "v2.0.0"}
        result = get_toolkit_version("github", versions)
        assert result == "v1.0.0"

    def test_get_toolkit_version_with_dict_missing_key(self):
        """Test get_toolkit_version with dict parameter missing key."""
        versions = {"slack": "v2.0.0"}
        result = get_toolkit_version("github", versions)
        assert result == "latest"

    def test_get_toolkit_version_with_none(self):
        """Test get_toolkit_version with None parameter."""
        result = get_toolkit_version("github", None)
        assert result == "latest"

    def test_get_toolkit_version_with_env_var(self):
        """Test get_toolkit_version with environment variable."""
        with pytest.MonkeyPatch().context():
            # The function doesn't directly use COMPOSIO_TOOLKIT_VERSION env var
            # It only looks at the toolkit_versions parameter
            result = get_toolkit_version("github", None)
            assert result == "latest"

    def test_get_toolkit_versions_with_string(self):
        """Test get_toolkit_versions with string parameter."""
        result = get_toolkit_versions("v1.0.0")
        assert result == "v1.0.0"

    def test_get_toolkit_versions_with_dict(self):
        """Test get_toolkit_versions with dict parameter."""
        versions = {"github": "v1.0.0", "slack": "v2.0.0"}
        result = get_toolkit_versions(versions)
        assert result == versions

    def test_get_toolkit_versions_with_none(self):
        """Test get_toolkit_versions with None parameter."""
        result = get_toolkit_versions(None)
        assert result == "latest"

    def test_get_toolkit_versions_with_env_toolkit_specific(self):
        """Test get_toolkit_versions with toolkit-specific environment variables."""
        with pytest.MonkeyPatch().context() as m:
            m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v2.0.0")
            m.setenv("COMPOSIO_TOOLKIT_VERSION_SLACK", "v1.5.0")
            result = get_toolkit_versions(None)
            expected = {"github": "v2.0.0", "slack": "v1.5.0"}
            assert result == expected

    def test_get_toolkit_versions_env_and_user_override(self):
        """Test that user-provided versions override environment variables."""
        with pytest.MonkeyPatch().context() as m:
            # Set environment variables
            m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v1.0.0")
            m.setenv("COMPOSIO_TOOLKIT_VERSION_SLACK", "v2.0.0")

            # User overrides should take precedence
            user_versions = {"github": "v3.0.0", "jira": "v4.0.0"}
            result = get_toolkit_versions(user_versions)

            expected = {
                "github": "v3.0.0",  # User override
                "slack": "v2.0.0",  # From env
                "jira": "v4.0.0",  # User provided
            }
            assert result == expected

    def test_get_toolkit_version_with_env_specific_toolkit(self):
        """Test get_toolkit_version works with environment-configured versions."""
        with pytest.MonkeyPatch().context() as m:
            m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v2.5.0")
            m.setenv("COMPOSIO_TOOLKIT_VERSION_SLACK", "v1.8.0")

            # Get versions from environment
            env_versions = get_toolkit_versions(None)

            # Test specific toolkit version retrieval
            github_version = get_toolkit_version("github", env_versions)
            slack_version = get_toolkit_version("slack", env_versions)
            unknown_version = get_toolkit_version("unknown", env_versions)

            assert github_version == "v2.5.0"
            assert slack_version == "v1.8.0"
            assert unknown_version == "latest"

    def test_mixed_case_env_vars_normalized(self):
        """Test that mixed case environment variable names are normalized."""
        with pytest.MonkeyPatch().context() as m:
            # Environment variables are typically uppercase
            m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v1.0.0")
            m.setenv("COMPOSIO_TOOLKIT_VERSION_OPENAI", "v2.0.0")

            result = get_toolkit_versions(None)

            # Should be normalized to lowercase
            assert "github" in result
            assert "openai" in result
            assert result["github"] == "v1.0.0"
            assert result["openai"] == "v2.0.0"

    def test_user_dict_case_normalization(self):
        """Test that user-provided dictionary keys are normalized to lowercase."""
        user_versions = {"GitHub": "v1.0.0", "SLACK": "v2.0.0", "OpenAI": "v3.0.0"}

        result = get_toolkit_versions(user_versions)

        expected = {"github": "v1.0.0", "slack": "v2.0.0", "openai": "v3.0.0"}
        assert result == expected

    def test_get_toolkit_version_lookup_is_case_insensitive(self):
        """The lookup slug is matched case-insensitively.

        Version maps are keyed by normalized (lowercase) slugs (write side
        covered by test_user_dict_case_normalization), so the read side must
        resolve any-cased slugs instead of silently returning 'latest'.
        """
        versions = {"github": "v1.0.0"}

        assert get_toolkit_version("GITHUB", versions) == "v1.0.0"
        assert get_toolkit_version("GitHub", versions) == "v1.0.0"
        assert get_toolkit_version("github", versions) == "v1.0.0"

    def test_priority_order_matches_typescript(self):
        """Test that priority order matches TypeScript implementation.

        Priority order should be:
        1. String global version (overrides everything)
        2. User-provided dict overrides env vars
        3. Environment variables
        4. Fallback to 'latest'
        """
        with pytest.MonkeyPatch().context() as m:
            # Test 1: String global version overrides everything
            m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "env_version")
            result = get_toolkit_version("github", "global_version")
            assert result == "global_version"

            # Test 2: User dict overrides env vars
            m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "env_version")
            m.setenv("COMPOSIO_TOOLKIT_VERSION_SLACK", "env_slack")
            user_dict = {"github": "user_override"}
            result = get_toolkit_versions(user_dict)
            expected = {
                "github": "user_override",  # User override
                "slack": "env_slack",  # From env
            }
            assert result == expected

            # Test 3: Environment variables when no user input
            result = get_toolkit_versions(None)
            expected = {"github": "env_version", "slack": "env_slack"}
            assert result == expected

    def test_empty_user_dict_uses_env_vars(self):
        """Test that empty user dict still uses environment variables."""
        with pytest.MonkeyPatch().context() as m:
            m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v1.0.0")

            # Empty dict should still use env vars
            result = get_toolkit_versions({})
            expected = {"github": "v1.0.0"}
            assert result == expected

    def test_toolkit_version_param_type_annotation(self):
        """Test ToolkitVersionParam type annotation."""
        import typing

        # Test that ToolkitVersionParam is a Union type
        assert hasattr(ToolkitVersionParam, "__origin__")
        assert ToolkitVersionParam.__origin__ is typing.Union