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 | """SDK-owned logging and deprecation surface. |
| 2 | |
| 3 | ``Composio(...)`` accepts ``logger`` / ``logging_level`` and routes the |
| 4 | generated ``composio_client`` logger through the SDK's redacting wrapper. |
| 5 | Runtime deprecations (the client's response-driven ones and the SDK's own) |
| 6 | all surface as :class:`ComposioDeprecationWarning`. |
| 7 | """ |
| 8 | |
| 9 | import io |
| 10 | import logging |
| 11 | import typing as t |
| 12 | import warnings |
| 13 | |
| 14 | import httpx |
| 15 | import pytest |
| 16 | |
| 17 | from composio import Composio, ComposioDeprecationWarning, exceptions |
| 18 | from composio.client import ( |
| 19 | CLIENT_LOGGER_NAME, |
| 20 | _ClientLogForwarder, |
| 21 | _forwarding_wrappers, |
| 22 | ) |
| 23 | from composio.core.models.base import allow_tracking |
| 24 | from composio.utils.logging import LogLevel |
| 25 | |
| 26 | _LIST_BODY: dict[str, t.Any] = { |
| 27 | "items": [], |
| 28 | "next_cursor": None, |
| 29 | "total_pages": 1, |
| 30 | "current_page": 1, |
| 31 | "total_items": 0, |
| 32 | } |
| 33 | |
| 34 | |
| 35 | @pytest.fixture(autouse=True) |
| 36 | def disable_telemetry(): |
| 37 | token = allow_tracking.set(False) |
| 38 | yield |
| 39 | allow_tracking.reset(token) |
| 40 | |
| 41 | |
| 42 | @pytest.fixture(autouse=True) |
| 43 | def reset_client_logger(): |
| 44 | """Start each test without the forwarder state earlier tests left behind. |
| 45 | |
| 46 | The forwarder and the set of live wrappers are process-wide, so a DEBUG |
| 47 | instance from an earlier test would otherwise keep the client logger |
| 48 | permissive and mask level assertions here. |
| 49 | """ |
| 50 | client_logger = logging.getLogger(CLIENT_LOGGER_NAME) |
| 51 | for handler in list(client_logger.handlers): |
| 52 | if isinstance(handler, _ClientLogForwarder): |
| 53 | client_logger.removeHandler(handler) |
| 54 | _forwarding_wrappers.clear() |
| 55 | client_logger.setLevel(logging.NOTSET) |
| 56 | yield |
| 57 | |
| 58 | |
| 59 | @pytest.fixture |
| 60 | def custom_logger() -> t.Iterator[tuple[logging.Logger, io.StringIO]]: |
| 61 | output = io.StringIO() |
| 62 | logger = logging.getLogger("composio-test-sdk-owned-logger") |
| 63 | logger.handlers = [logging.StreamHandler(output)] |
| 64 | logger.propagate = False |
| 65 | logger.setLevel(logging.DEBUG) |
| 66 | yield logger, output |
| 67 | logger.handlers = [] |
| 68 | |
| 69 | |
| 70 | def _mock_transport( |
| 71 | headers: t.Optional[dict[str, str]] = None, |
| 72 | seen: t.Optional[list[httpx.Request]] = None, |
| 73 | ) -> httpx.Client: |
| 74 | def handler(request: httpx.Request) -> httpx.Response: |
| 75 | if seen is not None: |
| 76 | seen.append(request) |
| 77 | return httpx.Response(200, json=_LIST_BODY, headers=headers or {}) |
| 78 | |
| 79 | return httpx.Client(transport=httpx.MockTransport(handler)) |
| 80 | |
| 81 | |
| 82 | def _forwarders() -> list[_ClientLogForwarder]: |
| 83 | return [ |
| 84 | handler |
| 85 | for handler in logging.getLogger(CLIENT_LOGGER_NAME).handlers |
| 86 | if isinstance(handler, _ClientLogForwarder) |
| 87 | ] |
| 88 | |
| 89 | |
| 90 | class TestCustomLogger: |
| 91 | def test_sdk_logs_use_custom_logger_with_redaction(self, custom_logger): |
| 92 | logger, output = custom_logger |
| 93 | composio = Composio(api_key="test-key", logger=logger) |
| 94 | |
| 95 | assert composio.logger.logger is logger |
| 96 | composio.logger.info("sdk record api_key=sdk-secret") |
| 97 | |
| 98 | text = output.getvalue() |
| 99 | assert "sdk record" in text |
| 100 | assert "sdk-secret" not in text |
| 101 | assert "[REDACTED]" in text |
| 102 | |
| 103 | def test_client_records_are_forwarded_with_redaction(self, custom_logger): |
| 104 | logger, output = custom_logger |
| 105 | Composio(api_key="test-key", logger=logger) |
| 106 | |
| 107 | logging.getLogger(CLIENT_LOGGER_NAME).info( |
| 108 | "Authorization: Bearer client-secret-token" |
| 109 | ) |
| 110 | |
| 111 | text = output.getvalue() |
| 112 | assert "Authorization" in text |
| 113 | assert "client-secret-token" not in text |
| 114 | assert "[REDACTED]" in text |
| 115 | |
| 116 | def test_client_request_lifecycle_reaches_custom_logger(self, custom_logger): |
| 117 | logger, output = custom_logger |
| 118 | composio = Composio( |
| 119 | api_key="test-key", http_client=_mock_transport(), logger=logger |
| 120 | ) |
| 121 | |
| 122 | composio.client.toolkits.list() |
| 123 | |
| 124 | text = output.getvalue() |
| 125 | assert "path=/api/v3.1/toolkits" in text |
| 126 | assert "status=200" in text |
| 127 | |
| 128 | def test_client_request_lifecycle_stays_out_of_info(self, custom_logger): |
| 129 | logger, output = custom_logger |
| 130 | logger.setLevel(logging.INFO) |
| 131 | composio = Composio( |
| 132 | api_key="test-key", http_client=_mock_transport(), logger=logger |
| 133 | ) |
| 134 | |
| 135 | composio.client.toolkits.list() |
| 136 | |
| 137 | assert logging.getLogger(CLIENT_LOGGER_NAME).level == logging.WARNING |
| 138 | assert "path=/api/v3.1/toolkits" not in output.getvalue() |
| 139 | |
| 140 | def test_without_retries_clone_keeps_custom_logger(self, custom_logger): |
| 141 | logger, output = custom_logger |
| 142 | composio = Composio( |
| 143 | api_key="test-key", http_client=_mock_transport(), logger=logger |
| 144 | ) |
| 145 | |
| 146 | composio.client.without_retries.toolkits.list() |
| 147 | |
| 148 | forwarders = _forwarders() |
| 149 | assert len(forwarders) == 1 |
| 150 | assert forwarders[0].wrapper.logger is logger |
| 151 | assert "path=/api/v3.1/toolkits" in output.getvalue() |
| 152 | |
| 153 | def test_client_logger_does_not_propagate_to_root(self, custom_logger): |
| 154 | logger, _ = custom_logger |
| 155 | Composio(api_key="test-key", logger=logger) |
| 156 | |
| 157 | client_logger = logging.getLogger(CLIENT_LOGGER_NAME) |
| 158 | assert client_logger.propagate is False |
| 159 | |
| 160 | def test_forwarder_is_installed_once_per_logger(self, custom_logger): |
| 161 | logger, _ = custom_logger |
| 162 | Composio(api_key="test-key", logger=logger) |
| 163 | Composio(api_key="test-key", logger=logger) |
| 164 | |
| 165 | forwarders = _forwarders() |
| 166 | assert len(forwarders) == 1 |
| 167 | assert forwarders[0].wrapper.logger is logger |
| 168 | |
| 169 | def test_client_records_follow_the_requesting_instance(self, custom_logger): |
| 170 | logger, output = custom_logger |
| 171 | other = logging.getLogger("composio-test-sdk-owned-logger-other") |
| 172 | other_output = io.StringIO() |
| 173 | other.handlers = [logging.StreamHandler(other_output)] |
| 174 | other.propagate = False |
| 175 | other.setLevel(logging.DEBUG) |
| 176 | try: |
| 177 | first = Composio( |
| 178 | api_key="test-key", http_client=_mock_transport(), logger=other |
| 179 | ) |
| 180 | second = Composio( |
| 181 | api_key="test-key", http_client=_mock_transport(), logger=logger |
| 182 | ) |
| 183 | assert len(_forwarders()) == 1 |
| 184 | |
| 185 | # A request through the earlier instance still logs to its own |
| 186 | # logger, even though a newer instance was constructed since. |
| 187 | first.client.without_retries.toolkits.list() |
| 188 | assert "path=/api/v3.1/toolkits" in other_output.getvalue() |
| 189 | assert "path=/api/v3.1/toolkits" not in output.getvalue() |
| 190 | |
| 191 | second.client.without_retries.toolkits.list() |
| 192 | assert "path=/api/v3.1/toolkits" in output.getvalue() |
| 193 | |
| 194 | # Outside any request, records go to the most recent instance. |
| 195 | logging.getLogger(CLIENT_LOGGER_NAME).info("delivered once") |
| 196 | assert "delivered once" in output.getvalue() |
| 197 | assert "delivered once" not in other_output.getvalue() |
| 198 | finally: |
| 199 | other.handlers = [] |
| 200 | |
| 201 | def test_quieter_instance_does_not_silence_earlier_debug_instance( |
| 202 | self, custom_logger |
| 203 | ): |
| 204 | logger, output = custom_logger |
| 205 | quiet = logging.getLogger("composio-test-sdk-owned-logger-quiet") |
| 206 | quiet_output = io.StringIO() |
| 207 | quiet.handlers = [logging.StreamHandler(quiet_output)] |
| 208 | quiet.propagate = False |
| 209 | quiet.setLevel(logging.WARNING) |
| 210 | try: |
| 211 | debug_instance = Composio( |
| 212 | api_key="test-key", http_client=_mock_transport(), logger=logger |
| 213 | ) |
| 214 | quiet_instance = Composio( |
| 215 | api_key="test-key", http_client=_mock_transport(), logger=quiet |
| 216 | ) |
| 217 | # The shared source logger stays permissive enough for the DEBUG |
| 218 | # instance; the quiet instance's wrapper filters its own output. |
| 219 | assert logging.getLogger(CLIENT_LOGGER_NAME).level == logging.DEBUG |
| 220 | |
| 221 | debug_instance.client.without_retries.toolkits.list() |
| 222 | assert "path=/api/v3.1/toolkits" in output.getvalue() |
| 223 | |
| 224 | quiet_instance.client.without_retries.toolkits.list() |
| 225 | assert "path=/api/v3.1/toolkits" not in quiet_output.getvalue() |
| 226 | finally: |
| 227 | quiet.handlers = [] |
| 228 | |
| 229 | def test_debug_instance_lowers_level_set_by_earlier_quiet_instance( |
| 230 | self, custom_logger |
| 231 | ): |
| 232 | logger, output = custom_logger |
| 233 | quiet = logging.getLogger("composio-test-sdk-owned-logger-quiet") |
| 234 | quiet.handlers = [logging.StreamHandler(io.StringIO())] |
| 235 | quiet.propagate = False |
| 236 | quiet.setLevel(logging.WARNING) |
| 237 | try: |
| 238 | Composio(api_key="test-key", http_client=_mock_transport(), logger=quiet) |
| 239 | assert logging.getLogger(CLIENT_LOGGER_NAME).level == logging.WARNING |
| 240 | |
| 241 | debug_instance = Composio( |
| 242 | api_key="test-key", http_client=_mock_transport(), logger=logger |
| 243 | ) |
| 244 | assert logging.getLogger(CLIENT_LOGGER_NAME).level == logging.DEBUG |
| 245 | |
| 246 | debug_instance.client.without_retries.toolkits.list() |
| 247 | assert "path=/api/v3.1/toolkits" in output.getvalue() |
| 248 | finally: |
| 249 | quiet.handlers = [] |
| 250 | |
| 251 | |
| 252 | class TestLoggingLevel: |
| 253 | def test_logging_level_applies_to_sdk_and_client_loggers(self, custom_logger): |
| 254 | logger, output = custom_logger |
| 255 | composio = Composio( |
| 256 | api_key="test-key", logger=logger, logging_level=LogLevel.WARNING |
| 257 | ) |
| 258 | |
| 259 | assert logger.level == logging.WARNING |
| 260 | assert logging.getLogger(CLIENT_LOGGER_NAME).level == logging.WARNING |
| 261 | assert composio._logging_level == "WARNING" |
| 262 | |
| 263 | composio.logger.info("sdk info dropped") |
| 264 | logging.getLogger(CLIENT_LOGGER_NAME).info("client info dropped") |
| 265 | composio.logger.warning("sdk warning kept") |
| 266 | logging.getLogger(CLIENT_LOGGER_NAME).warning("client warning kept") |
| 267 | |
| 268 | text = output.getvalue() |
| 269 | assert "dropped" not in text |
| 270 | assert "sdk warning kept" in text |
| 271 | assert "client warning kept" in text |
| 272 | |
| 273 | def test_logging_level_debug_enables_debug_records(self, custom_logger): |
| 274 | logger, output = custom_logger |
| 275 | logger.setLevel(logging.WARNING) |
| 276 | composio = Composio( |
| 277 | api_key="test-key", logger=logger, logging_level=LogLevel.DEBUG |
| 278 | ) |
| 279 | |
| 280 | composio.logger.debug("sdk debug kept") |
| 281 | logging.getLogger(CLIENT_LOGGER_NAME).debug("client debug kept") |
| 282 | |
| 283 | text = output.getvalue() |
| 284 | assert "sdk debug kept" in text |
| 285 | assert "client debug kept" in text |
| 286 | |
| 287 | |
| 288 | class TestDeprecationWarnings: |
| 289 | def test_category_is_re_exported(self): |
| 290 | assert exceptions.ComposioDeprecationWarning is ComposioDeprecationWarning |
| 291 | assert issubclass(ComposioDeprecationWarning, UserWarning) |
| 292 | assert not issubclass(ComposioDeprecationWarning, DeprecationWarning) |
| 293 | |
| 294 | def test_client_deprecation_header_reaches_caller(self, custom_logger): |
| 295 | logger, _ = custom_logger |
| 296 | composio = Composio( |
| 297 | api_key="test-key", |
| 298 | http_client=_mock_transport(headers={"Deprecation": "@1688169599"}), |
| 299 | logger=logger, |
| 300 | ) |
| 301 | |
| 302 | with pytest.warns(ComposioDeprecationWarning, match="toolkits.list"): |
| 303 | composio.client.toolkits.list() |
| 304 | |
| 305 | def test_no_warning_without_deprecation_header(self, custom_logger): |
| 306 | logger, _ = custom_logger |
| 307 | composio = Composio( |
| 308 | api_key="test-key", http_client=_mock_transport(), logger=logger |
| 309 | ) |
| 310 | |
| 311 | with warnings.catch_warnings(): |
| 312 | warnings.simplefilter("error", ComposioDeprecationWarning) |
| 313 | composio.client.toolkits.list() |
| 314 | |
| 315 | def test_tool_router_alias_warns_with_sdk_category(self): |
| 316 | composio = Composio(api_key="test-key") |
| 317 | |
| 318 | with pytest.warns(ComposioDeprecationWarning, match="tool_router"): |
| 319 | alias = composio.tool_router |
| 320 | |
| 321 | assert alias is composio.sessions |
| 322 | |
| 323 | |
| 324 | class TestToolsListWireParams: |
| 325 | def test_search_is_sent_as_query(self, custom_logger): |
| 326 | logger, _ = custom_logger |
| 327 | seen: list[httpx.Request] = [] |
| 328 | composio = Composio( |
| 329 | api_key="test-key", http_client=_mock_transport(seen=seen), logger=logger |
| 330 | ) |
| 331 | |
| 332 | with warnings.catch_warnings(): |
| 333 | warnings.simplefilter("error", ComposioDeprecationWarning) |
| 334 | composio.tools.get_raw_composio_tools(search="github issues") |
| 335 | |
| 336 | assert len(seen) == 1 |
| 337 | params = seen[0].url.params |
| 338 | assert params["query"] == "github issues" |
| 339 | assert "search" not in params |
| 340 | |
| 341 | |
| 342 | _TOOL_BODY: dict[str, t.Any] = { |
| 343 | "slug": "GMAIL_SEND_EMAIL", |
| 344 | "name": "Send email", |
| 345 | "description": "Sends an email", |
| 346 | "input_parameters": {"type": "object", "properties": {}}, |
| 347 | "output_parameters": {"type": "object", "properties": {}}, |
| 348 | "toolkit": {"slug": "gmail", "name": "Gmail", "logo": ""}, |
| 349 | "version": "20250114_00", |
| 350 | } |
| 351 | _EXECUTE_BODY: dict[str, t.Any] = { |
| 352 | "data": {"ok": True}, |
| 353 | "successful": True, |
| 354 | "error": None, |
| 355 | } |
| 356 | |
| 357 | _DEPRECATED_TOOLKITS_HEADER = "Composio-Deprecated-Toolkits" |
| 358 | _GMAIL_ITEM = ( |
| 359 | '"GMAIL";version="20250114_00";deprecated=@1779840000;' |
| 360 | 'sunset=@1787788800;reason="lifecycle"' |
| 361 | ) |
| 362 | |
| 363 | |
| 364 | def _tool_transport( |
| 365 | retrieve_headers: t.Optional[dict[str, str]] = None, |
| 366 | execute_headers: t.Optional[dict[str, str]] = None, |
| 367 | seen: t.Optional[list[httpx.Request]] = None, |
| 368 | event_hooks: t.Optional[dict[str, list[t.Callable[..., t.Any]]]] = None, |
| 369 | ) -> httpx.Client: |
| 370 | """Serve the tool schema on GET and the execute body on POST.""" |
| 371 | |
| 372 | def handler(request: httpx.Request) -> httpx.Response: |
| 373 | if seen is not None: |
| 374 | seen.append(request) |
| 375 | if request.method == "POST": |
| 376 | return httpx.Response( |
| 377 | 200, json=_EXECUTE_BODY, headers=execute_headers or {} |
| 378 | ) |
| 379 | return httpx.Response(200, json=_TOOL_BODY, headers=retrieve_headers or {}) |
| 380 | |
| 381 | return httpx.Client( |
| 382 | transport=httpx.MockTransport(handler), event_hooks=event_hooks or {} |
| 383 | ) |
| 384 | |
| 385 | |
| 386 | class TestToolkitDeprecationHeader: |
| 387 | """``Composio-Deprecated-Toolkits`` surfaces once per toolkit version as a |
| 388 | :class:`ComposioDeprecationWarning`, beside the client's own ``Deprecation`` |
| 389 | handling and without ever failing the call.""" |
| 390 | |
| 391 | @pytest.fixture(autouse=True) |
| 392 | def _reset_warned(self): |
| 393 | from composio.utils import toolkit_deprecation |
| 394 | |
| 395 | toolkit_deprecation._reset_for_tests() |
| 396 | yield |
| 397 | toolkit_deprecation._reset_for_tests() |
| 398 | |
| 399 | @staticmethod |
| 400 | def _deprecations(caught: list[warnings.WarningMessage]) -> list[str]: |
| 401 | return [ |
| 402 | str(w.message) |
| 403 | for w in caught |
| 404 | if issubclass(w.category, ComposioDeprecationWarning) |
| 405 | ] |
| 406 | |
| 407 | def test_tool_retrieve_warns_once(self, custom_logger): |
| 408 | logger, _ = custom_logger |
| 409 | composio = Composio( |
| 410 | api_key="test-key", |
| 411 | http_client=_tool_transport( |
| 412 | retrieve_headers={_DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM} |
| 413 | ), |
| 414 | logger=logger, |
| 415 | ) |
| 416 | |
| 417 | with warnings.catch_warnings(record=True) as caught: |
| 418 | warnings.simplefilter("always") |
| 419 | tool = composio.tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL") |
| 420 | composio.tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL") |
| 421 | |
| 422 | assert tool.slug == "GMAIL_SEND_EMAIL" |
| 423 | messages = self._deprecations(caught) |
| 424 | assert len(messages) == 1 |
| 425 | assert "[Deprecation] Toolkit GMAIL version 20250114_00" in messages[0] |
| 426 | assert "deprecated on 2026-05-27 (lifecycle)" in messages[0] |
| 427 | assert "stop working on 2026-08-27" in messages[0] |
| 428 | assert 'toolkit_versions={"gmail": "<version>"}' in messages[0] |
| 429 | assert "COMPOSIO_TOOLKIT_VERSION_GMAIL" in messages[0] |
| 430 | assert ( |
| 431 | "https://docs.composio.dev/docs/tools-direct/toolkit-versioning" |
| 432 | "#deprecation-and-sunset" |
| 433 | ) in messages[0] |
| 434 | |
| 435 | def test_execute_path_warns_once_across_retrieve_and_execute(self, custom_logger): |
| 436 | logger, _ = custom_logger |
| 437 | seen: list[httpx.Request] = [] |
| 438 | composio = Composio( |
| 439 | api_key="test-key", |
| 440 | http_client=_tool_transport( |
| 441 | retrieve_headers={_DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM}, |
| 442 | execute_headers={_DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM}, |
| 443 | seen=seen, |
| 444 | ), |
| 445 | logger=logger, |
| 446 | ) |
| 447 | |
| 448 | with warnings.catch_warnings(record=True) as caught: |
| 449 | warnings.simplefilter("always") |
| 450 | result = composio.tools.execute( |
| 451 | "GMAIL_SEND_EMAIL", {}, user_id="user-1", version="20250114_00" |
| 452 | ) |
| 453 | |
| 454 | assert result["successful"] is True |
| 455 | assert [request.method for request in seen] == ["GET", "POST"] |
| 456 | assert len(self._deprecations(caught)) == 1 |
| 457 | |
| 458 | def test_without_retries_clone_shares_the_hook(self, custom_logger): |
| 459 | """Only the execute response, served through ``client.without_retries``, |
| 460 | carries the header: the warning proves the clone shares the hook.""" |
| 461 | logger, _ = custom_logger |
| 462 | composio = Composio( |
| 463 | api_key="test-key", |
| 464 | http_client=_tool_transport( |
| 465 | execute_headers={_DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM} |
| 466 | ), |
| 467 | logger=logger, |
| 468 | ) |
| 469 | assert composio.client.without_retries._client is composio.client._client |
| 470 | |
| 471 | with warnings.catch_warnings(record=True) as caught: |
| 472 | warnings.simplefilter("always") |
| 473 | composio.tools.execute( |
| 474 | "GMAIL_SEND_EMAIL", {}, user_id="user-1", version="20250114_00" |
| 475 | ) |
| 476 | |
| 477 | messages = self._deprecations(caught) |
| 478 | assert len(messages) == 1 |
| 479 | assert "GMAIL version 20250114_00" in messages[0] |
| 480 | |
| 481 | def test_no_header_no_warning(self, custom_logger): |
| 482 | logger, _ = custom_logger |
| 483 | composio = Composio( |
| 484 | api_key="test-key", http_client=_tool_transport(), logger=logger |
| 485 | ) |
| 486 | |
| 487 | with warnings.catch_warnings(): |
| 488 | warnings.simplefilter("error", ComposioDeprecationWarning) |
| 489 | composio.tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL") |
| 490 | composio.tools.execute( |
| 491 | "GMAIL_SEND_EMAIL", {}, user_id="user-1", version="20250114_00" |
| 492 | ) |
| 493 | |
| 494 | def test_client_deprecation_and_toolkit_header_are_two_warnings( |
| 495 | self, custom_logger |
| 496 | ): |
| 497 | logger, _ = custom_logger |
| 498 | composio = Composio( |
| 499 | api_key="test-key", |
| 500 | http_client=_tool_transport( |
| 501 | retrieve_headers={ |
| 502 | "Deprecation": "@1688169599", |
| 503 | _DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM, |
| 504 | } |
| 505 | ), |
| 506 | logger=logger, |
| 507 | ) |
| 508 | |
| 509 | with warnings.catch_warnings(record=True) as caught: |
| 510 | warnings.simplefilter("always") |
| 511 | composio.tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL") |
| 512 | |
| 513 | messages = self._deprecations(caught) |
| 514 | assert len(messages) == 2 |
| 515 | ours = [m for m in messages if "[Deprecation] Toolkit GMAIL" in m] |
| 516 | theirs = [m for m in messages if "tools.retrieve" in m] |
| 517 | assert len(ours) == 1 |
| 518 | assert len(theirs) == 1 |
| 519 | |
| 520 | def test_malformed_header_keeps_body_and_stays_silent(self, custom_logger): |
| 521 | logger, _ = custom_logger |
| 522 | composio = Composio( |
| 523 | api_key="test-key", |
| 524 | http_client=_tool_transport( |
| 525 | retrieve_headers={_DEPRECATED_TOOLKITS_HEADER: '"GMAIL;version=;;@@'} |
| 526 | ), |
| 527 | logger=logger, |
| 528 | ) |
| 529 | |
| 530 | with warnings.catch_warnings(record=True) as caught: |
| 531 | warnings.simplefilter("always") |
| 532 | tool = composio.tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL") |
| 533 | |
| 534 | assert tool.slug == "GMAIL_SEND_EMAIL" |
| 535 | assert self._deprecations(caught) == [] |
| 536 | |
| 537 | def test_user_http_client_keeps_its_own_hook_and_gets_ours(self, custom_logger): |
| 538 | logger, _ = custom_logger |
| 539 | user_seen: list[httpx.Response] = [] |
| 540 | |
| 541 | def user_hook(response: httpx.Response) -> None: |
| 542 | user_seen.append(response) |
| 543 | |
| 544 | http_client = _tool_transport( |
| 545 | retrieve_headers={_DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM}, |
| 546 | event_hooks={"response": [user_hook]}, |
| 547 | ) |
| 548 | composio = Composio(api_key="test-key", http_client=http_client, logger=logger) |
| 549 | |
| 550 | with warnings.catch_warnings(record=True) as caught: |
| 551 | warnings.simplefilter("always") |
| 552 | composio.tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL") |
| 553 | |
| 554 | assert http_client.event_hooks["response"][0] is user_hook |
| 555 | assert len(http_client.event_hooks["response"]) == 2 |
| 556 | assert len(user_seen) == 1 |
| 557 | assert len(self._deprecations(caught)) == 1 |
| 558 | |
| 559 | def test_second_instance_does_not_rewarn_until_reset(self, custom_logger): |
| 560 | from composio.utils import toolkit_deprecation |
| 561 | |
| 562 | logger, _ = custom_logger |
| 563 | headers = {_DEPRECATED_TOOLKITS_HEADER: _GMAIL_ITEM} |
| 564 | |
| 565 | with warnings.catch_warnings(record=True) as caught: |
| 566 | warnings.simplefilter("always") |
| 567 | Composio( |
| 568 | api_key="test-key", |
| 569 | http_client=_tool_transport(retrieve_headers=headers), |
| 570 | logger=logger, |
| 571 | ).tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL") |
| 572 | Composio( |
| 573 | api_key="test-key", |
| 574 | http_client=_tool_transport(retrieve_headers=headers), |
| 575 | logger=logger, |
| 576 | ).tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL") |
| 577 | assert len(self._deprecations(caught)) == 1 |
| 578 | toolkit_deprecation._reset_for_tests() |
| 579 | Composio( |
| 580 | api_key="test-key", |
| 581 | http_client=_tool_transport(retrieve_headers=headers), |
| 582 | logger=logger, |
| 583 | ).tools.get_raw_composio_tool_by_slug("GMAIL_SEND_EMAIL") |
| 584 | |
| 585 | assert len(self._deprecations(caught)) == 2 |