Test timer repro (#1934)

* TimerRepro tests

* fmt

Author: tevoinea

src/ApiService/ApiService/TimerRepro.cs

@@ -5,33 +5,30 @@ namespace Microsoft.OneFuzz.Service;
 public class TimerRepro {
     private readonly ILogTracer _log;
 
-    private readonly IStorage _storage;
+    private readonly IOnefuzzContext _onefuzzContext;
 
-    private readonly IReproOperations _reproOperations;
-
-    public TimerRepro(ILogTracer log, IStorage storage, IReproOperations reproOperations) {
+    public TimerRepro(ILogTracer log, IOnefuzzContext onefuzzContext) {
         _log = log;
-        _storage = storage;
-        _reproOperations = reproOperations;
+        _onefuzzContext = onefuzzContext;
     }
 
     // [Function("TimerRepro")]
     public async Async.Task Run([TimerTrigger("00:00:30")] TimerInfo myTimer) {
-        var expired = _reproOperations.SearchExpired();
+        var expired = _onefuzzContext.ReproOperations.SearchExpired();
         await foreach (var repro in expired) {
             _log.Info($"stopping repro: {repro.VmId}");
-            await _reproOperations.Stopping(repro);
+            await _onefuzzContext.ReproOperations.Stopping(repro);
         }
 
         var expiredVmIds = expired.Select(repro => repro?.VmId);
 
-        await foreach (var repro in _reproOperations.SearchStates(VmStateHelper.NeedsWork)) {
+        await foreach (var repro in _onefuzzContext.ReproOperations.SearchStates(VmStateHelper.NeedsWork)) {
             if (await expiredVmIds.ContainsAsync(repro.VmId)) {
                 // this VM already got processed during the expired phase
                 continue;
             }
             _log.Info($"update repro: {repro.VmId}");
-            await _reproOperations.ProcessStateUpdates(repro);
+            await _onefuzzContext.ReproOperations.ProcessStateUpdates(repro);
         }
     }
 

src/ApiService/Tests/Tests.csproj

@@ -10,6 +10,7 @@
     <PackageReference Include="FsCheck" Version="2.16.4" />
     <PackageReference Include="FsCheck.Xunit" Version="2.16.4" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
+    <PackageReference Include="Moq" Version="4.17.2" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

src/ApiService/Tests/TimerReproTests.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.OneFuzz.Service;
+using Moq;
+using Xunit;
+
+namespace Tests;
+
+public class TimerReproTests {
+    private ILogTracer log;
+    private Mock<IOnefuzzContext> mockCtx;
+    private Mock<IReproOperations> mockReproOperations;
+
+    public TimerReproTests() {
+        mockCtx = new Mock<IOnefuzzContext>();
+
+        mockReproOperations = new Mock<IReproOperations>();
+
+        mockReproOperations.Setup(x => x.SearchExpired())
+            .Returns(AsyncEnumerable.Empty<Repro>());
+        mockReproOperations.Setup(x => x.SearchStates(VmStateHelper.NeedsWork))
+            .Returns(AsyncEnumerable.Empty<Repro>());
+
+        log = new Mock<ILogTracer>().Object;
+    }
+
+    [Fact]
+    public async System.Threading.Tasks.Task NoExpiredRepros() {
+        mockReproOperations.Setup(x => x.SearchExpired())
+            .Returns(AsyncEnumerable.Empty<Repro>());
+
+        mockCtx.Setup(x => x.ReproOperations)
+            .Returns(mockReproOperations.Object);
+
+        var timerRepro = new TimerRepro(log, mockCtx.Object);
+        await timerRepro.Run(new TimerInfo());
+
+        mockReproOperations.Verify(x => x.Stopping(It.IsAny<Repro>()), Times.Never());
+    }
+
+    [Fact]
+    public async System.Threading.Tasks.Task ExpiredRepro() {
+        mockReproOperations.Setup(x => x.SearchExpired())
+            .Returns(new List<Repro> {
+                GenerateRepro()
+            }.ToAsyncEnumerable());
+
+        mockCtx.Setup(x => x.ReproOperations)
+            .Returns(mockReproOperations.Object);
+
+        var timerRepro = new TimerRepro(log, mockCtx.Object);
+        await timerRepro.Run(new TimerInfo());
+
+        mockReproOperations.Verify(x => x.Stopping(It.IsAny<Repro>()), Times.Once());
+    }
+
+    [Fact]
+    public async System.Threading.Tasks.Task NoNeedsWorkRepros() {
+        mockReproOperations.Setup(x => x.SearchStates(VmStateHelper.NeedsWork))
+            .Returns(AsyncEnumerable.Empty<Repro>());
+
+        mockCtx.Setup(x => x.ReproOperations)
+            .Returns(mockReproOperations.Object);
+
+        var timerRepro = new TimerRepro(log, mockCtx.Object);
+        await timerRepro.Run(new TimerInfo());
+
+        mockReproOperations.Verify(x => x.ProcessStateUpdates(It.IsAny<Repro>(), It.IsAny<int>()), Times.Never());
+    }
+
+    [Fact]
+    public async System.Threading.Tasks.Task DontProcessExpiredVms() {
+        var expiredVm = GenerateRepro();
+        var notExpiredVm = GenerateRepro();
+
+        mockReproOperations.Setup(x => x.SearchExpired())
+            .Returns(new List<Repro> {
+                expiredVm
+            }.ToAsyncEnumerable());
+
+        mockReproOperations.Setup(x => x.SearchStates(VmStateHelper.NeedsWork))
+            .Returns(new List<Repro> {
+                expiredVm,
+                notExpiredVm
+            }.ToAsyncEnumerable());
+
+        mockCtx.Setup(x => x.ReproOperations)
+            .Returns(mockReproOperations.Object);
+
+        var timerRepro = new TimerRepro(log, mockCtx.Object);
+        await timerRepro.Run(new TimerInfo());
+
+        mockReproOperations.Verify(x => x.ProcessStateUpdates(It.IsAny<Repro>(), It.IsAny<int>()), Times.Once());
+    }
+
+    private static Repro GenerateRepro() {
+        return new Repro(
+            Guid.NewGuid(),
+            Guid.Empty,
+            Guid.Empty,
+            new ReproConfig(
+                new Container(String.Empty),
+                String.Empty,
+                0
+            ),
+            VmState.Init,
+            null,
+            Os.Linux,
+            null,
+            null,
+            null,
+            null);
+    }
+}