test: add coverage for mirror fallback, SileroVad registry, and voice text append

- Fix ModelRegistryTests.AllModels_ContainsAll for SileroVad (6 → 7)
- Add SileroVad type and optional model registry tests
- Add ModelManager tests: HuggingFace fallback, user mirror, non-HF URL passthrough
- Add OverlayViewModel tests: text append, partial transcription, space handling

Made-with: Cursor

Author: Hongwei-MB

tests/LiveLingo.Core.Tests/Models/ModelManagerTests.cs

@@ -565,6 +565,94 @@ public async Task MigrateStoragePathAsync_PreservesNestedDirectories()
         }
     }
 
+    [Fact]
+    public async Task EnsureModelAsync_FallsBackToMirror_WhenHuggingFaceUnreachable()
+    {
+        var requestedUrls = new List<string>();
+        var handler = new FallbackHttpMessageHandler(req =>
+        {
+            requestedUrls.Add(req.RequestUri!.ToString());
+            if (req.RequestUri.Host == "huggingface.co")
+                throw new HttpRequestException("DNS failure",
+                    new System.Net.Sockets.SocketException((int)System.Net.Sockets.SocketError.HostNotFound));
+        });
+        var options = Options.Create(new CoreOptions { ModelStoragePath = _tempDir });
+        var mgr = new ModelManager(options, new HttpClient(handler), _logger);
+
+        var desc = new ModelDescriptor("fallback-test", "Fallback Test",
+            "https://huggingface.co/test/model/resolve/main/model.bin", 100, ModelType.SpeechToText);
+
+        await mgr.EnsureModelAsync(desc, null, CancellationToken.None);
+
+        Assert.Contains(requestedUrls, u => u.Contains("hf-mirror.com"));
+        Assert.True(File.Exists(Path.Combine(_tempDir, "fallback-test", "manifest.json")));
+    }
+
+    [Fact]
+    public async Task EnsureModelAsync_UsesUserMirror_WhenConfigured()
+    {
+        var requestedUrls = new List<string>();
+        var handler = new FakeHttpMessageHandler(req => requestedUrls.Add(req.RequestUri!.ToString()));
+        var options = Options.Create(new CoreOptions
+        {
+            ModelStoragePath = _tempDir,
+            HuggingFaceMirror = "https://my-mirror.example.com"
+        });
+        var mgr = new ModelManager(options, new HttpClient(handler), _logger);
+
+        var desc = new ModelDescriptor("mirror-test", "Mirror Test",
+            "https://huggingface.co/test/model/resolve/main/model.bin", 100, ModelType.Translation);
+
+        await mgr.EnsureModelAsync(desc, null, CancellationToken.None);
+
+        Assert.All(requestedUrls, u => Assert.DoesNotContain("huggingface.co", u));
+        Assert.Contains(requestedUrls, u => u.Contains("my-mirror.example.com"));
+    }
+
+    [Fact]
+    public async Task EnsureModelAsync_DoesNotRewrite_NonHuggingFaceUrl()
+    {
+        var requestedUrls = new List<string>();
+        var handler = new FakeHttpMessageHandler(req => requestedUrls.Add(req.RequestUri!.ToString()));
+        var options = Options.Create(new CoreOptions
+        {
+            ModelStoragePath = _tempDir,
+            HuggingFaceMirror = "https://my-mirror.example.com"
+        });
+        var mgr = new ModelManager(options, new HttpClient(handler), _logger);
+
+        var desc = new ModelDescriptor("nonhf-test", "NonHF Test",
+            "https://dl.fbaipublicfiles.com/fasttext/model.ftz", 100, ModelType.LanguageDetection);
+
+        await mgr.EnsureModelAsync(desc, null, CancellationToken.None);
+
+        Assert.Contains(requestedUrls, u => u.Contains("dl.fbaipublicfiles.com"));
+        Assert.DoesNotContain(requestedUrls, u => u.Contains("my-mirror.example.com"));
+    }
+
+    [Fact]
+    public async Task EnsureModelAsync_NoFallback_WhenUserMirrorIsSet()
+    {
+        var handler = new FallbackHttpMessageHandler(req =>
+        {
+            if (req.RequestUri!.Host == "my-mirror.example.com")
+                throw new HttpRequestException("Mirror also failed",
+                    new System.Net.Sockets.SocketException((int)System.Net.Sockets.SocketError.HostNotFound));
+        });
+        var options = Options.Create(new CoreOptions
+        {
+            ModelStoragePath = _tempDir,
+            HuggingFaceMirror = "https://my-mirror.example.com"
+        });
+        var mgr = new ModelManager(options, new HttpClient(handler), _logger);
+
+        var desc = new ModelDescriptor("nofallback-test", "NoFallback",
+            "https://huggingface.co/test/model.bin", 100, ModelType.Translation);
+
+        await Assert.ThrowsAsync<HttpRequestException>(
+            () => mgr.EnsureModelAsync(desc, null, CancellationToken.None));
+    }
+
     private sealed class FakeHttpMessageHandler : HttpMessageHandler
     {
         private readonly Action<HttpRequestMessage>? _inspector;
@@ -587,4 +675,26 @@ protected override Task<HttpResponseMessage> SendAsync(
             return Task.FromResult(response);
         }
     }
