Files
Chronos/tests/Chronos.Data.Tests/Repositories/ScheduleRepositoryTests.cs
T
Alby96andClaude Opus 5.5 af9eeaab9b
CI / Build and test (push) Successful in 7m0s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 6s
Release / Build, test and publish (push) Successful in 13m28s
CI / PostgreSQL 16 integration (push) Successful in 5m52s
CI / PostgreSQL 17 integration (push) Successful in 4m50s
CI / Docker image (push) Successful in 1m4s
Release / Server image (push) Successful in 1m35s
feat: owner review 2 phase 2: scheduled jobs and log settings (#10)
- Jobs > Scheduled on the desktop and the admin panel. Every timer that queued work is now a visible system schedule: archive scan, upload clean-up, index backup, job-history and audit clean-ups, desktop housekeeping. New actions: verify, thumbnails, proxies, analysis, maintenance, backup, clean-ups, reports.
- The scheduler: migration 0007, in-house recurrence, compare-and-set claim, catch-up, scan at start.
- Log settings: levels, retention, size parts, total limit, daily or hourly rotation, audit retention, diagnostics share; the server writes Debug/Trace to its files again; logging never fails a job.

Upgrade: CHRONOS_LOG_LEVEL set in an existing container locks both levels; migration 0007 is one-way.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
2026-10-27 11:19:26 +01:00

193 lines
11 KiB
C#

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;
/// <summary>Schedules on both dialects (owner review 2, R10): round trip, system rows, the compare-and-set claim, due rows.</summary>
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;
}