yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrated ReportSite, OpenIddictCleanup and TemporaryFileCleanup to background jobs (#15555)

Browse Source 
* Migrated ReportSite, OpenIddictCleanup and TemporaryFileCleanup to the new background jobs introduced in v13.

* Fixed delay and period
This commit is contained in:
Bjarke Berg
2024-01-11 13:18:10 +01:00
committed by GitHub
parent 416c19854d
commit e291fae01e
24 changed files with 79 additions and 2020 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
tests/Umbraco.Tests.UnitTests/Umbraco.Core/Scheduling/ContentVersionCleanupTest.cs
View File

@@ -8,6 +8,7 @@ using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Core.Runtime;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Sync;
using Umbraco.Cms.Infrastructure.BackgroundJobs.Jobs;
using Umbraco.Cms.Infrastructure.HostedServices;
using Umbraco.Cms.Tests.UnitTests.AutoFixture;
@@ -24,7 +25,7 @@ internal class ContentVersionCleanupTest
[Frozen] Mock<IServerRoleAccessor> serverRoleAccessor,
[Frozen] Mock<IRuntimeState> runtimeState,
[Frozen] Mock<IContentVersionService> cleanupService,
ContentVersionCleanup sut)
ContentVersionCleanupJob sut)
{
settings.Setup(x => x.CurrentValue).Returns(new ContentSettings
{
@@ -34,77 +35,7 @@ internal class ContentVersionCleanupTest
mainDom.Setup(x => x.IsMainDom).Returns(true);
serverRoleAccessor.Setup(x => x.CurrentServerRole).Returns(ServerRole.SchedulingPublisher);
await sut.PerformExecuteAsync(null);
cleanupService.Verify(x => x.PerformContentVersionCleanup(It.IsAny<DateTime>()), Times.Never);
}
[Test]
[AutoMoqData]
public async Task ContentVersionCleanup_RuntimeLevelNotRun_DoesNotCleanupWillRepeat(
[Frozen] Mock<IOptionsMonitor<ContentSettings>> settings,
[Frozen] Mock<IMainDom> mainDom,
[Frozen] Mock<IServerRoleAccessor> serverRoleAccessor,
[Frozen] Mock<IRuntimeState> runtimeState,
[Frozen] Mock<IContentVersionService> cleanupService,
ContentVersionCleanup sut)
{
settings.Setup(x => x.CurrentValue).Returns(new ContentSettings
{
ContentVersionCleanupPolicy = new ContentVersionCleanupPolicySettings { EnableCleanup = true },
});
runtimeState.Setup(x => x.Level).Returns(RuntimeLevel.Unknown);
mainDom.Setup(x => x.IsMainDom).Returns(true);
serverRoleAccessor.Setup(x => x.CurrentServerRole).Returns(ServerRole.SchedulingPublisher);
await sut.PerformExecuteAsync(null);
cleanupService.Verify(x => x.PerformContentVersionCleanup(It.IsAny<DateTime>()), Times.Never);
}
[Test]
[AutoMoqData]
public async Task ContentVersionCleanup_ServerRoleUnknown_DoesNotCleanupWillRepeat(
[Frozen] Mock<IOptionsMonitor<ContentSettings>> settings,
[Frozen] Mock<IMainDom> mainDom,
[Frozen] Mock<IServerRoleAccessor> serverRoleAccessor,
[Frozen] Mock<IRuntimeState> runtimeState,
[Frozen] Mock<IContentVersionService> cleanupService,
ContentVersionCleanup sut)
{
settings.Setup(x => x.CurrentValue).Returns(new ContentSettings
{
ContentVersionCleanupPolicy = new ContentVersionCleanupPolicySettings { EnableCleanup = true },
});
runtimeState.Setup(x => x.Level).Returns(RuntimeLevel.Run);
mainDom.Setup(x => x.IsMainDom).Returns(true);
serverRoleAccessor.Setup(x => x.CurrentServerRole).Returns(ServerRole.Unknown);
await sut.PerformExecuteAsync(null);
cleanupService.Verify(x => x.PerformContentVersionCleanup(It.IsAny<DateTime>()), Times.Never);
}
[Test]
[AutoMoqData]
public async Task ContentVersionCleanup_NotMainDom_DoesNotCleanupWillNotRepeat(
[Frozen] Mock<IOptionsMonitor<ContentSettings>> settings,
[Frozen] Mock<IMainDom> mainDom,
[Frozen] Mock<IServerRoleAccessor> serverRoleAccessor,
[Frozen] Mock<IRuntimeState> runtimeState,
[Frozen] Mock<IContentVersionService> cleanupService,
ContentVersionCleanup sut)
{
settings.Setup(x => x.CurrentValue).Returns(new ContentSettings
{
ContentVersionCleanupPolicy = new ContentVersionCleanupPolicySettings { EnableCleanup = true },
});
runtimeState.Setup(x => x.Level).Returns(RuntimeLevel.Run);
mainDom.Setup(x => x.IsMainDom).Returns(false);
serverRoleAccessor.Setup(x => x.CurrentServerRole).Returns(ServerRole.SchedulingPublisher);
await sut.PerformExecuteAsync(null);
await sut.RunJobAsync();
cleanupService.Verify(x => x.PerformContentVersionCleanup(It.IsAny<DateTime>()), Times.Never);
}
@@ -117,7 +48,7 @@ internal class ContentVersionCleanupTest
[Frozen] Mock<IServerRoleAccessor> serverRoleAccessor,
[Frozen] Mock<IRuntimeState> runtimeState,
[Frozen] Mock<IContentVersionService> cleanupService,
ContentVersionCleanup sut)
ContentVersionCleanupJob sut)
{
settings.Setup(x => x.CurrentValue).Returns(new ContentSettings
{
@@ -128,7 +59,7 @@ internal class ContentVersionCleanupTest
mainDom.Setup(x => x.IsMainDom).Returns(true);
serverRoleAccessor.Setup(x => x.CurrentServerRole).Returns(ServerRole.SchedulingPublisher);
await sut.PerformExecuteAsync(null);
await sut.RunJobAsync();
cleanupService.Verify(x => x.PerformContentVersionCleanup(It.IsAny<DateTime>()), Times.Once);
}

2
tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/BackgroundJobs/Jobs/ServerRegistration/TouchServerJobTests.cs
View File

@@ -1,7 +1,6 @@
// Copyright (c) Umbraco.
// See LICENSE for more details.
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Moq;
using NUnit.Framework;
@@ -11,7 +10,6 @@ using Umbraco.Cms.Core.Hosting;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Sync;
using Umbraco.Cms.Infrastructure.BackgroundJobs.Jobs.ServerRegistration;
using Umbraco.Cms.Infrastructure.HostedServices.ServerRegistration;
using Umbraco.Cms.Tests.Common;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.BackgroundJobs.Jobs.ServerRegistration;

189
tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/HostedServices/HealthCheckNotifierTests.cs
View File

@@ -1,189 +0,0 @@
// Copyright (c) Umbraco.
// See LICENSE for more details.
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Configuration;
using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Core.HealthChecks;
using Umbraco.Cms.Core.HealthChecks.NotificationMethods;
using Umbraco.Cms.Core.Logging;
using Umbraco.Cms.Core.Runtime;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Sync;
using Umbraco.Cms.Infrastructure.HostedServices;
using Umbraco.Cms.Infrastructure.Scoping;
using Umbraco.Cms.Tests.Common;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.HostedServices;
[TestFixture]
[Obsolete("Replaced by BackgroundJobs.Jobs.HealthCheckNotifierJobTests")]
public class HealthCheckNotifierTests
{
private Mock<IHealthCheckNotificationMethod> _mockNotificationMethod;
private const string Check1Id = "00000000-0000-0000-0000-000000000001";
private const string Check2Id = "00000000-0000-0000-0000-000000000002";
private const string Check3Id = "00000000-0000-0000-0000-000000000003";
[Test]
public async Task Does_Not_Execute_When_Not_Enabled()
{
var sut = CreateHealthCheckNotifier(false);
await sut.PerformExecuteAsync(null);
VerifyNotificationsNotSent();
}
[TestCase(RuntimeLevel.Boot)]
[TestCase(RuntimeLevel.Install)]
[TestCase(RuntimeLevel.Unknown)]
[TestCase(RuntimeLevel.Upgrade)]
[TestCase(RuntimeLevel.BootFailed)]
public async Task Does_Not_Execute_When_Runtime_State_Is_Not_Run(RuntimeLevel runtimeLevel)
{
var sut = CreateHealthCheckNotifier(runtimeLevel: runtimeLevel);
await sut.PerformExecuteAsync(null);
VerifyNotificationsNotSent();
}
[Test]
public async Task Does_Not_Execute_When_Server_Role_Is_Subscriber()
{
var sut = CreateHealthCheckNotifier(serverRole: ServerRole.Subscriber);
await sut.PerformExecuteAsync(null);
VerifyNotificationsNotSent();
}
[Test]
public async Task Does_Not_Execute_When_Server_Role_Is_Unknown()
{
var sut = CreateHealthCheckNotifier(serverRole: ServerRole.Unknown);
await sut.PerformExecuteAsync(null);
VerifyNotificationsNotSent();
}
[Test]
public async Task Does_Not_Execute_When_Not_Main_Dom()
{
var sut = CreateHealthCheckNotifier(isMainDom: false);
await sut.PerformExecuteAsync(null);
VerifyNotificationsNotSent();
}
[Test]
public async Task Does_Not_Execute_With_No_Enabled_Notification_Methods()
{
var sut = CreateHealthCheckNotifier(notificationEnabled: false);
await sut.PerformExecuteAsync(null);
VerifyNotificationsNotSent();
}
[Test]
public async Task Executes_With_Enabled_Notification_Methods()
{
var sut = CreateHealthCheckNotifier();
await sut.PerformExecuteAsync(null);
VerifyNotificationsSent();
}
[Test]
public async Task Executes_Only_Enabled_Checks()
{
var sut = CreateHealthCheckNotifier();
await sut.PerformExecuteAsync(null);
_mockNotificationMethod.Verify(
x => x.SendAsync(
It.Is<HealthCheckResults>(y =>
y.ResultsAsDictionary.Count == 1 && y.ResultsAsDictionary.ContainsKey("Check1"))),
Times.Once);
}
private HealthCheckNotifier CreateHealthCheckNotifier(
bool enabled = true,
RuntimeLevel runtimeLevel = RuntimeLevel.Run,
ServerRole serverRole = ServerRole.Single,
bool isMainDom = true,
bool notificationEnabled = true)
{
var settings = new HealthChecksSettings
{
Notification = new HealthChecksNotificationSettings
{
Enabled = enabled,
DisabledChecks = new List<DisabledHealthCheckSettings> { new() { Id = Guid.Parse(Check3Id) } },
},
DisabledChecks = new List<DisabledHealthCheckSettings> { new() { Id = Guid.Parse(Check2Id) } },
};
var checks = new HealthCheckCollection(() => new List<HealthCheck>
{
new TestHealthCheck1(),
new TestHealthCheck2(),
new TestHealthCheck3(),
});
_mockNotificationMethod = new Mock<IHealthCheckNotificationMethod>();
_mockNotificationMethod.SetupGet(x => x.Enabled).Returns(notificationEnabled);
var notifications = new HealthCheckNotificationMethodCollection(() =>
new List<IHealthCheckNotificationMethod> { _mockNotificationMethod.Object });
var mockRunTimeState = new Mock<IRuntimeState>();
mockRunTimeState.SetupGet(x => x.Level).Returns(runtimeLevel);
var mockServerRegistrar = new Mock<IServerRoleAccessor>();
mockServerRegistrar.Setup(x => x.CurrentServerRole).Returns(serverRole);
var mockMainDom = new Mock<IMainDom>();
mockMainDom.SetupGet(x => x.IsMainDom).Returns(isMainDom);
var mockScopeProvider = new Mock<IScopeProvider>();
var mockLogger = new Mock<ILogger<HealthCheckNotifier>>();
var mockProfilingLogger = new Mock<IProfilingLogger>();
return new HealthCheckNotifier(
new TestOptionsMonitor<HealthChecksSettings>(settings),
checks,
notifications,
mockRunTimeState.Object,
mockServerRegistrar.Object,
mockMainDom.Object,
mockScopeProvider.Object,
mockLogger.Object,
mockProfilingLogger.Object,
Mock.Of<ICronTabParser>());
}
private void VerifyNotificationsNotSent() => VerifyNotificationsSentTimes(Times.Never());
private void VerifyNotificationsSent() => VerifyNotificationsSentTimes(Times.Once());
private void VerifyNotificationsSentTimes(Times times) =>
_mockNotificationMethod.Verify(x => x.SendAsync(It.IsAny<HealthCheckResults>()), times);
[HealthCheck(Check1Id, "Check1")]
private class TestHealthCheck1 : TestHealthCheck
{
}
[HealthCheck(Check2Id, "Check2")]
private class TestHealthCheck2 : TestHealthCheck
{
}
[HealthCheck(Check3Id, "Check3")]
private class TestHealthCheck3 : TestHealthCheck
{
}
private class TestHealthCheck : HealthCheck
{
public override HealthCheckStatus ExecuteAction(HealthCheckAction action) => new("Check message");
public override async Task<IEnumerable<HealthCheckStatus>> GetStatus() => Enumerable.Empty<HealthCheckStatus>();
}
}

127
tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/HostedServices/KeepAliveTests.cs
View File

@@ -1,127 +0,0 @@
// Copyright (c) Umbraco.
// See LICENSE for more details.
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Moq;
using Moq.Protected;
using NUnit.Framework;
using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Core.Hosting;
using Umbraco.Cms.Core.Logging;
using Umbraco.Cms.Core.Runtime;
using Umbraco.Cms.Core.Scoping;
using Umbraco.Cms.Core.Sync;
using Umbraco.Cms.Infrastructure.HostedServices;
using Umbraco.Cms.Tests.Common;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.HostedServices;
[TestFixture]
[Obsolete("Replaced by BackgroundJobs.Jobs.KeepAliveJobTests")]
public class KeepAliveTests
{
private Mock<HttpMessageHandler> _mockHttpMessageHandler;
private const string ApplicationUrl = "https://mysite.com";
[Test]
public async Task Does_Not_Execute_When_Not_Enabled()
{
var sut = CreateKeepAlive(false);
await sut.PerformExecuteAsync(null);
VerifyKeepAliveRequestNotSent();
}
[Test]
public async Task Does_Not_Execute_When_Server_Role_Is_Subscriber()
{
var sut = CreateKeepAlive(serverRole: ServerRole.Subscriber);
await sut.PerformExecuteAsync(null);
VerifyKeepAliveRequestNotSent();
}
[Test]
public async Task Does_Not_Execute_When_Server_Role_Is_Unknown()
{
var sut = CreateKeepAlive(serverRole: ServerRole.Unknown);
await sut.PerformExecuteAsync(null);
VerifyKeepAliveRequestNotSent();
}
[Test]
public async Task Does_Not_Execute_When_Not_Main_Dom()
{
var sut = CreateKeepAlive(isMainDom: false);
await sut.PerformExecuteAsync(null);
VerifyKeepAliveRequestNotSent();
}
[Test]
public async Task Executes_And_Calls_Ping_Url()
{
var sut = CreateKeepAlive();
await sut.PerformExecuteAsync(null);
VerifyKeepAliveRequestSent();
}
private KeepAlive CreateKeepAlive(
bool enabled = true,
ServerRole serverRole = ServerRole.Single,
bool isMainDom = true)
{
var settings = new KeepAliveSettings { DisableKeepAliveTask = !enabled };
var mockHostingEnvironment = new Mock<IHostingEnvironment>();
mockHostingEnvironment.SetupGet(x => x.ApplicationMainUrl).Returns(new Uri(ApplicationUrl));
mockHostingEnvironment.Setup(x => x.ToAbsolute(It.IsAny<string>()))
.Returns((string s) => s.TrimStart('~'));
var mockServerRegistrar = new Mock<IServerRoleAccessor>();
mockServerRegistrar.Setup(x => x.CurrentServerRole).Returns(serverRole);
var mockMainDom = new Mock<IMainDom>();
mockMainDom.SetupGet(x => x.IsMainDom).Returns(isMainDom);
var mockScopeProvider = new Mock<IScopeProvider>();
var mockLogger = new Mock<ILogger<KeepAlive>>();
var mockProfilingLogger = new Mock<IProfilingLogger>();
_mockHttpMessageHandler = new Mock<HttpMessageHandler>();
_mockHttpMessageHandler.Protected()
.Setup<Task<HttpResponseMessage>>(
"SendAsync",
ItExpr.IsAny<HttpRequestMessage>(),
ItExpr.IsAny<CancellationToken>())
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK))
.Verifiable();
_mockHttpMessageHandler.As<IDisposable>().Setup(s => s.Dispose());
var httpClient = new HttpClient(_mockHttpMessageHandler.Object);
var mockHttpClientFactory = new Mock<IHttpClientFactory>(MockBehavior.Strict);
mockHttpClientFactory.Setup(x => x.CreateClient(It.IsAny<string>())).Returns(httpClient);
return new KeepAlive(
mockHostingEnvironment.Object,
mockMainDom.Object,
new TestOptionsMonitor<KeepAliveSettings>(settings),
mockLogger.Object,
mockProfilingLogger.Object,
mockServerRegistrar.Object,
mockHttpClientFactory.Object);
}
private void VerifyKeepAliveRequestNotSent() => VerifyKeepAliveRequestSentTimes(Times.Never());
private void VerifyKeepAliveRequestSent() => VerifyKeepAliveRequestSentTimes(Times.Once());
private void VerifyKeepAliveRequestSentTimes(Times times) => _mockHttpMessageHandler.Protected()
.Verify(
"SendAsync",
times,
ItExpr.Is<HttpRequestMessage>(x => x.RequestUri.ToString() == $"{ApplicationUrl}/api/keepalive/ping"),
ItExpr.IsAny<CancellationToken>());
}