+
+    private sealed class FallbackHttpMessageHandler : HttpMessageHandler
+    {
+        private readonly Action<HttpRequestMessage>? _inspector;
+
+        public FallbackHttpMessageHandler(Action<HttpRequestMessage>? inspector = null)
+        {
+            _inspector = inspector;
+        }
+
+        protected override Task<HttpResponseMessage> SendAsync(
+            HttpRequestMessage request, CancellationToken ct)
+        {
+            _inspector?.Invoke(request);
+            var content = new byte[100];
+            Array.Fill(content, (byte)'x');
+            return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new ByteArrayContent(content)
+            });
+        }
+    }
 }

tests/LiveLingo.Core.Tests/Models/ModelRegistryTests.cs

@@ -31,9 +31,10 @@ public void OptionalModels_ContainsQwen()
     [Fact]
     public void AllModels_ContainsAll()
     {
-        Assert.Equal(6, ModelRegistry.AllModels.Count);
+        Assert.Equal(7, ModelRegistry.AllModels.Count);
         Assert.Contains(ModelRegistry.Qwen25_15B, ModelRegistry.AllModels);
         Assert.Contains(ModelRegistry.WhisperBase, ModelRegistry.AllModels);
+        Assert.Contains(ModelRegistry.SileroVad, ModelRegistry.AllModels);
     }
 
     [Fact]
@@ -125,6 +126,19 @@ public void AllModels_HaveNonEmptyDisplayNames()
             Assert.False(string.IsNullOrEmpty(model.DisplayName), $"Model {model.Id} has empty DisplayName");
     }
 
+    [Fact]
+    public void SileroVad_HasCorrectType()
+    {
+        Assert.Equal(ModelType.VoiceActivityDetection, ModelRegistry.SileroVad.Type);
+        Assert.True(ModelRegistry.SileroVad.SizeBytes > 0);
+    }
+
+    [Fact]
+    public void OptionalModels_ContainsSileroVad()
+    {
+        Assert.Contains(ModelRegistry.SileroVad, ModelRegistry.OptionalModels);
+    }
+
     [Theory]
     [InlineData("opus-mt-zh-en", "MarianMT Chinese\u2192English")]
     [InlineData("opus-mt-en-zh", "MarianMT English\u2192Chinese")]

tests/LiveLingo.Desktop.Tests/ViewModels/OverlayVoiceInputTests.cs

@@ -274,6 +274,116 @@ await _pipeline.Received().ProcessAsync(
             Arg.Any<CancellationToken>());
     }
 
