Files
Chronos/tests/Chronos.Data.Tests/Jobs/JobThroughputTests.cs
T
Alby96andClaude Opus 5.5 5f27a86406
CI / Build and test (pull_request) Failing after 2m3s
CI / PostgreSQL 16 integration (pull_request) Skipped
CI / PostgreSQL 17 integration (pull_request) Skipped
CI / Docker image (pull_request) Skipped
CI / Windows tests and installer (pull_request) Skipped
CI / YAML check (pull_request) Successful in 4s
refactor!: rename Titano to Chronos and move CI and releases to Gitea
The owner renamed the product and moved the repository to the self-hosted
Gitea (https://gitea.encke-hake.ts.net/BalboSoft/Chronos) for more control,
and asked for Actions and a first automatic release with the server package
and the Windows exe (docs/requests/2026-10-23-chronos-gitea.md).

- Chronos everywhere: a byte-exact rename of contents and paths, then a
  per-language review of the forms the old name's ending had dictated.
- Gitea instead of GitHub: the update check, licence, issue and support
  links read ChronosReleasesUrl; the update check takes the highest stable
  version, offers a pre-release build its final release and reports a
  repository it cannot see as a failed check. EULA, security policy and
  Gitea issue forms live at the repository root.
- Gitea Actions for the Linux act_runner (.gitea/workflows): CI, release,
  nightly image and performance gates in the .NET SDK container with git
  checkout. The release cross-compiles the Windows programs, checks their
  icon, version and DPI manifest, packs installers and zips, publishes the
  Gitea release and pushes the server image (REGISTRY_TOKEN). Windows-only
  tests run in an opt-in job on a Windows runner (WINDOWS_RUNNER).
- New Chronos.Tools commands: zip, gitea-release, postgres-ci (replaces the
  docker-exec script, which Gitea's service containers do not allow) and
  pe-check.

BREAKING CHANGE: programs, settings, data folders, file types, environment
variables and the Docker image use the new name; nothing is migrated from
Titano, which never had a release.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 11:34:48 +02:00

148 lines
5.5 KiB
C#

using Chronos.Core.Model;
using Chronos.Data.Jobs;
using Chronos.Protocol;
using Chronos.Testing;
namespace Chronos.Data.Tests.Jobs;
/// <summary>A clock the test moves by hand (BCL <see cref="TimeProvider"/>, no package).</summary>
internal sealed class ManualTime : TimeProvider
{
private long _ticks;
public override long TimestampFrequency => TimeSpan.TicksPerSecond;
public override long GetTimestamp() => Interlocked.Read(ref _ticks);
public void Advance(TimeSpan by) => Interlocked.Add(ref _ticks, by.Ticks);
}
[Category("jobs")]
public sealed class JobThroughputTests(TestContext context)
{
[Test]
public void TheFirstWindowWithProgressSeedsTheRate()
{
var throughput = new JobThroughput(0);
Assert.Null(throughput.Sample(2, 0, 100).Rate);
var (rate, eta) = throughput.Sample(4, 10, 100);
Assert.Equal(5.0, rate);
Assert.Equal(TimeSpan.FromSeconds(18), eta);
}
[Test]
public void AStalledJobLosesItsRateAndTimeLeftWithoutOverflowing()
{
// The owner's log: one sequence of 17 done, then a long one checkpointed every 10 s without moving the count.
var throughput = new JobThroughput(0);
throughput.Sample(600, 1, 17);
(double? Rate, TimeSpan? Eta) last = default;
for (var i = 1; i <= 2000; i++) last = throughput.Sample(600 + i * 10, 1, 17);
Assert.Null(last.Rate);
Assert.Null(last.Eta);
}
[Test]
public void ProgressThatGoesBackStartsANewWindow()
{
var throughput = new JobThroughput(0);
throughput.Sample(2, 20, 100);
throughput.Sample(3, 5, 100);
var (rate, _) = throughput.Sample(5, 15, 100);
Assert.Approximately(0.7 * 10 + 0.3 * 5, rate!.Value, 1e-9);
}
[Theory]
[Case(double.NaN)]
[Case(double.PositiveInfinity)]
[Case(-1.0)]
[Case(1e300)]
[Case(4e7)]
public void UnusableSecondsGiveNoTimeLeft(double seconds) => Assert.Null(JobEta.FromSeconds(seconds));
[Test]
public void UsableSecondsAndRatesGiveTheTimeLeft()
{
Assert.Equal(TimeSpan.FromSeconds(90), JobEta.FromSeconds(90));
Assert.Equal(TimeSpan.FromSeconds(4), JobEta.Of(8, 2));
Assert.Null(JobEta.Of(0, 2));
Assert.Null(JobEta.Of(8, null));
Assert.Null(JobEta.Of(8, 1e-300));
}
[Test]
public void ServerTimeLeftBeyondTheMaximumReadsUnknown()
{
var dto = new JobDto(Guid.NewGuid(), "render", [], null, "running", "normal", 1, 17, 1e-11, 1e300, null, null, 0, null,
DateTimeOffset.UtcNow, null, null);
Assert.Null(JobWire.FromDto(dto)!.Eta);
}
[Test]
public async Task AJobWhoseCountStallsForHoursStillEndsDone()
{
var time = new ManualTime();
var reported = new List<JobProgressInfo>();
await using var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(context.CreateTempDirectory(), "jobs.db")), context.Cancellation);
var handler = new CallbackHandler(JobKind.Proxies, async c =>
{
time.Advance(TimeSpan.FromSeconds(600));
await c.CheckpointAsync("1:0", 1, 17);
for (var frame = 1; frame <= 400; frame++)
{
time.Advance(TimeSpan.FromSeconds(11));
await c.CheckpointAsync($"1:{frame}", 1, 17);
}
});
await using var engine = new JobEngine(db, [handler], new JobEngineOptions { Workers = 1, WorkerId = "t", Time = time });
engine.Progress += p =>
{
lock (reported) reported.Add(p);
};
await engine.StartAsync();
var job = await engine.EnqueueAsync(JobKind.Proxies, [Guid.NewGuid()]);
var done = await WaitForAsync(db, job.Id, JobState.Done);
Assert.Null(done.Eta);
Assert.Null(done.ItemsPerSecond);
lock (reported) Assert.Null(reported[^1].Eta);
}
[Test]
public async Task AProgressSubscriberThatThrowsNeverFailsTheJob()
{
await using var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(context.CreateTempDirectory(), "jobs.db")), context.Cancellation);
var handler = new CallbackHandler(JobKind.Verify, async c =>
{
for (var i = 1; i <= 5; i++) await c.CheckpointAsync(i.ToString(System.Globalization.CultureInfo.InvariantCulture), i, 5);
});
await using var engine = new JobEngine(db, [handler], new JobEngineOptions { Workers = 1, WorkerId = "t" });
engine.Progress += _ => throw new InvalidOperationException("broken subscriber");
await engine.StartAsync();
var first = await engine.EnqueueAsync(JobKind.Verify, [Guid.NewGuid()]);
var second = await engine.EnqueueAsync(JobKind.Verify, [Guid.NewGuid()]);
Assert.Equal(5L, (await WaitForAsync(db, first.Id, JobState.Done)).ProgressDone);
await WaitForAsync(db, second.Id, JobState.Done);
}
private sealed class CallbackHandler(JobKind kind, Func<JobContext, Task> run) : IJobHandler
{
public JobKind Kind => kind;
public Task RunAsync(JobContext context) => run(context);
}
private static async Task<Job> WaitForAsync(ChronosDatabase db, Guid id, JobState state)
{
var until = DateTime.UtcNow.AddSeconds(15);
Job? job = null;
while (DateTime.UtcNow < until)
{
job = await db.Jobs.GetAsync(id);
if (job?.State == state) return job;
await Task.Delay(20);
}
Assert.Fail($"Job {id} is {job?.State}, not {state}");
return null!;
}
}