using Chronos.Core.Model; using Chronos.Data.Repositories; using Chronos.Data.Scheduling; using Chronos.Data.Tests.Infrastructure; using Chronos.Protocol; using Chronos.Testing; namespace Chronos.Data.Tests.Repositories; /// Schedules on both dialects (owner review 2, R10): round trip, system rows, the compare-and-set claim, due rows. public abstract class ScheduleRepositoryTests(TestContext context) : RepositoryTest(context) { private static Schedule NewSchedule(string name = "Nightly scan", string? systemKey = null) => new() { Id = Guid.CreateVersion7(), SystemKey = systemKey, Name = name, Action = ScheduleActions.Scan, Recurrence = "daily:03:00", Created = TestData.Now, Updated = TestData.Now, }; private static SystemSchedule System(string key, string recurrence = "every:10m", bool enabled = true) => new(key, "System " + key, ScheduleActions.Verify, ScheduleRecurrence.Parse(recurrence), new ScheduleParametersDto(Percent: 25), enabled, CatchUp: false); [Test] public async Task SchedulesRoundTripEveryField() { var db = await OpenChronosAsync(); var schedule = NewSchedule() with { SystemKey = "archive-scan", Target = "current", ParametersJson = """{"force": true}""", CatchUp = false, Priority = JobPriority.User, Enabled = false, NextRun = TestData.Now.AddHours(1), LastRun = TestData.Now.AddHours(-1), LastJobId = Guid.CreateVersion7(), LastOutcome = ScheduleOutcome.SkippedPending, CreatedBy = Guid.CreateVersion7(), Updated = TestData.Now.AddMinutes(5), }; await db.Schedules.InsertAsync(schedule, Ct); Assert.Equal(schedule, await db.Schedules.GetAsync(schedule.Id, Ct)); Assert.Equal(schedule, await db.Schedules.GetBySystemKeyAsync("archive-scan", Ct)); Assert.Null(await db.Schedules.GetAsync(Guid.CreateVersion7(), Ct)); var plain = NewSchedule("Weekly verify"); await db.Schedules.InsertAsync(plain, Ct); Assert.Equal(plain, await db.Schedules.GetAsync(plain.Id, Ct)); Assert.SequenceEqual([schedule.Id, plain.Id], (await db.Schedules.ListAsync(Ct)).Select(s => s.Id)); } [Test] public async Task UpdatesKeepTheRunHistoryAndSystemRowsAreNeverDeleted() { var db = await OpenChronosAsync(); var user = NewSchedule(); var system = NewSchedule("Backup", "index-backup"); await db.Schedules.InsertAsync(user, Ct); await db.Schedules.InsertAsync(system, Ct); await db.Schedules.RecordOutcomeAsync(user.Id, Guid.CreateVersion7(), ScheduleOutcome.Queued, TestData.Now, Ct); var recorded = (await db.Schedules.GetAsync(user.Id, Ct))!; var edited = recorded with { Name = "Renamed", Recurrence = "every:6h", Enabled = false, NextRun = null, Updated = TestData.Now.AddDays(1), LastOutcome = "ignored" }; Assert.True(await db.Schedules.UpdateAsync(edited, cancellationToken: Ct)); Assert.Equal(edited with { LastOutcome = recorded.LastOutcome }, await db.Schedules.GetAsync(user.Id, Ct)); // Without the next run: a run claimed meanwhile stays claimed. Assert.True(await db.Schedules.TryAdvanceAsync(system.Id, null, TestData.Now.AddHours(2), Ct)); Assert.True(await db.Schedules.UpdateAsync(system with { Name = "Backup 2", NextRun = null }, setNextRun: false, Ct)); Assert.Equal(TestData.Now.AddHours(2), (await db.Schedules.GetAsync(system.Id, Ct))!.NextRun); Assert.False(await db.Schedules.UpdateAsync(NewSchedule(), cancellationToken: Ct)); Assert.False(await db.Schedules.DeleteAsync(system.Id, Ct)); Assert.NotNull(await db.Schedules.GetAsync(system.Id, Ct)); Assert.True(await db.Schedules.DeleteAsync(user.Id, Ct)); Assert.False(await db.Schedules.DeleteAsync(user.Id, Ct)); } [Test] public async Task SeedingSystemSchedulesKeepsTheUsersEdits() { var db = await OpenChronosAsync(); Assert.Equal(2, await db.Schedules.EnsureSystemAsync([System("archive-scan"), System("index-backup", enabled: false)], TestData.Now, Ct)); var seeded = (await db.Schedules.GetBySystemKeyAsync("archive-scan", Ct))!; Assert.Equal(("System archive-scan", "verify", "every:10m", false, true, JobPriority.Background), (seeded.Name, seeded.Action, seeded.Recurrence, seeded.CatchUp, seeded.Enabled, seeded.Priority)); // Stored normalised: the verify defaults fill what the host left out. Assert.Equal(new ScheduleParametersDto(OlderThanDays: 30, Percent: 25), ScheduleMapping.Parameters(seeded)); Assert.Null(seeded.NextRun); Assert.False((await db.Schedules.GetBySystemKeyAsync("index-backup", Ct))!.Enabled); await db.Schedules.UpdateAsync(seeded with { Recurrence = "every:30m", Enabled = false }, cancellationToken: Ct); // A later start brings other defaults and a new system schedule: the edited row stays as the user left it. Assert.Equal(1, await db.Schedules.EnsureSystemAsync([System("archive-scan", "every:5m"), System("index-backup"), System("housekeeping")], TestData.Now, Ct)); var kept = (await db.Schedules.GetBySystemKeyAsync("archive-scan", Ct))!; Assert.Equal((seeded.Id, "every:30m", false), (kept.Id, kept.Recurrence, kept.Enabled)); Assert.Count(3, await db.Schedules.ListAsync(Ct)); Assert.Equal(0, await db.Schedules.EnsureSystemAsync([], TestData.Now, Ct)); await db.Schedules.TryAdvanceAsync(kept.Id, null, TestData.Now.AddHours(1), Ct); Assert.True(await db.Schedules.ResetSystemAsync("archive-scan", System("archive-scan", "every:15m"), TestData.Now.AddDays(1), Ct)); var reset = (await db.Schedules.GetBySystemKeyAsync("archive-scan", Ct))!; Assert.Equal((seeded.Id, "every:15m", true, (DateTimeOffset?)null, TestData.Now.AddDays(1)), (reset.Id, reset.Recurrence, reset.Enabled, reset.NextRun, reset.Updated)); Assert.False(await db.Schedules.ResetSystemAsync("unknown", System("unknown"), TestData.Now, Ct)); } [Test] public async Task OnlyOneClaimOfARunWins() { var db = await OpenChronosAsync(multiConnection: true); var schedule = NewSchedule() with { NextRun = TestData.Now }; await db.Schedules.InsertAsync(schedule, Ct); for (var round = 0; round < 5; round++) { var due = (await db.Schedules.GetAsync(schedule.Id, Ct))!.NextRun; var next = due!.Value.AddDays(1); var claims = await Task.WhenAll(Enumerable.Range(0, 8).Select(_ => Task.Run(() => db.Schedules.TryAdvanceAsync(schedule.Id, due, next, Ct)))); Assert.Equal(1, claims.Count(c => c)); Assert.Equal(next, (await db.Schedules.GetAsync(schedule.Id, Ct))!.NextRun); } Assert.False(await db.Schedules.TryAdvanceAsync(schedule.Id, TestData.Now, TestData.Now.AddDays(2), Ct), "a stale expectation loses"); var unset = NewSchedule("Unset"); await db.Schedules.InsertAsync(unset, Ct); Assert.True(await db.Schedules.TryAdvanceAsync(unset.Id, null, TestData.Now, Ct)); Assert.False(await db.Schedules.TryAdvanceAsync(unset.Id, null, TestData.Now.AddHours(1), Ct)); var disabled = NewSchedule("Disabled") with { Enabled = false, NextRun = TestData.Now }; await db.Schedules.InsertAsync(disabled, Ct); Assert.False(await db.Schedules.TryAdvanceAsync(disabled.Id, TestData.Now, TestData.Now.AddHours(1), Ct), "a disabled schedule is never claimed"); } [Test] public async Task DueSchedulesAreEnabledOnesAtOrBeforeNow() { var db = await OpenChronosAsync(); var late = NewSchedule("Late") with { NextRun = TestData.Now.AddHours(-2) }; var onTime = NewSchedule("On time") with { NextRun = TestData.Now }; var future = NewSchedule("Future") with { NextRun = TestData.Now.AddSeconds(1) }; var disabled = NewSchedule("Disabled") with { NextRun = TestData.Now.AddHours(-3), Enabled = false }; var unset = NewSchedule("Unset"); foreach (var s in new[] { onTime, future, disabled, unset, late }) await db.Schedules.InsertAsync(s, Ct); Assert.SequenceEqual([late.Id, onTime.Id], (await db.Schedules.ListDueAsync(TestData.Now, Ct)).Select(s => s.Id)); } [Test] public async Task ARunWithoutAJobKeepsThePreviousJob() { var db = await OpenChronosAsync(); var schedule = NewSchedule(); await db.Schedules.InsertAsync(schedule, Ct); var job = Guid.CreateVersion7(); Assert.True(await db.Schedules.RecordOutcomeAsync(schedule.Id, job, ScheduleOutcome.Queued, TestData.Now, Ct)); Assert.True(await db.Schedules.RecordOutcomeAsync(schedule.Id, null, ScheduleOutcome.SkippedPending, TestData.Now.AddMinutes(10), Ct)); var read = (await db.Schedules.GetAsync(schedule.Id, Ct))!; Assert.Equal((job, ScheduleOutcome.SkippedPending, TestData.Now.AddMinutes(10)), (read.LastJobId!.Value, read.LastOutcome!, read.LastRun!.Value)); Assert.False(await db.Schedules.RecordOutcomeAsync(Guid.CreateVersion7(), null, ScheduleOutcome.Queued, TestData.Now, Ct)); } [Test] public async Task VerifyCandidatesAreTheLeastRecentlyVerifiedFirst() { var db = await OpenChronosAsync(); var archive = TestData.Archive(); await db.Archives.UpsertAsync(archive, Ct); var never = TestData.Sequence(archive.Id) with { FrameCount = 3 }; var old = TestData.Sequence(archive.Id) with { FrameCount = 3, VerifiedAt = TestData.Now.AddDays(-60) }; var recent = TestData.Sequence(archive.Id) with { FrameCount = 3, VerifiedAt = TestData.Now.AddDays(-2) }; var empty = TestData.Sequence(archive.Id); foreach (var s in new[] { recent, empty, old, never }) await db.Sequences.UpsertAsync(s, Ct); var other = TestData.Archive("Other"); await db.Archives.UpsertAsync(other, Ct); await db.Sequences.UpsertAsync(TestData.Sequence(other.Id) with { FrameCount = 1 }, Ct); Assert.SequenceEqual([never.Id, old.Id, recent.Id], await db.Sequences.ListVerifyCandidatesAsync(archive.Id, null, 10, Ct)); Assert.SequenceEqual([never.Id, old.Id], await db.Sequences.ListVerifyCandidatesAsync(archive.Id, TestData.Now.AddDays(-30), 10, Ct)); Assert.SequenceEqual([never.Id], await db.Sequences.ListVerifyCandidatesAsync(archive.Id, null, 1, Ct)); } } public sealed class SqliteScheduleRepositoryTests(TestContext context) : ScheduleRepositoryTests(context) { protected override Backend Backend => Backend.SqliteMemory; } [RequiresEnvironment(PgTestServer.Variable)] public sealed class PostgresScheduleRepositoryTests(TestContext context) : ScheduleRepositoryTests(context) { protected override Backend Backend => Backend.Postgres; }