16
FileDownloadable,
17
FileHelper,
18
FileUploadable,
19
+ upload,
20
_is_url,
21
_get_extension_from_mimetype,
22
_generate_timestamped_filename,
28
)
29
from composio.core.models.base import allow_tracking
30
from composio.exceptions import (
31
+ BlockedInternalUrlError,
32
ErrorDownloadingFile,
33
ErrorUploadingFile,
34
ResponseTooLargeError,
1706
class TestUploadBytesToS3:
1707
"""Test cases for _upload_bytes_to_s3 function."""
1708
1707
- @patch("composio.core.models._files.requests.put")
1708
- def test_upload_bytes_to_s3_success(self, mock_put):
1709
+ @patch("composio.core.models._files.safe_request")
1710
+ def test_upload_bytes_to_s3_success(self, mock_safe_request):
1711
"""Test successful upload to S3."""
1712
mock_client = MagicMock()
1713
mock_s3_response = MagicMock()
1717
1718
mock_put_response = MagicMock()
1719
mock_put_response.status_code = 200
1718
- mock_put.return_value = mock_put_response
1720
+ mock_safe_request.return_value = mock_put_response
1721
1722
result = _upload_bytes_to_s3(
1723
client=mock_client,
1730
1731
assert result == "s3-key-123"
1732
mock_client.post.assert_called_once()
1731
- mock_put.assert_called_once_with(
1732
- url="https://s3.example.com/upload",
1733
+ mock_safe_request.assert_called_once_with(
1734
+ "PUT",
1735
+ "https://s3.example.com/upload",
1736
data=b"file content",
1737
headers={"Content-Type": "image/jpeg"},
1738
timeout=(5, 60),
1739
)
1740
1738
- @patch("composio.core.models._files.requests.put")
1739
- def test_upload_bytes_to_s3_failure(self, mock_put):
1741
+ @patch("composio.core.models._files.safe_request")
1742
+ def test_upload_bytes_to_s3_failure(self, mock_safe_request):
1743
"""Test error handling when S3 upload fails."""
1744
mock_client = MagicMock()
1745
mock_s3_response = MagicMock()
1749
1750
mock_put_response = MagicMock()
1751
mock_put_response.status_code = 500
1749
- mock_put.return_value = mock_put_response
1752
+ mock_safe_request.return_value = mock_put_response
1753
1754
with pytest.raises(ErrorUploadingFile) as exc_info:
1755
_upload_bytes_to_s3(
1763
1764
assert "Failed to upload to S3" in str(exc_info.value)
1765
1763
- @patch("composio.core.models._files.requests.put")
1764
- def test_upload_bytes_to_s3_timeout(self, mock_put):
1766
+ @patch("composio.core.models._files.safe_request")
1767
+ def test_upload_bytes_to_s3_timeout(self, mock_safe_request):
1768
"""Test request timeouts are reported as upload errors."""
1769
mock_client = MagicMock()
1770
mock_s3_response = MagicMock()
1773
mock_client.post.return_value = mock_s3_response
1774
# The exception text itself carries the presigned URL (incl. token), as
1775
# real urllib3 errors do — the SDK must not surface it in the message.
1773
- mock_put.side_effect = requests.exceptions.Timeout(
1776
+ mock_safe_request.side_effect = requests.exceptions.Timeout(
1777
"HTTPSConnectionPool(host='s3.example.com', port=443): "
1778
"Max retries exceeded with url: /upload?token=abc"
1779
)
2427
class TestS3UploadErrorHandling:
2428
"""Test S3 upload error handling."""
2429
2427
- @patch("composio.core.models._files.requests.put")
2428
- def test_403_is_treated_as_error(self, mock_put):
2430
+ @patch("composio.core.models._files.safe_request")
2431
+ def test_403_is_treated_as_error(self, mock_safe_request):
2432
"""HTTP 403 should be treated as upload failure."""
2433
mock_client = MagicMock()
2434
mock_s3_response = MagicMock()
2438
2439
mock_put_response = MagicMock()
2440
mock_put_response.status_code = 403
2438
- mock_put.return_value = mock_put_response
2441
+ mock_safe_request.return_value = mock_put_response
2442
2443
with pytest.raises(ErrorUploadingFile, match="403"):
2444
_upload_bytes_to_s3(
2450
toolkit="test",
2451
)
2452
2450
- @patch("composio.core.models._files.requests.put")
2451
- def test_200_is_success(self, mock_put):
2453
+ @patch("composio.core.models._files.safe_request")
2454
+ def test_200_is_success(self, mock_safe_request):
2455
"""HTTP 200 should be treated as success."""
2456
mock_client = MagicMock()
2457
mock_s3_response = MagicMock()
2461
2462
mock_put_response = MagicMock()
2463
mock_put_response.status_code = 200
2461
- mock_put.return_value = mock_put_response
2464
+ mock_safe_request.return_value = mock_put_response
2465
2466
result = _upload_bytes_to_s3(
2467
client=mock_client,
2473
)
2474
assert result == "s3-key"
2475
2473
- @patch("composio.core.models._files.requests.put")
2474
- def test_500_is_treated_as_error(self, mock_put):
2476
+ @patch("composio.core.models._files.safe_request")
2477
+ def test_500_is_treated_as_error(self, mock_safe_request):
2478
"""HTTP 500 should be treated as upload failure."""
2479
mock_client = MagicMock()
2480
mock_s3_response = MagicMock()
2484
2485
mock_put_response = MagicMock()
2486
mock_put_response.status_code = 500
2484
- mock_put.return_value = mock_put_response
2487
+ mock_safe_request.return_value = mock_put_response
2488
2489
with pytest.raises(ErrorUploadingFile, match="500"):
2490
_upload_bytes_to_s3(
2531
class TestFileDownloadablePathTraversal:
2532
"""SEC-316: server-controlled `name` must not escape the output dir."""
2533
2534
+ @pytest.fixture(autouse=True)
2535
+ def _allow_fetch_target(self):
2536
+ with patch("composio.core.models._files.assert_safe_fetch_target"):
2537
+ yield
2538
+
2539
def _mock_response(self, content: bytes = b"data") -> MagicMock:
2540
response = MagicMock()
2541
response.status_code = 200
2632
mock_get.assert_called_once_with(
2633
url="https://example.com/file",
2634
stream=True,
2635
+ allow_redirects=False,
2636
timeout=(5, 60),
2637
)
2638
3026
mock_client.post.assert_not_called()
3027
3028
def test_from_path_opt_out_disables_guard(self, mock_client):
3020
- """`sensitive_file_upload_protection=False` restores the legacy
3021
- (unguarded) behavior; the denylist no longer raises for that path."""
3022
- # A non-existent basename under `.ssh`: the `.ssh` segment still trips the
3023
- # denylist when protection is on, but the file never exists, so with
3024
- # protection off we deterministically hit the missing-file path (no real
3025
- # key read, no network) rather than the block error.
3029
p = Path.home() / ".ssh" / "composio-does-not-exist-guard-test"
3030
with pytest.raises(Exception) as exc_info:
3031
FileUploadable.from_path(
3036
sensitive_file_upload_protection=False,
3037
)
3038
assert not isinstance(exc_info.value, SensitiveFilePathBlockedError)
3036
- # Guard skipped, so the failure is downstream (missing file), before any
3037
- # presigned-URL request.
3039
mock_client.post.assert_not_called()
3040
+
3041
+
3042
+class TestResponseDerivedUrlsAreGuarded:
3043
+ def _download_response(self) -> MagicMock:
3044
+ response = MagicMock()
3045
+ response.status_code = 200
3046
+ response.iter_content = lambda chunk_size: [b"%PDF-1.4"]
3047
+ response.close = MagicMock()
3048
+ return response
3049
+
3050
+ def _s3_client(self, presigned_url: str) -> MagicMock:
3051
+ client = MagicMock()
3052
+ s3meta = MagicMock()
3053
+ s3meta.key = "s3-key"
3054
+ s3meta.new_presigned_url = presigned_url
3055
+ client.post.return_value = s3meta
3056
+ return client
3057
+
3058
+ def test_download_validates_s3url(self, tmp_path):
3059
+ f = FileDownloadable(
3060
+ name="report.pdf",
3061
+ mimetype="application/pdf",
3062
+ s3url="https://s3.example.com/file",
3063
+ )
3064
+ with patch(
3065
+ "composio.core.models._files.assert_safe_fetch_target"
3066
+ ) as mock_assert:
3067
+ with patch(
3068
+ "composio.core.models._files.requests.get",
3069
+ return_value=self._download_response(),
3070
+ ):
3071
+ f.download(tmp_path / "out", root=tmp_path / "out")
3072
+
3073
+ mock_assert.assert_called_once_with("https://s3.example.com/file")
3074
+
3075
+ def test_download_blocked_url_never_reaches_the_network(self, tmp_path):
3076
+ outdir = tmp_path / "out"
3077
+ f = FileDownloadable(
3078
+ name="report.pdf",
3079
+ mimetype="application/pdf",
3080
+ s3url="http://169.254.169.254/latest/meta-data",
3081
+ )
3082
+ with patch(
3083
+ "composio.core.models._files.assert_safe_fetch_target",
3084
+ side_effect=BlockedInternalUrlError("blocked"),
3085
+ ):
3086
+ with patch("composio.core.models._files.requests.get") as mock_get:
3087
+ with pytest.raises(BlockedInternalUrlError):
3088
+ f.download(outdir, root=outdir)
3089
+
3090
+ mock_get.assert_not_called()
3091
+ assert not outdir.exists()
3092
+
3093
+ def test_download_refuses_to_follow_redirects(self, tmp_path):
3094
+ f = FileDownloadable(
3095
+ name="report.pdf",
3096
+ mimetype="application/pdf",
3097
+ s3url="https://s3.example.com/file",
3098
+ )
3099
+ with patch("composio.core.models._files.assert_safe_fetch_target"):
3100
+ with patch(
3101
+ "composio.core.models._files.requests.get",
3102
+ return_value=self._download_response(),
3103
+ ) as mock_get:
3104
+ f.download(tmp_path / "out", root=tmp_path / "out")
3105
+
3106
+ assert mock_get.call_args.kwargs["allow_redirects"] is False
3107
+
3108
+ def test_upload_bytes_to_s3_goes_through_safe_request(self):
3109
+ client = self._s3_client("https://s3.example.com/upload")
3110
+ with patch("composio.core.models._files.safe_request") as mock_safe_request:
3111
+ mock_safe_request.return_value.status_code = 200
3112
+ _upload_bytes_to_s3(
3113
+ client=client,
3114
+ filename="test.jpg",
3115
+ content=b"data",
3116
+ mimetype="image/jpeg",
3117
+ tool="TEST",
3118
+ toolkit="test",
3119
+ )
3120
+
3121
+ assert mock_safe_request.call_args.args == (
3122
+ "PUT",
3123
+ "https://s3.example.com/upload",
3124
+ )
3125
+
3126
+ def test_upload_bytes_to_s3_blocked_url_sends_nothing(self):
3127
+ client = self._s3_client("http://169.254.169.254/upload")
3128
+ with patch(
3129
+ "composio.utils.url_safety.assert_safe_fetch_target",
3130
+ side_effect=BlockedInternalUrlError("blocked"),
3131
+ ):
3132
+ with patch("composio.utils.url_safety.requests.request") as mock_request:
3133
+ with pytest.raises(BlockedInternalUrlError):
3134
+ _upload_bytes_to_s3(
3135
+ client=client,
3136
+ filename="test.jpg",
3137
+ content=b"data",
3138
+ mimetype="image/jpeg",
3139
+ tool="TEST",
3140
+ toolkit="test",
3141
+ )
3142
+
3143
+ mock_request.assert_not_called()
3144
+
3145
+ def test_file_upload_goes_through_safe_request(self, tmp_path):
3146
+ source = tmp_path / "report.pdf"
3147
+ source.write_bytes(b"%PDF-1.4")
3148
+
3149
+ with patch("composio.core.models._files.safe_request") as mock_safe_request:
3150
+ mock_safe_request.return_value.status_code = 200
3151
+ assert upload(url="https://s3.example.com/upload", file=source) is True
3152
+
3153
+ assert mock_safe_request.call_args.args == (
3154
+ "PUT",
3155
+ "https://s3.example.com/upload",
3156
+ )
3157
+
3158
+ def test_file_upload_blocked_url_sends_nothing(self, tmp_path):
3159
+ source = tmp_path / "report.pdf"
3160
+ source.write_bytes(b"%PDF-1.4")
3161
+
3162
+ with patch(
3163
+ "composio.utils.url_safety.assert_safe_fetch_target",
3164
+ side_effect=BlockedInternalUrlError("blocked"),
3165
+ ):
3166
+ with patch("composio.utils.url_safety.requests.request") as mock_request:
3167
+ with pytest.raises(BlockedInternalUrlError):
3168
+ upload(url="http://127.0.0.1:9000/upload", file=source)
3169
+
3170
+ mock_request.assert_not_called()