Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
| 1 | """Test toolkit version utilities.""" |
| 2 | |
| 3 | import pytest |
| 4 | |
| 5 | from composio.core.types import ToolkitVersionParam |
| 6 | from composio.utils.toolkit_version import get_toolkit_version, get_toolkit_versions |
| 7 | |
| 8 | |
| 9 | class TestToolkitVersion: |
| 10 | """Test cases for toolkit version utilities.""" |
| 11 | |
| 12 | def test_get_toolkit_version_with_string(self): |
| 13 | """Test get_toolkit_version with string parameter.""" |
| 14 | result = get_toolkit_version("github", "v1.0.0") |
| 15 | assert result == "v1.0.0" |
| 16 | |
| 17 | def test_get_toolkit_version_with_dict(self): |
| 18 | """Test get_toolkit_version with dict parameter.""" |
| 19 | versions = {"github": "v1.0.0", "slack": "v2.0.0"} |
| 20 | result = get_toolkit_version("github", versions) |
| 21 | assert result == "v1.0.0" |
| 22 | |
| 23 | def test_get_toolkit_version_with_dict_missing_key(self): |
| 24 | """Test get_toolkit_version with dict parameter missing key.""" |
| 25 | versions = {"slack": "v2.0.0"} |
| 26 | result = get_toolkit_version("github", versions) |
| 27 | assert result == "latest" |
| 28 | |
| 29 | def test_get_toolkit_version_with_none(self): |
| 30 | """Test get_toolkit_version with None parameter.""" |
| 31 | result = get_toolkit_version("github", None) |
| 32 | assert result == "latest" |
| 33 | |
| 34 | def test_get_toolkit_versions_with_string(self): |
| 35 | """Test get_toolkit_versions with string parameter.""" |
| 36 | result = get_toolkit_versions("v1.0.0") |
| 37 | assert result == "v1.0.0" |
| 38 | |
| 39 | def test_get_toolkit_versions_with_dict(self): |
| 40 | """Test get_toolkit_versions with dict parameter.""" |
| 41 | versions = {"github": "v1.0.0", "slack": "v2.0.0"} |
| 42 | result = get_toolkit_versions(versions) |
| 43 | assert result == versions |
| 44 | |
| 45 | def test_get_toolkit_versions_with_none(self): |
| 46 | """Test get_toolkit_versions with None parameter.""" |
| 47 | result = get_toolkit_versions(None) |
| 48 | assert result == "latest" |
| 49 | |
| 50 | def test_get_toolkit_versions_with_env_toolkit_specific(self): |
| 51 | """Test get_toolkit_versions with toolkit-specific environment variables.""" |
| 52 | with pytest.MonkeyPatch().context() as m: |
| 53 | m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v2.0.0") |
| 54 | m.setenv("COMPOSIO_TOOLKIT_VERSION_SLACK", "v1.5.0") |
| 55 | result = get_toolkit_versions(None) |
| 56 | expected = {"github": "v2.0.0", "slack": "v1.5.0"} |
| 57 | assert result == expected |
| 58 | |
| 59 | def test_get_toolkit_versions_env_and_user_override(self): |
| 60 | """Test that user-provided versions override environment variables.""" |
| 61 | with pytest.MonkeyPatch().context() as m: |
| 62 | # Set environment variables |
| 63 | m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v1.0.0") |
| 64 | m.setenv("COMPOSIO_TOOLKIT_VERSION_SLACK", "v2.0.0") |
| 65 | |
| 66 | # User overrides should take precedence |
| 67 | user_versions = {"github": "v3.0.0", "jira": "v4.0.0"} |
| 68 | result = get_toolkit_versions(user_versions) |
| 69 | |
| 70 | expected = { |
| 71 | "github": "v3.0.0", # User override |
| 72 | "slack": "v2.0.0", # From env |
| 73 | "jira": "v4.0.0", # User provided |
| 74 | } |
| 75 | assert result == expected |
| 76 | |
| 77 | def test_get_toolkit_version_with_env_specific_toolkit(self): |
| 78 | """Test get_toolkit_version works with environment-configured versions.""" |
| 79 | with pytest.MonkeyPatch().context() as m: |
| 80 | m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v2.5.0") |
| 81 | m.setenv("COMPOSIO_TOOLKIT_VERSION_SLACK", "v1.8.0") |
| 82 | |
| 83 | # Get versions from environment |
| 84 | env_versions = get_toolkit_versions(None) |
| 85 | |
| 86 | # Test specific toolkit version retrieval |
| 87 | github_version = get_toolkit_version("github", env_versions) |
| 88 | slack_version = get_toolkit_version("slack", env_versions) |
| 89 | unknown_version = get_toolkit_version("unknown", env_versions) |
| 90 | |
| 91 | assert github_version == "v2.5.0" |
| 92 | assert slack_version == "v1.8.0" |
| 93 | assert unknown_version == "latest" |
| 94 | |
| 95 | def test_mixed_case_env_vars_normalized(self): |
| 96 | """Test that mixed case environment variable names are normalized.""" |
| 97 | with pytest.MonkeyPatch().context() as m: |
| 98 | # Environment variables are typically uppercase |
| 99 | m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v1.0.0") |
| 100 | m.setenv("COMPOSIO_TOOLKIT_VERSION_OPENAI", "v2.0.0") |
| 101 | |
| 102 | result = get_toolkit_versions(None) |
| 103 | |
| 104 | # Should be normalized to lowercase |
| 105 | assert "github" in result |
| 106 | assert "openai" in result |
| 107 | assert result["github"] == "v1.0.0" |
| 108 | assert result["openai"] == "v2.0.0" |
| 109 | |
| 110 | def test_user_dict_case_normalization(self): |
| 111 | """Test that user-provided dictionary keys are normalized to lowercase.""" |
| 112 | user_versions = {"GitHub": "v1.0.0", "SLACK": "v2.0.0", "OpenAI": "v3.0.0"} |
| 113 | |
| 114 | result = get_toolkit_versions(user_versions) |
| 115 | |
| 116 | expected = {"github": "v1.0.0", "slack": "v2.0.0", "openai": "v3.0.0"} |
| 117 | assert result == expected |
| 118 | |
| 119 | def test_get_toolkit_version_lookup_is_case_insensitive(self): |
| 120 | """The lookup slug is matched case-insensitively. |
| 121 | |
| 122 | Version maps are keyed by normalized (lowercase) slugs (write side |
| 123 | covered by test_user_dict_case_normalization), so the read side must |
| 124 | resolve any-cased slugs instead of silently returning 'latest'. |
| 125 | """ |
| 126 | versions = {"github": "v1.0.0"} |
| 127 | |
| 128 | assert get_toolkit_version("GITHUB", versions) == "v1.0.0" |
| 129 | assert get_toolkit_version("GitHub", versions) == "v1.0.0" |
| 130 | assert get_toolkit_version("github", versions) == "v1.0.0" |
| 131 | |
| 132 | def test_priority_order_matches_typescript(self): |
| 133 | """Test that priority order matches TypeScript implementation. |
| 134 | |
| 135 | Priority order should be: |
| 136 | 1. String global version (overrides everything) |
| 137 | 2. User-provided dict overrides env vars |
| 138 | 3. Environment variables |
| 139 | 4. Fallback to 'latest' |
| 140 | """ |
| 141 | with pytest.MonkeyPatch().context() as m: |
| 142 | # Test 1: String global version overrides everything |
| 143 | m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "env_version") |
| 144 | result = get_toolkit_version("github", "global_version") |
| 145 | assert result == "global_version" |
| 146 | |
| 147 | # Test 2: User dict overrides env vars |
| 148 | m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "env_version") |
| 149 | m.setenv("COMPOSIO_TOOLKIT_VERSION_SLACK", "env_slack") |
| 150 | user_dict = {"github": "user_override"} |
| 151 | result = get_toolkit_versions(user_dict) |
| 152 | expected = { |
| 153 | "github": "user_override", # User override |
| 154 | "slack": "env_slack", # From env |
| 155 | } |
| 156 | assert result == expected |
| 157 | |
| 158 | # Test 3: Environment variables when no user input |
| 159 | result = get_toolkit_versions(None) |
| 160 | expected = {"github": "env_version", "slack": "env_slack"} |
| 161 | assert result == expected |
| 162 | |
| 163 | def test_empty_user_dict_uses_env_vars(self): |
| 164 | """Test that empty user dict still uses environment variables.""" |
| 165 | with pytest.MonkeyPatch().context() as m: |
| 166 | m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v1.0.0") |
| 167 | |
| 168 | # Empty dict should still use env vars |
| 169 | result = get_toolkit_versions({}) |
| 170 | expected = {"github": "v1.0.0"} |
| 171 | assert result == expected |
| 172 | |
| 173 | def test_toolkit_version_param_type_annotation(self): |
| 174 | """Test ToolkitVersionParam type annotation.""" |
| 175 | import typing |
| 176 | |
| 177 | # Test that ToolkitVersionParam is a Union type |
| 178 | assert hasattr(ToolkitVersionParam, "__origin__") |
| 179 | assert ToolkitVersionParam.__origin__ is typing.Union |