Added a pause between indexing steps for shared embedding servers (#1114)

2026-11-04 20:27:21 +00:00 · 2026-10-27 08:05:52 +01:00
1 parent cbc4ce5413
commit dcba62b45c
@@ -0,0 +1,143 @@
+using AIStudio.Tools.Services.Indexing;
+
+namespace AIStudio.Tests.Tools;
+
+/// <summary>
+/// Checks the pause between two indexing steps, which spares an embedding server that many people share.
+/// </summary>
+/// <remarks>
+/// The pause is a gap after every step which worked on documents. It is drawn only once a step is
+/// about to start, and the time which passed by then counts toward it.
+/// </remarks>
+[TestFixture]
+public sealed class PauseBetweenStepsTests
+{
+    private static readonly DateTimeOffset STEP_ENDED = new(2026, 10, 27, 14, 0, 0, TimeSpan.Zero);
+
+    private static readonly PauseRange THIRTY_TO_SIXTY_SECONDS = new(30, 60);
+
+    [Test]
+    public void BeforeTheFirstStepNothingWaits()
+    {
+        var random = new LargestRandom();
+        var pause = new PauseBetweenSteps().GetPauseBeforeNextStep(STEP_ENDED, THIRTY_TO_SIXTY_SECONDS, random);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(pause, Is.EqualTo(PauseBeforeStep.NONE));
+            Assert.That(random.Draws, Is.Zero);
+        });
+    }
+
+    [Test]
+    public void TheNextStepWaitsForTheWholePauseRightAfterAStep()
+    {
+        var pauses = new PauseBetweenSteps();
+        pauses.RecordStepEnded(STEP_ENDED);
+
+        var pause = pauses.GetPauseBeforeNextStep(STEP_ENDED, THIRTY_TO_SIXTY_SECONDS, new LargestRandom());
+
+        Assert.That(pause, Is.EqualTo(new PauseBeforeStep(TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(60))));
+    }
+
+    [Test]
+    public void TheUpperBoundCanBeDrawn()
+    {
+        var pauses = new PauseBetweenSteps();
+        pauses.RecordStepEnded(STEP_ENDED);
+
+        var pause = pauses.GetPauseBeforeNextStep(STEP_ENDED, new PauseRange(45, 45), new LargestRandom());
+
+        Assert.That(pause.Pause, Is.EqualTo(TimeSpan.FromSeconds(45)));
+    }
+
+    [Test]
+    public void TimeWhichPassedSinceTheStepCountsTowardThePause()
+    {
+        var pauses = new PauseBetweenSteps();
+        pauses.RecordStepEnded(STEP_ENDED);
+
+        var pause = pauses.GetPauseBeforeNextStep(STEP_ENDED + TimeSpan.FromSeconds(25), THIRTY_TO_SIXTY_SECONDS, new LargestRandom());
+
+        Assert.That(pause, Is.EqualTo(new PauseBeforeStep(TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(35))));
+    }
+
+    [Test]
+    public void AStepWhichStartsLaterAnywayDoesNotWait()
+    {
+        var pauses = new PauseBetweenSteps();
+        pauses.RecordStepEnded(STEP_ENDED);
+
+        var pause = pauses.GetPauseBeforeNextStep(STEP_ENDED + TimeSpan.FromSeconds(60), THIRTY_TO_SIXTY_SECONDS, new LargestRandom());
+
+        Assert.That(pause, Is.EqualTo(PauseBeforeStep.NONE));
+    }
+
+    [Test]
+    public void NothingIsDrawnWhileThereIsNoPause()
+    {
+        var pauses = new PauseBetweenSteps();
+        pauses.RecordStepEnded(STEP_ENDED);
+        var random = new LargestRandom();
+
+        var withoutPause = pauses.GetPauseBeforeNextStep(STEP_ENDED, PauseRange.NONE, random);
+        var withPause = pauses.GetPauseBeforeNextStep(STEP_ENDED + TimeSpan.FromSeconds(10), THIRTY_TO_SIXTY_SECONDS, random);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(withoutPause, Is.EqualTo(PauseBeforeStep.NONE));
+            Assert.That(withPause, Is.EqualTo(new PauseBeforeStep(TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(50))));
+            Assert.That(random.Draws, Is.EqualTo(1));
+        });
+    }
+
+    [Test]
+    public void AStepWhichStoppedWhileWaitingLeavesTheRestOfThePauseToTheNextOne()
+    {
+        var pauses = new PauseBetweenSteps();
+        pauses.RecordStepEnded(STEP_ENDED);
+        var random = new LargestRandom();
+
+        pauses.GetPauseBeforeNextStep(STEP_ENDED, THIRTY_TO_SIXTY_SECONDS, random);
+        var nextPause = pauses.GetPauseBeforeNextStep(STEP_ENDED + TimeSpan.FromSeconds(20), new PauseRange(1, 1), random);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(nextPause, Is.EqualTo(new PauseBeforeStep(TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(40))));
+            Assert.That(random.Draws, Is.EqualTo(1));
+        });
+    }
+
+    [Test]
+    public void ANewStepOpensANewGap()
+    {
+        var pauses = new PauseBetweenSteps();
+        pauses.RecordStepEnded(STEP_ENDED);
+        var random = new LargestRandom();
+        pauses.GetPauseBeforeNextStep(STEP_ENDED, THIRTY_TO_SIXTY_SECONDS, random);
+
+        var nextStepEnded = STEP_ENDED + TimeSpan.FromMinutes(6);
+        pauses.RecordStepEnded(nextStepEnded);
+        var pause = pauses.GetPauseBeforeNextStep(nextStepEnded + TimeSpan.FromSeconds(5), new PauseRange(10, 10), random);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(pause, Is.EqualTo(new PauseBeforeStep(TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(5))));
+            Assert.That(random.Draws, Is.EqualTo(2));
+        });
+    }
+
+    /// <summary>
+    /// Always draws the largest value it may, and counts how often it was asked.
+    /// </summary>
+    private sealed class LargestRandom : Random
+    {
+        public int Draws { get; private set; }
+
+        public override int Next(int minValue, int maxValue)
+        {
+            this.Draws++;
+            return maxValue - 1;
+        }
+    }
+}