GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

openai/openai-dotnet

Public

mirrored from https://github.com/openai/openai-dotnetAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
OpenAI_2.2.0-beta.2

Branches

Tags

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

Clone

HTTPS

Download ZIP

openai-dotnet/tests/Files

tests/Files/FilesMockTests.cs

485lines · modecode

RawDownload
Latest commit unavailable.
1using NUnit.Framework;
2using OpenAI.Files;
3using OpenAI.Tests.Utility;
4using System;
5using System.ClientModel;
6using System.IO;
7using System.Linq;
8using System.Threading;
9using System.Threading.Tasks;
10
11namespace OpenAI.Tests.Files;
12
13[TestFixture(true)]
14[TestFixture(false)]
15[Parallelizable(ParallelScope.All)]
16[Category("Files")]
17[Category("Smoke")]
18public class FilesMockTests : SyncAsyncTestBase
19{
20 private static readonly ApiKeyCredential s_fakeCredential = new ApiKeyCredential("key");
21
22 public FilesMockTests(bool isAsync)
23 : base(isAsync)
24 {
25 }
26
27 public enum FileSourceKind
28 {
29 UsingStream,
30 UsingFilePath,
31 UsingBinaryData
32 }
33
34 private static Array s_fileSourceKindSource = Enum.GetValues(typeof(FileSourceKind));
35
36 private static object[] s_purposeSource =
37 {
38 ("assistants", FilePurpose.Assistants),
39 ("assistants_output", FilePurpose.AssistantsOutput),
40 ("batch", FilePurpose.Batch),
41 ("batch_output", FilePurpose.BatchOutput),
42 ("fine-tune", FilePurpose.FineTune),
43 ("fine-tune-results", FilePurpose.FineTuneResults),
44 ("vision", FilePurpose.Vision)
45 };
46
47#pragma warning disable CS0618
48 private static object[] s_statusSource =
49 {
50 ("uploaded", FileStatus.Uploaded),
51 ("processed", FileStatus.Processed),
52 ("error", FileStatus.Error)
53 };
54#pragma warning restore CS0618
55
56 [Test]
57 public async Task GetFileDeserializesId()
58 {
59 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
60 {
61 "id": "returned_file_id"
62 }
63 """);
64 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
65
66 OpenAIFile fileInfo = IsAsync
67 ? await client.GetFileAsync("file_id")
68 : client.GetFile("file_id");
69
70 Assert.That(fileInfo.Id, Is.EqualTo("returned_file_id"));
71 }
72
73 [Test]
74 public async Task GetFileDeserializesCreatedAt()
75 {
76 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
77 {
78 "created_at": 1704096000
79 }
80 """);
81 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
82
83 OpenAIFile fileInfo = IsAsync
84 ? await client.GetFileAsync("file_id")
85 : client.GetFile("file_id");
86
87 Assert.That(fileInfo.CreatedAt.ToUnixTimeSeconds(), Is.EqualTo(1704096000));
88 }
89
90 [Test]
91 [TestCaseSource(nameof(s_purposeSource))]
92 public async Task GetFileDeserializesPurpose((string stringValue, FilePurpose expectedValue) purpose)
93 {
94 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, $$"""
95 {
96 "purpose": "{{purpose.stringValue}}"
97 }
98 """);
99 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
100
101 OpenAIFile fileInfo = IsAsync
102 ? await client.GetFileAsync("file_id")
103 : client.GetFile("file_id");
104
105 Assert.That(fileInfo.Purpose, Is.EqualTo(purpose.expectedValue));
106 }
107
108
109#pragma warning disable CS0618
110 [Test]
111 [TestCaseSource(nameof(s_statusSource))]
112 public async Task GetFileDeserializesStatus((string stringValue, FileStatus expectedValue) status)
113 {
114 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, $$"""
115 {
116 "status": "{{status.stringValue}}"
117 }
118 """);
119 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
120
121 OpenAIFile fileInfo = IsAsync
122 ? await client.GetFileAsync("file_id")
123 : client.GetFile("file_id");
124
125 Assert.That(fileInfo.Status, Is.EqualTo(status.expectedValue));
126 }
127#pragma warning restore CS0618
128
129#pragma warning disable CS0618
130 [Test]
131 public async Task GetFileDeserializesStatusDetails()
132 {
133 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
134 {
135 "status_details": "This is definitely an error."
136 }
137 """);
138 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
139
140 OpenAIFile fileInfo = IsAsync
141 ? await client.GetFileAsync("file_id")
142 : client.GetFile("file_id");
143
144 Assert.That(fileInfo.StatusDetails, Is.EqualTo("This is definitely an error."));
145 }
146#pragma warning restore CS0618
147
148 [Test]
149 public void GetFileRespectsTheCancellationToken()
150 {
151 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential);
152 using CancellationTokenSource cancellationSource = new();
153 cancellationSource.Cancel();
154
155 if (IsAsync)
156 {
157 Assert.That(async () => await client.GetFileAsync("fileId", cancellationSource.Token),
158 Throws.InstanceOf<OperationCanceledException>());
159 }
160 else
161 {
162 Assert.That(() => client.GetFile("fileId", cancellationSource.Token),
163 Throws.InstanceOf<OperationCanceledException>());
164 }
165 }
166
167 [Test]
168 [TestCaseSource(nameof(s_fileSourceKindSource))]
169 public async Task UploadFileDeserializesId(FileSourceKind fileSourceKind)
170 {
171 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
172 {
173 "id": "returned_file_id"
174 }
175 """);
176 OpenAIFile fileInfo = await InvokeUploadFileSyncOrAsync(clientOptions, fileSourceKind);
177
178 Assert.That(fileInfo.Id, Is.EqualTo("returned_file_id"));
179 }
180
181 [Test]
182 [TestCaseSource(nameof(s_fileSourceKindSource))]
183 public async Task UploadFileDeserializesCreatedAt(FileSourceKind fileSourceKind)
184 {
185 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
186 {
187 "created_at": 1704096000
188 }
189 """);
190 OpenAIFile fileInfo = await InvokeUploadFileSyncOrAsync(clientOptions, fileSourceKind);
191
192 Assert.That(fileInfo.CreatedAt.ToUnixTimeSeconds(), Is.EqualTo(1704096000));
193 }
194
195 [Test]
196 public async Task UploadFileDeserializesPurpose(
197 [ValueSource(nameof(s_fileSourceKindSource))] FileSourceKind fileSourceKind,
198 [ValueSource(nameof(s_purposeSource))] (string stringValue, FilePurpose expectedValue) purpose)
199 {
200 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, $$"""
201 {
202 "purpose": "{{purpose.stringValue}}"
203 }
204 """);
205 OpenAIFile fileInfo = await InvokeUploadFileSyncOrAsync(clientOptions, fileSourceKind);
206
207 Assert.That(fileInfo.Purpose, Is.EqualTo(purpose.expectedValue));
208 }
209
210#pragma warning disable CS0618
211 [Test]
212 public async Task UploadFileDeserializesStatus(
213 [ValueSource(nameof(s_fileSourceKindSource))] FileSourceKind fileSourceKind,
214 [ValueSource(nameof(s_statusSource))] (string stringValue, FileStatus expectedValue) status)
215 {
216 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, $$"""
217 {
218 "status": "{{status.stringValue}}"
219 }
220 """);
221 OpenAIFile fileInfo = await InvokeUploadFileSyncOrAsync(clientOptions, fileSourceKind);
222
223 Assert.That(fileInfo.Status, Is.EqualTo(status.expectedValue));
224 }
225#pragma warning restore CS0618
226
227#pragma warning disable CS0618
228 [Test]
229 [TestCaseSource(nameof(s_fileSourceKindSource))]
230 public async Task UploadFileDeserializesStatusDetails(FileSourceKind fileSourceKind)
231 {
232 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
233 {
234 "status_details": "This is definitely an error."
235 }
236 """);
237 OpenAIFile fileInfo = await InvokeUploadFileSyncOrAsync(clientOptions, fileSourceKind);
238
239 Assert.That(fileInfo.StatusDetails, Is.EqualTo("This is definitely an error."));
240 }
241#pragma warning restore CS0618
242
243 [Test]
244 public void UploadFileRespectsTheCancellationToken()
245 {
246 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential);
247 using var stream = new MemoryStream(Array.Empty<byte>());
248 using CancellationTokenSource cancellationSource = new();
249 cancellationSource.Cancel();
250
251 if (IsAsync)
252 {
253 Assert.That(async () => await client.UploadFileAsync(stream, "filename.txt", FileUploadPurpose.Assistants, cancellationSource.Token),
254 Throws.InstanceOf<OperationCanceledException>());
255 }
256 else
257 {
258 Assert.That(() => client.UploadFile(stream, "filename.txt", FileUploadPurpose.Assistants, cancellationSource.Token),
259 Throws.InstanceOf<OperationCanceledException>());
260 }
261 }
262
263 [Test]
264 public async Task GetFilesDeserializesId()
265 {
266 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
267 {
268 "object": "list",
269 "data": [
270 {
271 "id": "returned_file_id"
272 }
273 ]
274 }
275 """);
276 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
277
278 OpenAIFileCollection fileInfoCollection = IsAsync
279 ? await client.GetFilesAsync(FilePurpose.Assistants)
280 : client.GetFiles(FilePurpose.Assistants);
281 OpenAIFile fileInfo = fileInfoCollection.Single();
282
283 Assert.That(fileInfo.Id, Is.EqualTo("returned_file_id"));
284 }
285
286 [Test]
287 public async Task GetFilesDeserializesCreatedAt()
288 {
289 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
290 {
291 "object": "list",
292 "data": [
293 {
294 "created_at": 1704096000
295 }
296 ]
297 }
298 """);
299 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
300
301 OpenAIFileCollection fileInfoCollection = IsAsync
302 ? await client.GetFilesAsync(FilePurpose.Assistants)
303 : client.GetFiles(FilePurpose.Assistants);
304 OpenAIFile fileInfo = fileInfoCollection.Single();
305
306 Assert.That(fileInfo.CreatedAt.ToUnixTimeSeconds(), Is.EqualTo(1704096000));
307 }
308
309 [Test]
310 [TestCaseSource(nameof(s_purposeSource))]
311 public async Task GetFilesDeserializesPurpose((string stringValue, FilePurpose expectedValue) purpose)
312 {
313 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, $$"""
314 {
315 "object": "list",
316 "data": [
317 {
318 "purpose": "{{purpose.stringValue}}"
319 }
320 ]
321 }
322 """);
323 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
324
325 OpenAIFileCollection fileInfoCollection = IsAsync
326 ? await client.GetFilesAsync(FilePurpose.Assistants)
327 : client.GetFiles(FilePurpose.Assistants);
328 OpenAIFile fileInfo = fileInfoCollection.Single();
329
330 Assert.That(fileInfo.Purpose, Is.EqualTo(purpose.expectedValue));
331 }
332
333#pragma warning disable CS0618
334 [Test]
335 [TestCaseSource(nameof(s_statusSource))]
336 public async Task GetFilesDeserializesStatus((string stringValue, FileStatus expectedValue) status)
337 {
338 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, $$"""
339 {
340 "object": "list",
341 "data": [
342 {
343 "status": "{{status.stringValue}}"
344 }
345 ]
346 }
347 """);
348 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
349
350 OpenAIFileCollection fileInfoCollection = IsAsync
351 ? await client.GetFilesAsync(FilePurpose.Assistants)
352 : client.GetFiles(FilePurpose.Assistants);
353 OpenAIFile fileInfo = fileInfoCollection.Single();
354
355 Assert.That(fileInfo.Status, Is.EqualTo(status.expectedValue));
356 }
357#pragma warning restore CS0618
358
359#pragma warning disable CS0618
360 [Test]
361 public async Task GetFilesDeserializesStatusDetails()
362 {
363 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
364 {
365 "object": "list",
366 "data": [
367 {
368 "status_details": "This is definitely an error."
369 }
370 ]
371 }
372 """);
373 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
374
375 OpenAIFileCollection fileInfoCollection = IsAsync
376 ? await client.GetFilesAsync(FilePurpose.Assistants)
377 : client.GetFiles(FilePurpose.Assistants);
378 OpenAIFile fileInfo = fileInfoCollection.Single();
379
380 Assert.That(fileInfo.StatusDetails, Is.EqualTo("This is definitely an error."));
381 }
382#pragma warning restore CS0618
383
384 [Test]
385 public void GetFilesRespectsTheCancellationToken()
386 {
387 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential);
388 using CancellationTokenSource cancellationSource = new();
389 cancellationSource.Cancel();
390
391 if (IsAsync)
392 {
393 Assert.That(async () => await client.GetFilesAsync(FilePurpose.Assistants, cancellationSource.Token),
394 Throws.InstanceOf<OperationCanceledException>());
395 }
396 else
397 {
398 Assert.That(() => client.GetFiles(FilePurpose.Assistants, cancellationSource.Token),
399 Throws.InstanceOf<OperationCanceledException>());
400 }
401 }
402
403 [Test]
404 public void DownloadFileRespectsTheCancellationToken()
405 {
406 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential);
407 using CancellationTokenSource cancellationSource = new();
408 cancellationSource.Cancel();
409
410 if (IsAsync)
411 {
412 Assert.That(async () => await client.DownloadFileAsync("fileId", cancellationSource.Token),
413 Throws.InstanceOf<OperationCanceledException>());
414 }
415 else
416 {
417 Assert.That(() => client.DownloadFile("fileId", cancellationSource.Token),
418 Throws.InstanceOf<OperationCanceledException>());
419 }
420 }
421
422 [Test]
423 public void DeleteFileRespectsTheCancellationToken()
424 {
425 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential);
426 using CancellationTokenSource cancellationSource = new();
427 cancellationSource.Cancel();
428
429 if (IsAsync)
430 {
431 Assert.That(async () => await client.DeleteFileAsync("fileId", cancellationSource.Token),
432 Throws.InstanceOf<OperationCanceledException>());
433 }
434 else
435 {
436 Assert.That(() => client.DeleteFile("fileId", cancellationSource.Token),
437 Throws.InstanceOf<OperationCanceledException>());
438 }
439 }
440
441 private OpenAIClientOptions GetClientOptionsWithMockResponse(int status, string content)
442 {
443 MockPipelineResponse response = new MockPipelineResponse(status);
444 response.SetContent(content);
445
446 return new OpenAIClientOptions()
447 {
448 Transport = new MockPipelineTransport(response)
449 };
450 }
451
452 private async ValueTask<OpenAIFile> InvokeUploadFileSyncOrAsync(OpenAIClientOptions clientOptions, FileSourceKind fileSourceKind)
453 {
454 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
455 string filename = "images_dog_and_cat.png";
456 string path = Path.Combine("Assets", filename);
457
458 if (fileSourceKind == FileSourceKind.UsingStream)
459 {
460 using FileStream file = File.OpenRead(path);
461
462 return IsAsync
463 ? await client.UploadFileAsync(file, filename, purpose: FileUploadPurpose.Assistants)
464 : client.UploadFile(file, filename, purpose: FileUploadPurpose.Assistants);
465 }
466 else if (fileSourceKind == FileSourceKind.UsingFilePath)
467 {
468 return IsAsync
469 ? await client.UploadFileAsync(path, purpose: FileUploadPurpose.Assistants)
470 : client.UploadFile(path, purpose: FileUploadPurpose.Assistants);
471 }
472 else if (fileSourceKind == FileSourceKind.UsingBinaryData)
473 {
474 using FileStream file = File.OpenRead(path);
475 BinaryData content = BinaryData.FromStream(file);
476
477 return IsAsync
478 ? await client.UploadFileAsync(content, filename, purpose: FileUploadPurpose.Assistants)
479 : client.UploadFile(content, filename, purpose: FileUploadPurpose.Assistants);
480 }
481
482 Assert.Fail("Invalid source kind.");
483 return null;
484 }
485}
486