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.1.0

Branches

Tags

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

Clone

HTTPS

Download ZIP

openai-dotnet/tests/Files

tests/Files/FilesMockTests.cs

480lines · 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 "data": [
269 {
270 "id": "returned_file_id"
271 }
272 ]
273 }
274 """);
275 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
276
277 OpenAIFileCollection fileInfoCollection = IsAsync
278 ? await client.GetFilesAsync(FilePurpose.Assistants)
279 : client.GetFiles(FilePurpose.Assistants);
280 OpenAIFile fileInfo = fileInfoCollection.Single();
281
282 Assert.That(fileInfo.Id, Is.EqualTo("returned_file_id"));
283 }
284
285 [Test]
286 public async Task GetFilesDeserializesCreatedAt()
287 {
288 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
289 {
290 "data": [
291 {
292 "created_at": 1704096000
293 }
294 ]
295 }
296 """);
297 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
298
299 OpenAIFileCollection fileInfoCollection = IsAsync
300 ? await client.GetFilesAsync(FilePurpose.Assistants)
301 : client.GetFiles(FilePurpose.Assistants);
302 OpenAIFile fileInfo = fileInfoCollection.Single();
303
304 Assert.That(fileInfo.CreatedAt.ToUnixTimeSeconds(), Is.EqualTo(1704096000));
305 }
306
307 [Test]
308 [TestCaseSource(nameof(s_purposeSource))]
309 public async Task GetFilesDeserializesPurpose((string stringValue, FilePurpose expectedValue) purpose)
310 {
311 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, $$"""
312 {
313 "data": [
314 {
315 "purpose": "{{purpose.stringValue}}"
316 }
317 ]
318 }
319 """);
320 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
321
322 OpenAIFileCollection fileInfoCollection = IsAsync
323 ? await client.GetFilesAsync(FilePurpose.Assistants)
324 : client.GetFiles(FilePurpose.Assistants);
325 OpenAIFile fileInfo = fileInfoCollection.Single();
326
327 Assert.That(fileInfo.Purpose, Is.EqualTo(purpose.expectedValue));
328 }
329
330#pragma warning disable CS0618
331 [Test]
332 [TestCaseSource(nameof(s_statusSource))]
333 public async Task GetFilesDeserializesStatus((string stringValue, FileStatus expectedValue) status)
334 {
335 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, $$"""
336 {
337 "data": [
338 {
339 "status": "{{status.stringValue}}"
340 }
341 ]
342 }
343 """);
344 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
345
346 OpenAIFileCollection fileInfoCollection = IsAsync
347 ? await client.GetFilesAsync(FilePurpose.Assistants)
348 : client.GetFiles(FilePurpose.Assistants);
349 OpenAIFile fileInfo = fileInfoCollection.Single();
350
351 Assert.That(fileInfo.Status, Is.EqualTo(status.expectedValue));
352 }
353#pragma warning restore CS0618
354
355#pragma warning disable CS0618
356 [Test]
357 public async Task GetFilesDeserializesStatusDetails()
358 {
359 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
360 {
361 "data": [
362 {
363 "status_details": "This is definitely an error."
364 }
365 ]
366 }
367 """);
368 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
369
370 OpenAIFileCollection fileInfoCollection = IsAsync
371 ? await client.GetFilesAsync(FilePurpose.Assistants)
372 : client.GetFiles(FilePurpose.Assistants);
373 OpenAIFile fileInfo = fileInfoCollection.Single();
374
375 Assert.That(fileInfo.StatusDetails, Is.EqualTo("This is definitely an error."));
376 }
377#pragma warning restore CS0618
378
379 [Test]
380 public void GetFilesRespectsTheCancellationToken()
381 {
382 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential);
383 using CancellationTokenSource cancellationSource = new();
384 cancellationSource.Cancel();
385
386 if (IsAsync)
387 {
388 Assert.That(async () => await client.GetFilesAsync(FilePurpose.Assistants, cancellationSource.Token),
389 Throws.InstanceOf<OperationCanceledException>());
390 }
391 else
392 {
393 Assert.That(() => client.GetFiles(FilePurpose.Assistants, cancellationSource.Token),
394 Throws.InstanceOf<OperationCanceledException>());
395 }
396 }
397
398 [Test]
399 public void DownloadFileRespectsTheCancellationToken()
400 {
401 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential);
402 using CancellationTokenSource cancellationSource = new();
403 cancellationSource.Cancel();
404
405 if (IsAsync)
406 {
407 Assert.That(async () => await client.DownloadFileAsync("fileId", cancellationSource.Token),
408 Throws.InstanceOf<OperationCanceledException>());
409 }
410 else
411 {
412 Assert.That(() => client.DownloadFile("fileId", cancellationSource.Token),
413 Throws.InstanceOf<OperationCanceledException>());
414 }
415 }
416
417 [Test]
418 public void DeleteFileRespectsTheCancellationToken()
419 {
420 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential);
421 using CancellationTokenSource cancellationSource = new();
422 cancellationSource.Cancel();
423
424 if (IsAsync)
425 {
426 Assert.That(async () => await client.DeleteFileAsync("fileId", cancellationSource.Token),
427 Throws.InstanceOf<OperationCanceledException>());
428 }
429 else
430 {
431 Assert.That(() => client.DeleteFile("fileId", cancellationSource.Token),
432 Throws.InstanceOf<OperationCanceledException>());
433 }
434 }
435
436 private OpenAIClientOptions GetClientOptionsWithMockResponse(int status, string content)
437 {
438 MockPipelineResponse response = new MockPipelineResponse(status);
439 response.SetContent(content);
440
441 return new OpenAIClientOptions()
442 {
443 Transport = new MockPipelineTransport(response)
444 };
445 }
446
447 private async ValueTask<OpenAIFile> InvokeUploadFileSyncOrAsync(OpenAIClientOptions clientOptions, FileSourceKind fileSourceKind)
448 {
449 OpenAIFileClient client = new OpenAIFileClient(s_fakeCredential, clientOptions);
450 string filename = "images_dog_and_cat.png";
451 string path = Path.Combine("Assets", filename);
452
453 if (fileSourceKind == FileSourceKind.UsingStream)
454 {
455 using FileStream file = File.OpenRead(path);
456
457 return IsAsync
458 ? await client.UploadFileAsync(file, filename, purpose: FileUploadPurpose.Assistants)
459 : client.UploadFile(file, filename, purpose: FileUploadPurpose.Assistants);
460 }
461 else if (fileSourceKind == FileSourceKind.UsingFilePath)
462 {
463 return IsAsync
464 ? await client.UploadFileAsync(path, purpose: FileUploadPurpose.Assistants)
465 : client.UploadFile(path, purpose: FileUploadPurpose.Assistants);
466 }
467 else if (fileSourceKind == FileSourceKind.UsingBinaryData)
468 {
469 using FileStream file = File.OpenRead(path);
470 BinaryData content = BinaryData.FromStream(file);
471
472 return IsAsync
473 ? await client.UploadFileAsync(content, filename, purpose: FileUploadPurpose.Assistants)
474 : client.UploadFile(content, filename, purpose: FileUploadPurpose.Assistants);
475 }
476
477 Assert.Fail("Invalid source kind.");
478 return null;
479 }
480}
481