423 lines
21 KiB
C#
423 lines
21 KiB
C#
using System.ComponentModel.DataAnnotations;
|
|
using FluentAssertions;
|
|
using SlpModularCms.Modules.Hero.Models;
|
|
using SlpModularCms.Modules.Hero.Services;
|
|
|
|
namespace SlpModularCms.Modules.Hero.Tests;
|
|
|
|
/// <summary>A changed focus is part of saving the hero: nothing live changes before that save.</summary>
|
|
public class HeroFocusSaveTests
|
|
{
|
|
private static HeroSaveRequest Save(Guid imageId, IReadOnlyList<HeroImageFocusRequest>? 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<Guid>(), cancelled.Token);
|
|
await act.Should().ThrowAsync<OperationCanceledException>();
|
|
|
|
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<HeroSaveRejectedException>();
|
|
|
|
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<HeroSaveRejectedException>()).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<ValidationResult>();
|
|
|
|
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<ValidationResult>();
|
|
|
|
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<HeroImageNotFoundException>();
|
|
}
|
|
|
|
[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<HeroImageRenderException>(() => rig.Images.RenderNextPendingAsync(new HashSet<Guid>(), default));
|
|
failure.ImageId.Should().Be(Guid.Parse(broken.Id));
|
|
|
|
var handled = await rig.Images.RenderNextPendingAsync(new HashSet<Guid> { 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<OperationCanceledException>();
|
|
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<HeroSaveRequest>(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");
|
|
}
|
|
}
|