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

Branches

Tags

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

Clone

HTTPS

Download ZIP

openai-dotnet/tests/Files

tests/Files/FilesTests.cs

425lines · modecode

RawDownload
Latest commit unavailable.
1using NUnit.Framework;
2using OpenAI.Files;
3using OpenAI.Tests.Utility;
4using System;
5using System.ClientModel;
6using System.ClientModel.Primitives;
7using System.Collections.Generic;
8using System.IO;
9using System.Linq;
10using System.Threading.Tasks;
11using static OpenAI.Tests.TestHelpers;
12
13namespace OpenAI.Tests.Files;
14
15[TestFixture(true)]
16[TestFixture(false)]
17[Parallelizable(ParallelScope.Fixtures)]
18[Category("Files")]
19public class FilesTests : SyncAsyncTestBase
20{
21 private static OpenAIFileClient GetTestClient() => GetTestClient<OpenAIFileClient>(TestScenario.Files);
22
23 public FilesTests(bool isAsync) : base(isAsync)
24 {
25 }
26
27 [OneTimeTearDown]
28 public void TearDown()
29 {
30 OpenAIFileClient client = GetTestClient();
31
32 RequestOptions noThrowOptions = new() { ErrorOptions = ClientErrorBehaviors.NoThrow };
33 foreach (string fileId in FileIdsForCleanup)
34 {
35 _ = client.DeleteFile(fileId, noThrowOptions);
36 }
37 }
38
39 [Test]
40 public async Task ListFiles()
41 {
42 OpenAIFileClient client = GetTestClient();
43 using Stream file1 = BinaryData.FromString("Hello! This is a test text file. Please delete me.").ToStream();
44 using Stream file2 = BinaryData.FromString("Hello! This is another test text file. Please delete me.").ToStream();
45 string filename = "test-file-delete-me.txt";
46 string visionFilename = "images_dog_and_cat.png";
47 string visionFilePath = Path.Combine("Assets", visionFilename);
48
49 OpenAIFile uploadedFile1 = null;
50 OpenAIFile uploadedFile2 = null;
51 OpenAIFile uploadedVisionFile = null;
52 OpenAIFileCollection fileInfoCollection;
53
54 try
55 {
56 uploadedFile1 = await client.UploadFileAsync(file1, filename, FileUploadPurpose.Assistants);
57 Validate(uploadedFile1);
58 uploadedFile2 = await client.UploadFileAsync(file2, filename, FileUploadPurpose.Assistants);
59 Validate(uploadedFile2);
60 uploadedVisionFile = await client.UploadFileAsync(visionFilePath, FileUploadPurpose.Vision);
61 Validate(uploadedVisionFile);
62
63 fileInfoCollection = IsAsync
64 ? await client.GetFilesAsync(FilePurpose.Assistants)
65 : client.GetFiles(FilePurpose.Assistants);
66 }
67 finally
68 {
69 if (uploadedVisionFile != null)
70 {
71 await client.DeleteFileAsync(uploadedVisionFile.Id);
72 }
73
74 if (uploadedFile2 != null)
75 {
76 await client.DeleteFileAsync(uploadedFile2.Id);
77 }
78
79 if (uploadedFile1 != null)
80 {
81 await client.DeleteFileAsync(uploadedFile1.Id);
82 }
83 }
84
85 OpenAIFile fileInfo1 = null;
86 OpenAIFile fileInfo2 = null;
87 OpenAIFile visionFileInfo = null;
88
89 foreach (OpenAIFile item in fileInfoCollection)
90 {
91 if (item.Id == uploadedFile1.Id)
92 {
93 fileInfo1 = item;
94 }
95 else if (item.Id == uploadedFile2.Id)
96 {
97 fileInfo2 = item;
98 }
99 else if (item.Id == uploadedVisionFile.Id)
100 {
101 visionFileInfo = item;
102 }
103 }
104
105 Assert.That(fileInfo1, Is.Not.Null);
106 Assert.That(fileInfo1.SizeInBytes, Is.EqualTo(uploadedFile1.SizeInBytes));
107 Assert.That(fileInfo1.CreatedAt, Is.EqualTo(uploadedFile1.CreatedAt));
108 Assert.That(fileInfo1.Filename, Is.EqualTo(uploadedFile1.Filename));
109 Assert.That(fileInfo1.Purpose, Is.EqualTo(uploadedFile1.Purpose));
110#pragma warning disable CS0618
111 Assert.That(fileInfo1.Status, Is.EqualTo(uploadedFile1.Status));
112 Assert.That(fileInfo1.StatusDetails, Is.EqualTo(uploadedFile1.StatusDetails));
113#pragma warning restore CS0618
114
115 Assert.That(fileInfo2, Is.Not.Null);
116 Assert.That(fileInfo2.SizeInBytes, Is.EqualTo(uploadedFile2.SizeInBytes));
117 Assert.That(fileInfo2.CreatedAt, Is.EqualTo(uploadedFile2.CreatedAt));
118 Assert.That(fileInfo2.Filename, Is.EqualTo(uploadedFile2.Filename));
119 Assert.That(fileInfo2.Purpose, Is.EqualTo(uploadedFile2.Purpose));
120#pragma warning disable CS0618
121 Assert.That(fileInfo2.Status, Is.EqualTo(uploadedFile2.Status));
122 Assert.That(fileInfo2.StatusDetails, Is.EqualTo(uploadedFile2.StatusDetails));
123#pragma warning restore CS0618
124
125 Assert.That(visionFileInfo, Is.Null);
126 }
127
128 public enum FileSourceKind
129 {
130 UsingStream,
131 UsingFilePath,
132 UsingBinaryData
133 }
134
135 private static Array s_fileSourceKindSource = Enum.GetValues(typeof(FileSourceKind));
136
137 [Test]
138 [TestCaseSource(nameof(s_fileSourceKindSource))]
139 public async Task UploadFile(FileSourceKind fileSourceKind)
140 {
141 OpenAIFileClient client = GetTestClient();
142 string filename = "images_dog_and_cat.png";
143 string path = Path.Combine("Assets", filename);
144 OpenAIFile fileInfo = null;
145
146 try
147 {
148 if (fileSourceKind == FileSourceKind.UsingStream)
149 {
150 using Stream file = File.OpenRead(path);
151
152 fileInfo = IsAsync
153 ? await client.UploadFileAsync(file, filename, FileUploadPurpose.Vision)
154 : client.UploadFile(file, filename, FileUploadPurpose.Vision);
155 Validate(fileInfo);
156 }
157 else if (fileSourceKind == FileSourceKind.UsingFilePath)
158 {
159 fileInfo = IsAsync
160 ? await client.UploadFileAsync(path, FileUploadPurpose.Vision)
161 : client.UploadFile(path, FileUploadPurpose.Vision);
162 Validate(fileInfo);
163 }
164 else if (fileSourceKind == FileSourceKind.UsingBinaryData)
165 {
166 using Stream file = File.OpenRead(path);
167 BinaryData content = BinaryData.FromStream(file);
168
169 fileInfo = IsAsync
170 ? await client.UploadFileAsync(content, filename, FileUploadPurpose.Vision)
171 : client.UploadFile(content, filename, FileUploadPurpose.Vision);
172 Validate(fileInfo);
173 }
174 else
175 {
176 Assert.Fail("Invalid source kind.");
177 }
178 }
179 finally
180 {
181 if (fileInfo != null)
182 {
183 await client.DeleteFileAsync(fileInfo.Id);
184 }
185 }
186
187 long expectedSize = new FileInfo(path).Length;
188 long unixTime2024 = (new DateTimeOffset(2024, 01, 01, 0, 0, 0, TimeSpan.Zero)).ToUnixTimeSeconds();
189 string expectedFilename = (fileSourceKind == FileSourceKind.UsingFilePath) ? path : filename;
190
191 Assert.That(fileInfo, Is.Not.Null);
192 Assert.That(fileInfo.Id, Is.Not.Null.And.Not.Empty);
193 Assert.That(fileInfo.SizeInBytes, Is.EqualTo(expectedSize));
194 Assert.That(fileInfo.CreatedAt.ToUnixTimeSeconds(), Is.GreaterThan(unixTime2024));
195 Assert.That(fileInfo.Filename, Is.EqualTo(expectedFilename));
196 Assert.That(fileInfo.Purpose, Is.EqualTo(FilePurpose.Vision));
197#pragma warning disable CS0618
198 Assert.That(fileInfo.Status, Is.Not.EqualTo(default(FileStatus)));
199#pragma warning restore CS0618
200 }
201
202 [Test]
203 public void UploadFileCanParseServiceError()
204 {
205 OpenAIFileClient client = GetTestClient();
206 string filename = "images_dog_and_cat.png";
207 string path = Path.Combine("Assets", filename);
208 FileUploadPurpose fakePurpose = new FileUploadPurpose("world_domination");
209 ClientResultException ex = null;
210
211 if (IsAsync)
212 {
213 ex = Assert.ThrowsAsync<ClientResultException>(async () => await client.UploadFileAsync(path, fakePurpose));
214 }
215 else
216 {
217 ex = Assert.Throws<ClientResultException>(() => client.UploadFile(path, fakePurpose));
218 }
219
220 Assert.That(ex.Status, Is.EqualTo(400));
221 }
222
223 [Test]
224 [TestCase(true)]
225 [TestCase(false)]
226 public async Task DeleteFile(bool useFileInfoOverload)
227 {
228 OpenAIFileClient client = GetTestClient();
229 string fileContent = "Hello! This is a test text file. Please delete me.";
230 using Stream file = BinaryData.FromString(fileContent).ToStream();
231 string filename = "test-file-delete-me.txt";
232
233 OpenAIFile uploadedFile = await client.UploadFileAsync(file, filename, FileUploadPurpose.Assistants);
234 Validate(uploadedFile);
235 FileDeletionResult result;
236
237 if (useFileInfoOverload)
238 {
239 result = IsAsync
240 ? await client.DeleteFileAsync(uploadedFile.Id)
241 : client.DeleteFile(uploadedFile.Id);
242 }
243 else
244 {
245 result = IsAsync
246 ? await client.DeleteFileAsync(uploadedFile.Id)
247 : client.DeleteFile(uploadedFile.Id);
248 }
249
250 Assert.That(result.FileId, Is.EqualTo(uploadedFile.Id));
251 Assert.That(result.Deleted, Is.True);
252 }
253
254 [Test]
255 public void DeleteFileCanParseServiceError()
256 {
257 OpenAIFileClient client = GetTestClient();
258 ClientResultException ex = null;
259
260 if (IsAsync)
261 {
262 ex = Assert.ThrowsAsync<ClientResultException>(async () => await client.DeleteFileAsync("fake_id"));
263 }
264 else
265 {
266 ex = Assert.Throws<ClientResultException>(() => client.DeleteFile("fake_id"));
267 }
268
269 Assert.That(ex.Status, Is.EqualTo(404));
270 }
271
272 [Test]
273 public async Task GetFile()
274 {
275 OpenAIFileClient client = GetTestClient();
276 using Stream file = BinaryData.FromString("Hello! This is a test text file. Please delete me.").ToStream();
277 string filename = "test-file-delete-me.txt";
278 OpenAIFile uploadedFile = null;
279 OpenAIFile fileInfo;
280
281 try
282 {
283 uploadedFile = await client.UploadFileAsync(file, filename, FileUploadPurpose.Assistants);
284 Validate(uploadedFile);
285
286 fileInfo = IsAsync
287 ? await client.GetFileAsync(uploadedFile.Id)
288 : client.GetFile(uploadedFile.Id);
289 }
290 finally
291 {
292 if (uploadedFile != null)
293 {
294 await client.DeleteFileAsync(uploadedFile.Id);
295 }
296 }
297
298 Assert.That(fileInfo, Is.Not.Null);
299 Assert.That(fileInfo.Id, Is.EqualTo(uploadedFile.Id));
300 Assert.That(fileInfo.SizeInBytes, Is.EqualTo(uploadedFile.SizeInBytes));
301 Assert.That(fileInfo.CreatedAt, Is.EqualTo(uploadedFile.CreatedAt));
302 Assert.That(fileInfo.Filename, Is.EqualTo(uploadedFile.Filename));
303 Assert.That(fileInfo.Purpose, Is.EqualTo(uploadedFile.Purpose));
304#pragma warning disable CS0618
305 Assert.That(fileInfo.Status, Is.EqualTo(uploadedFile.Status));
306 Assert.That(fileInfo.StatusDetails, Is.EqualTo(uploadedFile.StatusDetails));
307#pragma warning restore CS0618
308 }
309
310 [Test]
311 public void GetFileCanParseServiceError()
312 {
313 OpenAIFileClient client = GetTestClient();
314 ClientResultException ex = null;
315
316 if (IsAsync)
317 {
318 ex = Assert.ThrowsAsync<ClientResultException>(async () => await client.GetFileAsync("fake_id"));
319 }
320 else
321 {
322 ex = Assert.Throws<ClientResultException>(() => client.GetFile("fake_id"));
323 }
324
325 Assert.That(ex.Status, Is.EqualTo(404));
326 }
327
328 [Test]
329 public async Task DownloadContent()
330 {
331 OpenAIFileClient client = GetTestClient();
332 string filename = "images_dog_and_cat.png";
333 string path = Path.Combine("Assets", filename);
334 using Stream file = File.OpenRead(path);
335 OpenAIFile uploadedFile = null;
336 BinaryData downloadedContent;
337
338 try
339 {
340 uploadedFile = await client.UploadFileAsync(file, filename, FileUploadPurpose.Vision);
341 Validate(uploadedFile);
342
343 downloadedContent = IsAsync
344 ? await client.DownloadFileAsync(uploadedFile.Id)
345 : client.DownloadFile(uploadedFile.Id);
346 }
347 finally
348 {
349 if (uploadedFile != null)
350 {
351 await client.DeleteFileAsync(uploadedFile.Id);
352 }
353 }
354
355 byte[] originalFileBytes = File.ReadAllBytes(path);
356 byte[] downloadedBytes = downloadedContent.ToArray();
357
358 Assert.That(downloadedBytes.SequenceEqual(originalFileBytes));
359 }
360
361 [Test]
362 public void DownloadFileCanParseServiceError()
363 {
364 OpenAIFileClient client = GetTestClient();
365 ClientResultException ex = null;
366
367 if (IsAsync)
368 {
369 ex = Assert.ThrowsAsync<ClientResultException>(async () => await client.DownloadFileAsync("fake_id"));
370 }
371 else
372 {
373 ex = Assert.Throws<ClientResultException>(() => client.DownloadFile("fake_id"));
374 }
375
376 Assert.That(ex.Status, Is.EqualTo(404));
377 }
378
379 [Test]
380 public void SerializeFileCollection()
381 {
382 // TODO: Add this test.
383 }
384
385 [Test]
386 public async Task NonAsciiFilename()
387 {
388 OpenAIFileClient client = GetTestClient();
389 string filename = "你好.txt";
390 BinaryData fileContent = BinaryData.FromString("世界您好！这是个测试。");
391 OpenAIFile uploadedFile = IsAsync
392 ? await client.UploadFileAsync(fileContent, filename, FileUploadPurpose.Assistants)
393 : client.UploadFile(fileContent, filename, FileUploadPurpose.Assistants);
394 Validate(uploadedFile);
395 Assert.That(uploadedFile?.Filename, Is.EqualTo(filename));
396 }
397
398 [Test]
399 public async Task UserDataPurpose()
400 {
401 OpenAIFileClient client = GetTestClient();
402
403 BinaryData fileContent = BinaryData.FromString("Hello, world!");
404 OpenAIFile uploadedFile = IsAsync
405 ? await client.UploadFileAsync(fileContent, "test_hello_world.txt", FileUploadPurpose.UserData)
406 : client.UploadFile(fileContent, "test_hello_world.txt", FileUploadPurpose.UserData);
407 Validate(uploadedFile);
408 Assert.That(uploadedFile.Purpose, Is.EqualTo(FilePurpose.UserData));
409 }
410
411 private void Validate<T>(T instance)
412 {
413 if (instance is OpenAIFile file)
414 {
415 Assert.That(file?.Id, Is.Not.Null.And.Not.Empty);
416 FileIdsForCleanup.Add(file.Id);
417 }
418 else
419 {
420 throw new NotImplementedException();
421 }
422 }
423
424 private readonly List<string> FileIdsForCleanup = [];
425}