106
tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/HostedServices/LogScrubberTests.cs
View File

@@ -1,106 +0,0 @@
// Copyright (c) Umbraco.
// See LICENSE for more details.
using System.Data;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Core.Events;
using Umbraco.Cms.Core.Logging;
using Umbraco.Cms.Core.Runtime;
using Umbraco.Cms.Core.Scoping;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Sync;
using Umbraco.Cms.Infrastructure.HostedServices;
using Umbraco.Cms.Tests.Common;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.HostedServices;
[TestFixture]
[Obsolete("Replaced by BackgroundJobs.Jobs.LogScrubberJobTests")]
public class LogScrubberTests
{
private Mock<IAuditService> _mockAuditService;
private const int MaxLogAgeInMinutes = 60;
[Test]
public async Task Does_Not_Execute_When_Server_Role_Is_Subscriber()
{
var sut = CreateLogScrubber(ServerRole.Subscriber);
await sut.PerformExecuteAsync(null);
VerifyLogsNotScrubbed();
}
[Test]
public async Task Does_Not_Execute_When_Server_Role_Is_Unknown()
{
var sut = CreateLogScrubber(ServerRole.Unknown);
await sut.PerformExecuteAsync(null);
VerifyLogsNotScrubbed();
}
[Test]
public async Task Does_Not_Execute_When_Not_Main_Dom()
{
var sut = CreateLogScrubber(isMainDom: false);
await sut.PerformExecuteAsync(null);
VerifyLogsNotScrubbed();
}
[Test]
public async Task Executes_And_Scrubs_Logs()
{
var sut = CreateLogScrubber();
await sut.PerformExecuteAsync(null);
VerifyLogsScrubbed();
}
private LogScrubber CreateLogScrubber(
ServerRole serverRole = ServerRole.Single,
bool isMainDom = true)
{
var settings = new LoggingSettings { MaxLogAge = TimeSpan.FromMinutes(MaxLogAgeInMinutes) };
var mockServerRegistrar = new Mock<IServerRoleAccessor>();
mockServerRegistrar.Setup(x => x.CurrentServerRole).Returns(serverRole);
var mockMainDom = new Mock<IMainDom>();
mockMainDom.SetupGet(x => x.IsMainDom).Returns(isMainDom);
var mockScope = new Mock<IScope>();
var mockScopeProvider = new Mock<ICoreScopeProvider>();
mockScopeProvider
.Setup(x => x.CreateCoreScope(
It.IsAny<IsolationLevel>(),
It.IsAny<RepositoryCacheMode>(),
It.IsAny<IEventDispatcher>(),
It.IsAny<IScopedNotificationPublisher>(),
It.IsAny<bool?>(),
It.IsAny<bool>(),
It.IsAny<bool>()))
.Returns(mockScope.Object);
var mockLogger = new Mock<ILogger<LogScrubber>>();
var mockProfilingLogger = new Mock<IProfilingLogger>();
_mockAuditService = new Mock<IAuditService>();
return new LogScrubber(
mockMainDom.Object,
mockServerRegistrar.Object,
_mockAuditService.Object,
new TestOptionsMonitor<LoggingSettings>(settings),
mockScopeProvider.Object,
mockLogger.Object,
mockProfilingLogger.Object);
}
private void VerifyLogsNotScrubbed() => VerifyLogsScrubbed(Times.Never());
private void VerifyLogsScrubbed() => VerifyLogsScrubbed(Times.Once());
private void VerifyLogsScrubbed(Times times) =>
_mockAuditService.Verify(x => x.CleanLogs(It.Is<int>(y => y == MaxLogAgeInMinutes)), times);
}

