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/FilesTests.cs

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