Repository navigation
Expand file tree
/
Copy pathtest_file_processing.py
More file actions
95 lines (73 loc) · 3.54 KB
/
Copy pathtest_file_processing.py
File metadata and controls
95 lines (73 loc) · 3.54 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
from __future__ import annotations
import asyncio
from typing import Any, cast
from unittest import mock
import pytest
from openai import OpenAI, AsyncOpenAI
from openai.lib import _files as file_helpers
from openai._models import construct_type_unchecked
from openai.resources.files import Files, AsyncFiles
from openai.types.file_object import FileObject
FILE_ID = "file-synthetic"
def make_file(status: str) -> FileObject:
return construct_type_unchecked(type_=FileObject, value={"id": FILE_ID, "status": status})
@pytest.fixture(params=["sync", "async"])
def files_resource(request: pytest.FixtureRequest) -> Files | AsyncFiles:
client = mock.Mock()
if request.param == "sync":
return Files(cast(OpenAI, client))
return AsyncFiles(cast(AsyncOpenAI, client))
async def wait(resource: Files | AsyncFiles, **kwargs: Any) -> FileObject:
if isinstance(resource, AsyncFiles):
return await resource.wait_for_processing(FILE_ID, **kwargs)
return resource.wait_for_processing(FILE_ID, **kwargs)
@pytest.mark.parametrize("status", ["processed", "error", "deleted"])
async def test_terminal_result(files_resource: Files | AsyncFiles, status: str) -> None:
terminal = make_file(status)
with (
mock.patch.object(files_resource, "retrieve", return_value=terminal) as retrieve,
mock.patch.object(files_resource, "_sleep") as sleep,
):
assert await wait(files_resource) is terminal
retrieve.assert_called_once_with(FILE_ID)
sleep.assert_not_called()
async def test_poll_until_processed(files_resource: Files | AsyncFiles) -> None:
terminal = make_file("processed")
with (
mock.patch.object(files_resource, "retrieve", side_effect=[make_file("uploaded"), terminal]) as retrieve,
mock.patch.object(files_resource, "_sleep") as sleep,
):
assert await wait(files_resource, poll_interval=0.25) is terminal
assert retrieve.call_count == 2
sleep.assert_called_once_with(0.25)
async def test_timeout_after_wall_clock_rollback(files_resource: Files | AsyncFiles) -> None:
with (
mock.patch.object(file_helpers, "time") as clock,
mock.patch.object(files_resource, "retrieve", return_value=make_file("uploaded")),
mock.patch.object(
files_resource,
"_sleep",
side_effect=[None, AssertionError("poll continued after the deadline")],
) as sleep,
):
clock.time.side_effect = [100.0, 90.0]
clock.monotonic.side_effect = [100.0, 102.0]
with pytest.raises(RuntimeError, match=f"Giving up on waiting for file {FILE_ID}"):
await wait(files_resource, poll_interval=5.0, max_wait_seconds=1.0)
sleep.assert_called_once_with(5.0)
async def test_retrieve_error_propagates(files_resource: Files | AsyncFiles) -> None:
error = RuntimeError("synthetic retrieval failure")
with mock.patch.object(files_resource, "retrieve", side_effect=error):
with pytest.raises(RuntimeError) as caught:
await wait(files_resource)
assert caught.value is error
async def test_async_cancellation_propagates() -> None:
resource = AsyncFiles(cast(AsyncOpenAI, mock.Mock()))
cancellation = asyncio.CancelledError()
with (
mock.patch.object(resource, "retrieve", return_value=make_file("uploaded")),
mock.patch.object(resource, "_sleep", side_effect=cancellation),
):
with pytest.raises(asyncio.CancelledError) as caught:
await resource.wait_for_processing(FILE_ID)
assert caught.value is cancellation