+    [Fact]
+    public async Task ToggleVoice_AppendsToExistingSourceText()
+    {
+        var vm = CreateVm();
+        vm.SourceText = "existing text";
+        vm.VoiceState = VoiceInputState.Idle;
+
+        _coordinator.State.Returns(VoiceInputState.Idle);
+        _coordinator.StartRecordingAsync(Arg.Any<string?>(), Arg.Any<CancellationToken>())
+            .Returns(new SpeechInputResult(true, null, SpeechInputErrorCode.None));
+
+        await vm.ToggleVoiceInputCommand.ExecuteAsync(null);
+
+        vm.VoiceState = VoiceInputState.Recording;
+
+        _coordinator.StopAndTranscribeAsync(Arg.Any<string?>(), Arg.Any<CancellationToken>())
+            .Returns(new SpeechInputResult(true, "new voice", SpeechInputErrorCode.None));
+
+        await vm.ToggleVoiceInputCommand.ExecuteAsync(null);
+
+        Assert.Equal("existing text new voice", vm.SourceText);
+    }
+
+    [Fact]
+    public async Task ToggleVoice_EmptySourceText_NoLeadingSpace()
+    {
+        var vm = CreateVm();
+        vm.SourceText = string.Empty;
+        vm.VoiceState = VoiceInputState.Idle;
+
+        _coordinator.State.Returns(VoiceInputState.Idle);
+        _coordinator.StartRecordingAsync(Arg.Any<string?>(), Arg.Any<CancellationToken>())
+            .Returns(new SpeechInputResult(true, null, SpeechInputErrorCode.None));
+
+        await vm.ToggleVoiceInputCommand.ExecuteAsync(null);
+
+        vm.VoiceState = VoiceInputState.Recording;
+
+        _coordinator.StopAndTranscribeAsync(Arg.Any<string?>(), Arg.Any<CancellationToken>())
+            .Returns(new SpeechInputResult(true, "hello", SpeechInputErrorCode.None));
+
+        await vm.ToggleVoiceInputCommand.ExecuteAsync(null);
+
+        Assert.Equal("hello", vm.SourceText);
+    }
+
+    [Fact]
+    public async Task PartialTranscription_AppendsToExistingSourceText()
+    {
+        var coordinator = Substitute.For<ISpeechInputCoordinator>();
+        Action<string>? partialHandler = null;
+        coordinator.When(c => c.PartialTranscription += Arg.Any<Action<string>>())
+            .Do(ci => partialHandler = ci.Arg<Action<string>>());
+
+        var vm = CreateVm(coordinator);
+        vm.SourceText = "before";
+
+        coordinator.State.Returns(VoiceInputState.Idle);
+        coordinator.StartRecordingAsync(Arg.Any<string?>(), Arg.Any<CancellationToken>())
+            .Returns(new SpeechInputResult(true, null, SpeechInputErrorCode.None));
+
+        await vm.ToggleVoiceInputCommand.ExecuteAsync(null);
+
+        vm.VoiceState = VoiceInputState.Recording;
+        Assert.NotNull(partialHandler);
+        partialHandler!.Invoke("partial result");
+
+        Assert.Equal("before partial result", vm.SourceText);
+    }
+
+    [Fact]
+    public async Task PartialTranscription_IgnoredWhenNotRecording()
+    {
+        var coordinator = Substitute.For<ISpeechInputCoordinator>();
+        Action<string>? partialHandler = null;
+        coordinator.When(c => c.PartialTranscription += Arg.Any<Action<string>>())
+            .Do(ci => partialHandler = ci.Arg<Action<string>>());
+
+        var vm = CreateVm(coordinator);
+        vm.SourceText = "original";
+
+        Assert.NotNull(partialHandler);
+        partialHandler!.Invoke("should be ignored");
+
+        Assert.Equal("original", vm.SourceText);
+    }
+
+    [Fact]
+    public async Task ToggleVoice_ExistingTextEndingWithSpace_NoDoubleSpace()
+    {
+        var vm = CreateVm();
+        vm.SourceText = "ends with space ";
+        vm.VoiceState = VoiceInputState.Idle;
+
+        _coordinator.State.Returns(VoiceInputState.Idle);
+        _coordinator.StartRecordingAsync(Arg.Any<string?>(), Arg.Any<CancellationToken>())
+            .Returns(new SpeechInputResult(true, null, SpeechInputErrorCode.None));
+
+        await vm.ToggleVoiceInputCommand.ExecuteAsync(null);
+
+        vm.VoiceState = VoiceInputState.Recording;
+
+        _coordinator.StopAndTranscribeAsync(Arg.Any<string?>(), Arg.Any<CancellationToken>())
+            .Returns(new SpeechInputResult(true, "next", SpeechInputErrorCode.None));
+
+        await vm.ToggleVoiceInputCommand.ExecuteAsync(null);
+
+        Assert.Equal("ends with space next", vm.SourceText);
+    }
+
     private sealed class DeterministicTranslationEngine : ITranslationEngine
     {
         public IReadOnlyList<LanguageInfo> SupportedLanguages { get; } =