143
tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/HostedServices/ScheduledPublishingTests.cs
View File

@@ -1,143 +0,0 @@
// Copyright (c) Umbraco.
// See LICENSE for more details.
using System.Data;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Events;
using Umbraco.Cms.Core.Runtime;
using Umbraco.Cms.Core.Scoping;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Sync;
using Umbraco.Cms.Core.Web;
using Umbraco.Cms.Infrastructure;
using Umbraco.Cms.Infrastructure.HostedServices;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.HostedServices;
[TestFixture]
[Obsolete("Replaced by BackgroundJobs.Jobs.ScheduledPublishingJobTests")]
public class ScheduledPublishingTests
{
private Mock<IContentService> _mockContentService;
private Mock<ILogger<ScheduledPublishing>> _mockLogger;
[Test]
public async Task Does_Not_Execute_When_Not_Enabled()
{
var sut = CreateScheduledPublishing(false);
await sut.PerformExecuteAsync(null);
VerifyScheduledPublishingNotPerformed();
}
[TestCase(RuntimeLevel.Boot)]
[TestCase(RuntimeLevel.Install)]
[TestCase(RuntimeLevel.Unknown)]
[TestCase(RuntimeLevel.Upgrade)]
[TestCase(RuntimeLevel.BootFailed)]
public async Task Does_Not_Execute_When_Runtime_State_Is_Not_Run(RuntimeLevel runtimeLevel)
{
var sut = CreateScheduledPublishing(runtimeLevel: runtimeLevel);
await sut.PerformExecuteAsync(null);
VerifyScheduledPublishingNotPerformed();
}
[Test]
public async Task Does_Not_Execute_When_Server_Role_Is_Subscriber()
{
var sut = CreateScheduledPublishing(serverRole: ServerRole.Subscriber);
await sut.PerformExecuteAsync(null);
VerifyScheduledPublishingNotPerformed();
}
[Test]
public async Task Does_Not_Execute_When_Server_Role_Is_Unknown()
{
var sut = CreateScheduledPublishing(serverRole: ServerRole.Unknown);
await sut.PerformExecuteAsync(null);
VerifyScheduledPublishingNotPerformed();
}
[Test]
public async Task Does_Not_Execute_When_Not_Main_Dom()
{
var sut = CreateScheduledPublishing(isMainDom: false);
await sut.PerformExecuteAsync(null);
VerifyScheduledPublishingNotPerformed();
}
[Test]
public async Task Executes_And_Performs_Scheduled_Publishing()
{
var sut = CreateScheduledPublishing();
await sut.PerformExecuteAsync(null);
VerifyScheduledPublishingPerformed();
}
private ScheduledPublishing CreateScheduledPublishing(
bool enabled = true,
RuntimeLevel runtimeLevel = RuntimeLevel.Run,
ServerRole serverRole = ServerRole.Single,
bool isMainDom = true)
{
if (enabled)
{
Suspendable.ScheduledPublishing.Resume();
}
else
{
Suspendable.ScheduledPublishing.Suspend();
}
var mockRunTimeState = new Mock<IRuntimeState>();
mockRunTimeState.SetupGet(x => x.Level).Returns(runtimeLevel);
var mockServerRegistrar = new Mock<IServerRoleAccessor>();
mockServerRegistrar.Setup(x => x.CurrentServerRole).Returns(serverRole);
var mockMainDom = new Mock<IMainDom>();
mockMainDom.SetupGet(x => x.IsMainDom).Returns(isMainDom);
_mockContentService = new Mock<IContentService>();
var mockUmbracoContextFactory = new Mock<IUmbracoContextFactory>();
mockUmbracoContextFactory.Setup(x => x.EnsureUmbracoContext())
.Returns(new UmbracoContextReference(null, false, null));
_mockLogger = new Mock<ILogger<ScheduledPublishing>>();
var mockServerMessenger = new Mock<IServerMessenger>();
var mockScopeProvider = new Mock<ICoreScopeProvider>();
mockScopeProvider
.Setup(x => x.CreateCoreScope(
It.IsAny<IsolationLevel>(),
It.IsAny<RepositoryCacheMode>(),
It.IsAny<IEventDispatcher>(),
It.IsAny<IScopedNotificationPublisher>(),
It.IsAny<bool?>(),
It.IsAny<bool>(),
It.IsAny<bool>()))
.Returns(Mock.Of<IScope>());
return new ScheduledPublishing(
mockRunTimeState.Object,
mockMainDom.Object,
mockServerRegistrar.Object,
_mockContentService.Object,
mockUmbracoContextFactory.Object,
_mockLogger.Object,
mockServerMessenger.Object,
mockScopeProvider.Object);
}
private void VerifyScheduledPublishingNotPerformed() => VerifyScheduledPublishingPerformed(Times.Never());
private void VerifyScheduledPublishingPerformed() => VerifyScheduledPublishingPerformed(Times.Once());
private void VerifyScheduledPublishingPerformed(Times times) =>
_mockContentService.Verify(x => x.PerformScheduledPublish(It.IsAny<DateTime>()), times);
}

