Implement meeting assistant v1

2026-05-20 02:06:16 +02:00
parent 90df1edc03
commit 0297bcc0f6
120 changed files with 11883 additions and 180 deletions
@@ -0,0 +1,128 @@
+using MeetingAssistant.Transcription;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace MeetingAssistant.Tests;
+
+public sealed class SpeechRecognitionPipelineHostedServiceTests
+{
+    [Fact]
+    public async Task HostedServiceInitializesAndWarmsConfiguredPipelineWithoutBlockingStartup()
+    {
+        var pipeline = new CapturingSpeechRecognitionPipeline { BlockReadinessUntilCancelled = true };
+        var service = new SpeechRecognitionPipelineHostedService(
+            new CapturingSpeechRecognitionPipelineFactory(pipeline),
+            NullLogger<SpeechRecognitionPipelineHostedService>.Instance);
+
+        var startTask = service.StartAsync(CancellationToken.None);
+
+        await startTask.WaitAsync(TimeSpan.FromSeconds(1));
+        await pipeline.WaitForInitializeAsync();
+        await pipeline.WaitForReadinessAsync();
+
+        await service.StopAsync(CancellationToken.None);
+
+        Assert.Equal(1, pipeline.InitializeCount);
+        Assert.Equal(1, pipeline.ReadinessCount);
+        Assert.True(pipeline.ReadinessCancellationWasObserved);
+        Assert.True(pipeline.Disposed);
+    }
+
+    private sealed class CapturingSpeechRecognitionPipelineFactory : ISpeechRecognitionPipelineFactory
+    {
+        private readonly ISpeechRecognitionPipeline pipeline;
+
+        public CapturingSpeechRecognitionPipelineFactory(ISpeechRecognitionPipeline pipeline)
+        {
+            this.pipeline = pipeline;
+        }
+
+        public ISpeechRecognitionPipeline Create()
+        {
+            return pipeline;
+        }
+    }
+
+    private sealed class CapturingSpeechRecognitionPipeline : ISpeechRecognitionPipeline
+    {
+        private readonly TaskCompletionSource initialized = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        private readonly TaskCompletionSource readinessChecked = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        public int InitializeCount { get; private set; }
+
+        public int ReadinessCount { get; private set; }
+
+        public bool BlockReadinessUntilCancelled { get; init; }
+
+        public bool ReadinessCancellationWasObserved { get; private set; }
+
+        public bool Disposed { get; private set; }
+
+        public Task WaitForInitializeAsync()
+        {
+            return initialized.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        }
+
+        public Task WaitForReadinessAsync()
+        {
+            return readinessChecked.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        }
+
+        public Task InitializeAsync(CancellationToken cancellationToken)
+        {
+            InitializeCount++;
+            initialized.TrySetResult();
+            return Task.CompletedTask;
+        }
+
+        public async Task WaitUntilReadyAsync(CancellationToken cancellationToken)
+        {
+            ReadinessCount++;
+            readinessChecked.TrySetResult();
+            if (!BlockReadinessUntilCancelled)
+            {
+                return;
+            }
+
+            try
+            {
+                await Task.Delay(Timeout.InfiniteTimeSpan, cancellationToken);
+            }
+            catch (OperationCanceledException)
+            {
+                ReadinessCancellationWasObserved = true;
+                throw;
+            }
+        }
+
+        public ValueTask WriteAsync(MeetingAssistant.Recording.AudioChunk chunk, CancellationToken cancellationToken)
+        {
+            return ValueTask.CompletedTask;
+        }
+
+        public Task CompleteAsync(CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+
+        public async IAsyncEnumerable<TranscriptionSegment> ReadLiveTranscriptAsync(
+            [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+        {
+            await Task.CompletedTask;
+            yield break;
+        }
+
+        public Task<IReadOnlyList<TranscriptionSegment>> ReadFinishedTranscriptAsync(
+            string audioPath,
+            SpeechRecognitionPipelineOptions options,
+            CancellationToken cancellationToken)
+        {
+            return Task.FromResult<IReadOnlyList<TranscriptionSegment>>([]);
+        }
+
+        public ValueTask DisposeAsync()
+        {
+            Disposed = true;
+            return ValueTask.CompletedTask;
+        }
+    }
+}