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/Audio

tests/Audio/TranscriptionMockTests.cs

196lines · modecode

RawDownload
Latest commit unavailable.
1using System;
2using System.ClientModel;
3using System.IO;
4using System.Linq;
5using System.Threading;
6using System.Threading.Tasks;
7using NUnit.Framework;
8using OpenAI.Audio;
9using OpenAI.Tests.Utility;
10
11namespace OpenAI.Tests.Audio;
12
13[TestFixture(true)]
14[TestFixture(false)]
15[Parallelizable(ParallelScope.All)]
16[Category("Audio")]
17[Category("Smoke")]
18public partial class TranscriptionMockTests : SyncAsyncTestBase
19{
20 private static readonly ApiKeyCredential s_fakeCredential = new ApiKeyCredential("key");
21
22 public TranscriptionMockTests(bool isAsync)
23 : base(isAsync)
24 {
25 }
26
27 public enum AudioSourceKind
28 {
29 UsingStream,
30 UsingFilePath
31 }
32
33 [Test]
34 [TestCase(AudioSourceKind.UsingStream)]
35 [TestCase(AudioSourceKind.UsingFilePath)]
36 public async Task TranscribeAudioDeserializesLanguage(AudioSourceKind audioSourceKind)
37 {
38 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
39 {
40 "language": "la"
41 }
42 """);
43 AudioTranscription transcription = await InvokeTranscribeAudioSyncOrAsync(clientOptions, audioSourceKind);
44
45 Assert.That(transcription.Language, Is.EqualTo("la"));
46 }
47
48 [TestCase(AudioSourceKind.UsingStream)]
49 [TestCase(AudioSourceKind.UsingFilePath)]
50 public async Task TranscribeAudioDeserializesDuration(AudioSourceKind audioSourceKind)
51 {
52 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
53 {
54 "duration": 185
55 }
56 """);
57 AudioTranscription transcription = await InvokeTranscribeAudioSyncOrAsync(clientOptions, audioSourceKind);
58
59 Assert.That(transcription.Duration, Is.EqualTo(TimeSpan.FromSeconds(185)));
60 }
61
62 [Test]
63 [TestCase(AudioSourceKind.UsingStream)]
64 [TestCase(AudioSourceKind.UsingFilePath)]
65 public async Task TranscribeAudioDeserializesText(AudioSourceKind audioSourceKind)
66 {
67 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
68 {
69 "text": "The quick brown fox got lost."
70 }
71 """);
72 AudioTranscription transcription = await InvokeTranscribeAudioSyncOrAsync(clientOptions, audioSourceKind);
73
74 Assert.That(transcription.Text, Is.EqualTo("The quick brown fox got lost."));
75 }
76
77 [Test]
78 [TestCase(AudioSourceKind.UsingStream)]
79 [TestCase(AudioSourceKind.UsingFilePath)]
80 public async Task TranscribeAudioDeserializesWord(AudioSourceKind audioSourceKind)
81 {
82 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
83 {
84 "words": [
85 {
86 "word": "pneumonoultramicroscopicsilicovolcanoconiosis",
87 "start": 2.5,
88 "end": 7.5
89 }
90 ]
91 }
92 """);
93 AudioTranscription transcription = await InvokeTranscribeAudioSyncOrAsync(clientOptions, audioSourceKind);
94 TranscribedWord word = transcription.Words.Single();
95
96 Assert.That(word.Word, Is.EqualTo("pneumonoultramicroscopicsilicovolcanoconiosis"));
97 Assert.That(word.StartTime, Is.EqualTo(TimeSpan.FromSeconds(2.5)));
98 Assert.That(word.EndTime, Is.EqualTo(TimeSpan.FromSeconds(7.5)));
99 }
100
101 [Test]
102 [TestCase(AudioSourceKind.UsingStream)]
103 [TestCase(AudioSourceKind.UsingFilePath)]
104 public async Task TranscribeAudioDeserializesSegment(AudioSourceKind audioSourceKind)
105 {
106 OpenAIClientOptions clientOptions = GetClientOptionsWithMockResponse(200, """
107 {
108 "segments": [
109 {
110 "id": 15,
111 "seek": 50,
112 "start": 2.5,
113 "end": 7.5,
114 "text": "The quick brown fox got lost.",
115 "tokens": [
116 255, 305, 678
117 ],
118 "temperature": 0.8,
119 "avg_logprob": -0.3,
120 "compression_ratio": 1.5,
121 "no_speech_prob": 0.2
122 }
123 ]
124 }
125 """);
126 AudioTranscription transcription = await InvokeTranscribeAudioSyncOrAsync(clientOptions, audioSourceKind);
127 TranscribedSegment segment = transcription.Segments.Single();
128
129 Assert.That(segment.Id, Is.EqualTo(15));
130 Assert.That(segment.SeekOffset, Is.EqualTo(50));
131 Assert.That(segment.StartTime, Is.EqualTo(TimeSpan.FromSeconds(2.5)));
132 Assert.That(segment.EndTime, Is.EqualTo(TimeSpan.FromSeconds(7.5)));
133 Assert.That(segment.Text, Is.EqualTo("The quick brown fox got lost."));
134 Assert.That(segment.TokenIds.Span.SequenceEqual([255, 305, 678]), Is.True);
135 Assert.That(segment.Temperature, Is.EqualTo(0.8f));
136 Assert.That(segment.AverageLogProbability, Is.EqualTo(-0.3f));
137 Assert.That(segment.CompressionRatio, Is.EqualTo(1.5f));
138 Assert.That(segment.NoSpeechProbability, Is.EqualTo(0.2f));
139 }
140
141 [Test]
142 public void TranscribeAudioFromStreamRespectsTheCancellationToken()
143 {
144 AudioClient client = new AudioClient("model", s_fakeCredential);
145 using Stream stream = new MemoryStream();
146 using CancellationTokenSource cancellationSource = new();
147 cancellationSource.Cancel();
148
149 if (IsAsync)
150 {
151 Assert.That(async () => await client.TranscribeAudioAsync(stream, "filename", cancellationToken: cancellationSource.Token),
152 Throws.InstanceOf<OperationCanceledException>());
153 }
154 else
155 {
156 Assert.That(() => client.TranscribeAudio(stream, "filename", cancellationToken: cancellationSource.Token),
157 Throws.InstanceOf<OperationCanceledException>());
158 }
159 }
160
161 private OpenAIClientOptions GetClientOptionsWithMockResponse(int status, string content)
162 {
163 MockPipelineResponse response = new MockPipelineResponse(status);
164 response.SetContent(content);
165
166 return new OpenAIClientOptions()
167 {
168 Transport = new MockPipelineTransport(response)
169 };
170 }
171
172 private async ValueTask<AudioTranscription> InvokeTranscribeAudioSyncOrAsync(OpenAIClientOptions clientOptions, AudioSourceKind audioSourceKind)
173 {
174 AudioClient client = new AudioClient("model", s_fakeCredential, clientOptions);
175 string filename = "audio_french.wav";
176 string path = Path.Combine("Assets", filename);
177
178 if (audioSourceKind == AudioSourceKind.UsingStream)
179 {
180 using FileStream audio = File.OpenRead(path);
181
182 return IsAsync
183 ? await client.TranscribeAudioAsync(audio, filename)
184 : client.TranscribeAudio(audio, filename);
185 }
186 else if (audioSourceKind == AudioSourceKind.UsingFilePath)
187 {
188 return IsAsync
189 ? await client.TranscribeAudioAsync(path)
190 : client.TranscribeAudio(path);
191 }
192
193 Assert.Fail("Invalid source kind.");
194 return null;
195 }
196}
197