66
tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/HostedServices/ServerRegistration/InstructionProcessTaskTests.cs
View File

@@ -1,66 +0,0 @@
// Copyright (c) Umbraco.
// See LICENSE for more details.
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Sync;
using Umbraco.Cms.Infrastructure.HostedServices.ServerRegistration;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.HostedServices.ServerRegistration;
[TestFixture]
[Obsolete("Replaced by BackgroundJobs.Jobs.ServerRegistration.InstructionProcessJobTests")]
public class InstructionProcessTaskTests
{
private Mock<IServerMessenger> _mockDatabaseServerMessenger;
[TestCase(RuntimeLevel.Boot)]
[TestCase(RuntimeLevel.Install)]
[TestCase(RuntimeLevel.Unknown)]
[TestCase(RuntimeLevel.Upgrade)]
[TestCase(RuntimeLevel.BootFailed)]
public async Task Does_Not_Execute_When_Runtime_State_Is_Not_Run(RuntimeLevel runtimeLevel)
{
var sut = CreateInstructionProcessTask(runtimeLevel);
await sut.PerformExecuteAsync(null);
VerifyMessengerNotSynced();
}
[Test]
public async Task Executes_And_Touches_Server()
{
var sut = CreateInstructionProcessTask();
await sut.PerformExecuteAsync(null);
VerifyMessengerSynced();
}
private InstructionProcessTask CreateInstructionProcessTask(RuntimeLevel runtimeLevel = RuntimeLevel.Run)
{
var mockRunTimeState = new Mock<IRuntimeState>();
mockRunTimeState.SetupGet(x => x.Level).Returns(runtimeLevel);
var mockLogger = new Mock<ILogger<InstructionProcessTask>>();
_mockDatabaseServerMessenger = new Mock<IServerMessenger>();
var settings = new GlobalSettings();
return new InstructionProcessTask(
mockRunTimeState.Object,
_mockDatabaseServerMessenger.Object,
mockLogger.Object,
Options.Create(settings));
}
private void VerifyMessengerNotSynced() => VerifyMessengerSyncedTimes(Times.Never());
private void VerifyMessengerSynced() => VerifyMessengerSyncedTimes(Times.Once());
private void VerifyMessengerSyncedTimes(Times times) => _mockDatabaseServerMessenger.Verify(x => x.Sync(), times);
}

