diff --git a/Directory.Packages.props b/Directory.Packages.props index 40909ed4..6e63f2d0 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -48,8 +48,6 @@ - - @@ -93,7 +91,6 @@ - @@ -127,7 +124,6 @@ - @@ -140,6 +136,7 @@ + diff --git a/OpenIddict.slnx b/OpenIddict.slnx index 0e76237a..a82e216d 100644 --- a/OpenIddict.slnx +++ b/OpenIddict.slnx @@ -66,7 +66,6 @@ - @@ -95,7 +94,6 @@ - diff --git a/sandbox/OpenIddict.Sandbox.AspNet.Client/Web.config b/sandbox/OpenIddict.Sandbox.AspNet.Client/Web.config index 79435b34..92cb6ef4 100644 --- a/sandbox/OpenIddict.Sandbox.AspNet.Client/Web.config +++ b/sandbox/OpenIddict.Sandbox.AspNet.Client/Web.config @@ -172,18 +172,6 @@ - - - - - - - - - - - - diff --git a/sandbox/OpenIddict.Sandbox.AspNetCore.Client/OpenIddict.Sandbox.AspNetCore.Client.csproj b/sandbox/OpenIddict.Sandbox.AspNetCore.Client/OpenIddict.Sandbox.AspNetCore.Client.csproj index 011b2a3f..828e7234 100644 --- a/sandbox/OpenIddict.Sandbox.AspNetCore.Client/OpenIddict.Sandbox.AspNetCore.Client.csproj +++ b/sandbox/OpenIddict.Sandbox.AspNetCore.Client/OpenIddict.Sandbox.AspNetCore.Client.csproj @@ -7,7 +7,6 @@ - diff --git a/sandbox/OpenIddict.Sandbox.AspNetCore.Client/Program.cs b/sandbox/OpenIddict.Sandbox.AspNetCore.Client/Program.cs index 21e31a7f..b194b1ce 100644 --- a/sandbox/OpenIddict.Sandbox.AspNetCore.Client/Program.cs +++ b/sandbox/OpenIddict.Sandbox.AspNetCore.Client/Program.cs @@ -6,7 +6,6 @@ using Microsoft.IdentityModel.Tokens; using OpenIddict.Client; using OpenIddict.Client.WebIntegration; using OpenIddict.Sandbox.AspNetCore.Client.Models; -using Quartz; using static OpenIddict.Abstractions.OpenIddictConstants; var builder = WebApplication.CreateBuilder(args); @@ -36,17 +35,6 @@ builder.Services.AddAuthentication(options => options.SlidingExpiration = false; }); -// OpenIddict offers native integration with Quartz.NET to perform scheduled tasks -// (like pruning orphaned authorizations from the database) at regular intervals. -builder.Services.AddQuartz(options => -{ - options.UseSimpleTypeLoader(); - options.UseInMemoryStore(); -}); - -// Register the Quartz.NET service and configure it to block shutdown until jobs are complete. -builder.Services.AddQuartzHostedService(options => options.WaitForJobsToComplete = true); - builder.Services.AddOpenIddict() // Register the OpenIddict core components. @@ -61,8 +49,13 @@ builder.Services.AddOpenIddict() // options.UseMongoDb() // .UseDatabase(new MongoClient().GetDatabase("openiddict")); - // Enable Quartz.NET integration. - options.UseQuartz(); + // Note: by default, OpenIddict automatically prunes authorizations, sessions and tokens + // that are no longer valid at regular intervals. For those who prefer using their own + // pruning mechanism (e.g based on Quartz.NET or Hangfire), automatic pruning can be disabled. + // + // options.DisableAutomaticAuthorizationPruning() + // .DisableAutomaticSessionPruning() + // .DisableAutomaticTokenPruning(); }) // Register the OpenIddict client components. diff --git a/sandbox/OpenIddict.Sandbox.AspNetCore.Server/OpenIddict.Sandbox.AspNetCore.Server.csproj b/sandbox/OpenIddict.Sandbox.AspNetCore.Server/OpenIddict.Sandbox.AspNetCore.Server.csproj index 057c0336..30858557 100644 --- a/sandbox/OpenIddict.Sandbox.AspNetCore.Server/OpenIddict.Sandbox.AspNetCore.Server.csproj +++ b/sandbox/OpenIddict.Sandbox.AspNetCore.Server/OpenIddict.Sandbox.AspNetCore.Server.csproj @@ -9,7 +9,6 @@ - diff --git a/sandbox/OpenIddict.Sandbox.AspNetCore.Server/Program.cs b/sandbox/OpenIddict.Sandbox.AspNetCore.Server/Program.cs index 62ba3e97..05390651 100644 --- a/sandbox/OpenIddict.Sandbox.AspNetCore.Server/Program.cs +++ b/sandbox/OpenIddict.Sandbox.AspNetCore.Server/Program.cs @@ -10,7 +10,6 @@ using Microsoft.IdentityModel.Tokens; using OpenIddict.Abstractions; using OpenIddict.Sandbox.AspNetCore.Server.Models; using OpenIddict.Sandbox.AspNetCore.Server.Services; -using Quartz; using static OpenIddict.Abstractions.OpenIddictConstants; var builder = WebApplication.CreateBuilder(args); @@ -50,17 +49,6 @@ builder.Services.Configure(options => options.OnR return Task.CompletedTask; }); -// OpenIddict offers native integration with Quartz.NET to perform scheduled tasks -// (like pruning orphaned authorizations/tokens from the database) at regular intervals. -builder.Services.AddQuartz(options => -{ - options.UseSimpleTypeLoader(); - options.UseInMemoryStore(); -}); - -// Register the Quartz.NET service and configure it to block shutdown until jobs are complete. -builder.Services.AddQuartzHostedService(options => options.WaitForJobsToComplete = true); - builder.Services.AddOpenIddict() // Register the OpenIddict core components. @@ -75,8 +63,13 @@ builder.Services.AddOpenIddict() // options.UseMongoDb() // .UseDatabase(new MongoClient().GetDatabase("openiddict")); - // Enable Quartz.NET integration. - options.UseQuartz(); + // Note: by default, OpenIddict automatically prunes authorizations, sessions and tokens + // that are no longer valid at regular intervals. For those who prefer using their own + // pruning mechanism (e.g based on Quartz.NET or Hangfire), automatic pruning can be disabled. + // + // options.DisableAutomaticAuthorizationPruning() + // .DisableAutomaticSessionPruning() + // .DisableAutomaticTokenPruning(); }) // Register the OpenIddict client components. diff --git a/sandbox/OpenIddict.Sandbox.Console.Client/Program.cs b/sandbox/OpenIddict.Sandbox.Console.Client/Program.cs index 5481ce0f..13928e3c 100644 --- a/sandbox/OpenIddict.Sandbox.Console.Client/Program.cs +++ b/sandbox/OpenIddict.Sandbox.Console.Client/Program.cs @@ -32,6 +32,14 @@ builder.Services.AddOpenIddict() options.UseEntityFramework() .UseDbContext(); #endif + + // Note: by default, OpenIddict automatically prunes authorizations, sessions and tokens + // that are no longer valid at regular intervals. For those who prefer using their own + // pruning mechanism (e.g based on Quartz.NET or Hangfire), automatic pruning can be disabled. + // + // options.DisableAutomaticAuthorizationPruning() + // .DisableAutomaticSessionPruning() + // .DisableAutomaticTokenPruning(); }) // Register the OpenIddict client components. diff --git a/src/OpenIddict.Abstractions/OpenIddictResources.resx b/src/OpenIddict.Abstractions/OpenIddictResources.resx index 0e5466e4..debb0713 100644 --- a/src/OpenIddict.Abstractions/OpenIddictResources.resx +++ b/src/OpenIddict.Abstractions/OpenIddictResources.resx @@ -383,10 +383,6 @@ Consider using 'options.AddSigningCredentials(SigningCredentials)' instead. Endpoint URIs cannot start with '{0}'. - - Dependency injection support must be enabled in Quartz.NET when using the OpenIddict integration. -To enable DI support, call 'services.AddQuartz(options => options.UseMicrosoftDependencyInjectionJobFactory())' or 'services.AddQuartz(options => options.UseMicrosoftDependencyInjectionScopedJobFactory())'. - Reference tokens cannot be used when disabling token storage. @@ -896,10 +892,6 @@ To apply configuration responses, create a class implementing 'IOpenIddictServer The Entity Framework 6.x stores cannot be used with generic types. Consider creating non-generic classes derived from the default entities for the application, authorization, scope and token entities. - - - The core services must be registered when enabling the OpenIddict Quartz.NET integration. -To register the OpenIddict core services, reference the 'OpenIddict.Core' package and call 'services.AddOpenIddict().AddCore()' from 'ConfigureServices'. The maximum refire count cannot be negative. @@ -3287,22 +3279,16 @@ This may indicate that the hashed entry is corrupted or malformed. The session '{Identifier}' was no longer valid. - - https://documentation.openiddict.com/errors/{0} + + A non-fatal error occurred while pruning tokens from the database. - - Removes orphaned tokens and authorizations from the database. + + A non-fatal error occurred while pruning authorizations from the database. - - Starts the scheduled task at regular intervals. + + A non-fatal error occurred while pruning sessions from the database. - - OpenIddict job - - - Built-in automatic trigger - - - OpenIddict/Quartz.NET integration + + https://documentation.openiddict.com/errors/{0} \ No newline at end of file diff --git a/src/OpenIddict.Core/OpenIddict.Core.csproj b/src/OpenIddict.Core/OpenIddict.Core.csproj index e8616c44..5c53a8f4 100644 --- a/src/OpenIddict.Core/OpenIddict.Core.csproj +++ b/src/OpenIddict.Core/OpenIddict.Core.csproj @@ -15,6 +15,7 @@ + diff --git a/src/OpenIddict.Core/OpenIddictCoreBackgroundService.cs b/src/OpenIddict.Core/OpenIddictCoreBackgroundService.cs new file mode 100644 index 00000000..846e8181 --- /dev/null +++ b/src/OpenIddict.Core/OpenIddictCoreBackgroundService.cs @@ -0,0 +1,144 @@ +/* + * Licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0) + * See https://github.com/openiddict/openiddict-core for more information concerning + * the license and the contributors participating to this project. + */ + +using System.ComponentModel; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Options; + +namespace OpenIddict.Core; + +/// +/// Represents a hosted service performing background tasks for OpenIddict. +/// +[EditorBrowsable(EditorBrowsableState.Never)] +public sealed class OpenIddictCoreBackgroundService : BackgroundService +{ + private readonly ILogger _logger; + private readonly IOptionsMonitor _options; + private readonly IServiceProvider _provider; + + /// + /// Creates a new instance of the class. + /// + /// The logger. + /// The OpenIddict core options. + /// The service provider. + public OpenIddictCoreBackgroundService( + ILogger logger, + IOptionsMonitor options, + IServiceProvider provider) + { + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + _options = options ?? throw new ArgumentNullException(nameof(options)); + _provider = provider ?? throw new ArgumentNullException(nameof(provider)); + } + + /// + protected override async Task ExecuteAsync(CancellationToken stoppingToken) + { + var options = _options.CurrentValue; + + // Note: if all the automatic pruning features are disabled, the background service no-ops. + if (options.DisableAutomaticAuthorizationPruning && + options.DisableAutomaticSessionPruning && options.DisableAutomaticTokenPruning) + { + return; + } + + // Note: an initialization delay is used to avoid executing the pruning logic immediately after + // the application starts and to reduce the risk of multiple instances of the application + // pruning the database at the same time (which could lead to deadlocks in some cases). +#if NET + await Task.Delay(TimeSpan.FromMinutes(Random.Shared.Next(1, 10)), options.TimeProvider, stoppingToken); +#else + await Task.Delay(TimeSpan.FromMinutes(Random.Shared.Next(1, 10)), stoppingToken); +#endif + + using var timer = new PeriodicTimer(TimeSpan.FromHours(1), options.TimeProvider); + + // Note: exceptions thrown by the pruning logic are caught and logged to avoid crashing + // the background service and to ensure these exceptions are not propagated to the + // .NET Generic Host (which would cause the application to be stopped by default). + + do + { + await using var scope = _provider.CreateAsyncScope(); + + // Important: since authorizations that still have tokens attached are never + // pruned, the tokens MUST be deleted before deleting the authorizations. + + if (!options.DisableAutomaticTokenPruning) + { + var manager = scope.ServiceProvider.GetRequiredService(); + var threshold = options.TimeProvider.GetUtcNow() - options.MinimumTokenLifespan; + + try + { + await manager.PruneAsync(threshold, stoppingToken); + } + + catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested) + { + return; + } + + catch (Exception exception) when (!OpenIddictHelpers.IsFatal(exception)) + { + _logger.LogInformation(6298, exception, SR.GetResourceString(SR.ID6298)); + } + } + + if (!options.DisableAutomaticAuthorizationPruning) + { + var manager = scope.ServiceProvider.GetRequiredService(); + var threshold = options.TimeProvider.GetUtcNow() - options.MinimumAuthorizationLifespan; + + try + { + await manager.PruneAsync(threshold, stoppingToken); + } + + catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested) + { + return; + } + + catch (Exception exception) when (!OpenIddictHelpers.IsFatal(exception)) + { + _logger.LogInformation(6299, exception, SR.GetResourceString(SR.ID6299)); + } + } + + // Important: since sessions that still have tokens attached are never + // pruned, the tokens MUST be deleted before deleting the sessions. + + if (!options.DisableAutomaticSessionPruning) + { + var manager = scope.ServiceProvider.GetRequiredService(); + var threshold = options.TimeProvider.GetUtcNow() - options.MinimumSessionLifespan; + + try + { + await manager.PruneAsync(threshold, stoppingToken); + } + + catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested) + { + return; + } + + catch (Exception exception) when (!OpenIddictHelpers.IsFatal(exception)) + { + _logger.LogInformation(6300, exception, SR.GetResourceString(SR.ID6300)); + } + } + } + + while (await timer.WaitForNextTickAsync(stoppingToken)); + } +} diff --git a/src/OpenIddict.Core/OpenIddictCoreBuilder.cs b/src/OpenIddict.Core/OpenIddictCoreBuilder.cs index 353eca76..c38c9b48 100644 --- a/src/OpenIddict.Core/OpenIddictCoreBuilder.cs +++ b/src/OpenIddict.Core/OpenIddictCoreBuilder.cs @@ -57,6 +57,27 @@ public sealed class OpenIddictCoreBuilder return this; } + /// + /// Disables automatic authorizations pruning. + /// + /// The instance. + public OpenIddictCoreBuilder DisableAutomaticAuthorizationPruning() + => Configure(options => options.DisableAutomaticAuthorizationPruning = true); + + /// + /// Disables automatic sessions pruning. + /// + /// The instance. + public OpenIddictCoreBuilder DisableAutomaticSessionPruning() + => Configure(options => options.DisableAutomaticSessionPruning = true); + + /// + /// Disables automatic tokens pruning. + /// + /// The instance. + public OpenIddictCoreBuilder DisableAutomaticTokenPruning() + => Configure(options => options.DisableAutomaticTokenPruning = true); + /// /// Replaces the application manager by the specified type. /// @@ -719,6 +740,42 @@ public sealed class OpenIddictCoreBuilder return Configure(options => options.EntityCacheLimit = limit); } + /// + /// Sets the minimum lifespan authorizations must have to be pruned. + /// + /// The minimum lifespan authorizations must have to be pruned. + /// The instance. + public OpenIddictCoreBuilder SetMinimumAuthorizationLifespan(TimeSpan lifespan) + { + ArgumentOutOfRangeException.ThrowIfLessThan(lifespan, TimeSpan.FromMinutes(10)); + + return Configure(options => options.MinimumAuthorizationLifespan = lifespan); + } + + /// + /// Sets the minimum lifespan sessions must have to be pruned. + /// + /// The minimum lifespan sessions must have to be pruned. + /// The instance. + public OpenIddictCoreBuilder SetMinimumSessionLifespan(TimeSpan lifespan) + { + ArgumentOutOfRangeException.ThrowIfLessThan(lifespan, TimeSpan.FromMinutes(10)); + + return Configure(options => options.MinimumSessionLifespan = lifespan); + } + + /// + /// Sets the minimum lifespan tokens must have to be pruned. + /// + /// The minimum lifespan tokens must have to be pruned. + /// The instance. + public OpenIddictCoreBuilder SetMinimumTokenLifespan(TimeSpan lifespan) + { + ArgumentOutOfRangeException.ThrowIfLessThan(lifespan, TimeSpan.FromMinutes(10)); + + return Configure(options => options.MinimumTokenLifespan = lifespan); + } + /// [EditorBrowsable(EditorBrowsableState.Never)] public override bool Equals([NotNullWhen(true)] object? obj) => base.Equals(obj); diff --git a/src/OpenIddict.Core/OpenIddictCoreExtensions.cs b/src/OpenIddict.Core/OpenIddictCoreExtensions.cs index 2dc8aff1..c9de0215 100644 --- a/src/OpenIddict.Core/OpenIddictCoreExtensions.cs +++ b/src/OpenIddict.Core/OpenIddictCoreExtensions.cs @@ -59,6 +59,8 @@ public static class OpenIddictCoreExtensions builder.Services.TryAddScoped(static provider => throw new InvalidOperationException(SR.GetResourceString(SR.ID0472))); + builder.Services.AddHostedService(); + // Note: TryAddEnumerable() is used here to ensure the initializers are registered only once. builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton< IPostConfigureOptions, OpenIddictCoreConfiguration>()); diff --git a/src/OpenIddict.Core/OpenIddictCoreOptions.cs b/src/OpenIddict.Core/OpenIddictCoreOptions.cs index 20a35b4b..842d5457 100644 --- a/src/OpenIddict.Core/OpenIddictCoreOptions.cs +++ b/src/OpenIddict.Core/OpenIddictCoreOptions.cs @@ -63,6 +63,21 @@ public sealed class OpenIddictCoreOptions [EditorBrowsable(EditorBrowsableState.Advanced)] public bool DisableEntityCaching { get; set; } + /// + /// Gets or sets a boolean indicating whether authorizations pruning should be disabled. + /// + public bool DisableAutomaticAuthorizationPruning { get; set; } + + /// + /// Gets or sets a boolean indicating whether sessions pruning should be disabled. + /// + public bool DisableAutomaticSessionPruning { get; set; } + + /// + /// Gets or sets a boolean indicating whether tokens pruning should be disabled. + /// + public bool DisableAutomaticTokenPruning { get; set; } + /// /// Gets or sets the maximum number of cached entries allowed. When the threshold /// is reached, the cache is automatically compacted to ensure it doesn't grow @@ -72,6 +87,24 @@ public sealed class OpenIddictCoreOptions [EditorBrowsable(EditorBrowsableState.Advanced)] public int EntityCacheLimit { get; set; } = 250; + /// + /// Gets or sets the minimum lifespan authorizations must have to be pruned. + /// By default, this value is set to 14 days and cannot be less than 10 minutes. + /// + public TimeSpan MinimumAuthorizationLifespan { get; set; } = TimeSpan.FromDays(14); + + /// + /// Gets or sets the minimum lifespan sessions must have to be pruned. + /// By default, this value is set to 14 days and cannot be less than 10 minutes. + /// + public TimeSpan MinimumSessionLifespan { get; set; } = TimeSpan.FromDays(14); + + /// + /// Gets or sets the minimum lifespan tokens must have to be pruned. + /// By default, this value is set to 14 days and cannot be less than 10 minutes. + /// + public TimeSpan MinimumTokenLifespan { get; set; } = TimeSpan.FromDays(14); + /// /// Gets or sets the time provider. /// diff --git a/src/OpenIddict.Quartz/OpenIddict.Quartz.csproj b/src/OpenIddict.Quartz/OpenIddict.Quartz.csproj deleted file mode 100644 index 8cd60427..00000000 --- a/src/OpenIddict.Quartz/OpenIddict.Quartz.csproj +++ /dev/null @@ -1,31 +0,0 @@ - - - - $(NetFrameworkTargetFrameworks);$(NetCoreTargetFrameworks) - - - - Quartz.NET integration package for OpenIddict. - $(PackageTags);quartz - - - - - - - - - - - - - - - - - - - - - - diff --git a/src/OpenIddict.Quartz/OpenIddictQuartzBuilder.cs b/src/OpenIddict.Quartz/OpenIddictQuartzBuilder.cs deleted file mode 100644 index c11a86f9..00000000 --- a/src/OpenIddict.Quartz/OpenIddictQuartzBuilder.cs +++ /dev/null @@ -1,138 +0,0 @@ -/* - * Licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0) - * See https://github.com/openiddict/openiddict-core for more information concerning - * the license and the contributors participating to this project. - */ - -using System.ComponentModel; -using System.Diagnostics.CodeAnalysis; -using OpenIddict.Quartz; - -namespace Microsoft.Extensions.DependencyInjection; - -/// -/// Exposes the necessary methods required to configure the OpenIddict Quartz.NET integration. -/// -public sealed class OpenIddictQuartzBuilder -{ - /// - /// Initializes a new instance of . - /// - /// The services collection. - public OpenIddictQuartzBuilder(IServiceCollection services) - => Services = services ?? throw new ArgumentNullException(nameof(services)); - - /// - /// Gets the services collection. - /// - [EditorBrowsable(EditorBrowsableState.Never)] - public IServiceCollection Services { get; } - - /// - /// Enables validation of options during application startup. - /// - /// The instance. - public OpenIddictQuartzBuilder ValidateOnStart() - { - Services.AddOptionsWithValidateOnStart(); - - return this; - } - - /// - /// Amends the default OpenIddict Quartz.NET configuration. - /// - /// The delegate used to configure the OpenIddict options. - /// This extension can be safely called multiple times. - /// The instance. - [EditorBrowsable(EditorBrowsableState.Advanced)] - public OpenIddictQuartzBuilder Configure(Action configuration) - { - ArgumentNullException.ThrowIfNull(configuration); - - Services.Configure(configuration); - - return this; - } - - /// - /// Disables authorizations pruning. - /// - /// The instance. - public OpenIddictQuartzBuilder DisableAuthorizationPruning() - => Configure(options => options.DisableAuthorizationPruning = true); - - /// - /// Disables sessions pruning. - /// - /// The instance. - public OpenIddictQuartzBuilder DisableSessionPruning() - => Configure(options => options.DisableSessionPruning = true); - - /// - /// Disables tokens pruning. - /// - /// The instance. - public OpenIddictQuartzBuilder DisableTokenPruning() - => Configure(options => options.DisableTokenPruning = true); - - /// - /// Sets the number of times a failed Quartz.NET job can be retried. - /// - /// The number of times a failed Quartz.NET job can be retried. - /// The instance. - public OpenIddictQuartzBuilder SetMaximumRefireCount(int count) - { - ArgumentOutOfRangeException.ThrowIfNegative(count); - - return Configure(options => options.MaximumRefireCount = count); - } - - /// - /// Sets the minimum lifespan authorizations must have to be pruned. - /// - /// The minimum lifespan authorizations must have to be pruned. - /// The instance. - public OpenIddictQuartzBuilder SetMinimumAuthorizationLifespan(TimeSpan lifespan) - { - ArgumentOutOfRangeException.ThrowIfLessThan(lifespan, TimeSpan.FromMinutes(10)); - - return Configure(options => options.MinimumAuthorizationLifespan = lifespan); - } - - /// - /// Sets the minimum lifespan sessions must have to be pruned. - /// - /// The minimum lifespan sessions must have to be pruned. - /// The instance. - public OpenIddictQuartzBuilder SetMinimumSessionLifespan(TimeSpan lifespan) - { - ArgumentOutOfRangeException.ThrowIfLessThan(lifespan, TimeSpan.FromMinutes(10)); - - return Configure(options => options.MinimumSessionLifespan = lifespan); - } - - /// - /// Sets the minimum lifespan tokens must have to be pruned. - /// - /// The minimum lifespan tokens must have to be pruned. - /// The instance. - public OpenIddictQuartzBuilder SetMinimumTokenLifespan(TimeSpan lifespan) - { - ArgumentOutOfRangeException.ThrowIfLessThan(lifespan, TimeSpan.FromMinutes(10)); - - return Configure(options => options.MinimumTokenLifespan = lifespan); - } - - /// - [EditorBrowsable(EditorBrowsableState.Never)] - public override bool Equals([NotNullWhen(true)] object? obj) => base.Equals(obj); - - /// - [EditorBrowsable(EditorBrowsableState.Never)] - public override int GetHashCode() => base.GetHashCode(); - - /// - [EditorBrowsable(EditorBrowsableState.Never)] - public override string? ToString() => base.ToString(); -} diff --git a/src/OpenIddict.Quartz/OpenIddictQuartzConfiguration.cs b/src/OpenIddict.Quartz/OpenIddictQuartzConfiguration.cs deleted file mode 100644 index e6d87cd2..00000000 --- a/src/OpenIddict.Quartz/OpenIddictQuartzConfiguration.cs +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0) - * See https://github.com/openiddict/openiddict-core for more information concerning - * the license and the contributors participating to this project. - */ - -using System.ComponentModel; -using Microsoft.Extensions.DependencyInjection; -using Microsoft.Extensions.Options; - -namespace OpenIddict.Quartz; - -/// -/// Contains the methods required to ensure that the OpenIddict Quartz.NET configuration is valid. -/// -[EditorBrowsable(EditorBrowsableState.Advanced)] -public sealed class OpenIddictQuartzConfiguration : IPostConfigureOptions -{ - private readonly IServiceProvider _provider; - - /// - /// Creates a new instance of the class. - /// - /// The service provider. - public OpenIddictQuartzConfiguration(IServiceProvider provider) - => _provider = provider ?? throw new ArgumentNullException(nameof(provider)); - - /// - public void PostConfigure(string? name, OpenIddictQuartzOptions options) - { - ArgumentNullException.ThrowIfNull(options); - - options.TimeProvider ??= _provider.GetService() ?? TimeProvider.System; - } -} diff --git a/src/OpenIddict.Quartz/OpenIddictQuartzExtensions.cs b/src/OpenIddict.Quartz/OpenIddictQuartzExtensions.cs deleted file mode 100644 index 8a35970d..00000000 --- a/src/OpenIddict.Quartz/OpenIddictQuartzExtensions.cs +++ /dev/null @@ -1,83 +0,0 @@ -/* - * Licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0) - * See https://github.com/openiddict/openiddict-core for more information concerning - * the license and the contributors participating to this project. - */ - -using Microsoft.Extensions.DependencyInjection.Extensions; -using Microsoft.Extensions.Options; -using OpenIddict.Quartz; - -namespace Microsoft.Extensions.DependencyInjection; - -/// -/// Exposes extensions allowing to register the OpenIddict Quartz.NET integration. -/// -public static class OpenIddictQuartzExtensions -{ - /// - /// Registers the OpenIddict Quartz.NET integration in the DI container. - /// - /// The services builder used by OpenIddict to register new services. - /// This extension can be safely called multiple times. - /// The instance. - public static OpenIddictQuartzBuilder UseQuartz(this OpenIddictCoreBuilder builder) - { - ArgumentNullException.ThrowIfNull(builder); - - // Note: the AddQuartz() method MUST only be called once to avoid adding multiple jobs and triggers. - if (!builder.Services.Any(static descriptor => descriptor.ServiceType == typeof(OpenIddictQuartzJob))) - { - builder.Services.AddQuartz(options => - { - options.AddJob(static builder => - { - builder.StoreDurably() - .WithIdentity(OpenIddictQuartzJob.Identity) - .WithDescription(SR.GetResourceString(SR.ID8001)); - }); - - options.AddTrigger(static builder => - { - // Note: this trigger uses a quite long interval (1 hour), which means it may be potentially never - // reached if the application is shut down or recycled. As such, this trigger is set up to fire - // between 1 and 10 minutes after the application starts to ensure the job is executed at least once. - builder.ForJob(OpenIddictQuartzJob.Identity) - .WithIdentity(SR.GetResourceString(SR.ID8004), SR.GetResourceString(SR.ID8005)) - .WithSimpleSchedule(options => options.WithInterval(TimeSpan.FromHours(1)).RepeatForever()) - .WithDescription(SR.GetResourceString(SR.ID8002)) - .StartAt(TimeProvider.System.GetUtcNow() + TimeSpan.FromMinutes(new Random().Next(1, 10))); - }); - }); - } - -#if !NET - // Note: unlike Quartz.NET 4.0+, Quartz.NET 3.x doesn't automatically register the job as a service. - builder.Services.TryAddTransient(); -#endif - - // Note: TryAddEnumerable() is used here to ensure the initializer is registered only once. - builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton< - IPostConfigureOptions, OpenIddictQuartzConfiguration>()); - - return new OpenIddictQuartzBuilder(builder.Services); - } - - /// - /// Registers the OpenIddict Quartz.NET integration in the DI container. - /// - /// The services builder used by OpenIddict to register new services. - /// The configuration delegate used to configure the Quartz.NET services. - /// This extension can be safely called multiple times. - /// The instance. - public static OpenIddictCoreBuilder UseQuartz( - this OpenIddictCoreBuilder builder, Action configuration) - { - ArgumentNullException.ThrowIfNull(builder); - ArgumentNullException.ThrowIfNull(configuration); - - configuration(builder.UseQuartz()); - - return builder; - } -} diff --git a/src/OpenIddict.Quartz/OpenIddictQuartzJob.cs b/src/OpenIddict.Quartz/OpenIddictQuartzJob.cs deleted file mode 100644 index c9e305ac..00000000 --- a/src/OpenIddict.Quartz/OpenIddictQuartzJob.cs +++ /dev/null @@ -1,207 +0,0 @@ -/* - * Licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0) - * See https://github.com/openiddict/openiddict-core for more information concerning - * the license and the contributors participating to this project. - */ - -using System.ComponentModel; -using Microsoft.Extensions.DependencyInjection; -using Microsoft.Extensions.Options; - -namespace OpenIddict.Quartz; - -/// -/// Represents a Quartz.NET job performing scheduled tasks for OpenIddict. -/// -[DisallowConcurrentExecution, EditorBrowsable(EditorBrowsableState.Advanced)] -public sealed class OpenIddictQuartzJob : IJob -{ - private readonly IServiceProvider _provider; - -#if !NET - /// - /// Creates a new instance of the class. - /// - public OpenIddictQuartzJob() => throw new InvalidOperationException(SR.GetResourceString(SR.ID0082)); -#endif - - /// - /// Creates a new instance of the class. - /// - /// The service provider. - public OpenIddictQuartzJob(IServiceProvider provider) - => _provider = provider ?? throw new ArgumentNullException(nameof(provider)); - - /// - /// Gets the default identity assigned to this job. - /// - public static JobKey Identity { get; } = new JobKey( - name: SR.GetResourceString(SR.ID8003), - group: SR.GetResourceString(SR.ID8005)); - - /// -#if NET - public async ValueTask Execute(IJobExecutionContext context, CancellationToken cancellationToken = default) -#else - public async Task Execute(IJobExecutionContext context) -#endif - { - ArgumentNullException.ThrowIfNull(context); - - List? exceptions = null; - - await using var scope = _provider.CreateAsyncScope(); - - var options = scope.ServiceProvider.GetRequiredService>().CurrentValue; - - // Important: since authorizations that still have tokens attached are never - // pruned, the tokens MUST be deleted before deleting the authorizations. - - if (!options.DisableTokenPruning) - { - var manager = scope.ServiceProvider.GetService() - ?? throw new JobExecutionException(new InvalidOperationException(SR.GetResourceString(SR.ID0278))) - { - RefireImmediately = false, - UnscheduleAllTriggers = true, - UnscheduleFiringTrigger = true - }; - - var threshold = options.TimeProvider.GetUtcNow() - options.MinimumTokenLifespan; - - try - { - await manager.PruneAsync(threshold, context.CancellationToken); - } - - // OperationCanceledExceptions are typically thrown when the host is about to shut down. - // To allow the host to shut down as fast as possible, this exception type is special-cased - // to prevent further processing in this job and inform Quartz.NET it shouldn't be refired. - catch (OperationCanceledException exception) when (context.CancellationToken.IsCancellationRequested) - { - throw new JobExecutionException(exception) - { - RefireImmediately = false - }; - } - - // AggregateExceptions are generally thrown by the manager itself when one or multiple exception(s) - // occurred while trying to prune the entities. In this case, add the inner exceptions to the collection. - catch (AggregateException exception) when (!OpenIddictHelpers.IsFatal(exception)) - { - exceptions ??= new List(capacity: exception.InnerExceptions.Count); - exceptions.AddRange(exception.InnerExceptions); - } - - // Other non-fatal exceptions are assumed to be transient and are added to the exceptions collection - // to be re-thrown later (typically, at the very end of this job, as an AggregateException). - catch (Exception exception) when (!OpenIddictHelpers.IsFatal(exception)) - { - exceptions ??= new List(capacity: 1); - exceptions.Add(exception); - } - } - - if (!options.DisableAuthorizationPruning) - { - var manager = scope.ServiceProvider.GetService() - ?? throw new JobExecutionException(new InvalidOperationException(SR.GetResourceString(SR.ID0278))) - { - RefireImmediately = false, - UnscheduleAllTriggers = true, - UnscheduleFiringTrigger = true - }; - - var threshold = options.TimeProvider.GetUtcNow() - options.MinimumAuthorizationLifespan; - - try - { - await manager.PruneAsync(threshold, context.CancellationToken); - } - - // OperationCanceledExceptions are typically thrown when the host is about to shut down. - // To allow the host to shut down as fast as possible, this exception type is special-cased - // to prevent further processing in this job and inform Quartz.NET it shouldn't be refired. - catch (OperationCanceledException exception) when (context.CancellationToken.IsCancellationRequested) - { - throw new JobExecutionException(exception) - { - RefireImmediately = false - }; - } - - // AggregateExceptions are generally thrown by the manager itself when one or multiple exception(s) - // occurred while trying to prune the entities. In this case, add the inner exceptions to the collection. - catch (AggregateException exception) when (!OpenIddictHelpers.IsFatal(exception)) - { - exceptions ??= new List(capacity: exception.InnerExceptions.Count); - exceptions.AddRange(exception.InnerExceptions); - } - - // Other non-fatal exceptions are assumed to be transient and are added to the exceptions collection - // to be re-thrown later (typically, at the very end of this job, as an AggregateException). - catch (Exception exception) when (!OpenIddictHelpers.IsFatal(exception)) - { - exceptions ??= new List(capacity: 1); - exceptions.Add(exception); - } - } - - // Important: since sessions that still have tokens attached are never - // pruned, the tokens MUST be deleted before deleting the sessions. - - if (!options.DisableSessionPruning) - { - var manager = scope.ServiceProvider.GetService() - ?? throw new JobExecutionException(new InvalidOperationException(SR.GetResourceString(SR.ID0278))) - { - RefireImmediately = false, - UnscheduleAllTriggers = true, - UnscheduleFiringTrigger = true - }; - - var threshold = options.TimeProvider.GetUtcNow() - options.MinimumSessionLifespan; - - try - { - await manager.PruneAsync(threshold, context.CancellationToken); - } - - // OperationCanceledExceptions are typically thrown when the host is about to shut down. - // To allow the host to shut down as fast as possible, this exception type is special-cased - // to prevent further processing in this job and inform Quartz.NET it shouldn't be refired. - catch (OperationCanceledException exception) when (context.CancellationToken.IsCancellationRequested) - { - throw new JobExecutionException(exception) - { - RefireImmediately = false - }; - } - - // AggregateExceptions are generally thrown by the manager itself when one or multiple exception(s) - // occurred while trying to prune the entities. In this case, add the inner exceptions to the collection. - catch (AggregateException exception) when (!OpenIddictHelpers.IsFatal(exception)) - { - exceptions ??= new List(capacity: exception.InnerExceptions.Count); - exceptions.AddRange(exception.InnerExceptions); - } - - // Other non-fatal exceptions are assumed to be transient and are added to the exceptions collection - // to be re-thrown later (typically, at the very end of this job, as an AggregateException). - catch (Exception exception) when (!OpenIddictHelpers.IsFatal(exception)) - { - exceptions ??= new List(capacity: 1); - exceptions.Add(exception); - } - } - - if (exceptions is { Count: > 0 }) - { - throw new JobExecutionException(new AggregateException(exceptions)) - { - // Only refire the job if the maximum refire count set in the options wasn't reached. - RefireImmediately = context.RefireCount < options.MaximumRefireCount - }; - } - } -} diff --git a/src/OpenIddict.Quartz/OpenIddictQuartzOptions.cs b/src/OpenIddict.Quartz/OpenIddictQuartzOptions.cs deleted file mode 100644 index 57539a24..00000000 --- a/src/OpenIddict.Quartz/OpenIddictQuartzOptions.cs +++ /dev/null @@ -1,62 +0,0 @@ -/* - * Licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0) - * See https://github.com/openiddict/openiddict-core for more information concerning - * the license and the contributors participating to this project. - */ - -namespace OpenIddict.Quartz; - -/// -/// Provides various settings needed to configure the OpenIddict Quartz.NET integration. -/// -public sealed class OpenIddictQuartzOptions -{ - /// - /// Gets or sets a boolean indicating whether authorizations pruning should be disabled. - /// - public bool DisableAuthorizationPruning { get; set; } - - /// - /// Gets or sets a boolean indicating whether sessions pruning should be disabled. - /// - public bool DisableSessionPruning { get; set; } - - /// - /// Gets or sets a boolean indicating whether tokens pruning should be disabled. - /// - public bool DisableTokenPruning { get; set; } - - /// - /// Gets or sets the number of times a failed Quartz.NET job can be retried. - /// By default, failed jobs are automatically retried twice after the initial failure. - /// - public int MaximumRefireCount { get; set; } = 2; - - /// - /// Gets or sets the minimum lifespan authorizations must have to be pruned. - /// By default, this value is set to 14 days and cannot be less than 10 minutes. - /// - public TimeSpan MinimumAuthorizationLifespan { get; set; } = TimeSpan.FromDays(14); - - /// - /// Gets or sets the minimum lifespan sessions must have to be pruned. - /// By default, this value is set to 14 days and cannot be less than 10 minutes. - /// - public TimeSpan MinimumSessionLifespan { get; set; } = TimeSpan.FromDays(14); - - /// - /// Gets or sets the minimum lifespan tokens must have to be pruned. - /// By default, this value is set to 14 days and cannot be less than 10 minutes. - /// - public TimeSpan MinimumTokenLifespan { get; set; } = TimeSpan.FromDays(14); - - /// - /// Gets or sets the time provider. - /// - /// - /// Note: if this property is not explicitly set, the time provider is - /// automatically resolved from the dependency injection container. - /// If no service can be found, is used. - /// - public TimeProvider TimeProvider { get; set; } = default!; -} diff --git a/test/OpenIddict.Core.Tests/OpenIddict.Core.Tests.csproj b/test/OpenIddict.Core.Tests/OpenIddict.Core.Tests.csproj index 9856eda4..cb436349 100644 --- a/test/OpenIddict.Core.Tests/OpenIddict.Core.Tests.csproj +++ b/test/OpenIddict.Core.Tests/OpenIddict.Core.Tests.csproj @@ -13,6 +13,10 @@ + + + + diff --git a/test/OpenIddict.Core.Tests/OpenIddictCoreBackgroundServiceTests.cs b/test/OpenIddict.Core.Tests/OpenIddictCoreBackgroundServiceTests.cs new file mode 100644 index 00000000..7e5a0675 --- /dev/null +++ b/test/OpenIddict.Core.Tests/OpenIddictCoreBackgroundServiceTests.cs @@ -0,0 +1,861 @@ +/* + * Licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0) + * See https://github.com/openiddict/openiddict-core for more information concerning + * the license and the contributors participating to this project. + */ + +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Options; +using Moq; +using Xunit; + +#if NET +using Microsoft.Extensions.Time.Testing; +#endif + +namespace OpenIddict.Core.Tests; + +public class OpenIddictCoreBackgroundServiceTests +{ + [Theory] + [InlineData("logger")] + [InlineData("options")] + [InlineData("provider")] + public void Constructor_ThrowsAnExceptionForNullDependencies(string parameter) + { + // Act and assert + var exception = Assert.Throws(() => new OpenIddictCoreBackgroundService( + parameter is "logger" ? null! : Mock.Of>(), + parameter is "options" ? null! : Mock.Of>(), + parameter is "provider" ? null! : Mock.Of())); + + Assert.Equal(parameter, exception.ParamName); + } + + [Fact] + public async Task ExecuteAsync_StopsWhenAllPruningIsDisabled() + { + // Arrange + var options = new OpenIddictCoreOptions + { + DisableAutomaticAuthorizationPruning = true, + DisableAutomaticSessionPruning = true, + DisableAutomaticTokenPruning = true + }; + var factory = new Mock(); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory.Object); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await service.ExecuteTask!; + + // Assert + factory.Verify(factory => factory.CreateScope(), Times.Never()); + } + +#if NET + [Fact] + public async Task ExecuteAsync_UsesAndDisposesServiceScope() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + var options = new OpenIddictCoreOptions { TimeProvider = clock.Object }; + var scope = new Mock(); + var factory = new Mock(); + var manager = new Mock(); + var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Callback(() => completion.SetResult()).Returns(new ValueTask(0)); + var scoped = Mock.Of(provider => + provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of() && + provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of() && + provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object); + scope.SetupGet(scope => scope.ServiceProvider).Returns(scoped); + factory.Setup(factory => factory.CreateScope()).Returns(scope.Object); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory.Object); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + await completion.Task.WaitAsync(TimeSpan.FromSeconds(5)); + await service.StopAsync(CancellationToken.None); + + // Assert + factory.Verify(factory => factory.CreateScope(), Times.Once()); + scope.Verify(scope => scope.Dispose(), Times.Once()); + } + + [Fact] + public async Task ExecuteAsync_SkipsTokenPruningWhenDisabled() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions + { + DisableAutomaticTokenPruning = true, + TimeProvider = clock.Object + }; + + var tokens = new Mock(); + var authorizations = new Mock(); + var sessions = new Mock(); + var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + sessions.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Callback(() => completion.SetResult()).Returns(new ValueTask(0)); + + var scoped = Mock.Of(provider => + provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && + provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && + provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + await completion.Task.WaitAsync(TimeSpan.FromSeconds(5)); + await service.StopAsync(CancellationToken.None); + + // Assert + tokens.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Never()); + authorizations.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + sessions.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + } + + [Fact] + public async Task ExecuteAsync_SkipsAuthorizationPruningWhenDisabled() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions + { + DisableAutomaticAuthorizationPruning = true, + TimeProvider = clock.Object + }; + + var tokens = new Mock(); + var authorizations = new Mock(); + var sessions = new Mock(); + var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + sessions.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Callback(() => completion.SetResult()).Returns(new ValueTask(0)); + + var scoped = Mock.Of(provider => + provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && + provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && + provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + await completion.Task.WaitAsync(TimeSpan.FromSeconds(5)); + await service.StopAsync(CancellationToken.None); + + // Assert + tokens.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + authorizations.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Never()); + sessions.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + } + + [Fact] + public async Task ExecuteAsync_SkipsSessionPruningWhenDisabled() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions + { + DisableAutomaticSessionPruning = true, + TimeProvider = clock.Object + }; + + var tokens = new Mock(); + var authorizations = new Mock(); + var sessions = new Mock(); + var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + authorizations.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Callback(() => completion.SetResult()).Returns(new ValueTask(0)); + + var scoped = Mock.Of(provider => + provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && + provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && + provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + await completion.Task.WaitAsync(TimeSpan.FromSeconds(5)); + await service.StopAsync(CancellationToken.None); + + // Assert + tokens.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + authorizations.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + sessions.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Never()); + } + + [Fact] + public async Task ExecuteAsync_PrunesTokensBeforeAuthorizationsAndSessionsUsingConfiguredThresholds() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + var options = new OpenIddictCoreOptions { TimeProvider = clock.Object }; + options.MinimumTokenLifespan = TimeSpan.FromDays(1); + options.MinimumAuthorizationLifespan = TimeSpan.FromDays(2); + options.MinimumSessionLifespan = TimeSpan.FromDays(3); + var tokens = new Mock(); + var authorizations = new Mock(); + var sessions = new Mock(); + var calls = new List(); + var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + tokens.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Callback((date, _) => + { + Assert.Equal(options.TimeProvider.GetUtcNow() - options.MinimumTokenLifespan, date); + calls.Add("token"); + }).Returns(new ValueTask(0)); + authorizations.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Callback((date, _) => + { + Assert.Equal(options.TimeProvider.GetUtcNow() - options.MinimumAuthorizationLifespan, date); + calls.Add("authorization"); + }).Returns(new ValueTask(0)); + sessions.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Callback((date, _) => + { + Assert.Equal(options.TimeProvider.GetUtcNow() - options.MinimumSessionLifespan, date); + calls.Add("session"); + completion.SetResult(); + }).Returns(new ValueTask(0)); + var scoped = Mock.Of(provider => + provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && + provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && + provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + await completion.Task.WaitAsync(TimeSpan.FromSeconds(5)); + await service.StopAsync(CancellationToken.None); + + // Assert + Assert.Equal(["token", "authorization", "session"], calls); + } + + [Fact] + public async Task ExecuteAsync_RepeatsPruningOnTimerTicks() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + var options = new OpenIddictCoreOptions { TimeProvider = clock.Object }; + options.DisableAutomaticAuthorizationPruning = true; + options.DisableAutomaticSessionPruning = true; + var tokens = new Mock(); + var first = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var second = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var count = 0; + tokens.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Callback(() => (Interlocked.Increment(ref count) is 1 ? first : second).SetResult()) + .Returns(new ValueTask(0)); + var factory = new Mock(); + factory.Setup(factory => factory.CreateScope()) + .Returns(() => Mock.Of(scope => scope.ServiceProvider == + Mock.Of(provider => provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object))); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory.Object); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + await first.Task.WaitAsync(TimeSpan.FromSeconds(5)); + clock.Object.Advance(TimeSpan.FromHours(1)); + await second.Task.WaitAsync(TimeSpan.FromSeconds(5)); + await service.StopAsync(CancellationToken.None); + + // Assert + factory.Verify(factory => factory.CreateScope(), Times.Exactly(2)); + tokens.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), + Times.Exactly(2)); + } + + [Fact] + public async Task ExecuteAsync_LogsNonFatalTokenPruningErrorsAndContinues() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions { TimeProvider = clock.Object }; + var tokens = new Mock(); + var authorizations = new Mock(); + var sessions = new Mock(); + var logger = new Mock>(); + var error = new ApplicationException(); + var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + tokens.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Throws(error); + sessions.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Callback(() => completion.SetResult()).Returns(new ValueTask(0)); + + var scoped = Mock.Of(provider => + provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && + provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && + provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService(logger.Object, monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + await completion.Task.WaitAsync(TimeSpan.FromSeconds(5)); + await service.StopAsync(CancellationToken.None); + + // Assert + Assert.Contains(logger.Invocations, invocation => string.Equals(invocation.Method.Name, "Log", StringComparison.Ordinal) && + invocation.Arguments[0] is LogLevel.Information && + invocation.Arguments[1] is EventId id && id.Id is 6298 && + ReferenceEquals(invocation.Arguments[3], error)); + authorizations.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + sessions.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + } + + [Fact] + public async Task ExecuteAsync_LogsNonFatalAuthorizationPruningErrorsAndContinues() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions { TimeProvider = clock.Object }; + var tokens = new Mock(); + var authorizations = new Mock(); + var sessions = new Mock(); + var logger = new Mock>(); + var error = new ApplicationException(); + var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + authorizations.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Throws(error); + sessions.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Callback(() => completion.SetResult()).Returns(new ValueTask(0)); + + var scoped = Mock.Of(provider => + provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && + provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && + provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService(logger.Object, monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + await completion.Task.WaitAsync(TimeSpan.FromSeconds(5)); + await service.StopAsync(CancellationToken.None); + + // Assert + Assert.Contains(logger.Invocations, invocation => string.Equals(invocation.Method.Name, "Log", StringComparison.Ordinal) && + invocation.Arguments[0] is LogLevel.Information && + invocation.Arguments[1] is EventId id && id.Id is 6299 && + ReferenceEquals(invocation.Arguments[3], error)); + sessions.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + } + + [Fact] + public async Task ExecuteAsync_LogsNonFatalSessionPruningErrorsAndContinues() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions { TimeProvider = clock.Object }; + var tokens = new Mock(); + var authorizations = new Mock(); + var sessions = new Mock(); + var logger = new Mock>(); + var error = new ApplicationException(); + var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + sessions.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Callback(() => completion.SetResult()).Throws(error); + + var scoped = Mock.Of(provider => + provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && + provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && + provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService(logger.Object, monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + await completion.Task.WaitAsync(TimeSpan.FromSeconds(5)); + await service.StopAsync(CancellationToken.None); + + // Assert + Assert.Contains(logger.Invocations, invocation => string.Equals(invocation.Method.Name, "Log", StringComparison.Ordinal) && + invocation.Arguments[0] is LogLevel.Information && + invocation.Arguments[1] is EventId id && id.Id is 6300 && + ReferenceEquals(invocation.Arguments[3], error)); + sessions.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + } + + [Fact] + public async Task ExecuteAsync_RethrowsOutOfMemoryExceptionsThrownDuringTokenPruning() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions + { + DisableAutomaticAuthorizationPruning = true, + DisableAutomaticSessionPruning = true, + TimeProvider = clock.Object + }; + + var manager = new Mock(); + manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Throws(new OutOfMemoryException()); + + var scoped = Mock.Of(provider => provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + + // Assert + await Assert.ThrowsAsync(async () => + await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System)); + } + + [Fact] + public async Task ExecuteAsync_RethrowsOutOfMemoryExceptionsThrownDuringAuthorizationPruning() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions + { + DisableAutomaticTokenPruning = true, + DisableAutomaticSessionPruning = true, + TimeProvider = clock.Object + }; + + var manager = new Mock(); + manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Throws(new OutOfMemoryException()); + + var scoped = Mock.Of(provider => provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + + // Assert + await Assert.ThrowsAsync(async () => + await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System)); + } + + [Fact] + public async Task ExecuteAsync_RethrowsOutOfMemoryExceptionsThrownDuringSessionPruning() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions + { + DisableAutomaticTokenPruning = true, + DisableAutomaticAuthorizationPruning = true, + TimeProvider = clock.Object + }; + + var manager = new Mock(); + manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Throws(new OutOfMemoryException()); + + var scoped = Mock.Of(provider => provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + + // Assert + await Assert.ThrowsAsync(async () => + await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System)); + } + + [Fact] + public async Task ExecuteAsync_StopsWhenTokenPruningIsCanceled() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions + { + DisableAutomaticAuthorizationPruning = true, + DisableAutomaticSessionPruning = true, + TimeProvider = clock.Object + }; + + var manager = new Mock(); + var started = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var canceled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Returns((DateTimeOffset _, CancellationToken token) => + { + token.Register(() => canceled.TrySetCanceled(token)); + started.SetResult(); + return new ValueTask(canceled.Task); + }); + + var scoped = Mock.Of(provider => provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + await started.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + await service.StopAsync(CancellationToken.None); + await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + + // Assert + manager.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + } + + [Fact] + public async Task ExecuteAsync_StopsWhenAuthorizationPruningIsCanceled() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions + { + DisableAutomaticTokenPruning = true, + DisableAutomaticSessionPruning = true, + TimeProvider = clock.Object + }; + + var manager = new Mock(); + var started = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var canceled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Returns((DateTimeOffset _, CancellationToken token) => + { + token.Register(() => canceled.TrySetCanceled(token)); + started.SetResult(); + return new ValueTask(canceled.Task); + }); + + var scoped = Mock.Of(provider => provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + await started.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + await service.StopAsync(CancellationToken.None); + await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + + // Assert + manager.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + } + + [Fact] + public async Task ExecuteAsync_StopsWhenSessionPruningIsCanceled() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions + { + DisableAutomaticTokenPruning = true, + DisableAutomaticAuthorizationPruning = true, + TimeProvider = clock.Object + }; + + var manager = new Mock(); + var started = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var canceled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) + .Returns((DateTimeOffset _, CancellationToken token) => + { + token.Register(() => canceled.TrySetCanceled(token)); + started.SetResult(); + return new ValueTask(canceled.Task); + }); + + var scoped = Mock.Of(provider => provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + await started.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + await service.StopAsync(CancellationToken.None); + await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + + // Assert + manager.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); + } + + [Fact] + public async Task ExecuteAsync_FailsWhenTokenManagerIsMissing() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions + { + DisableAutomaticAuthorizationPruning = true, + DisableAutomaticSessionPruning = true, + TimeProvider = clock.Object + }; + + var scoped = new Mock(); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped.Object); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + + // Assert + await Assert.ThrowsAsync(async () => + await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System)); + scoped.Verify(provider => provider.GetService(typeof(IOpenIddictTokenManager)), Times.Once()); + } + + [Fact] + public async Task ExecuteAsync_FailsWhenAuthorizationManagerIsMissing() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions + { + DisableAutomaticTokenPruning = true, + DisableAutomaticSessionPruning = true, + TimeProvider = clock.Object + }; + + var scoped = new Mock(); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped.Object); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + + // Assert + await Assert.ThrowsAsync(async () => + await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System)); + scoped.Verify(provider => provider.GetService(typeof(IOpenIddictAuthorizationManager)), Times.Once()); + } + + [Fact] + public async Task ExecuteAsync_FailsWhenSessionManagerIsMissing() + { + // Arrange + var clock = new Mock { CallBase = true }; + var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + clock.Setup(clock => clock.CreateTimer(It.IsAny(), It.IsAny(), + It.IsAny(), It.IsAny())) + .CallBase().Callback(() => timer.TrySetResult()); + + var options = new OpenIddictCoreOptions + { + DisableAutomaticTokenPruning = true, + DisableAutomaticAuthorizationPruning = true, + TimeProvider = clock.Object + }; + + var scoped = new Mock(); + var scope = Mock.Of(scope => scope.ServiceProvider == scoped.Object); + var factory = Mock.Of(factory => factory.CreateScope() == scope); + var provider = Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); + var monitor = Mock.Of>(monitor => monitor.CurrentValue == options); + using var service = new OpenIddictCoreBackgroundService( + Mock.Of>(), monitor, provider); + + // Act + await service.StartAsync(CancellationToken.None); + await timer.Task.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System); + clock.Object.Advance(TimeSpan.FromMinutes(10)); + + // Assert + await Assert.ThrowsAsync(async () => + await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System)); + scoped.Verify(provider => provider.GetService(typeof(IOpenIddictSessionManager)), Times.Once()); + } +#endif +} diff --git a/test/OpenIddict.Core.Tests/OpenIddictCoreBuilderTests.cs b/test/OpenIddict.Core.Tests/OpenIddictCoreBuilderTests.cs index 762f5c63..facbc751 100644 --- a/test/OpenIddict.Core.Tests/OpenIddictCoreBuilderTests.cs +++ b/test/OpenIddict.Core.Tests/OpenIddictCoreBuilderTests.cs @@ -25,6 +25,122 @@ public class OpenIddictCoreBuilderTests Assert.Equal("services", exception.ParamName); } + [Fact] + public void Configure_DelegateIsCorrectlyRegistered() + { + // Arrange + var services = CreateServices(); + var builder = CreateBuilder(services); + var configuration = new Action(options => { }); + + // Act + builder.Configure(configuration); + + // Assert + Assert.Contains(services, service => service.ServiceType == typeof(IConfigureOptions) && + service.ImplementationInstance is ConfigureNamedOptions options && + options.Action == configuration && string.IsNullOrEmpty(options.Name)); + } + + [Fact] + public void Configure_ThrowsAnExceptionWhenConfigurationIsNull() + { + // Arrange + var builder = CreateBuilder(CreateServices()); + + // Act and assert + var exception = Assert.Throws(() => builder.Configure(configuration: null!)); + + Assert.Equal("configuration", exception.ParamName); + } + + [Fact] + public void DisableAutomaticAuthorizationPruning_AuthorizationPruningIsDisabled() + { + var services = CreateServices(); + CreateBuilder(services).DisableAutomaticAuthorizationPruning(); + + Assert.True(services.BuildServiceProvider().GetRequiredService>().Value.DisableAutomaticAuthorizationPruning); + } + + [Fact] + public void DisableAutomaticSessionPruning_SessionPruningIsDisabled() + { + var services = CreateServices(); + CreateBuilder(services).DisableAutomaticSessionPruning(); + + Assert.True(services.BuildServiceProvider().GetRequiredService>().Value.DisableAutomaticSessionPruning); + } + + [Fact] + public void DisableAutomaticTokenPruning_TokenPruningIsDisabled() + { + var services = CreateServices(); + CreateBuilder(services).DisableAutomaticTokenPruning(); + + Assert.True(services.BuildServiceProvider().GetRequiredService>().Value.DisableAutomaticTokenPruning); + } + + [Theory] + [InlineData(0)] + [InlineData(9)] + public void SetMinimumAuthorizationLifespan_ThrowsAnExceptionForInvalidLifespan(int minutes) + { + var exception = Assert.Throws(() => + CreateBuilder(CreateServices()).SetMinimumAuthorizationLifespan(TimeSpan.FromMinutes(minutes))); + + Assert.Equal("lifespan", exception.ParamName); + } + + [Theory] + [InlineData(0)] + [InlineData(9)] + public void SetMinimumSessionLifespan_ThrowsAnExceptionForInvalidLifespan(int minutes) + { + var exception = Assert.Throws(() => + CreateBuilder(CreateServices()).SetMinimumSessionLifespan(TimeSpan.FromMinutes(minutes))); + + Assert.Equal("lifespan", exception.ParamName); + } + + [Theory] + [InlineData(0)] + [InlineData(9)] + public void SetMinimumTokenLifespan_ThrowsAnExceptionForInvalidLifespan(int minutes) + { + var exception = Assert.Throws(() => + CreateBuilder(CreateServices()).SetMinimumTokenLifespan(TimeSpan.FromMinutes(minutes))); + + Assert.Equal("lifespan", exception.ParamName); + } + + [Fact] + public void SetMinimumAuthorizationLifespan_MinimumAuthorizationLifespanIsSet() + { + var services = CreateServices(); + CreateBuilder(services).SetMinimumAuthorizationLifespan(TimeSpan.FromDays(42)); + + Assert.Equal(TimeSpan.FromDays(42), services.BuildServiceProvider().GetRequiredService>().Value.MinimumAuthorizationLifespan); + } + + [Fact] + public void SetMinimumSessionLifespan_MinimumSessionLifespanIsSet() + { + var services = CreateServices(); + CreateBuilder(services).SetMinimumSessionLifespan(TimeSpan.FromDays(42)); + + Assert.Equal(TimeSpan.FromDays(42), services.BuildServiceProvider().GetRequiredService>().Value.MinimumSessionLifespan); + } + + [Fact] + public void SetMinimumTokenLifespan_MinimumTokenLifespanIsSet() + { + var services = CreateServices(); + CreateBuilder(services).SetMinimumTokenLifespan(TimeSpan.FromDays(42)); + + Assert.Equal(TimeSpan.FromDays(42), services.BuildServiceProvider().GetRequiredService>().Value.MinimumTokenLifespan); + } + [Fact] public void ReplaceApplicationManager_ThrowsAnExceptionForClosedSourceManager() { diff --git a/test/OpenIddict.Core.Tests/OpenIddictCoreExtensionsTests.cs b/test/OpenIddict.Core.Tests/OpenIddictCoreExtensionsTests.cs index 3a2c3ac4..c0af9484 100644 --- a/test/OpenIddict.Core.Tests/OpenIddictCoreExtensionsTests.cs +++ b/test/OpenIddict.Core.Tests/OpenIddictCoreExtensionsTests.cs @@ -5,6 +5,7 @@ */ using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; using Xunit; @@ -66,6 +67,41 @@ public class OpenIddictCoreExtensionsTests Assert.Contains(services, service => service.ServiceType == typeof(IOptions<>)); } + [Fact] + public void AddCore_RegistersBackgroundService() + { + // Arrange + var services = new ServiceCollection(); + + // Act + new OpenIddictBuilder(services).AddCore(); + + // Assert + Assert.Contains(services, service => service.ServiceType == typeof(IHostedService) && + service.ImplementationType == typeof(OpenIddictCoreBackgroundService) && + service.Lifetime is ServiceLifetime.Singleton); + } + + [Fact] + public void AddCore_CanBeSafelyInvokedMultipleTimes() + { + // Arrange + var services = new ServiceCollection(); + var builder = new OpenIddictBuilder(services); + + // Act + builder.AddCore(); + builder.AddCore(); + builder.AddCore(); + + // Assert + Assert.Single(services, service => service.ServiceType == typeof(IHostedService) && + service.ImplementationType == typeof(OpenIddictCoreBackgroundService)); + + Assert.Single(services, service => service.ServiceType == typeof(IPostConfigureOptions) && + service.ImplementationType == typeof(OpenIddictCoreConfiguration)); + } + [Theory] [InlineData(typeof(OpenIddictApplicationManager<>))] [InlineData(typeof(OpenIddictAuthorizationManager<>))] diff --git a/test/OpenIddict.Quartz.Tests/OpenIddict.Quartz.Tests.csproj b/test/OpenIddict.Quartz.Tests/OpenIddict.Quartz.Tests.csproj deleted file mode 100644 index aee54d13..00000000 --- a/test/OpenIddict.Quartz.Tests/OpenIddict.Quartz.Tests.csproj +++ /dev/null @@ -1,22 +0,0 @@ - - - - $(NetFrameworkTargetFrameworks);$(NetCoreTargetFrameworks) - - - - - - - - - - - - - - - - - - diff --git a/test/OpenIddict.Quartz.Tests/OpenIddictQuartzBuilderTests.cs b/test/OpenIddict.Quartz.Tests/OpenIddictQuartzBuilderTests.cs deleted file mode 100644 index 05d4bfef..00000000 --- a/test/OpenIddict.Quartz.Tests/OpenIddictQuartzBuilderTests.cs +++ /dev/null @@ -1,226 +0,0 @@ -using Microsoft.Extensions.DependencyInjection; -using Microsoft.Extensions.Options; -using Xunit; - -namespace OpenIddict.Quartz.Tests; - -public class OpenIddictQuartzBuilderTests -{ - [Fact] - public void Constructor_ThrowsAnExceptionForNullServices() - { - // Arrange - var services = (IServiceCollection) null!; - - // Act and assert - var exception = Assert.Throws(() => new OpenIddictQuartzBuilder(services)); - - Assert.Equal("services", exception.ParamName); - } - - [Fact] - public void Configure_DelegateIsCorrectlyRegistered() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - var configuration = new Action(options => { }); - - // Act - builder.Configure(configuration); - - // Assert - Assert.Contains(services, service => service.ServiceType == typeof(IConfigureOptions) && - service.ImplementationInstance is ConfigureNamedOptions options && - options.Action == configuration && string.IsNullOrEmpty(options.Name)); - } - - [Fact] - public void Configure_ThrowsAnExceptionWhenConfigurationIsNull() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - - // Act and assert - var exception = Assert.Throws(() => builder.Configure(configuration: null!)); - Assert.Equal("configuration", exception.ParamName); - } - - [Fact] - public void DisableAuthorizationPruning_AuthorizationPruningIsDisabled() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - - // Act - builder.DisableAuthorizationPruning(); - - var options = GetOptions(services); - - // Assert - Assert.True(options.DisableAuthorizationPruning); - } - - [Fact] - public void DisableSessionPruning_SessionPruningIsDisabled() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - - // Act - builder.DisableSessionPruning(); - - var options = GetOptions(services); - - // Assert - Assert.True(options.DisableSessionPruning); - } - - [Fact] - public void DisableTokenPruning_TokenPruningIsDisabled() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - - // Act - builder.DisableTokenPruning(); - - var options = GetOptions(services); - - // Assert - Assert.True(options.DisableTokenPruning); - } - - [Fact] - public void SetMaximumRefireCount_ThrowsAnExceptionForNegativeCount() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - - // Act and assert - var exception = Assert.Throws(() => builder.SetMaximumRefireCount(-1)); - - Assert.Equal("count", exception.ParamName); - } - - [Fact] - public void SetMaximumRefireCount_MaximumRefireCountIsSet() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - - // Act - builder.SetMaximumRefireCount(42); - - var options = GetOptions(services); - - // Assert - Assert.Equal(42, options.MaximumRefireCount); - } - - [Fact] - public void SetMinimumAuthorizationLifespan_ThrowsAnExceptionForNegativeLifespan() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - - // Act and assert - var exception = Assert.Throws(() => builder.SetMinimumAuthorizationLifespan(TimeSpan.FromSeconds(-1))); - - Assert.Equal("lifespan", exception.ParamName); - } - - [Fact] - public void SetMinimumAuthorizationLifespan_MinimumAuthorizationLifespanIsSet() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - - // Act - builder.SetMinimumAuthorizationLifespan(TimeSpan.FromDays(42)); - - var options = GetOptions(services); - - // Assert - Assert.Equal(42, options.MinimumAuthorizationLifespan.TotalDays); - } - - [Fact] - public void SetMinimumSessionLifespan_ThrowsAnExceptionForNegativeLifespan() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - - // Act and assert - var exception = Assert.Throws(() => builder.SetMinimumSessionLifespan(TimeSpan.FromSeconds(-1))); - - Assert.Equal("lifespan", exception.ParamName); - } - - [Fact] - public void SetMinimumSessionLifespan_MinimumSessionLifespanIsSet() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - - // Act - builder.SetMinimumSessionLifespan(TimeSpan.FromDays(42)); - - var options = GetOptions(services); - - // Assert - Assert.Equal(42, options.MinimumSessionLifespan.TotalDays); - } - - [Fact] - public void SetMinimumTokenLifespan_ThrowsAnExceptionForNegativeLifespan() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - - // Act and assert - var exception = Assert.Throws(() => builder.SetMinimumTokenLifespan(TimeSpan.FromSeconds(-1))); - - Assert.Equal("lifespan", exception.ParamName); - } - - [Fact] - public void SetMinimumTokenLifespan_MinimumTokenLifespanIsSet() - { - // Arrange - var services = CreateServices(); - var builder = CreateBuilder(services); - - // Act - builder.SetMinimumTokenLifespan(TimeSpan.FromDays(42)); - - var options = GetOptions(services); - - // Assert - Assert.Equal(42, options.MinimumTokenLifespan.TotalDays); - } - - private static IServiceCollection CreateServices() - => new ServiceCollection().AddOptions(); - - private static OpenIddictQuartzBuilder CreateBuilder(IServiceCollection services) - => new(services); - - private static OpenIddictQuartzOptions GetOptions(IServiceCollection services) - { - var provider = services.BuildServiceProvider(); - var options = provider.GetRequiredService>(); - return options.Value; - } -} diff --git a/test/OpenIddict.Quartz.Tests/OpenIddictQuartzExtensionsTests.cs b/test/OpenIddict.Quartz.Tests/OpenIddictQuartzExtensionsTests.cs deleted file mode 100644 index cbf5b173..00000000 --- a/test/OpenIddict.Quartz.Tests/OpenIddictQuartzExtensionsTests.cs +++ /dev/null @@ -1,75 +0,0 @@ -using Microsoft.Extensions.DependencyInjection; -using Microsoft.Extensions.Options; -using Xunit; - -namespace OpenIddict.Quartz.Tests; - -public class OpenIddictQuartzExtensionsTests -{ - [Fact] - public void UseQuartz_ThrowsAnExceptionForNullBuilder() - { - // Arrange - var builder = (OpenIddictCoreBuilder) null!; - - // Act and assert - var exception = Assert.Throws(builder.UseQuartz); - - Assert.Equal("builder", exception.ParamName); - } - - [Fact] - public void UseQuartz_ThrowsAnExceptionForNullConfiguration() - { - // Arrange - var services = new ServiceCollection(); - var builder = new OpenIddictCoreBuilder(services); - - // Act and assert - var exception = Assert.Throws(() => builder.UseQuartz(configuration: null!)); - - Assert.Equal("configuration", exception.ParamName); - } - - [Fact] - public void UseQuartz_RegistersJobService() - { - // Arrange - var services = new ServiceCollection(); - var builder = new OpenIddictCoreBuilder(services); - - // Act - builder.UseQuartz(); - - // Assert -#if NET - Assert.Contains(services, service => service.ServiceType == typeof(OpenIddictQuartzJob) && - service.ImplementationType == typeof(OpenIddictQuartzJob) && - service.Lifetime is ServiceLifetime.Scoped); -#else - Assert.Contains(services, service => service.ServiceType == typeof(OpenIddictQuartzJob) && - service.ImplementationType == typeof(OpenIddictQuartzJob) && - service.Lifetime is ServiceLifetime.Transient); -#endif - } - - [Fact] - public void UseQuartz_CanBeSafelyInvokedMultipleTimes() - { - // Arrange - var services = new ServiceCollection(); - var builder = new OpenIddictCoreBuilder(services); - - // Act - builder.UseQuartz(); - builder.UseQuartz(); - builder.UseQuartz(); - - // Assert - Assert.Single(services, service => service.ServiceType == typeof(OpenIddictQuartzJob) && - service.ImplementationType == typeof(OpenIddictQuartzJob)); - - Assert.Single(services, service => service.ServiceType == typeof(IPostConfigureOptions) && - service.ImplementationType == typeof(OpenIddictQuartzConfiguration)); - } -} diff --git a/test/OpenIddict.Quartz.Tests/OpenIddictQuartzJobTests.cs b/test/OpenIddict.Quartz.Tests/OpenIddictQuartzJobTests.cs deleted file mode 100644 index 7c93830b..00000000 --- a/test/OpenIddict.Quartz.Tests/OpenIddictQuartzJobTests.cs +++ /dev/null @@ -1,571 +0,0 @@ -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(() => new OpenIddictQuartzJob()); - - Assert.Equal(SR.GetResourceString(SR.ID0082), exception.Message); - } -#endif - - [Fact] - public async Task Execute_UsesServiceScope() - { - // Arrange - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - TimeProvider = TimeProvider.System - }); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of() && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var scope = Mock.Of(scope => scope.ServiceProvider == provider); - var factory = Mock.Of(factory => factory.CreateScope() == scope); - - var job = new OpenIddictQuartzJob(Mock.Of(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory)); - - // Act - await job.Execute(Mock.Of()); - - 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>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - DisableTokenPruning = true, - TimeProvider = TimeProvider.System - }); - - var manager = new Mock(); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var job = CreateJob(provider); - - // Act - await job.Execute(Mock.Of()); - - // Assert - manager.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Never()); - } - - [Fact] - public async Task Execute_IgnoresPruningWhenAuthorizationPruningIsDisabled() - { - // Arrange - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - DisableAuthorizationPruning = true, - TimeProvider = TimeProvider.System - }); - - var manager = new Mock(); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object && - provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of() && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var job = CreateJob(provider); - - // Act - await job.Execute(Mock.Of()); - - // Assert - manager.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Never()); - } - - [Fact] - public async Task Execute_IgnoresPruningWhenSessionPruningIsDisabled() - { - // Arrange - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - DisableSessionPruning = true, - TimeProvider = TimeProvider.System - }); - - var manager = new Mock(); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object && - provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of() && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var job = CreateJob(provider); - - // Act - await job.Execute(Mock.Of()); - - // Assert - manager.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Never()); - } - - [Fact] - public async Task Execute_UnschedulesTriggersWhenTokenManagerIsMissing() - { - // Arrange - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - TimeProvider = TimeProvider.System - }); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictTokenManager)) == null && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var job = CreateJob(provider); - - // Act and assert - var exception = await Assert.ThrowsAsync(async () => - await job.Execute(Mock.Of())); - - Assert.False(exception.RefireImmediately); - Assert.True(exception.UnscheduleAllTriggers); - Assert.True(exception.UnscheduleFiringTrigger); - - Assert.IsType(exception.InnerException); - Assert.Equal(SR.GetResourceString(SR.ID0278), exception.InnerException!.Message); - } - - [Fact] - public async Task Execute_UnschedulesTriggersWhenAuthorizationManagerIsMissing() - { - // Arrange - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - TimeProvider = TimeProvider.System - }); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == null && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var job = CreateJob(provider); - - // Act and assert - var exception = await Assert.ThrowsAsync(async () => - await job.Execute(Mock.Of())); - - Assert.False(exception.RefireImmediately); - Assert.True(exception.UnscheduleAllTriggers); - Assert.True(exception.UnscheduleFiringTrigger); - - Assert.IsType(exception.InnerException); - Assert.Equal(SR.GetResourceString(SR.ID0278), exception.InnerException!.Message); - } - - [Fact] - public async Task Execute_UnschedulesTriggersWhenSessionManagerIsMissing() - { - // Arrange - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - TimeProvider = TimeProvider.System - }); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictSessionManager)) == null && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var job = CreateJob(provider); - - // Act and assert - var exception = await Assert.ThrowsAsync(async () => - await job.Execute(Mock.Of())); - - Assert.False(exception.RefireImmediately); - Assert.True(exception.UnscheduleAllTriggers); - Assert.True(exception.UnscheduleFiringTrigger); - - Assert.IsType(exception.InnerException); - Assert.Equal(SR.GetResourceString(SR.ID0278), exception.InnerException!.Message); - } - - [Fact] - public async Task Execute_RethrowsOutOfMemoryExceptionsThrownDuringTokenPruning() - { - // Arrange - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - TimeProvider = TimeProvider.System - }); - - var manager = new Mock(); - manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(new OutOfMemoryException()); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var job = CreateJob(provider); - - // Act and assert - await Assert.ThrowsAsync(async () => await job.Execute(Mock.Of())); - } - - [Fact] - public async Task Execute_RethrowsOutOfMemoryExceptionsThrownDuringAuthorizationPruning() - { - // Arrange - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - TimeProvider = TimeProvider.System - }); - - var manager = new Mock(); - manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(new OutOfMemoryException()); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object && - provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of() && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var job = CreateJob(provider); - - // Act and assert - await Assert.ThrowsAsync(async () => await job.Execute(Mock.Of())); - } - - [Fact] - public async Task Execute_RethrowsOutOfMemoryExceptionsThrownDuringSessionPruning() - { - // Arrange - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - TimeProvider = TimeProvider.System - }); - - var manager = new Mock(); - manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(new OutOfMemoryException()); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var job = CreateJob(provider); - - // Act and assert - await Assert.ThrowsAsync(async () => await job.Execute(Mock.Of())); - } - - [Fact] - public async Task Execute_DisablesRefiringWhenJobIsCanceledDuringTokenPruning() - { - // Arrange - var token = new CancellationToken(canceled: true); - - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - TimeProvider = TimeProvider.System - }); - - var manager = new Mock(); - manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(new OperationCanceledException(token)); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var context = Mock.Of(context => context.CancellationToken == token); - - var job = CreateJob(provider); - - // Act and assert - var exception = await Assert.ThrowsAsync(async () => await job.Execute(context)); - - Assert.False(exception.RefireImmediately); - - manager.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); - } - - [Fact] - public async Task Execute_DisablesRefiringWhenJobIsCanceledDuringAuthorizationPruning() - { - // Arrange - var token = new CancellationToken(canceled: true); - - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - TimeProvider = TimeProvider.System - }); - - var manager = new Mock(); - manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(new OperationCanceledException(token)); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object && - provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of() && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var context = Mock.Of(context => context.CancellationToken == token); - - var job = CreateJob(provider); - - // Act and assert - var exception = await Assert.ThrowsAsync(async () => await job.Execute(context)); - - Assert.False(exception.RefireImmediately); - - manager.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); - } - - [Fact] - public async Task Execute_DisablesRefiringWhenJobIsCanceledDuringSessionPruning() - { - // Arrange - var token = new CancellationToken(canceled: true); - - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - TimeProvider = TimeProvider.System - }); - - var manager = new Mock(); - manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(new OperationCanceledException(token)); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var context = Mock.Of(context => context.CancellationToken == token); - - var job = CreateJob(provider); - - // Act and assert - var exception = await Assert.ThrowsAsync(async () => await job.Execute(context)); - - Assert.False(exception.RefireImmediately); - - manager.Verify(manager => manager.PruneAsync(It.IsAny(), It.IsAny()), Times.Once()); - } - - [Fact] - public async Task Execute_AllowsRefiringWhenExceptionsAreThrown() - { - // Arrange - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - TimeProvider = TimeProvider.System - }); - - var provider = new Mock(); - 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))) - .Returns(monitor); - - var context = Mock.Of(context => context.RefireCount == 0); - - var job = CreateJob(provider.Object); - - // Act and assert - var exception = await Assert.ThrowsAsync(async () => await job.Execute(context)); - - Assert.True(exception.RefireImmediately); - Assert.IsType(exception.InnerException); - Assert.Equal(3, ((AggregateException) exception.InnerException!).InnerExceptions.Count); - Assert.IsType(((AggregateException) exception.InnerException!).InnerExceptions[0]); - Assert.IsType(((AggregateException) exception.InnerException!).InnerExceptions[1]); - Assert.IsType(((AggregateException) exception.InnerException!).InnerExceptions[2]); - - static IOpenIddictAuthorizationManager CreateAuthorizationManager(Exception exception) - { - var mock = new Mock(); - mock.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(exception); - - return mock.Object; - } - - static IOpenIddictSessionManager CreateSessionManager(Exception exception) - { - var mock = new Mock(); - mock.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(exception); - - return mock.Object; - } - - static IOpenIddictTokenManager CreateTokenManager(Exception exception) - { - var mock = new Mock(); - mock.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(exception); - - return mock.Object; - } - } - - [Fact] - public async Task Execute_AllowsRefiringWhenAggregateExceptionsAreThrown() - { - // Arrange - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - TimeProvider = TimeProvider.System - }); - - var provider = new Mock(); - 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))) - .Returns(monitor); - - var context = Mock.Of(context => context.RefireCount == 0); - - var job = CreateJob(provider.Object); - - // Act and assert - var exception = await Assert.ThrowsAsync(async () => await job.Execute(context)); - - Assert.True(exception.RefireImmediately); - Assert.IsType(exception.InnerException); - Assert.Equal(6, ((AggregateException) exception.InnerException!).InnerExceptions.Count); - Assert.IsType(((AggregateException) exception.InnerException!).InnerExceptions[0]); - Assert.IsType(((AggregateException) exception.InnerException!).InnerExceptions[1]); - Assert.IsType(((AggregateException) exception.InnerException!).InnerExceptions[2]); - Assert.IsType(((AggregateException) exception.InnerException!).InnerExceptions[3]); - Assert.IsType(((AggregateException) exception.InnerException!).InnerExceptions[4]); - Assert.IsType(((AggregateException) exception.InnerException!).InnerExceptions[5]); - - static IOpenIddictAuthorizationManager CreateAuthorizationManager(Exception exception) - { - var mock = new Mock(); - mock.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(exception); - - return mock.Object; - } - - static IOpenIddictSessionManager CreateSessionManager(Exception exception) - { - var mock = new Mock(); - mock.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(exception); - - return mock.Object; - } - - static IOpenIddictTokenManager CreateTokenManager(Exception exception) - { - var mock = new Mock(); - mock.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(exception); - - return mock.Object; - } - } - - [Fact] - public async Task Execute_DisallowsRefiringWhenMaximumRefireCountIsReached() - { - // Arrange - var monitor = Mock.Of>( - monitor => monitor.CurrentValue == new OpenIddictQuartzOptions - { - MaximumRefireCount = 5, - TimeProvider = TimeProvider.System - }); - - var manager = new Mock(); - manager.Setup(manager => manager.PruneAsync(It.IsAny(), It.IsAny())) - .Throws(new ApplicationException()); - - var provider = Mock.Of(provider => - provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object && - provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of() && - provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of() && - provider.GetService(typeof(IOptionsMonitor)) == monitor); - - var context = Mock.Of(context => context.RefireCount == 5); - - var job = CreateJob(provider); - - // Act and assert - var exception = await Assert.ThrowsAsync(async () => await job.Execute(context)); - - Assert.False(exception.RefireImmediately); - } - - private static OpenIddictQuartzJob CreateJob(IServiceProvider provider) - { - var scope = Mock.Of(scope => scope.ServiceProvider == provider); - var factory = Mock.Of(factory => factory.CreateScope() == scope); - - return new OpenIddictQuartzJob(Mock.Of(provider => - provider.GetService(typeof(IServiceScopeFactory)) == factory)); - } -}