using System.ComponentModel.DataAnnotations;
using FluentAssertions;
using SlpModularCms.Modules.Hero.Models;
using SlpModularCms.Modules.Hero.Services;
namespace SlpModularCms.Modules.Hero.Tests;
/// A changed focus is part of saving the hero: nothing live changes before that save.
public class HeroFocusSaveTests
{
private static HeroSaveRequest Save(Guid imageId, IReadOnlyList? focus)
=> new("Andrea Slop", null, null, "single", [], [new HeroSlideRequest(null, imageId, "foto")], focus);
[Fact]
public async Task TheLiveHero_KeepsItsOldSet_UntilTheNewSetIsCut_AndThenSwitchesToIt()
{
using var rig = new HeroTestRig();
var image = await rig.Upload(HeroTestRig.Photo());
var id = Guid.Parse(image.Id);
await rig.Service.SaveAsync(Save(id, null), HeroTestRig.Admin, default);
var before = (await rig.Public.GetActiveAsync(default))!.Slides[0].Image.Src;
// The save returns without cutting anything: the old set stays live and the admin sees the image as processing.
var saved = await rig.Service.SaveAsync(Save(id, [new HeroImageFocusRequest(id, new FocusDto(0.5, 0.5, 1), null, new FocusDto(1.0, 0.5, 1))]), HeroTestRig.Admin, default);
(await rig.Public.GetActiveAsync(default))!.Slides[0].Image.Src.Should().Be(before);
saved.Slides[0].Image.Processing.Should().BeTrue();
(await rig.RenderPending()).Should().Be(1);
var after = (await rig.Public.GetActiveAsync(default))!.Slides[0].Image;
var beforeSet = before.Split('/')[3];
after.Variants.Should().OnlyContain(v => !v.Url.Contains(beforeSet), "a changed focus gives new addresses");
after.FocusByRatio.Should().ContainKey("tall");
(await rig.Service.GetAsync(default)).Slides[0].Image.Processing.Should().BeFalse();
}
[Fact]
public async Task TheOldFiles_StayOnDisk_AfterTheSwitch_UntilTheCleanUp()
{
using var rig = new HeroTestRig();
var image = await rig.Upload(HeroTestRig.Photo());
var id = Guid.Parse(image.Id);
await rig.Service.SaveAsync(Save(id, null), HeroTestRig.Admin, default);
var oldVariant = image.Variants.First();
await rig.Service.SaveAsync(Save(id, [new HeroImageFocusRequest(id, new FocusDto(0.1, 0.1, 1.5))]), HeroTestRig.Admin, default);
await rig.RenderPending();
(await rig.Store.ExistsAsync(oldVariant.Url["/media/".Length..], default)).Should().BeTrue("a site that still holds the old data keeps working for the retention time");
rig.Db.HeroRetiredFiles.Should().ContainSingle(f => f.Kind == "set");
}
[Fact]
public async Task AnUpload_ReturnsWithoutCuttingAnything_AndIsNotPublishedUntilItsSetExists()
{
using var rig = new HeroTestRig();
var dto = await rig.UploadWithoutRendering(HeroTestRig.Photo());
dto.Processing.Should().BeTrue();
dto.Variants.Should().BeEmpty();
await rig.Service.SaveAsync(Save(Guid.Parse(dto.Id), null), HeroTestRig.Admin, default);
(await rig.Public.GetActiveAsync(default))!.Slides.Should().BeEmpty("a slide whose image is not ready is not published");
await rig.RenderPending();
(await rig.Public.GetActiveAsync(default))!.Slides.Should().ContainSingle();
}
[Fact]
public async Task TwoFocusSaves_BeforeTheRenderRuns_AreCutOnce_AtTheLastFocus()
{
using var rig = new HeroTestRig();
var image = await rig.Upload(HeroTestRig.Photo());
var id = Guid.Parse(image.Id);
await rig.Service.SaveAsync(Save(id, [new HeroImageFocusRequest(id, new FocusDto(0.2, 0.2, 1))]), HeroTestRig.Admin, default);
await rig.Service.SaveAsync(Save(id, [new HeroImageFocusRequest(id, new FocusDto(0.9, 0.9, 1))]), HeroTestRig.Admin, default);
(await rig.RenderPending()).Should().Be(1);
var done = rig.Db.HeroImages.Single();
done.SetHash.Should().Be(HeroMapping.TargetSetHash(done));
done.FocusX.Should().Be(0.9);
}
[Fact]
public async Task ACancelledRenderOrSave_LeavesTheStoredHeroAlone_AndARepeatWorks()
{
using var rig = new HeroTestRig();
var image = await rig.Upload(HeroTestRig.Photo());
var id = Guid.Parse(image.Id);
await rig.Service.SaveAsync(Save(id, null), HeroTestRig.Admin, default);
var live = rig.Db.HeroImages.Single().SetHash;
await rig.Service.SaveAsync(Save(id, [new HeroImageFocusRequest(id, new FocusDto(0.9, 0.1, 1))]), HeroTestRig.Admin, default);
using var cancelled = new CancellationTokenSource();
await cancelled.CancelAsync();
var act = async () => await rig.Images.RenderNextPendingAsync(new HashSet(), cancelled.Token);
await act.Should().ThrowAsync();
rig.Db.HeroImages.Single().SetHash.Should().Be(live, "nothing was switched");
(await rig.RenderPending()).Should().Be(1);
HeroMapping.NeedsRender(rig.Db.HeroImages.Single()).Should().BeFalse();
}
[Fact]
public async Task APreparedFocusThatIsNeverSaved_LeavesOnlyUnreferencedFiles_ThatTheCleanUpRemoves()
{
using var rig = new HeroTestRig();
var image = await rig.Upload(HeroTestRig.Photo());
var id = Guid.Parse(image.Id);
await rig.Service.SaveAsync(Save(id, null), HeroTestRig.Admin, default);
var live = rig.Db.HeroImages.Single().SetHash;
// The save stops after the new files were written (here: the hero refers to a slide of another hero).
var failing = new HeroSaveRequest("Andrea Slop", null, null, "single", [], [new HeroSlideRequest(Guid.NewGuid(), id, "foto")],
[new HeroImageFocusRequest(id, new FocusDto(0.9, 0.9, 2))]);
var act = async () => await rig.Service.SaveAsync(failing, HeroTestRig.Admin, default);
await act.Should().ThrowAsync();
rig.Db.HeroImages.Single().SetHash.Should().Be(live, "the failed save did not change the stored image");
(await rig.Public.GetActiveAsync(default))!.Slides[0].Image.Src.Should().Contain(live);
}
[Fact]
public async Task AFocusForAnUnknownImage_IsRejected()
{
using var rig = new HeroTestRig();
var act = async () => await rig.Service.SaveAsync(Save(Guid.NewGuid(), null) with { Slides = [], ImageFocus = [new HeroImageFocusRequest(Guid.NewGuid(), new FocusDto(0.5, 0.5, 1))] }, HeroTestRig.Admin, default);
(await act.Should().ThrowAsync()).Which.Field.Should().Be("ImageFocus[0].ImageId");
}
[Theory]
[InlineData(-0.1, 0.5, 1.0)]
[InlineData(0.5, 1.1, 1.0)]
[InlineData(0.5, 0.5, 0.5)]
[InlineData(0.5, 0.5, 4.5)]
public void AnInvalidFocusInTheRequest_IsRefusedByTheValidation(double x, double y, double zoom)
{
var request = Save(Guid.NewGuid(), [new HeroImageFocusRequest(Guid.NewGuid(), new FocusDto(x, y, zoom))]);
var results = new List();
Validator.TryValidateObject(request, new ValidationContext(request), results, true);
results.SelectMany(r => r.MemberNames).Should().Contain("ImageFocus[0]");
}
[Fact]
public void AValidFocusEdit_PassesTheValidation()
{
var request = Save(Guid.NewGuid(), [new HeroImageFocusRequest(Guid.NewGuid(), new FocusDto(0.2, 0.9, 2), new FocusDto(0.1, 0.1, 1), null)]);
var results = new List();
Validator.TryValidateObject(request, new ValidationContext(request), results, true);
results.Should().BeEmpty();
}
[Fact]
public async Task AnImageTheRendererGaveUpOn_IsShownAsFailed_AndARetryClearsIt()
{
using var rig = new HeroTestRig();
var dto = await rig.UploadWithoutRendering(HeroTestRig.Photo());
var id = Guid.Parse(dto.Id);
await rig.Service.SaveAsync(Save(id, null), HeroTestRig.Admin, default);
for (var i = 0; i < HeroRenderSignal.MaxAttempts; i++)
{
rig.Signal.RecordFailure(id);
}
var failed = (await rig.Service.GetAsync(default)).Slides[0].Image;
failed.Processing.Should().BeTrue();
failed.Failed.Should().BeTrue();
await rig.Images.RetryRenderAsync(id, default);
(await rig.Service.GetAsync(default)).Slides[0].Image.Failed.Should().BeFalse();
(await rig.RenderPending()).Should().Be(1);
}
[Fact]
public async Task ARetryForAnUnknownImage_IsNotFound()
{
using var rig = new HeroTestRig();
var act = async () => await rig.Images.RetryRenderAsync(Guid.NewGuid(), default);
await act.Should().ThrowAsync();
}
[Fact]
public void TheUploadLimits_ListTheFormatsTheHostAccepts_InPlainWords()
{
using var rig = new HeroTestRig();
var limits = HeroMapping.UploadLimits(rig.Status, rig.Media);
limits.Formats.Should().Contain(["JPEG", "PNG", "WebP"]).And.OnlyHaveUniqueItems();
limits.Formats.Should().BeEquivalentTo(rig.Status.AcceptedInput.Select(f => f == SlpModularCms.Core.Media.ImageFormat.Jpeg ? "JPEG" : f == SlpModularCms.Core.Media.ImageFormat.WebP ? "WebP" : f.ToString().ToUpperInvariant()));
limits.MaxUploadBytes.Should().Be(rig.Media.MaxUploadBytes);
limits.MaxMegapixels.Should().Be((int)(rig.Media.MaxPixels / 1_000_000));
}
[Fact]
public async Task AnImageThatCannotBeCut_FailsWithItsId_AndTheOthersAreStillCut()
{
using var rig = new HeroTestRig();
var broken = await rig.UploadWithoutRendering(HeroTestRig.Photo(seed: 1));
var fine = await rig.UploadWithoutRendering(HeroTestRig.Photo(seed: 2));
// The original of the first photo is gone (a lost file): cutting it cannot work.
await rig.Store.DeleteAsync(rig.Db.HeroImages.Single(i => i.Id == Guid.Parse(broken.Id)).OriginalKey, default);
var failure = await Assert.ThrowsAsync(() => rig.Images.RenderNextPendingAsync(new HashSet(), default));
failure.ImageId.Should().Be(Guid.Parse(broken.Id));
var handled = await rig.Images.RenderNextPendingAsync(new HashSet { failure.ImageId }, default);
handled.Should().Be(Guid.Parse(fine.Id));
HeroMapping.NeedsRender(rig.Db.HeroImages.Single(i => i.Id == Guid.Parse(fine.Id))).Should().BeFalse();
HeroMapping.NeedsRender(rig.Db.HeroImages.Single(i => i.Id == Guid.Parse(broken.Id))).Should().BeTrue();
}
[Fact]
public async Task ASetFromOneDecode_GivesTheSameSizesAndFormats_AsCuttingEveryVariantOnItsOwn_AndReportsEveryStep()
{
using var rig = new HeroTestRig();
var photo = HeroTestRig.Photo(2400, 1600);
var info = await rig.Processor.InspectAsync(photo, SlpModularCms.Core.Media.ImageFormat.Jpeg, default);
var ratios = new[] { SlpModularCms.Core.Media.Ratio.Wide, SlpModularCms.Core.Media.Ratio.Tall }
.Select(r => new SlpModularCms.Core.Media.RatioPlan(r, new SlpModularCms.Core.Media.FocusSetting(0.3, 0.6, 1.5).Normalize(), SlpModularCms.Core.Media.VariantPlanner.DefaultWidths(r)))
.ToList();
var specs = SlpModularCms.Core.Media.VariantPlanner.Plan(info.Width, info.Height, ratios, rig.Processor.SupportedOutput);
var steps = new List<(int Done, int Total)>();
var set = await rig.Processor.RenderSetAsync(photo, SlpModularCms.Core.Media.ImageFormat.Jpeg, specs, (done, total) => steps.Add((done, total)), default);
set.Should().HaveCount(specs.Count);
for (var i = 0; i < specs.Count; i++)
{
var single = await rig.Processor.RenderAsync(photo, SlpModularCms.Core.Media.ImageFormat.Jpeg, specs[i], default);
(set[i].Width, set[i].Height, set[i].Format).Should().Be((single.Width, single.Height, single.Format), $"variant {i}");
}
steps.Should().HaveCount(specs.Count);
steps.Select(x => x.Done).Should().BeInAscendingOrder();
steps.Last().Should().Be((specs.Count, specs.Count));
}
[Fact]
public async Task ACancelledSet_StopsBetweenVariants()
{
using var rig = new HeroTestRig();
var photo = HeroTestRig.Photo(2400, 1600);
var info = await rig.Processor.InspectAsync(photo, SlpModularCms.Core.Media.ImageFormat.Jpeg, default);
var ratios = new[] { new SlpModularCms.Core.Media.RatioPlan(SlpModularCms.Core.Media.Ratio.Wide, new SlpModularCms.Core.Media.FocusSetting(0.5, 0.5, 1).Normalize(), SlpModularCms.Core.Media.VariantPlanner.DefaultWidths(SlpModularCms.Core.Media.Ratio.Wide)) };
var specs = SlpModularCms.Core.Media.VariantPlanner.Plan(info.Width, info.Height, ratios, rig.Processor.SupportedOutput);
using var cts = new CancellationTokenSource();
var done = 0;
var act = async () => await rig.Processor.RenderSetAsync(photo, SlpModularCms.Core.Media.ImageFormat.Jpeg, specs, (_, _) => { done++; cts.Cancel(); }, cts.Token);
await act.Should().ThrowAsync();
done.Should().BeLessThan(specs.Count);
}
[Fact]
public async Task EveryImageWithoutACompleteSet_IsProcessing_InTheAdminApi_AndTwoNewPhotosAreBothCut()
{
using var rig = new HeroTestRig();
// The helper Upload cuts everything that is pending, so the finished photo is made first.
var ready = await rig.Upload(HeroTestRig.Photo(seed: 3));
var first = await rig.UploadWithoutRendering(HeroTestRig.Photo(seed: 1));
var second = await rig.UploadWithoutRendering(HeroTestRig.Photo(seed: 2));
var request = new HeroSaveRequest("Titel", null, null, "slideshow", [],
[new HeroSlideRequest(null, Guid.Parse(first.Id), "een"), new HeroSlideRequest(null, Guid.Parse(second.Id), "twee"), new HeroSlideRequest(null, Guid.Parse(ready.Id), "drie")]);
var saved = await rig.Service.SaveAsync(request, HeroTestRig.Admin, default);
saved.Slides.Select(s => s.Image.Processing).Should().Equal(true, true, false);
(await rig.Service.GetAsync(default)).Slides.Select(s => s.Image.Processing).Should().Equal(true, true, false);
(await rig.RenderPending()).Should().Be(2, "both new photos are cut, one after the other");
(await rig.Service.GetAsync(default)).Slides.Should().OnlyContain(s => !s.Image.Processing && s.Image.Variants.Count > 0);
}
[Theory]
[InlineData(3000, 2000)]
[InlineData(2000, 3000)]
[InlineData(1600, 1600)]
[InlineData(3000, 1000)]
public async Task EverySet_HasAFullFramePreviewAtTheShapeOfThePicture_ThatIsNotPublishedToWebsites(int width, int height)
{
using var rig = new HeroTestRig();
var image = await rig.Upload(HeroTestRig.Photo(width, height));
var id = Guid.Parse(image.Id);
await rig.Service.SaveAsync(Save(id, null), HeroTestRig.Admin, default);
var admin = (await rig.Service.GetAsync(default)).Slides[0].Image;
var stored = rig.Db.HeroImages.Single();
admin.PreviewSrc.Should().NotBeNull();
var preview = stored.Variants.Single(v => v.Ratio == "full");
(preview.Width / (double)preview.Height).Should().BeApproximately(width / (double)height, 0.01, "the preview is the whole picture, not a crop");
preview.Width.Should().Be(Math.Min(1280, width));
admin.Variants.Should().NotContain(v => v.Ratio == "full", "the admin lists only the variants of the website");
(await rig.Public.GetActiveAsync(default))!.Slides[0].Image.Variants.Should().NotContain(v => v.Ratio == "full");
(await rig.Store.ExistsAsync($"hero/{stored.SetHash}/{preview.FileName}", default)).Should().BeTrue();
}
[Fact]
public async Task ASetMadeBeforeThePreviewExisted_GetsOnlyThePreviewAdded_WithoutBeingProcessingOrChangingItsAddresses()
{
using var rig = new HeroTestRig();
var image = await rig.Upload(HeroTestRig.Photo(2000, 3000));
var id = Guid.Parse(image.Id);
await rig.Service.SaveAsync(Save(id, null), HeroTestRig.Admin, default);
var stored = rig.Db.HeroImages.Single();
var setBefore = stored.SetHash;
var preview = stored.Variants.Single(v => v.Ratio == "full");
stored.Variants = stored.Variants.Where(v => v.Ratio != "full").ToList(); // as an older set looked
await rig.Db.SaveChangesAsync();
await rig.Store.DeleteAsync($"hero/{setBefore}/{preview.FileName}", default);
var oldLook = (await rig.Service.GetAsync(default)).Slides[0].Image;
oldLook.Processing.Should().BeFalse("adding the preview is not work the administrator waits for");
oldLook.PreviewSrc.Should().BeNull();
(await rig.RenderPending()).Should().Be(1);
var after = rig.Db.HeroImages.Single();
after.SetHash.Should().Be(setBefore, "nothing live changes");
(await rig.Service.GetAsync(default)).Slides[0].Image.PreviewSrc.Should().NotBeNull();
(await rig.Store.ExistsAsync($"hero/{setBefore}/{preview.FileName}", default)).Should().BeTrue();
}
[Fact]
public async Task APhotoThatIsAlreadyThere_ComesBackAsReused_WithItsVariants_AndNothingToWaitFor()
{
using var rig = new HeroTestRig();
var photo = HeroTestRig.Photo(seed: 5);
var first = await rig.Upload(photo);
var again = await rig.UploadWithoutRendering(photo);
again.Id.Should().Be(first.Id);
again.Reused.Should().BeTrue();
again.Processing.Should().BeFalse();
again.Variants.Should().NotBeEmpty();
first.Reused.Should().BeFalse();
}
[Fact]
public async Task TheStateOfOneImage_IsAskedForByItsId_WithTheRunningRenderersFlags()
{
using var rig = new HeroTestRig();
var dto = await rig.UploadWithoutRendering(HeroTestRig.Photo(seed: 6));
var id = Guid.Parse(dto.Id);
(await rig.Images.GetImageAsync(id, default))!.Processing.Should().BeTrue();
rig.Signal.SetProgress(id, 4, 19);
var busy = (await rig.Images.GetImageAsync(id, default))!;
(busy.RenderDone, busy.RenderTotal).Should().Be((4, 19));
rig.Signal.ClearProgress(id);
await rig.RenderPending();
var done = (await rig.Images.GetImageAsync(id, default))!;
done.Processing.Should().BeFalse();
done.Variants.Should().NotBeEmpty();
(await rig.Images.GetImageAsync(Guid.NewGuid(), default)).Should().BeNull();
}
[Fact]
public async Task APutWithAChangedFocus_ShowsTheImageAsBeingRecut_InTheNextAdminRead_AndAsReadyAfterTheRenderer()
{
using var rig = new HeroTestRig();
var image = await rig.Upload(HeroTestRig.Photo(2400, 1600));
var id = Guid.Parse(image.Id);
await rig.Service.SaveAsync(Save(id, null), HeroTestRig.Admin, default);
(await rig.Service.GetAsync(default)).Slides[0].Image.Processing.Should().BeFalse();
// The body of the PUT as the admin sends it (camelCase JSON), bound the way the controller binds it.
var json = $$"""
{"title":"Andrea Slop","tagline":null,"lead":null,"display":"single","buttons":[],"isActive":true,"startsAt":null,"endsAt":null,
"slides":[{"id":null,"imageId":"{{id}}","alt":"foto","decorative":false,"isActive":true}],
"imageFocus":[{"imageId":"{{id}}","focus":{"x":0.2,"y":0.3,"zoom":1.5},"wide":null,"tall":null}]}
""";
var request = System.Text.Json.JsonSerializer.Deserialize(json, new System.Text.Json.JsonSerializerOptions(System.Text.Json.JsonSerializerDefaults.Web))!;
request.ImageFocus.Should().ContainSingle().Which.Focus.Should().Be(new FocusDto(0.2, 0.3, 1.5));
var response = await rig.Service.SaveAsync(request, HeroTestRig.Admin, default);
response.Slides.Single(s => s.ImageId == image.Id).Image.Processing.Should().BeTrue("the answer of the PUT already says the new crop is being made");
var read = (await rig.Service.GetAsync(default)).Slides.Single(s => s.ImageId == image.Id).Image;
read.Processing.Should().BeTrue();
read.Variants.Should().NotBeEmpty("the old crop stays published meanwhile");
(await rig.RenderPending()).Should().Be(1);
var done = (await rig.Service.GetAsync(default)).Slides.Single(s => s.ImageId == image.Id).Image;
done.Processing.Should().BeFalse();
done.Focus.Should().Be(new FocusDto(0.2, 0.3, 1.5));
}
[Fact]
public async Task AHigherZoom_GivesASmallerSet_BecauseNoVariantIsMadeLargerThanItsCrop()
{
using var rig = new HeroTestRig();
var image = await rig.Upload(HeroTestRig.Photo(2400, 1600));
var id = Guid.Parse(image.Id);
await rig.Service.SaveAsync(Save(id, null), HeroTestRig.Admin, default);
var normal = rig.Db.HeroImages.Single().Variants.Count;
await rig.Service.SaveAsync(Save(id, [new HeroImageFocusRequest(id, new FocusDto(0.5, 0.5, 3))]), HeroTestRig.Admin, default);
await rig.RenderPending();
rig.Db.HeroImages.Single().Variants.Count.Should().BeLessThan(normal, "a zoomed crop is smaller, so the wide sizes above it are left out");
}
}