107
tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/HostedServices/ServerRegistration/TouchServerTaskTests.cs
View File

@@ -1,107 +0,0 @@
// Copyright (c) Umbraco.
// See LICENSE for more details.
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Core.Hosting;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Sync;
using Umbraco.Cms.Infrastructure.HostedServices.ServerRegistration;
using Umbraco.Cms.Tests.Common;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.HostedServices.ServerRegistration;
[TestFixture]
[Obsolete("Replaced by BackgroundJobs.Jobs.ServerRegistration.TouchServerJobTests")]
public class TouchServerTaskTests
{
private Mock<IServerRegistrationService> _mockServerRegistrationService;
private const string ApplicationUrl = "https://mysite.com/";
private readonly TimeSpan _staleServerTimeout = TimeSpan.FromMinutes(2);
[TestCase(RuntimeLevel.Boot)]
[TestCase(RuntimeLevel.Install)]
[TestCase(RuntimeLevel.Unknown)]
[TestCase(RuntimeLevel.Upgrade)]
[TestCase(RuntimeLevel.BootFailed)]
public async Task Does_Not_Execute_When_Runtime_State_Is_Not_Run(RuntimeLevel runtimeLevel)
{
var sut = CreateTouchServerTask(runtimeLevel);
await sut.PerformExecuteAsync(null);
VerifyServerNotTouched();
}
[Test]
public async Task Does_Not_Execute_When_Application_Url_Is_Not_Available()
{
var sut = CreateTouchServerTask(applicationUrl: string.Empty);
await sut.PerformExecuteAsync(null);
VerifyServerNotTouched();
}
[Test]
public async Task Executes_And_Touches_Server()
{
var sut = CreateTouchServerTask();
await sut.PerformExecuteAsync(null);
VerifyServerTouched();
}
[Test]
public async Task Does_Not_Execute_When_Role_Accessor_Is_Not_Elected()
{
var sut = CreateTouchServerTask(useElection: false);
await sut.PerformExecuteAsync(null);
VerifyServerNotTouched();
}
private TouchServerTask CreateTouchServerTask(
RuntimeLevel runtimeLevel = RuntimeLevel.Run,
string applicationUrl = ApplicationUrl,
bool useElection = true)
{
var mockRequestAccessor = new Mock<IHostingEnvironment>();
mockRequestAccessor.SetupGet(x => x.ApplicationMainUrl)
.Returns(!string.IsNullOrEmpty(applicationUrl) ? new Uri(ApplicationUrl) : null);
var mockRunTimeState = new Mock<IRuntimeState>();
mockRunTimeState.SetupGet(x => x.Level).Returns(runtimeLevel);
var mockLogger = new Mock<ILogger<TouchServerTask>>();
_mockServerRegistrationService = new Mock<IServerRegistrationService>();
var settings = new GlobalSettings
{
DatabaseServerRegistrar = new DatabaseServerRegistrarSettings { StaleServerTimeout = _staleServerTimeout },
};
IServerRoleAccessor roleAccessor = useElection
? new ElectedServerRoleAccessor(_mockServerRegistrationService.Object)
: new SingleServerRoleAccessor();
return new TouchServerTask(
mockRunTimeState.Object,
_mockServerRegistrationService.Object,
mockRequestAccessor.Object,
mockLogger.Object,
new TestOptionsMonitor<GlobalSettings>(settings),
roleAccessor);
}
private void VerifyServerNotTouched() => VerifyServerTouchedTimes(Times.Never());
private void VerifyServerTouched() => VerifyServerTouchedTimes(Times.Once());
private void VerifyServerTouchedTimes(Times times) => _mockServerRegistrationService
.Verify(
x => x.TouchServer(
It.Is<string>(y => y == ApplicationUrl),
It.Is<TimeSpan>(y => y == _staleServerTimeout)),
times);
}

