main
1# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
2
3from __future__ import annotations
4
5import os
6from typing import Any, cast
7
8import pytest
9
10from openai import OpenAI, AsyncOpenAI
11from tests.utils import assert_matches_type
12from openai.types.conversations import (
13 Conversation,
14 ConversationDeletedResource,
15)
16
17base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
18
19
20class TestConversations:
21 parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
22
23 @parametrize
24 def test_method_create(self, client: OpenAI) -> None:
25 conversation = client.conversations.create()
26 assert_matches_type(Conversation, conversation, path=["response"])
27
28 @parametrize
29 def test_method_create_with_all_params(self, client: OpenAI) -> None:
30 conversation = client.conversations.create(
31 items=[
32 {
33 "content": "string",
34 "role": "user",
35 "type": "message",
36 }
37 ],
38 metadata={"foo": "string"},
39 )
40 assert_matches_type(Conversation, conversation, path=["response"])
41
42 @parametrize
43 def test_raw_response_create(self, client: OpenAI) -> None:
44 response = client.conversations.with_raw_response.create()
45
46 assert response.is_closed is True
47 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
48 conversation = response.parse()
49 assert_matches_type(Conversation, conversation, path=["response"])
50
51 @parametrize
52 def test_streaming_response_create(self, client: OpenAI) -> None:
53 with client.conversations.with_streaming_response.create() as response:
54 assert not response.is_closed
55 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
56
57 conversation = response.parse()
58 assert_matches_type(Conversation, conversation, path=["response"])
59
60 assert cast(Any, response.is_closed) is True
61
62 @parametrize
63 def test_method_retrieve(self, client: OpenAI) -> None:
64 conversation = client.conversations.retrieve(
65 "conv_123",
66 )
67 assert_matches_type(Conversation, conversation, path=["response"])
68
69 @parametrize
70 def test_raw_response_retrieve(self, client: OpenAI) -> None:
71 response = client.conversations.with_raw_response.retrieve(
72 "conv_123",
73 )
74
75 assert response.is_closed is True
76 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
77 conversation = response.parse()
78 assert_matches_type(Conversation, conversation, path=["response"])
79
80 @parametrize
81 def test_streaming_response_retrieve(self, client: OpenAI) -> None:
82 with client.conversations.with_streaming_response.retrieve(
83 "conv_123",
84 ) as response:
85 assert not response.is_closed
86 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
87
88 conversation = response.parse()
89 assert_matches_type(Conversation, conversation, path=["response"])
90
91 assert cast(Any, response.is_closed) is True
92
93 @parametrize
94 def test_path_params_retrieve(self, client: OpenAI) -> None:
95 with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
96 client.conversations.with_raw_response.retrieve(
97 "",
98 )
99
100 @parametrize
101 def test_method_update(self, client: OpenAI) -> None:
102 conversation = client.conversations.update(
103 conversation_id="conv_123",
104 metadata={"foo": "string"},
105 )
106 assert_matches_type(Conversation, conversation, path=["response"])
107
108 @parametrize
109 def test_raw_response_update(self, client: OpenAI) -> None:
110 response = client.conversations.with_raw_response.update(
111 conversation_id="conv_123",
112 metadata={"foo": "string"},
113 )
114
115 assert response.is_closed is True
116 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
117 conversation = response.parse()
118 assert_matches_type(Conversation, conversation, path=["response"])
119
120 @parametrize
121 def test_streaming_response_update(self, client: OpenAI) -> None:
122 with client.conversations.with_streaming_response.update(
123 conversation_id="conv_123",
124 metadata={"foo": "string"},
125 ) as response:
126 assert not response.is_closed
127 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
128
129 conversation = response.parse()
130 assert_matches_type(Conversation, conversation, path=["response"])
131
132 assert cast(Any, response.is_closed) is True
133
134 @parametrize
135 def test_path_params_update(self, client: OpenAI) -> None:
136 with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
137 client.conversations.with_raw_response.update(
138 conversation_id="",
139 metadata={"foo": "string"},
140 )
141
142 @parametrize
143 def test_method_delete(self, client: OpenAI) -> None:
144 conversation = client.conversations.delete(
145 "conv_123",
146 )
147 assert_matches_type(ConversationDeletedResource, conversation, path=["response"])
148
149 @parametrize
150 def test_raw_response_delete(self, client: OpenAI) -> None:
151 response = client.conversations.with_raw_response.delete(
152 "conv_123",
153 )
154
155 assert response.is_closed is True
156 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
157 conversation = response.parse()
158 assert_matches_type(ConversationDeletedResource, conversation, path=["response"])
159
160 @parametrize
161 def test_streaming_response_delete(self, client: OpenAI) -> None:
162 with client.conversations.with_streaming_response.delete(
163 "conv_123",
164 ) as response:
165 assert not response.is_closed
166 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
167
168 conversation = response.parse()
169 assert_matches_type(ConversationDeletedResource, conversation, path=["response"])
170
171 assert cast(Any, response.is_closed) is True
172
173 @parametrize
174 def test_path_params_delete(self, client: OpenAI) -> None:
175 with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
176 client.conversations.with_raw_response.delete(
177 "",
178 )
179
180
181class TestAsyncConversations:
182 parametrize = pytest.mark.parametrize(
183 "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
184 )
185
186 @parametrize
187 async def test_method_create(self, async_client: AsyncOpenAI) -> None:
188 conversation = await async_client.conversations.create()
189 assert_matches_type(Conversation, conversation, path=["response"])
190
191 @parametrize
192 async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
193 conversation = await async_client.conversations.create(
194 items=[
195 {
196 "content": "string",
197 "role": "user",
198 "type": "message",
199 }
200 ],
201 metadata={"foo": "string"},
202 )
203 assert_matches_type(Conversation, conversation, path=["response"])
204
205 @parametrize
206 async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
207 response = await async_client.conversations.with_raw_response.create()
208
209 assert response.is_closed is True
210 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
211 conversation = response.parse()
212 assert_matches_type(Conversation, conversation, path=["response"])
213
214 @parametrize
215 async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
216 async with async_client.conversations.with_streaming_response.create() as response:
217 assert not response.is_closed
218 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
219
220 conversation = await response.parse()
221 assert_matches_type(Conversation, conversation, path=["response"])
222
223 assert cast(Any, response.is_closed) is True
224
225 @parametrize
226 async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
227 conversation = await async_client.conversations.retrieve(
228 "conv_123",
229 )
230 assert_matches_type(Conversation, conversation, path=["response"])
231
232 @parametrize
233 async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
234 response = await async_client.conversations.with_raw_response.retrieve(
235 "conv_123",
236 )
237
238 assert response.is_closed is True
239 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
240 conversation = response.parse()
241 assert_matches_type(Conversation, conversation, path=["response"])
242
243 @parametrize
244 async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
245 async with async_client.conversations.with_streaming_response.retrieve(
246 "conv_123",
247 ) as response:
248 assert not response.is_closed
249 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
250
251 conversation = await response.parse()
252 assert_matches_type(Conversation, conversation, path=["response"])
253
254 assert cast(Any, response.is_closed) is True
255
256 @parametrize
257 async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
258 with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
259 await async_client.conversations.with_raw_response.retrieve(
260 "",
261 )
262
263 @parametrize
264 async def test_method_update(self, async_client: AsyncOpenAI) -> None:
265 conversation = await async_client.conversations.update(
266 conversation_id="conv_123",
267 metadata={"foo": "string"},
268 )
269 assert_matches_type(Conversation, conversation, path=["response"])
270
271 @parametrize
272 async def test_raw_response_update(self, async_client: AsyncOpenAI) -> None:
273 response = await async_client.conversations.with_raw_response.update(
274 conversation_id="conv_123",
275 metadata={"foo": "string"},
276 )
277
278 assert response.is_closed is True
279 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
280 conversation = response.parse()
281 assert_matches_type(Conversation, conversation, path=["response"])
282
283 @parametrize
284 async def test_streaming_response_update(self, async_client: AsyncOpenAI) -> None:
285 async with async_client.conversations.with_streaming_response.update(
286 conversation_id="conv_123",
287 metadata={"foo": "string"},
288 ) as response:
289 assert not response.is_closed
290 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
291
292 conversation = await response.parse()
293 assert_matches_type(Conversation, conversation, path=["response"])
294
295 assert cast(Any, response.is_closed) is True
296
297 @parametrize
298 async def test_path_params_update(self, async_client: AsyncOpenAI) -> None:
299 with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
300 await async_client.conversations.with_raw_response.update(
301 conversation_id="",
302 metadata={"foo": "string"},
303 )
304
305 @parametrize
306 async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
307 conversation = await async_client.conversations.delete(
308 "conv_123",
309 )
310 assert_matches_type(ConversationDeletedResource, conversation, path=["response"])
311
312 @parametrize
313 async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
314 response = await async_client.conversations.with_raw_response.delete(
315 "conv_123",
316 )
317
318 assert response.is_closed is True
319 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
320 conversation = response.parse()
321 assert_matches_type(ConversationDeletedResource, conversation, path=["response"])
322
323 @parametrize
324 async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
325 async with async_client.conversations.with_streaming_response.delete(
326 "conv_123",
327 ) as response:
328 assert not response.is_closed
329 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
330
331 conversation = await response.parse()
332 assert_matches_type(ConversationDeletedResource, conversation, path=["response"])
333
334 assert cast(Any, response.is_closed) is True
335
336 @parametrize
337 async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
338 with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
339 await async_client.conversations.with_raw_response.delete(
340 "",
341 )