From 3d1e17b07f82e78d3a748bcfb9bcbefb70769cb4 Mon Sep 17 00:00:00 2001 From: Andy Butland Date: Mon, 7 Apr 2025 10:04:11 +0200 Subject: [PATCH] Integration tests for content publishing with ancestor unpublished (#18941) * Resolved warnings in test class. * Refactor regions into partial classes. * Aligned test names. * Variable name refactoring. * Added tests for unpublished paths. * Adjust tests to verify current behaviour. * Cleaned up project file. --- .../Builders/ContentTypeBaseBuilder.cs | 14 +- .../Builders/ContentTypeBuilder.cs | 3 +- ...entPublishingServiceTests.ClearSchedule.cs | 193 +++ .../ContentPublishingServiceTests.Publish.cs | 280 ++++ ...tPublishingServiceTests.SchedulePublish.cs | 258 +++ ...ublishingServiceTests.ScheduleUnpublish.cs | 221 +++ ...ublishingServiceTests.UnschedulePublish.cs | 248 +++ ...lishingServiceTests.UnscheduleUnpublish.cs | 247 +++ .../Services/ContentPublishingServiceTests.cs | 1405 +---------------- .../Umbraco.Tests.Integration.csproj | 18 + 10 files changed, 1517 insertions(+), 1370 deletions(-) create mode 100644 tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.ClearSchedule.cs create mode 100644 tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.Publish.cs create mode 100644 tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.SchedulePublish.cs create mode 100644 tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.ScheduleUnpublish.cs create mode 100644 tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.UnschedulePublish.cs create mode 100644 tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.UnscheduleUnpublish.cs diff --git a/tests/Umbraco.Tests.Common/Builders/ContentTypeBaseBuilder.cs b/tests/Umbraco.Tests.Common/Builders/ContentTypeBaseBuilder.cs index a5d3597662..e01d87aa0e 100644 --- a/tests/Umbraco.Tests.Common/Builders/ContentTypeBaseBuilder.cs +++ b/tests/Umbraco.Tests.Common/Builders/ContentTypeBaseBuilder.cs @@ -1,8 +1,6 @@ // Copyright (c) Umbraco. // See LICENSE for more details. -using System; -using System.Collections.Generic; using Umbraco.Cms.Core.Models; using Umbraco.Cms.Core.Strings; using Umbraco.Cms.Tests.Common.Builders.Extensions; @@ -29,7 +27,8 @@ public abstract class ContentTypeBaseBuilder IWithIconBuilder, IWithThumbnailBuilder, IWithTrashedBuilder, - IWithIsContainerBuilder + IWithIsContainerBuilder, + IWithAllowAsRootBuilder where TParent : IBuildContentTypes { private string _alias; @@ -49,6 +48,7 @@ public abstract class ContentTypeBaseBuilder private string _thumbnail; private bool? _trashed; private DateTime? _updateDate; + private bool? _allowedAtRoot; public ContentTypeBaseBuilder(TParent parentBuilder) : base(parentBuilder) @@ -168,6 +168,12 @@ public abstract class ContentTypeBaseBuilder set => _updateDate = value; } + bool? IWithAllowAsRootBuilder.AllowAsRoot + { + get => _allowedAtRoot; + set => _allowedAtRoot = value; + } + protected int GetId() => _id ?? 0; protected Guid GetKey() => _key ?? Guid.NewGuid(); @@ -202,6 +208,8 @@ public abstract class ContentTypeBaseBuilder protected Guid? GetListView() => _listView; + protected bool GetAllowedAtRoot() => _allowedAtRoot ?? false; + protected void BuildPropertyGroups(ContentTypeCompositionBase contentType, IEnumerable propertyGroups) { foreach (var propertyGroup in propertyGroups) diff --git a/tests/Umbraco.Tests.Common/Builders/ContentTypeBuilder.cs b/tests/Umbraco.Tests.Common/Builders/ContentTypeBuilder.cs index 65c2b85d79..54e9090ddb 100644 --- a/tests/Umbraco.Tests.Common/Builders/ContentTypeBuilder.cs +++ b/tests/Umbraco.Tests.Common/Builders/ContentTypeBuilder.cs @@ -1,8 +1,6 @@ // Copyright (c) Umbraco. // See LICENSE for more details. -using System.Collections.Generic; -using System.Linq; using Umbraco.Cms.Core; using Umbraco.Cms.Core.Models; using Umbraco.Cms.Core.Models.ContentEditing; @@ -125,6 +123,7 @@ public class ContentTypeBuilder contentType.Trashed = GetTrashed(); contentType.ListView = GetListView(); contentType.IsElement = _isElement ?? false; + contentType.AllowedAsRoot = GetAllowedAtRoot(); contentType.HistoryCleanup = new HistoryCleanup(); contentType.Variations = contentVariation; diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.ClearSchedule.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.ClearSchedule.cs new file mode 100644 index 0000000000..d639190cfa --- /dev/null +++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.ClearSchedule.cs @@ -0,0 +1,193 @@ +using NUnit.Framework; +using Umbraco.Cms.Core; +using Umbraco.Cms.Core.Models; +using Umbraco.Cms.Core.Models.ContentPublishing; +using Umbraco.Cms.Core.Services; +using Umbraco.Cms.Tests.Integration.Testing; + +namespace Umbraco.Cms.Tests.Integration.Umbraco.Core.Services; + +public partial class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent +{ + [Test] + public async Task Can_Clear_Schedule_Invariant() + { + var doctype = await SetupInvariantDoctypeAsync(); + var content = await CreateInvariantContentAsync(doctype); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishInvariantAsync(content); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var clearScheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = Constants.System.InvariantCulture, + Schedule = new ContentScheduleModel(), + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(clearScheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsNull(content!.PublishDate); + Assert.AreEqual(0, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Clear_Schedule_Single_Culture() + { + var setupInfo = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + setupInfo.LangEn, + setupInfo.LangDa, + setupInfo.LangBe, + setupInfo.contentType); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishForAllCulturesAsync(content, setupInfo); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = setupInfo.LangEn.IsoCode, + Schedule = new ContentScheduleModel(), + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Any()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Any()); + Assert.AreEqual(4, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Clear_Schedule_Some_Cultures() + { + var setupInfo = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + setupInfo.LangEn, + setupInfo.LangDa, + setupInfo.LangBe, + setupInfo.contentType); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishForAllCulturesAsync(content, setupInfo); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = setupInfo.LangEn.IsoCode, + Schedule = new ContentScheduleModel(), + }, + new() + { + Culture = setupInfo.LangDa.IsoCode, + Schedule = new ContentScheduleModel(), + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Any()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Any()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Release).Any()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Expire).Any()); + Assert.AreEqual(2, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Clear_Schedule_All_Cultures() + { + var setupInfo = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + setupInfo.LangEn, + setupInfo.LangDa, + setupInfo.LangBe, + setupInfo.contentType); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishForAllCulturesAsync(content, setupInfo); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = setupInfo.LangEn.IsoCode, + Schedule = new ContentScheduleModel(), + }, + new() + { + Culture = setupInfo.LangDa.IsoCode, + Schedule = new ContentScheduleModel(), + }, + new() + { + Culture = setupInfo.LangBe.IsoCode, + Schedule = new ContentScheduleModel(), + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.AreEqual(0, schedules.FullSchedule.Count); + }); + } +} diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.Publish.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.Publish.cs new file mode 100644 index 0000000000..9e1669ae35 --- /dev/null +++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.Publish.cs @@ -0,0 +1,280 @@ +using NUnit.Framework; +using Umbraco.Cms.Core; +using Umbraco.Cms.Core.Models.ContentPublishing; +using Umbraco.Cms.Core.Services; +using Umbraco.Cms.Core.Services.OperationStatus; +using Umbraco.Cms.Tests.Integration.Testing; + +namespace Umbraco.Cms.Tests.Integration.Umbraco.Core.Services; + +public partial class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent +{ + [Test] + public async Task Can_Publish_Single_Culture() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var setupData = await CreateVariantContentAsync(langEn, langDa, langBe, contentType); + + var publishAttempt = await ContentPublishingService.PublishAsync( + setupData.Key, + [new() { Culture = langEn.IsoCode }], + Constants.Security.SuperUserKey); + + Assert.IsTrue(publishAttempt.Success); + var content = ContentService.GetById(setupData.Key); + Assert.AreEqual(1, content!.PublishedCultures.Count()); + } + + [Test] + public async Task Can_Publish_Some_Cultures() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync(langEn, langDa, langBe, contentType); + + var publishAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() { Culture = langEn.IsoCode }, new() { Culture = langDa.IsoCode }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(publishAttempt.Success); + content = ContentService.GetById(content.Key); + Assert.AreEqual(2, content!.PublishedCultures.Count()); + } + + [Test] + public async Task Can_Publish_All_Cultures() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync(langEn, langDa, langBe, contentType); + + var publishAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() { Culture = langEn.IsoCode }, + new() { Culture = langDa.IsoCode }, + new() { Culture = langBe.IsoCode }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(publishAttempt.Success); + content = ContentService.GetById(content.Key); + Assert.AreEqual(3, content!.PublishedCultures.Count()); + } + + [Test] + public async Task Cannot_Publish_Invariant_In_Variant_Setup() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + + var publishAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [new() { Culture = Constants.System.InvariantCulture }], + Constants.Security.SuperUserKey); + + Assert.IsFalse(publishAttempt.Success); + Assert.AreEqual(ContentPublishingOperationStatus.CannotPublishInvariantWhenVariant, publishAttempt.Status); + + content = ContentService.GetById(content.Key); + Assert.AreEqual(0, content!.PublishedCultures.Count()); + } + + [Test] + public async Task Can_Publish_Invariant_In_Invariant_Setup() + { + var doctype = await SetupInvariantDoctypeAsync(); + var content = await CreateInvariantContentAsync(doctype); + + var publishAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [new() { Culture = Constants.System.InvariantCulture }], + Constants.Security.SuperUserKey); + + Assert.IsTrue(publishAttempt.Success); + + content = ContentService.GetById(content.Key); + Assert.NotNull(content!.PublishDate); + } + + [Test] + public async Task Cannot_Publish_Unknown_Culture() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + + var publishAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() { Culture = langEn.IsoCode }, + new() { Culture = langDa.IsoCode }, + new() { Culture = UnknownCulture }, + ], + Constants.Security.SuperUserKey); + + Assert.IsFalse(publishAttempt.Success); + Assert.AreEqual(ContentPublishingOperationStatus.InvalidCulture, publishAttempt.Status); + + content = ContentService.GetById(content.Key); + Assert.AreEqual(0, content!.PublishedCultures.Count()); + } + + [Test] + public async Task Cannot_Publish_Scheduled_Culture() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = langEn.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + } + ], + Constants.Security.SuperUserKey); + + if (scheduleAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var publishAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [new() { Culture = langEn.IsoCode }], + Constants.Security.SuperUserKey); + + Assert.IsFalse(publishAttempt.Success); + Assert.AreEqual(ContentPublishingOperationStatus.CultureAwaitingRelease, publishAttempt.Status); + + content = ContentService.GetById(content.Key); + Assert.AreEqual(0, content!.PublishedCultures.Count()); + } + + // TODO: The following three tests verify existing functionality that could be reconsidered. + // The existing behaviour, verified on Umbraco 13 and 15 is as follows: + // - For invariant content, if a parent is unpublished and I try to publish the child, I get a ContentPublishingOperationStatus.PathNotPublished error. + // - For variant content, if I publish the parent in English but not Danish, I can publish the child in Danish. + // This is inconsistent so we should consider if this is the desired behaviour. + // For now though, the following tests verify the existing behaviour. + + [Test] + public async Task Cannot_Publish_With_Unpublished_Parent() + { + var doctype = await SetupInvariantDoctypeAsync(); + var parentContent = await CreateInvariantContentAsync(doctype); + var childContent = await CreateInvariantContentAsync(doctype, parentContent.Key); + + var publishAttempt = await ContentPublishingService.PublishAsync( + childContent.Key, + [new() { Culture = Constants.System.InvariantCulture }], + Constants.Security.SuperUserKey); + + Assert.IsFalse(publishAttempt.Success); + Assert.AreEqual(ContentPublishingOperationStatus.PathNotPublished, publishAttempt.Status); + + // Now publish the parent and re-try publishing the child. + publishAttempt = await ContentPublishingService.PublishAsync( + parentContent.Key, + [new() { Culture = Constants.System.InvariantCulture }], + Constants.Security.SuperUserKey); + Assert.IsTrue(publishAttempt.Success); + + publishAttempt = await ContentPublishingService.PublishAsync( + childContent.Key, + [new() { Culture = Constants.System.InvariantCulture }], + Constants.Security.SuperUserKey); + Assert.IsTrue(publishAttempt.Success); + } + + [Test] + public async Task Cannot_Publish_Culture_With_Unpublished_Parent() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var parentContent = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + var childContent = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType, + parentContent.Key); + + // Publish child in English, should not succeed. + var publishAttempt = await ContentPublishingService.PublishAsync( + childContent.Key, + [new() { Culture = langEn.IsoCode }], + Constants.Security.SuperUserKey); + Assert.IsFalse(publishAttempt.Success); + Assert.AreEqual(ContentPublishingOperationStatus.PathNotPublished, publishAttempt.Status); + + // Now publish the parent and re-try publishing the child. + publishAttempt = await ContentPublishingService.PublishAsync( + parentContent.Key, + [new() { Culture = langEn.IsoCode }], + Constants.Security.SuperUserKey); + Assert.IsTrue(publishAttempt.Success); + + publishAttempt = await ContentPublishingService.PublishAsync( + childContent.Key, + [new() { Culture = langEn.IsoCode }], + Constants.Security.SuperUserKey); + Assert.IsTrue(publishAttempt.Success); + } + + [Test] + public async Task Can_Publish_Culture_With_Unpublished_Parent_Culture() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var parentContent = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + var childContent = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType, + parentContent.Key); + + // Publish parent in English. + var publishAttempt = await ContentPublishingService.PublishAsync( + parentContent.Key, + [new() { Culture = langEn.IsoCode }], + Constants.Security.SuperUserKey); + Assert.IsTrue(publishAttempt.Success); + + // Publish child in English, should succeed. + publishAttempt = await ContentPublishingService.PublishAsync( + childContent.Key, + [new() { Culture = langEn.IsoCode }], + Constants.Security.SuperUserKey); + Assert.IsTrue(publishAttempt.Success); + + // Publish child in Danish, should also succeed. + publishAttempt = await ContentPublishingService.PublishAsync( + childContent.Key, + [new() { Culture = langDa.IsoCode }], + Constants.Security.SuperUserKey); + Assert.IsTrue(publishAttempt.Success); + } +} diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.SchedulePublish.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.SchedulePublish.cs new file mode 100644 index 0000000000..e3e0a65f2a --- /dev/null +++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.SchedulePublish.cs @@ -0,0 +1,258 @@ +using NUnit.Framework; +using Umbraco.Cms.Core; +using Umbraco.Cms.Core.Models; +using Umbraco.Cms.Core.Models.ContentPublishing; +using Umbraco.Cms.Core.Services; +using Umbraco.Cms.Core.Services.OperationStatus; +using Umbraco.Cms.Tests.Integration.Testing; + +namespace Umbraco.Cms.Tests.Integration.Umbraco.Core.Services; + +public partial class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent +{ + [Test] + public async Task Can_Schedule_Publish_Invariant() + { + var doctype = await SetupInvariantDoctypeAsync(); + var content = await CreateInvariantContentAsync(doctype); + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = Constants.System.InvariantCulture, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsNull(content!.PublishDate); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(Constants.System.InvariantCulture, ContentScheduleAction.Release).Single().Date); + Assert.AreEqual(1, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Schedule_Publish_Single_Culture() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = langEn.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(langEn.IsoCode, ContentScheduleAction.Release).Single().Date); + Assert.AreEqual(1, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Schedule_Publish_Some_Cultures() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = langEn.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + new() + { + Culture = langDa.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(langEn.IsoCode, ContentScheduleAction.Release).Single().Date); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(langDa.IsoCode, ContentScheduleAction.Release).Single().Date); + Assert.AreEqual(2, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Schedule_Publish_All_Cultures() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = langEn.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + new() + { + Culture = langDa.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + new() + { + Culture = langBe.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(langEn.IsoCode, ContentScheduleAction.Release).Single().Date); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(langDa.IsoCode, ContentScheduleAction.Release).Single().Date); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(langBe.IsoCode, ContentScheduleAction.Release).Single().Date); + Assert.AreEqual(3, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Cannot_Schedule_Publish_Unknown_Culture() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = langEn.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + new() + { + Culture = langDa.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + new() + { + Culture = UnknownCulture, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate } + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsFalse(scheduleAttempt.Success); + Assert.AreEqual(ContentPublishingOperationStatus.InvalidCulture, scheduleAttempt.Status); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.AreEqual(0, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Publish_And_Schedule_Different_Cultures() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = langEn.IsoCode, + }, + new() + { + Culture = langDa.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(1, content!.PublishedCultures.Count()); + Assert.AreEqual(1, schedules.FullSchedule.Count); + }); + } +} diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.ScheduleUnpublish.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.ScheduleUnpublish.cs new file mode 100644 index 0000000000..c49f8684ab --- /dev/null +++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.ScheduleUnpublish.cs @@ -0,0 +1,221 @@ +using NUnit.Framework; +using Umbraco.Cms.Core; +using Umbraco.Cms.Core.Models; +using Umbraco.Cms.Core.Models.ContentPublishing; +using Umbraco.Cms.Core.Services; +using Umbraco.Cms.Core.Services.OperationStatus; +using Umbraco.Cms.Tests.Integration.Testing; + +namespace Umbraco.Cms.Tests.Integration.Umbraco.Core.Services; + +public partial class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent +{ + [Test] + public async Task Can_Schedule_Unpublish_Invariant() + { + var doctype = await SetupInvariantDoctypeAsync(); + var content = await CreateInvariantContentAsync(doctype); + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = Constants.System.InvariantCulture, + Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsNull(content!.PublishDate); + Assert.AreEqual( + _scheduleUnPublishDate, + schedules.GetSchedule(Constants.System.InvariantCulture, ContentScheduleAction.Expire).Single().Date); + Assert.AreEqual(1, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Schedule_Unpublish_Single_Culture() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = langEn.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(langEn.IsoCode, ContentScheduleAction.Expire).Single().Date); + Assert.AreEqual(1, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Schedule_Unpublish_Some_Cultures() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = langEn.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, + }, + new() + { + Culture = langDa.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(langEn.IsoCode, ContentScheduleAction.Expire).Single().Date); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(langDa.IsoCode, ContentScheduleAction.Expire).Single().Date); + Assert.AreEqual(2, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Schedule_Unpublish_All_Cultures() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = langEn.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, + }, + new() + { + Culture = langDa.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, + }, + new() + { + Culture = langBe.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(langEn.IsoCode, ContentScheduleAction.Expire).Single().Date); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(langDa.IsoCode, ContentScheduleAction.Expire).Single().Date); + Assert.AreEqual( + _schedulePublishDate, + schedules.GetSchedule(langBe.IsoCode, ContentScheduleAction.Expire).Single().Date); + Assert.AreEqual(3, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Cannot_Schedule_Unpublish_Unknown_Culture() + { + var (langEn, langDa, langBe, contentType) = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + langEn, + langDa, + langBe, + contentType); + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = langEn.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, + }, + new() + { + Culture = langDa.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, + }, + new() + { + Culture = UnknownCulture, + Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate } + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsFalse(scheduleAttempt.Success); + Assert.AreEqual(ContentPublishingOperationStatus.InvalidCulture, scheduleAttempt.Status); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.AreEqual(0, schedules.FullSchedule.Count); + }); + } +} diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.UnschedulePublish.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.UnschedulePublish.cs new file mode 100644 index 0000000000..c4d0ab1c1e --- /dev/null +++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.UnschedulePublish.cs @@ -0,0 +1,248 @@ +using NUnit.Framework; +using Umbraco.Cms.Core; +using Umbraco.Cms.Core.Models; +using Umbraco.Cms.Core.Models.ContentPublishing; +using Umbraco.Cms.Core.Services; +using Umbraco.Cms.Core.Services.OperationStatus; +using Umbraco.Cms.Tests.Integration.Testing; + +namespace Umbraco.Cms.Tests.Integration.Umbraco.Core.Services; + +public partial class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent +{ + [Test] + public async Task Can_UnSchedule_Publish_Invariant() + { + var doctype = await SetupInvariantDoctypeAsync(); + var content = await CreateInvariantContentAsync(doctype); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishInvariantAsync(content); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var unscheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = Constants.System.InvariantCulture, + Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(unscheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsNull(content!.PublishDate); + Assert.IsFalse(schedules.GetSchedule(Constants.System.InvariantCulture, ContentScheduleAction.Release).Any()); + Assert.IsTrue(schedules.GetSchedule(Constants.System.InvariantCulture, ContentScheduleAction.Expire).Any()); + Assert.AreEqual(1, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Unschedule_Publish_Single_Culture() + { + var setupInfo = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + setupInfo.LangEn, + setupInfo.LangDa, + setupInfo.LangBe, + setupInfo.contentType); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishForAllCulturesAsync(content, setupInfo); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = setupInfo.LangEn.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Any()); + Assert.AreEqual(5, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Unschedule_Publish_Some_Cultures() + { + var setupInfo = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + setupInfo.LangEn, + setupInfo.LangDa, + setupInfo.LangBe, + setupInfo.contentType); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishForAllCulturesAsync(content, setupInfo); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = setupInfo.LangEn.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate } + }, + new() + { + Culture = setupInfo.LangDa.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate } + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Any()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Release).Any()); + Assert.AreEqual(4, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Unschedule_Publish_All_Cultures() + { + var setupInfo = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + setupInfo.LangEn, + setupInfo.LangDa, + setupInfo.LangBe, + setupInfo.contentType); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishForAllCulturesAsync(content, setupInfo); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = setupInfo.LangEn.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, + }, + new() + { + Culture = setupInfo.LangDa.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, + }, + new() + { + Culture = setupInfo.LangBe.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Any()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Release).Any()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangBe.IsoCode, ContentScheduleAction.Release).Any()); + Assert.AreEqual(3, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Cannot_Unschedule_Publish_Unknown_Culture() + { + var setupInfo = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + setupInfo.LangEn, + setupInfo.LangDa, + setupInfo.LangBe, + setupInfo.contentType); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishForAllCulturesAsync(content, setupInfo); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = setupInfo.LangEn.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, + }, + new() + { + Culture = setupInfo.LangDa.IsoCode, + Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, + }, + new() + { + Culture = UnknownCulture, + Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsFalse(scheduleAttempt.Success); + Assert.AreEqual(ContentPublishingOperationStatus.InvalidCulture, scheduleAttempt.Status); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.AreEqual(6, schedules.FullSchedule.Count); + }); + } +} diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.UnscheduleUnpublish.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.UnscheduleUnpublish.cs new file mode 100644 index 0000000000..3e3a5ea61a --- /dev/null +++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.UnscheduleUnpublish.cs @@ -0,0 +1,247 @@ +using NUnit.Framework; +using Umbraco.Cms.Core; +using Umbraco.Cms.Core.Models; +using Umbraco.Cms.Core.Models.ContentPublishing; +using Umbraco.Cms.Core.Services; +using Umbraco.Cms.Core.Services.OperationStatus; +using Umbraco.Cms.Tests.Integration.Testing; + +namespace Umbraco.Cms.Tests.Integration.Umbraco.Core.Services; + +public partial class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent +{ + [Test] + public async Task Can_UnSchedule_Unpublish_Invariant() + { + var doctype = await SetupInvariantDoctypeAsync(); + var content = await CreateInvariantContentAsync(doctype); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishInvariantAsync(content); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var unscheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = Constants.System.InvariantCulture, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(unscheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsNull(content!.PublishDate); + Assert.IsFalse(schedules.GetSchedule(Constants.System.InvariantCulture, ContentScheduleAction.Expire).Any()); + Assert.IsTrue(schedules.GetSchedule(Constants.System.InvariantCulture, ContentScheduleAction.Release).Any()); + Assert.AreEqual(1, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Unschedule_Unpublish_Single_Culture() + { + var setupInfo = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + setupInfo.LangEn, + setupInfo.LangDa, + setupInfo.LangBe, + setupInfo.contentType); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishForAllCulturesAsync(content, setupInfo); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = setupInfo.LangEn.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Any()); + Assert.AreEqual(5, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Unschedule_Unpublish_Some_Cultures() + { + var setupInfo = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + setupInfo.LangEn, + setupInfo.LangDa, + setupInfo.LangBe, + setupInfo.contentType); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishForAllCulturesAsync(content, setupInfo); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = setupInfo.LangEn.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate } + }, + new() + { + Culture = setupInfo.LangDa.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate } + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Any()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Expire).Any()); + Assert.AreEqual(4, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Can_Unschedule_Unpublish_All_Cultures() + { + var setupInfo = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + setupInfo.LangEn, + setupInfo.LangDa, + setupInfo.LangBe, + setupInfo.contentType); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishForAllCulturesAsync(content, setupInfo); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = setupInfo.LangEn.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + new() + { + Culture = setupInfo.LangDa.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + new() + { + Culture = setupInfo.LangBe.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsTrue(scheduleAttempt.Success); + + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Any()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Expire).Any()); + Assert.IsFalse(schedules.GetSchedule(setupInfo.LangBe.IsoCode, ContentScheduleAction.Expire).Any()); + Assert.AreEqual(3, schedules.FullSchedule.Count); + }); + } + + [Test] + public async Task Cannot_Unschedule_Unpublish_Unknown_Culture() + { + var setupInfo = await SetupVariantDoctypeAsync(); + var content = await CreateVariantContentAsync( + setupInfo.LangEn, + setupInfo.LangDa, + setupInfo.LangBe, + setupInfo.contentType); + + var scheduleSetupAttempt = + await SchedulePublishAndUnPublishForAllCulturesAsync(content, setupInfo); + + if (scheduleSetupAttempt.Success is false) + { + throw new Exception("Setup failed"); + } + + var scheduleAttempt = await ContentPublishingService.PublishAsync( + content.Key, + [ + new() + { + Culture = setupInfo.LangEn.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + new() + { + Culture = setupInfo.LangDa.IsoCode, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + new() + { + Culture = UnknownCulture, + Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, + }, + ], + Constants.Security.SuperUserKey); + + Assert.IsFalse(scheduleAttempt.Success); + Assert.AreEqual(ContentPublishingOperationStatus.InvalidCulture, scheduleAttempt.Status); + var schedules = ContentService.GetContentScheduleByContentId(content.Id); + content = ContentService.GetById(content.Key); + + Assert.Multiple(() => + { + Assert.AreEqual(0, content!.PublishedCultures.Count()); + Assert.AreEqual(6, schedules.FullSchedule.Count); + }); + } +} diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.cs index 050b08582c..d1d283612c 100644 --- a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.cs +++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentPublishingServiceTests.cs @@ -18,7 +18,7 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Core.Services; Database = UmbracoTestOptions.Database.NewSchemaPerTest, PublishedRepositoryEvents = true, WithApplication = true)] -public class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent +public partial class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent { private const string UnknownCulture = "ke-Ke"; @@ -39,1345 +39,7 @@ public class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent private IContentEditingService ContentEditingService => GetRequiredService(); - #region Publish - - [Test] - public async Task Can_Publish_Single_Culture() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var publishAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List { new() { Culture = setupInfo.LangEn.IsoCode } }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(publishAttempt.Success); - var content = ContentService.GetById(setupData.Key); - Assert.AreEqual(1, content!.PublishedCultures.Count()); - } - - [Test] - public async Task Can_Publish_Some_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var publishAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() { Culture = setupInfo.LangEn.IsoCode }, new() { Culture = setupInfo.LangDa.IsoCode }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(publishAttempt.Success); - var content = ContentService.GetById(setupData.Key); - Assert.AreEqual(2, content!.PublishedCultures.Count()); - } - - [Test] - public async Task Can_Publish_All_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var publishAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() { Culture = setupInfo.LangEn.IsoCode }, - new() { Culture = setupInfo.LangDa.IsoCode }, - new() { Culture = setupInfo.LangBe.IsoCode }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(publishAttempt.Success); - var content = ContentService.GetById(setupData.Key); - Assert.AreEqual(3, content!.PublishedCultures.Count()); - } - - [Test] - public async Task Can_NOT_Publish_Invariant_In_Variant_Setup() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var publishAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List { new() { Culture = Constants.System.InvariantCulture } }, - Constants.Security.SuperUserKey); - - Assert.IsFalse(publishAttempt.Success); - Assert.AreEqual(ContentPublishingOperationStatus.CannotPublishInvariantWhenVariant, publishAttempt.Status); - - var content = ContentService.GetById(setupData.Key); - Assert.AreEqual(0, content!.PublishedCultures.Count()); - } - - [Test] - public async Task Can_Publish_Invariant_In_Invariant_Setup() - { - var doctype = await SetupInvariantDoctypeAsync(); - var setupData = await CreateInvariantContentAsync(doctype); - - var publishAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List { new() { Culture = Constants.System.InvariantCulture } }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(publishAttempt.Success); - - var content = ContentService.GetById(setupData.Key); - Assert.NotNull(content!.PublishDate); - } - //todo more tests for invariant - //todo update schedule date - - [Test] - public async Task Can_NOT_Publish_Unknown_Culture() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var publishAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() { Culture = setupInfo.LangEn.IsoCode }, - new() { Culture = setupInfo.LangDa.IsoCode }, - new() { Culture = UnknownCulture }, - }, - Constants.Security.SuperUserKey); - - Assert.IsFalse(publishAttempt.Success); - Assert.AreEqual(ContentPublishingOperationStatus.InvalidCulture, publishAttempt.Status); - - var content = ContentService.GetById(setupData.Key); - Assert.AreEqual(0, content!.PublishedCultures.Count()); - } - - [Test] - public async Task Can_NOT_Publish_Scheduled_Culture() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - } - }, - Constants.Security.SuperUserKey); - - if (scheduleAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var publishAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List { new() { Culture = setupInfo.LangEn.IsoCode } }, - Constants.Security.SuperUserKey); - - Assert.IsFalse(publishAttempt.Success); - Assert.AreEqual(ContentPublishingOperationStatus.CultureAwaitingRelease, publishAttempt.Status); - - var content = ContentService.GetById(setupData.Key); - Assert.AreEqual(0, content!.PublishedCultures.Count()); - } - - #endregion - - #region Schedule Publish - - [Test] - public async Task Can_Schedule_Publish_Invariant() - { - var doctype = await SetupInvariantDoctypeAsync(); - var setupData = await CreateInvariantContentAsync(doctype); - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = Constants.System.InvariantCulture, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsNull(content!.PublishDate); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(Constants.System.InvariantCulture, ContentScheduleAction.Release).Single().Date); - Assert.AreEqual(1, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Schedule_Publish_Single_Culture() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Single().Date); - Assert.AreEqual(1, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Schedule_Publish_Some_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Single().Date); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Release).Single().Date); - Assert.AreEqual(2, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Schedule_Publish_All_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - new() - { - Culture = setupInfo.LangBe.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Single().Date); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Release).Single().Date); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(setupInfo.LangBe.IsoCode, ContentScheduleAction.Release).Single().Date); - Assert.AreEqual(3, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_NOT_Schedule_Publish_Unknown_Culture() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - new() - { - Culture = UnknownCulture, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate } - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsFalse(scheduleAttempt.Success); - Assert.AreEqual(ContentPublishingOperationStatus.InvalidCulture, scheduleAttempt.Status); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.AreEqual(0, schedules.FullSchedule.Count); - }); - } - - #endregion - - #region Schedule Unpublish - - [Test] - public async Task Can_Schedule_Unpublish_Invariant() - { - var doctype = await SetupInvariantDoctypeAsync(); - var setupData = await CreateInvariantContentAsync(doctype); - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = Constants.System.InvariantCulture, - Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsNull(content!.PublishDate); - Assert.AreEqual( - _scheduleUnPublishDate, - schedules.GetSchedule(Constants.System.InvariantCulture, ContentScheduleAction.Expire).Single().Date); - Assert.AreEqual(1, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Schedule_Unpublish_Single_Culture() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Single().Date); - Assert.AreEqual(1, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Schedule_Unpublish_Some_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Single().Date); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Expire).Single().Date); - Assert.AreEqual(2, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Schedule_Unpublish_All_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, - }, - new() - { - Culture = setupInfo.LangBe.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Single().Date); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Expire).Single().Date); - Assert.AreEqual( - _schedulePublishDate, - schedules.GetSchedule(setupInfo.LangBe.IsoCode, ContentScheduleAction.Expire).Single().Date); - Assert.AreEqual(3, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_NOT_Schedule_Unpublish_Unknown_Culture() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate }, - }, - new() - { - Culture = UnknownCulture, - Schedule = new ContentScheduleModel { UnpublishDate = _schedulePublishDate } - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsFalse(scheduleAttempt.Success); - Assert.AreEqual(ContentPublishingOperationStatus.InvalidCulture, scheduleAttempt.Status); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.AreEqual(0, schedules.FullSchedule.Count); - }); - } - - #endregion - - #region Unschedule Publish - - [Test] - public async Task Can_UnSchedule_Publish_Invariant() - { - var doctype = await SetupInvariantDoctypeAsync(); - var setupData = await CreateInvariantContentAsync(doctype); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishInvariantAsync(setupData); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var unscheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = Constants.System.InvariantCulture, - Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(unscheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsNull(content!.PublishDate); - Assert.IsFalse(schedules.GetSchedule(Constants.System.InvariantCulture, ContentScheduleAction.Release).Any()); - Assert.IsTrue(schedules.GetSchedule(Constants.System.InvariantCulture, ContentScheduleAction.Expire).Any()); - Assert.AreEqual(1, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Unschedule_Publish_Single_Culture() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishForAllCulturesAsync(setupData, setupInfo); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Any()); - Assert.AreEqual(5, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Unschedule_Publish_Some_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishForAllCulturesAsync(setupData, setupInfo); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate } - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate } - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Any()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Release).Any()); - Assert.AreEqual(4, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Unschedule_Publish_All_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishForAllCulturesAsync(setupData, setupInfo); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, - }, - new() - { - Culture = setupInfo.LangBe.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Any()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Release).Any()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangBe.IsoCode, ContentScheduleAction.Release).Any()); - Assert.AreEqual(3, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_NOT_Unschedule_Publish_Unknown_Culture() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishForAllCulturesAsync(setupData, setupInfo); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, - }, - new() - { - Culture = UnknownCulture, - Schedule = new ContentScheduleModel { UnpublishDate = _scheduleUnPublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsFalse(scheduleAttempt.Success); - Assert.AreEqual(ContentPublishingOperationStatus.InvalidCulture, scheduleAttempt.Status); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.AreEqual(6, schedules.FullSchedule.Count); - }); - } - - #endregion - - #region Unschedule Unpublish - - [Test] - public async Task Can_UnSchedule_Unpublish_Invariant() - { - var doctype = await SetupInvariantDoctypeAsync(); - var setupData = await CreateInvariantContentAsync(doctype); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishInvariantAsync(setupData); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var unscheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = Constants.System.InvariantCulture, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(unscheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsNull(content!.PublishDate); - Assert.IsFalse(schedules.GetSchedule(Constants.System.InvariantCulture, ContentScheduleAction.Expire).Any()); - Assert.IsTrue(schedules.GetSchedule(Constants.System.InvariantCulture, ContentScheduleAction.Release).Any()); - Assert.AreEqual(1, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Unschedule_Unpublish_Single_Culture() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishForAllCulturesAsync(setupData, setupInfo); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Any()); - Assert.AreEqual(5, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Unschedule_Unpublish_Some_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishForAllCulturesAsync(setupData, setupInfo); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate } - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate } - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Any()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Expire).Any()); - Assert.AreEqual(4, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Unschedule_Unpublish_All_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishForAllCulturesAsync(setupData, setupInfo); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - new() - { - Culture = setupInfo.LangBe.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Any()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Expire).Any()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangBe.IsoCode, ContentScheduleAction.Expire).Any()); - Assert.AreEqual(3, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_NOT_Unschedule_Unpublish_Unknown_Culture() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishForAllCulturesAsync(setupData, setupInfo); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - new() - { - Culture = UnknownCulture, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsFalse(scheduleAttempt.Success); - Assert.AreEqual(ContentPublishingOperationStatus.InvalidCulture, scheduleAttempt.Status); - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.AreEqual(6, schedules.FullSchedule.Count); - }); - } - - #endregion - - #region Clean Schedule - - [Test] - public async Task Can_Clear_Schedule_Invariant() - { - var doctype = await SetupInvariantDoctypeAsync(); - var setupData = await CreateInvariantContentAsync(doctype); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishInvariantAsync(setupData); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var clearScheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = Constants.System.InvariantCulture, - Schedule = new ContentScheduleModel(), - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(clearScheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsNull(content!.PublishDate); - Assert.AreEqual(0, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Clear_Schedule_Single_Culture() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishForAllCulturesAsync(setupData, setupInfo); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel(), - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Any()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Any()); - Assert.AreEqual(4, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Clear_Schedule_Some_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishForAllCulturesAsync(setupData, setupInfo); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel(), - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel(), - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Release).Any()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangEn.IsoCode, ContentScheduleAction.Expire).Any()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Release).Any()); - Assert.IsFalse(schedules.GetSchedule(setupInfo.LangDa.IsoCode, ContentScheduleAction.Expire).Any()); - Assert.AreEqual(2, schedules.FullSchedule.Count); - }); - } - - [Test] - public async Task Can_Clear_Schedule_All_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleSetupAttempt = - await SchedulePublishAndUnPublishForAllCulturesAsync(setupData, setupInfo); - - if (scheduleSetupAttempt.Success is false) - { - throw new Exception("Setup failed"); - } - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - Schedule = new ContentScheduleModel(), - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel(), - }, - new() - { - Culture = setupInfo.LangBe.IsoCode, - Schedule = new ContentScheduleModel(), - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(0, content!.PublishedCultures.Count()); - Assert.AreEqual(0, schedules.FullSchedule.Count); - }); - } - - #endregion - - #region Combinations - - [Test] - public async Task Can_Publish_And_Schedule_Different_Cultures() - { - var setupInfo = await SetupVariantDoctypeAsync(); - var setupData = await CreateVariantContentAsync( - setupInfo.LangEn, - setupInfo.LangDa, - setupInfo.LangBe, - setupInfo.contentType); - - var scheduleAttempt = await ContentPublishingService.PublishAsync( - setupData.Key, - new List - { - new() - { - Culture = setupInfo.LangEn.IsoCode, - }, - new() - { - Culture = setupInfo.LangDa.IsoCode, - Schedule = new ContentScheduleModel { PublishDate = _schedulePublishDate }, - }, - }, - Constants.Security.SuperUserKey); - - Assert.IsTrue(scheduleAttempt.Success); - - var schedules = ContentService.GetContentScheduleByContentId(setupData.Id); - var content = ContentService.GetById(setupData.Key); - - Assert.Multiple(() => - { - Assert.AreEqual(1, content!.PublishedCultures.Count()); - Assert.AreEqual(1, schedules.FullSchedule.Count); - }); - } - #endregion - - #region Helper methods - - private async Task<(ILanguage LangEn, ILanguage LangDa, ILanguage LangBe, IContentType contentType)> - SetupVariantDoctypeAsync() + private async Task<(ILanguage LangEn, ILanguage LangDa, ILanguage LangBe, IContentType contentType)> SetupVariantDoctypeAsync() { var langEn = (await LanguageService.GetAsync("en-US"))!; var langDa = new LanguageBuilder() @@ -1397,10 +59,10 @@ public class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent .WithName("Variant Content") .WithContentVariation(ContentVariation.Culture) .AddPropertyGroup() - .WithAlias("content") - .WithName("Content") - .WithSupportsPublishing(true) - .Done() + .WithAlias("content") + .WithName("Content") + .WithSupportsPublishing(true) + .Done() .Build(); contentType.AllowedAsRoot = true; @@ -1410,11 +72,17 @@ public class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent throw new Exception("Something unexpected went wrong setting up the test data structure"); } + contentType.AllowedContentTypes = [new ContentTypeSort(contentType.Key, 1, contentType.Alias)]; + var updateAttempt = await ContentTypeService.UpdateAsync(contentType, Constants.Security.SuperUserKey); + if (updateAttempt.Success is false) + { + throw new Exception("Something unexpected went wrong setting up the test data structure"); + } + return (langEn, langDa, langBe, contentType); } - private async Task CreateVariantContentAsync(ILanguage langEn, ILanguage langDa, ILanguage langBe, - IContentType contentType) + private async Task CreateVariantContentAsync(ILanguage langEn, ILanguage langDa, ILanguage langBe, IContentType contentType, Guid? parentKey = null) { var documentKey = Guid.NewGuid(); @@ -1422,8 +90,9 @@ public class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent { Key = documentKey, ContentTypeKey = contentType.Key, - Variants = new[] - { + ParentKey = parentKey, + Variants = + [ new VariantModel { Name = langEn.CultureName, @@ -1442,7 +111,7 @@ public class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent Culture = langBe.IsoCode, Properties = Enumerable.Empty(), } - } + ] }; var createAttempt = await ContentEditingService.CreateAsync(createModel, Constants.Security.SuperUserKey); @@ -1462,36 +131,46 @@ public class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent var contentType = new ContentTypeBuilder() .WithAlias("invariantContent") .WithName("Invariant Content") + .WithAllowAsRoot(true) .AddPropertyGroup() - .WithAlias("content") - .WithName("Content") - .WithSupportsPublishing(true) - .Done() + .WithAlias("content") + .WithName("Content") + .WithSupportsPublishing(true) + .Done() .Build(); - contentType.AllowedAsRoot = true; var createAttempt = await ContentTypeService.CreateAsync(contentType, Constants.Security.SuperUserKey); if (createAttempt.Success is false) { throw new Exception("Something unexpected went wrong setting up the test data structure"); } + contentType.AllowedContentTypes = [new ContentTypeSort(contentType.Key, 1, contentType.Alias)]; + var updateAttempt = await ContentTypeService.UpdateAsync(contentType, Constants.Security.SuperUserKey); + if (updateAttempt.Success is false) + { + throw new Exception("Something unexpected went wrong setting up the test data structure"); + } + return contentType; } - private async Task CreateInvariantContentAsync(IContentType contentType) + private async Task CreateInvariantContentAsync(IContentType contentType, Guid? parentKey = null) { var documentKey = Guid.NewGuid(); var createModel = new ContentCreateModel { - Key = documentKey, ContentTypeKey = contentType.Key, InvariantName = "Test", + Key = documentKey, + ContentTypeKey = contentType.Key, + InvariantName = "Test", + ParentKey = parentKey, }; var createAttempt = await ContentEditingService.CreateAsync(createModel, Constants.Security.SuperUserKey); if (createAttempt.Success is false) { - throw new Exception("Something unexpected went wrong setting up the test data"); + throw new Exception($"Something unexpected went wrong setting up the test data. Status: {createAttempt.Status}"); } return createAttempt.Result.Content!; @@ -1503,8 +182,7 @@ public class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent (ILanguage LangEn, ILanguage LangDa, ILanguage LangBe, IContentType contentType) setupInfo) => await ContentPublishingService.PublishAsync( setupData.Key, - new List - { + [ new() { Culture = setupInfo.LangEn.IsoCode, @@ -1531,7 +209,7 @@ public class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent PublishDate = _schedulePublishDate, UnpublishDate = _scheduleUnPublishDate, }, }, - }, + ], Constants.Security.SuperUserKey); private async Task> @@ -1539,8 +217,7 @@ public class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent IContent setupData) => await ContentPublishingService.PublishAsync( setupData.Key, - new List - { + [ new() { Culture = Constants.System.InvariantCulture, @@ -1550,8 +227,6 @@ public class ContentPublishingServiceTests : UmbracoIntegrationTestWithContent PublishDate = _schedulePublishDate, UnpublishDate = _scheduleUnPublishDate, }, }, - }, + ], Constants.Security.SuperUserKey); - - #endregion } diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj b/tests/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj index 30521afe57..289d431f45 100644 --- a/tests/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj +++ b/tests/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj @@ -190,6 +190,24 @@ BlockListElementLevelVariationTests.cs + + ContentPublishingServiceTests.cs + + + ContentPublishingServiceTests.cs + + + ContentPublishingServiceTests.cs + + + ContentPublishingServiceTests.cs + + + ContentPublishingServiceTests.cs + + + ContentPublishingServiceTests.cs + DocumentNavigationServiceTests.cs