60
tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/HostedServices/TempFileCleanupTests.cs
View File

@@ -1,60 +0,0 @@
// Copyright (c) Umbraco.
// See LICENSE for more details.
using System.IO;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Moq;
using NUnit.Framework;
using Umbraco.Cms.Core.IO;
using Umbraco.Cms.Core.Runtime;
using Umbraco.Cms.Infrastructure.HostedServices;
namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.HostedServices
{
[TestFixture]
[Obsolete("Replaced by BackgroundJobs.Jobs.TempFileCleanupTests")]
public class TempFileCleanupTests
{
private Mock<IIOHelper> _mockIOHelper;
private readonly string _testPath = Path.Combine(TestContext.CurrentContext.TestDirectory.Split("bin")[0], "App_Data", "TEMP");
[Test]
public async Task Does_Not_Execute_When_Not_Main_Dom()
{
TempFileCleanup sut = CreateTempFileCleanup(isMainDom: false);
await sut.PerformExecuteAsync(null);
VerifyFilesNotCleaned();
}
[Test]
public async Task Executes_And_Cleans_Files()
{
TempFileCleanup sut = CreateTempFileCleanup();
await sut.PerformExecuteAsync(null);
VerifyFilesCleaned();
}
private TempFileCleanup CreateTempFileCleanup(bool isMainDom = true)
{
var mockMainDom = new Mock<IMainDom>();
mockMainDom.SetupGet(x => x.IsMainDom).Returns(isMainDom);
_mockIOHelper = new Mock<IIOHelper>();
_mockIOHelper.Setup(x => x.GetTempFolders())
.Returns(new DirectoryInfo[] { new(_testPath) });
_mockIOHelper.Setup(x => x.CleanFolder(It.IsAny<DirectoryInfo>(), It.IsAny<TimeSpan>()))
.Returns(CleanFolderResult.Success());
var mockLogger = new Mock<ILogger<TempFileCleanup>>();
return new TempFileCleanup(_mockIOHelper.Object, mockMainDom.Object, mockLogger.Object);
}
private void VerifyFilesNotCleaned() => VerifyFilesCleaned(Times.Never());
private void VerifyFilesCleaned() => VerifyFilesCleaned(Times.Once());
private void VerifyFilesCleaned(Times times) => _mockIOHelper.Verify(x => x.CleanFolder(It.Is<DirectoryInfo>(y => y.FullName == _testPath), It.IsAny<TimeSpan>()), times);
}
}