Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

next
py 179 lines 7.48 KB
Raw
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