GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

openai/openai-python

Public

mirrored fromhttps://github.com/openai/openai-pythonAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
codex/flowkit-pr-copy-link-test-20260406

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

openai-python/tests/api_resources/skills

tests/api_resources/skills/test_versions.py

407lines · modecode

RawDownload
Latest commit unavailable.
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.pagination import SyncCursorPage, AsyncCursorPage
13from openai.types.skills import SkillVersion, DeletedSkillVersion
14
15base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
16
17
18class TestVersions:
19 parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
20
21 @parametrize
22 def test_method_create(self, client: OpenAI) -> None:
23 version = client.skills.versions.create(
24 skill_id="skill_123",
25 )
26 assert_matches_type(SkillVersion, version, path=["response"])
27
28 @parametrize
29 def test_method_create_with_all_params(self, client: OpenAI) -> None:
30 version = client.skills.versions.create(
31 skill_id="skill_123",
32 default=True,
33 files=[b"Example data"],
34 )
35 assert_matches_type(SkillVersion, version, path=["response"])
36
37 @parametrize
38 def test_raw_response_create(self, client: OpenAI) -> None:
39 response = client.skills.versions.with_raw_response.create(
40 skill_id="skill_123",
41 )
42
43 assert response.is_closed is True
44 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
45 version = response.parse()
46 assert_matches_type(SkillVersion, version, path=["response"])
47
48 @parametrize
49 def test_streaming_response_create(self, client: OpenAI) -> None:
50 with client.skills.versions.with_streaming_response.create(
51 skill_id="skill_123",
52 ) as response:
53 assert not response.is_closed
54 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
55
56 version = response.parse()
57 assert_matches_type(SkillVersion, version, path=["response"])
58
59 assert cast(Any, response.is_closed) is True
60
61 @parametrize
62 def test_path_params_create(self, client: OpenAI) -> None:
63 with pytest.raises(ValueError, match=r"Expected a non-empty value for `skill_id` but received ''"):
64 client.skills.versions.with_raw_response.create(
65 skill_id="",
66 )
67
68 @parametrize
69 def test_method_retrieve(self, client: OpenAI) -> None:
70 version = client.skills.versions.retrieve(
71 version="version",
72 skill_id="skill_123",
73 )
74 assert_matches_type(SkillVersion, version, path=["response"])
75
76 @parametrize
77 def test_raw_response_retrieve(self, client: OpenAI) -> None:
78 response = client.skills.versions.with_raw_response.retrieve(
79 version="version",
80 skill_id="skill_123",
81 )
82
83 assert response.is_closed is True
84 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
85 version = response.parse()
86 assert_matches_type(SkillVersion, version, path=["response"])
87
88 @parametrize
89 def test_streaming_response_retrieve(self, client: OpenAI) -> None:
90 with client.skills.versions.with_streaming_response.retrieve(
91 version="version",
92 skill_id="skill_123",
93 ) as response:
94 assert not response.is_closed
95 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
96
97 version = response.parse()
98 assert_matches_type(SkillVersion, version, path=["response"])
99
100 assert cast(Any, response.is_closed) is True
101
102 @parametrize
103 def test_path_params_retrieve(self, client: OpenAI) -> None:
104 with pytest.raises(ValueError, match=r"Expected a non-empty value for `skill_id` but received ''"):
105 client.skills.versions.with_raw_response.retrieve(
106 version="version",
107 skill_id="",
108 )
109
110 with pytest.raises(ValueError, match=r"Expected a non-empty value for `version` but received ''"):
111 client.skills.versions.with_raw_response.retrieve(
112 version="",
113 skill_id="skill_123",
114 )
115
116 @parametrize
117 def test_method_list(self, client: OpenAI) -> None:
118 version = client.skills.versions.list(
119 skill_id="skill_123",
120 )
121 assert_matches_type(SyncCursorPage[SkillVersion], version, path=["response"])
122
123 @parametrize
124 def test_method_list_with_all_params(self, client: OpenAI) -> None:
125 version = client.skills.versions.list(
126 skill_id="skill_123",
127 after="skillver_123",
128 limit=0,
129 order="asc",
130 )
131 assert_matches_type(SyncCursorPage[SkillVersion], version, path=["response"])
132
133 @parametrize
134 def test_raw_response_list(self, client: OpenAI) -> None:
135 response = client.skills.versions.with_raw_response.list(
136 skill_id="skill_123",
137 )
138
139 assert response.is_closed is True
140 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
141 version = response.parse()
142 assert_matches_type(SyncCursorPage[SkillVersion], version, path=["response"])
143
144 @parametrize
145 def test_streaming_response_list(self, client: OpenAI) -> None:
146 with client.skills.versions.with_streaming_response.list(
147 skill_id="skill_123",
148 ) as response:
149 assert not response.is_closed
150 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
151
152 version = response.parse()
153 assert_matches_type(SyncCursorPage[SkillVersion], version, path=["response"])
154
155 assert cast(Any, response.is_closed) is True
156
157 @parametrize
158 def test_path_params_list(self, client: OpenAI) -> None:
159 with pytest.raises(ValueError, match=r"Expected a non-empty value for `skill_id` but received ''"):
160 client.skills.versions.with_raw_response.list(
161 skill_id="",
162 )
163
164 @parametrize
165 def test_method_delete(self, client: OpenAI) -> None:
166 version = client.skills.versions.delete(
167 version="version",
168 skill_id="skill_123",
169 )
170 assert_matches_type(DeletedSkillVersion, version, path=["response"])
171
172 @parametrize
173 def test_raw_response_delete(self, client: OpenAI) -> None:
174 response = client.skills.versions.with_raw_response.delete(
175 version="version",
176 skill_id="skill_123",
177 )
178
179 assert response.is_closed is True
180 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
181 version = response.parse()
182 assert_matches_type(DeletedSkillVersion, version, path=["response"])
183
184 @parametrize
185 def test_streaming_response_delete(self, client: OpenAI) -> None:
186 with client.skills.versions.with_streaming_response.delete(
187 version="version",
188 skill_id="skill_123",
189 ) as response:
190 assert not response.is_closed
191 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
192
193 version = response.parse()
194 assert_matches_type(DeletedSkillVersion, version, path=["response"])
195
196 assert cast(Any, response.is_closed) is True
197
198 @parametrize
199 def test_path_params_delete(self, client: OpenAI) -> None:
200 with pytest.raises(ValueError, match=r"Expected a non-empty value for `skill_id` but received ''"):
201 client.skills.versions.with_raw_response.delete(
202 version="version",
203 skill_id="",
204 )
205
206 with pytest.raises(ValueError, match=r"Expected a non-empty value for `version` but received ''"):
207 client.skills.versions.with_raw_response.delete(
208 version="",
209 skill_id="skill_123",
210 )
211
212
213class TestAsyncVersions:
214 parametrize = pytest.mark.parametrize(
215 "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
216 )
217
218 @parametrize
219 async def test_method_create(self, async_client: AsyncOpenAI) -> None:
220 version = await async_client.skills.versions.create(
221 skill_id="skill_123",
222 )
223 assert_matches_type(SkillVersion, version, path=["response"])
224
225 @parametrize
226 async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
227 version = await async_client.skills.versions.create(
228 skill_id="skill_123",
229 default=True,
230 files=[b"Example data"],
231 )
232 assert_matches_type(SkillVersion, version, path=["response"])
233
234 @parametrize
235 async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
236 response = await async_client.skills.versions.with_raw_response.create(
237 skill_id="skill_123",
238 )
239
240 assert response.is_closed is True
241 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
242 version = response.parse()
243 assert_matches_type(SkillVersion, version, path=["response"])
244
245 @parametrize
246 async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
247 async with async_client.skills.versions.with_streaming_response.create(
248 skill_id="skill_123",
249 ) as response:
250 assert not response.is_closed
251 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
252
253 version = await response.parse()
254 assert_matches_type(SkillVersion, version, path=["response"])
255
256 assert cast(Any, response.is_closed) is True
257
258 @parametrize
259 async def test_path_params_create(self, async_client: AsyncOpenAI) -> None:
260 with pytest.raises(ValueError, match=r"Expected a non-empty value for `skill_id` but received ''"):
261 await async_client.skills.versions.with_raw_response.create(
262 skill_id="",
263 )
264
265 @parametrize
266 async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
267 version = await async_client.skills.versions.retrieve(
268 version="version",
269 skill_id="skill_123",
270 )
271 assert_matches_type(SkillVersion, version, path=["response"])
272
273 @parametrize
274 async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
275 response = await async_client.skills.versions.with_raw_response.retrieve(
276 version="version",
277 skill_id="skill_123",
278 )
279
280 assert response.is_closed is True
281 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
282 version = response.parse()
283 assert_matches_type(SkillVersion, version, path=["response"])
284
285 @parametrize
286 async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
287 async with async_client.skills.versions.with_streaming_response.retrieve(
288 version="version",
289 skill_id="skill_123",
290 ) as response:
291 assert not response.is_closed
292 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
293
294 version = await response.parse()
295 assert_matches_type(SkillVersion, version, path=["response"])
296
297 assert cast(Any, response.is_closed) is True
298
299 @parametrize
300 async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
301 with pytest.raises(ValueError, match=r"Expected a non-empty value for `skill_id` but received ''"):
302 await async_client.skills.versions.with_raw_response.retrieve(
303 version="version",
304 skill_id="",
305 )
306
307 with pytest.raises(ValueError, match=r"Expected a non-empty value for `version` but received ''"):
308 await async_client.skills.versions.with_raw_response.retrieve(
309 version="",
310 skill_id="skill_123",
311 )
312
313 @parametrize
314 async def test_method_list(self, async_client: AsyncOpenAI) -> None:
315 version = await async_client.skills.versions.list(
316 skill_id="skill_123",
317 )
318 assert_matches_type(AsyncCursorPage[SkillVersion], version, path=["response"])
319
320 @parametrize
321 async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
322 version = await async_client.skills.versions.list(
323 skill_id="skill_123",
324 after="skillver_123",
325 limit=0,
326 order="asc",
327 )
328 assert_matches_type(AsyncCursorPage[SkillVersion], version, path=["response"])
329
330 @parametrize
331 async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
332 response = await async_client.skills.versions.with_raw_response.list(
333 skill_id="skill_123",
334 )
335
336 assert response.is_closed is True
337 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
338 version = response.parse()
339 assert_matches_type(AsyncCursorPage[SkillVersion], version, path=["response"])
340
341 @parametrize
342 async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
343 async with async_client.skills.versions.with_streaming_response.list(
344 skill_id="skill_123",
345 ) as response:
346 assert not response.is_closed
347 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
348
349 version = await response.parse()
350 assert_matches_type(AsyncCursorPage[SkillVersion], version, path=["response"])
351
352 assert cast(Any, response.is_closed) is True
353
354 @parametrize
355 async def test_path_params_list(self, async_client: AsyncOpenAI) -> None:
356 with pytest.raises(ValueError, match=r"Expected a non-empty value for `skill_id` but received ''"):
357 await async_client.skills.versions.with_raw_response.list(
358 skill_id="",
359 )
360
361 @parametrize
362 async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
363 version = await async_client.skills.versions.delete(
364 version="version",
365 skill_id="skill_123",
366 )
367 assert_matches_type(DeletedSkillVersion, version, path=["response"])
368
369 @parametrize
370 async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
371 response = await async_client.skills.versions.with_raw_response.delete(
372 version="version",
373 skill_id="skill_123",
374 )
375
376 assert response.is_closed is True
377 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
378 version = response.parse()
379 assert_matches_type(DeletedSkillVersion, version, path=["response"])
380
381 @parametrize
382 async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
383 async with async_client.skills.versions.with_streaming_response.delete(
384 version="version",
385 skill_id="skill_123",
386 ) as response:
387 assert not response.is_closed
388 assert response.http_request.headers.get("X-Stainless-Lang") == "python"
389
390 version = await response.parse()
391 assert_matches_type(DeletedSkillVersion, version, path=["response"])
392
393 assert cast(Any, response.is_closed) is True
394
395 @parametrize
396 async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
397 with pytest.raises(ValueError, match=r"Expected a non-empty value for `skill_id` but received ''"):
398 await async_client.skills.versions.with_raw_response.delete(
399 version="version",
400 skill_id="",
401 )
402
403 with pytest.raises(ValueError, match=r"Expected a non-empty value for `version` but received ''"):
404 await async_client.skills.versions.with_raw_response.delete(
405 version="",
406 skill_id="skill_123",
407 )