openiddict-core/test/OpenIddict.Quartz.Tests/OpenIddictQuartzJobTests.cs

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using Moq;
using Quartz;
using Xunit;

namespace OpenIddict.Quartz.Tests;

public class OpenIddictQuartzJobTests
{
#if !NET
    [Fact]
    public void Constructor_ThrowsAnExceptionWhenServiceProviderCannotBeResolved()
    {
        // Arrange, act and assert
        var exception = Assert.Throws<InvalidOperationException>(() => new OpenIddictQuartzJob());

        Assert.Equal(SR.GetResourceString(SR.ID0082), exception.Message);
    }
#endif

    [Fact]
    public async Task Execute_UsesServiceScope()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                TimeProvider = TimeProvider.System
            });

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() &&
            provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of<IOpenIddictSessionManager>() &&
            provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == provider);
        var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope);

        var job = new OpenIddictQuartzJob(Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory));

        // Act
        await job.Execute(Mock.Of<IJobExecutionContext>());

        Mock.Get(factory).Verify(factory => factory.CreateScope(), Times.Once());
        Mock.Get(scope).Verify(scope => scope.Dispose(), Times.Once());
    }

    [Fact]
    public async Task Execute_IgnoresPruningWhenTokenPruningIsDisabled()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                DisableTokenPruning = true,
                TimeProvider = TimeProvider.System
            });

        var manager = new Mock<IOpenIddictAuthorizationManager>();

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() &&
            provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of<IOpenIddictSessionManager>() &&
            provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var job = CreateJob(provider);

        // Act
        await job.Execute(Mock.Of<IJobExecutionContext>());

        // Assert
        manager.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Never());
    }

    [Fact]
    public async Task Execute_IgnoresPruningWhenAuthorizationPruningIsDisabled()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                DisableAuthorizationPruning = true,
                TimeProvider = TimeProvider.System
            });

        var manager = new Mock<IOpenIddictAuthorizationManager>();

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object &&
            provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of<IOpenIddictSessionManager>() &&
            provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var job = CreateJob(provider);

        // Act
        await job.Execute(Mock.Of<IJobExecutionContext>());

        // Assert
        manager.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Never());
    }

    [Fact]
    public async Task Execute_IgnoresPruningWhenSessionPruningIsDisabled()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                DisableSessionPruning = true,
                TimeProvider = TimeProvider.System
            });

        var manager = new Mock<IOpenIddictSessionManager>();

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() &&
            provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object &&
            provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var job = CreateJob(provider);

        // Act
        await job.Execute(Mock.Of<IJobExecutionContext>());

        // Assert
        manager.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Never());
    }

    [Fact]
    public async Task Execute_UnschedulesTriggersWhenTokenManagerIsMissing()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                TimeProvider = TimeProvider.System
            });

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() &&
            provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of<IOpenIddictSessionManager>() &&
            provider.GetService(typeof(IOpenIddictTokenManager)) == null &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var job = CreateJob(provider);

        // Act and assert
        var exception = await Assert.ThrowsAsync<JobExecutionException>(async () =>
            await job.Execute(Mock.Of<IJobExecutionContext>()));

        Assert.False(exception.RefireImmediately);
        Assert.True(exception.UnscheduleAllTriggers);
        Assert.True(exception.UnscheduleFiringTrigger);

        Assert.IsType<InvalidOperationException>(exception.InnerException);
        Assert.Equal(SR.GetResourceString(SR.ID0278), exception.InnerException!.Message);
    }

    [Fact]
    public async Task Execute_UnschedulesTriggersWhenAuthorizationManagerIsMissing()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                TimeProvider = TimeProvider.System
            });

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == null &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var job = CreateJob(provider);

        // Act and assert
        var exception = await Assert.ThrowsAsync<JobExecutionException>(async () =>
            await job.Execute(Mock.Of<IJobExecutionContext>()));

        Assert.False(exception.RefireImmediately);
        Assert.True(exception.UnscheduleAllTriggers);
        Assert.True(exception.UnscheduleFiringTrigger);

        Assert.IsType<InvalidOperationException>(exception.InnerException);
        Assert.Equal(SR.GetResourceString(SR.ID0278), exception.InnerException!.Message);
    }

    [Fact]
    public async Task Execute_UnschedulesTriggersWhenSessionManagerIsMissing()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                TimeProvider = TimeProvider.System
            });

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictSessionManager)) == null &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var job = CreateJob(provider);

        // Act and assert
        var exception = await Assert.ThrowsAsync<JobExecutionException>(async () =>
            await job.Execute(Mock.Of<IJobExecutionContext>()));

        Assert.False(exception.RefireImmediately);
        Assert.True(exception.UnscheduleAllTriggers);
        Assert.True(exception.UnscheduleFiringTrigger);

        Assert.IsType<InvalidOperationException>(exception.InnerException);
        Assert.Equal(SR.GetResourceString(SR.ID0278), exception.InnerException!.Message);
    }

    [Fact]
    public async Task Execute_RethrowsOutOfMemoryExceptionsThrownDuringTokenPruning()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                TimeProvider = TimeProvider.System
            });

        var manager = new Mock<IOpenIddictTokenManager>();
        manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
            .Throws(new OutOfMemoryException());

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() &&
            provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var job = CreateJob(provider);

        // Act and assert
        await Assert.ThrowsAsync<OutOfMemoryException>(async () => await job.Execute(Mock.Of<IJobExecutionContext>()));
    }

    [Fact]
    public async Task Execute_RethrowsOutOfMemoryExceptionsThrownDuringAuthorizationPruning()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                TimeProvider = TimeProvider.System
            });

        var manager = new Mock<IOpenIddictAuthorizationManager>();
        manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
            .Throws(new OutOfMemoryException());

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object &&
            provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var job = CreateJob(provider);

        // Act and assert
        await Assert.ThrowsAsync<OutOfMemoryException>(async () => await job.Execute(Mock.Of<IJobExecutionContext>()));
    }

    [Fact]
    public async Task Execute_RethrowsOutOfMemoryExceptionsThrownDuringSessionPruning()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                TimeProvider = TimeProvider.System
            });

        var manager = new Mock<IOpenIddictSessionManager>();
        manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
            .Throws(new OutOfMemoryException());

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() &&
            provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() &&
            provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var job = CreateJob(provider);

        // Act and assert
        await Assert.ThrowsAsync<OutOfMemoryException>(async () => await job.Execute(Mock.Of<IJobExecutionContext>()));
    }

    [Fact]
    public async Task Execute_DisablesRefiringWhenJobIsCanceledDuringTokenPruning()
    {
        // Arrange
        var token = new CancellationToken(canceled: true);

        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                TimeProvider = TimeProvider.System
            });

        var manager = new Mock<IOpenIddictTokenManager>();
        manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
            .Throws(new OperationCanceledException(token));

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() &&
            provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var context = Mock.Of<IJobExecutionContext>(context => context.CancellationToken == token);

        var job = CreateJob(provider);

        // Act and assert
        var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => await job.Execute(context));

        Assert.False(exception.RefireImmediately);

        manager.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once());
    }

    [Fact]
    public async Task Execute_DisablesRefiringWhenJobIsCanceledDuringAuthorizationPruning()
    {
        // Arrange
        var token = new CancellationToken(canceled: true);

        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                TimeProvider = TimeProvider.System
            });

        var manager = new Mock<IOpenIddictAuthorizationManager>();
        manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
            .Throws(new OperationCanceledException(token));

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object &&
            provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var context = Mock.Of<IJobExecutionContext>(context => context.CancellationToken == token);

        var job = CreateJob(provider);

        // Act and assert
        var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => await job.Execute(context));

        Assert.False(exception.RefireImmediately);

        manager.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once());
    }

    [Fact]
    public async Task Execute_DisablesRefiringWhenJobIsCanceledDuringSessionPruning()
    {
        // Arrange
        var token = new CancellationToken(canceled: true);

        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                TimeProvider = TimeProvider.System
            });

        var manager = new Mock<IOpenIddictSessionManager>();
        manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
            .Throws(new OperationCanceledException(token));

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() &&
            provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() &&
            provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var context = Mock.Of<IJobExecutionContext>(context => context.CancellationToken == token);

        var job = CreateJob(provider);

        // Act and assert
        var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => await job.Execute(context));

        Assert.False(exception.RefireImmediately);

        manager.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once());
    }

    [Fact]
    public async Task Execute_AllowsRefiringWhenExceptionsAreThrown()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                TimeProvider = TimeProvider.System
            });

        var provider = new Mock<IServiceProvider>();
        provider.Setup(provider => provider.GetService(typeof(IOpenIddictAuthorizationManager)))
            .Returns(CreateAuthorizationManager(new ApplicationException()));

        provider.Setup(provider => provider.GetService(typeof(IOpenIddictSessionManager)))
            .Returns(CreateSessionManager(new ApplicationException()));

        provider.Setup(provider => provider.GetService(typeof(IOpenIddictTokenManager)))
            .Returns(CreateTokenManager(new ApplicationException()));

        provider.Setup(provider => provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)))
            .Returns(monitor);

        var context = Mock.Of<IJobExecutionContext>(context => context.RefireCount == 0);

        var job = CreateJob(provider.Object);

        // Act and assert
        var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => await job.Execute(context));

        Assert.True(exception.RefireImmediately);
        Assert.IsType<AggregateException>(exception.InnerException);
        Assert.Equal(3, ((AggregateException) exception.InnerException!).InnerExceptions.Count);
        Assert.IsType<ApplicationException>(((AggregateException) exception.InnerException!).InnerExceptions[0]);
        Assert.IsType<ApplicationException>(((AggregateException) exception.InnerException!).InnerExceptions[1]);
        Assert.IsType<ApplicationException>(((AggregateException) exception.InnerException!).InnerExceptions[2]);

        static IOpenIddictAuthorizationManager CreateAuthorizationManager(Exception exception)
        {
            var mock = new Mock<IOpenIddictAuthorizationManager>();
            mock.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
                .Throws(exception);

            return mock.Object;
        }

        static IOpenIddictSessionManager CreateSessionManager(Exception exception)
        {
            var mock = new Mock<IOpenIddictSessionManager>();
            mock.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
                .Throws(exception);

            return mock.Object;
        }

        static IOpenIddictTokenManager CreateTokenManager(Exception exception)
        {
            var mock = new Mock<IOpenIddictTokenManager>();
            mock.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
                .Throws(exception);

            return mock.Object;
        }
    }

    [Fact]
    public async Task Execute_AllowsRefiringWhenAggregateExceptionsAreThrown()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                TimeProvider = TimeProvider.System
            });

        var provider = new Mock<IServiceProvider>();
        provider.Setup(provider => provider.GetService(typeof(IOpenIddictAuthorizationManager)))
            .Returns(CreateAuthorizationManager(new AggregateException(
                new InvalidOperationException(), new ApplicationException())));

        provider.Setup(provider => provider.GetService(typeof(IOpenIddictSessionManager)))
            .Returns(CreateSessionManager(new AggregateException(
                new InvalidOperationException(), new ApplicationException())));

        provider.Setup(provider => provider.GetService(typeof(IOpenIddictTokenManager)))
            .Returns(CreateTokenManager(new AggregateException(
                new InvalidOperationException(), new ApplicationException())));

        provider.Setup(provider => provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)))
            .Returns(monitor);

        var context = Mock.Of<IJobExecutionContext>(context => context.RefireCount == 0);

        var job = CreateJob(provider.Object);

        // Act and assert
        var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => await job.Execute(context));

        Assert.True(exception.RefireImmediately);
        Assert.IsType<AggregateException>(exception.InnerException);
        Assert.Equal(6, ((AggregateException) exception.InnerException!).InnerExceptions.Count);
        Assert.IsType<InvalidOperationException>(((AggregateException) exception.InnerException!).InnerExceptions[0]);
        Assert.IsType<ApplicationException>(((AggregateException) exception.InnerException!).InnerExceptions[1]);
        Assert.IsType<InvalidOperationException>(((AggregateException) exception.InnerException!).InnerExceptions[2]);
        Assert.IsType<ApplicationException>(((AggregateException) exception.InnerException!).InnerExceptions[3]);
        Assert.IsType<InvalidOperationException>(((AggregateException) exception.InnerException!).InnerExceptions[4]);
        Assert.IsType<ApplicationException>(((AggregateException) exception.InnerException!).InnerExceptions[5]);

        static IOpenIddictAuthorizationManager CreateAuthorizationManager(Exception exception)
        {
            var mock = new Mock<IOpenIddictAuthorizationManager>();
            mock.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
                .Throws(exception);

            return mock.Object;
        }

        static IOpenIddictSessionManager CreateSessionManager(Exception exception)
        {
            var mock = new Mock<IOpenIddictSessionManager>();
            mock.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
                .Throws(exception);

            return mock.Object;
        }

        static IOpenIddictTokenManager CreateTokenManager(Exception exception)
        {
            var mock = new Mock<IOpenIddictTokenManager>();
            mock.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
                .Throws(exception);

            return mock.Object;
        }
    }

    [Fact]
    public async Task Execute_DisallowsRefiringWhenMaximumRefireCountIsReached()
    {
        // Arrange
        var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
            monitor => monitor.CurrentValue == new OpenIddictQuartzOptions
            {
                MaximumRefireCount = 5,
                TimeProvider = TimeProvider.System
            });

        var manager = new Mock<IOpenIddictAuthorizationManager>();
        manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()))
            .Throws(new ApplicationException());

        var provider = Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object &&
            provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of<IOpenIddictSessionManager>() &&
            provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() &&
            provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor);

        var context = Mock.Of<IJobExecutionContext>(context => context.RefireCount == 5);

        var job = CreateJob(provider);

        // Act and assert
        var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => await job.Execute(context));

        Assert.False(exception.RefireImmediately);
    }

    private static OpenIddictQuartzJob CreateJob(IServiceProvider provider)
    {
        var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == provider);
        var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope);

        return new OpenIddictQuartzJob(Mock.Of<IServiceProvider>(provider =>
            provider.GetService(typeof(IServiceScopeFactory)) == factory));
    }
}