28 changed files with 1285 additions and 1520 deletions
@ -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; |
|||
|
|||
/// <summary>
|
|||
/// Represents a hosted service performing background tasks for OpenIddict.
|
|||
/// </summary>
|
|||
[EditorBrowsable(EditorBrowsableState.Never)] |
|||
public sealed class OpenIddictCoreBackgroundService : BackgroundService |
|||
{ |
|||
private readonly ILogger<OpenIddictCoreBackgroundService> _logger; |
|||
private readonly IOptionsMonitor<OpenIddictCoreOptions> _options; |
|||
private readonly IServiceProvider _provider; |
|||
|
|||
/// <summary>
|
|||
/// Creates a new instance of the <see cref="OpenIddictCoreBackgroundService"/> class.
|
|||
/// </summary>
|
|||
/// <param name="logger">The logger.</param>
|
|||
/// <param name="options">The OpenIddict core options.</param>
|
|||
/// <param name="provider">The service provider.</param>
|
|||
public OpenIddictCoreBackgroundService( |
|||
ILogger<OpenIddictCoreBackgroundService> logger, |
|||
IOptionsMonitor<OpenIddictCoreOptions> options, |
|||
IServiceProvider provider) |
|||
{ |
|||
_logger = logger ?? throw new ArgumentNullException(nameof(logger)); |
|||
_options = options ?? throw new ArgumentNullException(nameof(options)); |
|||
_provider = provider ?? throw new ArgumentNullException(nameof(provider)); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
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<IOpenIddictTokenManager>(); |
|||
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<IOpenIddictAuthorizationManager>(); |
|||
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<IOpenIddictSessionManager>(); |
|||
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)); |
|||
} |
|||
} |
|||
@ -1,31 +0,0 @@ |
|||
<Project Sdk="Microsoft.NET.Sdk"> |
|||
|
|||
<PropertyGroup> |
|||
<TargetFrameworks>$(NetFrameworkTargetFrameworks);$(NetCoreTargetFrameworks)</TargetFrameworks> |
|||
</PropertyGroup> |
|||
|
|||
<PropertyGroup> |
|||
<Description>Quartz.NET integration package for OpenIddict.</Description> |
|||
<PackageTags>$(PackageTags);quartz</PackageTags> |
|||
</PropertyGroup> |
|||
|
|||
<ItemGroup> |
|||
<ProjectReference Include="..\OpenIddict.Core\OpenIddict.Core.csproj" /> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup> |
|||
<PackageReference Include="Quartz" /> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup Condition=" '$(TargetFrameworkIdentifier)' == '.NETFramework' "> |
|||
<PackageReference Include="Quartz.Extensions.DependencyInjection" /> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup> |
|||
<Using Include="OpenIddict.Abstractions" /> |
|||
<Using Include="OpenIddict.Abstractions.OpenIddictConstants" Static="true" /> |
|||
<Using Include="OpenIddict.Abstractions.OpenIddictResources" Alias="SR" /> |
|||
<Using Include="Quartz" /> |
|||
</ItemGroup> |
|||
|
|||
</Project> |
|||
@ -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; |
|||
|
|||
/// <summary>
|
|||
/// Exposes the necessary methods required to configure the OpenIddict Quartz.NET integration.
|
|||
/// </summary>
|
|||
public sealed class OpenIddictQuartzBuilder |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of <see cref="OpenIddictQuartzBuilder"/>.
|
|||
/// </summary>
|
|||
/// <param name="services">The services collection.</param>
|
|||
public OpenIddictQuartzBuilder(IServiceCollection services) |
|||
=> Services = services ?? throw new ArgumentNullException(nameof(services)); |
|||
|
|||
/// <summary>
|
|||
/// Gets the services collection.
|
|||
/// </summary>
|
|||
[EditorBrowsable(EditorBrowsableState.Never)] |
|||
public IServiceCollection Services { get; } |
|||
|
|||
/// <summary>
|
|||
/// Enables validation of options during application startup.
|
|||
/// </summary>
|
|||
/// <returns>The <see cref="OpenIddictQuartzBuilder"/> instance.</returns>
|
|||
public OpenIddictQuartzBuilder ValidateOnStart() |
|||
{ |
|||
Services.AddOptionsWithValidateOnStart<OpenIddictQuartzOptions>(); |
|||
|
|||
return this; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Amends the default OpenIddict Quartz.NET configuration.
|
|||
/// </summary>
|
|||
/// <param name="configuration">The delegate used to configure the OpenIddict options.</param>
|
|||
/// <remarks>This extension can be safely called multiple times.</remarks>
|
|||
/// <returns>The <see cref="OpenIddictQuartzBuilder"/> instance.</returns>
|
|||
[EditorBrowsable(EditorBrowsableState.Advanced)] |
|||
public OpenIddictQuartzBuilder Configure(Action<OpenIddictQuartzOptions> configuration) |
|||
{ |
|||
ArgumentNullException.ThrowIfNull(configuration); |
|||
|
|||
Services.Configure(configuration); |
|||
|
|||
return this; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Disables authorizations pruning.
|
|||
/// </summary>
|
|||
/// <returns>The <see cref="OpenIddictQuartzBuilder"/> instance.</returns>
|
|||
public OpenIddictQuartzBuilder DisableAuthorizationPruning() |
|||
=> Configure(options => options.DisableAuthorizationPruning = true); |
|||
|
|||
/// <summary>
|
|||
/// Disables sessions pruning.
|
|||
/// </summary>
|
|||
/// <returns>The <see cref="OpenIddictQuartzBuilder"/> instance.</returns>
|
|||
public OpenIddictQuartzBuilder DisableSessionPruning() |
|||
=> Configure(options => options.DisableSessionPruning = true); |
|||
|
|||
/// <summary>
|
|||
/// Disables tokens pruning.
|
|||
/// </summary>
|
|||
/// <returns>The <see cref="OpenIddictQuartzBuilder"/> instance.</returns>
|
|||
public OpenIddictQuartzBuilder DisableTokenPruning() |
|||
=> Configure(options => options.DisableTokenPruning = true); |
|||
|
|||
/// <summary>
|
|||
/// Sets the number of times a failed Quartz.NET job can be retried.
|
|||
/// </summary>
|
|||
/// <param name="count">The number of times a failed Quartz.NET job can be retried.</param>
|
|||
/// <returns>The <see cref="OpenIddictQuartzBuilder"/> instance.</returns>
|
|||
public OpenIddictQuartzBuilder SetMaximumRefireCount(int count) |
|||
{ |
|||
ArgumentOutOfRangeException.ThrowIfNegative(count); |
|||
|
|||
return Configure(options => options.MaximumRefireCount = count); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the minimum lifespan authorizations must have to be pruned.
|
|||
/// </summary>
|
|||
/// <param name="lifespan">The minimum lifespan authorizations must have to be pruned.</param>
|
|||
/// <returns>The <see cref="OpenIddictQuartzBuilder"/> instance.</returns>
|
|||
public OpenIddictQuartzBuilder SetMinimumAuthorizationLifespan(TimeSpan lifespan) |
|||
{ |
|||
ArgumentOutOfRangeException.ThrowIfLessThan(lifespan, TimeSpan.FromMinutes(10)); |
|||
|
|||
return Configure(options => options.MinimumAuthorizationLifespan = lifespan); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the minimum lifespan sessions must have to be pruned.
|
|||
/// </summary>
|
|||
/// <param name="lifespan">The minimum lifespan sessions must have to be pruned.</param>
|
|||
/// <returns>The <see cref="OpenIddictQuartzBuilder"/> instance.</returns>
|
|||
public OpenIddictQuartzBuilder SetMinimumSessionLifespan(TimeSpan lifespan) |
|||
{ |
|||
ArgumentOutOfRangeException.ThrowIfLessThan(lifespan, TimeSpan.FromMinutes(10)); |
|||
|
|||
return Configure(options => options.MinimumSessionLifespan = lifespan); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the minimum lifespan tokens must have to be pruned.
|
|||
/// </summary>
|
|||
/// <param name="lifespan">The minimum lifespan tokens must have to be pruned.</param>
|
|||
/// <returns>The <see cref="OpenIddictQuartzBuilder"/> instance.</returns>
|
|||
public OpenIddictQuartzBuilder SetMinimumTokenLifespan(TimeSpan lifespan) |
|||
{ |
|||
ArgumentOutOfRangeException.ThrowIfLessThan(lifespan, TimeSpan.FromMinutes(10)); |
|||
|
|||
return Configure(options => options.MinimumTokenLifespan = lifespan); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
[EditorBrowsable(EditorBrowsableState.Never)] |
|||
public override bool Equals([NotNullWhen(true)] object? obj) => base.Equals(obj); |
|||
|
|||
/// <inheritdoc/>
|
|||
[EditorBrowsable(EditorBrowsableState.Never)] |
|||
public override int GetHashCode() => base.GetHashCode(); |
|||
|
|||
/// <inheritdoc/>
|
|||
[EditorBrowsable(EditorBrowsableState.Never)] |
|||
public override string? ToString() => base.ToString(); |
|||
} |
|||
@ -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; |
|||
|
|||
/// <summary>
|
|||
/// Contains the methods required to ensure that the OpenIddict Quartz.NET configuration is valid.
|
|||
/// </summary>
|
|||
[EditorBrowsable(EditorBrowsableState.Advanced)] |
|||
public sealed class OpenIddictQuartzConfiguration : IPostConfigureOptions<OpenIddictQuartzOptions> |
|||
{ |
|||
private readonly IServiceProvider _provider; |
|||
|
|||
/// <summary>
|
|||
/// Creates a new instance of the <see cref="OpenIddictQuartzConfiguration"/> class.
|
|||
/// </summary>
|
|||
/// <param name="provider">The service provider.</param>
|
|||
public OpenIddictQuartzConfiguration(IServiceProvider provider) |
|||
=> _provider = provider ?? throw new ArgumentNullException(nameof(provider)); |
|||
|
|||
/// <inheritdoc/>
|
|||
public void PostConfigure(string? name, OpenIddictQuartzOptions options) |
|||
{ |
|||
ArgumentNullException.ThrowIfNull(options); |
|||
|
|||
options.TimeProvider ??= _provider.GetService<TimeProvider>() ?? TimeProvider.System; |
|||
} |
|||
} |
|||
@ -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; |
|||
|
|||
/// <summary>
|
|||
/// Exposes extensions allowing to register the OpenIddict Quartz.NET integration.
|
|||
/// </summary>
|
|||
public static class OpenIddictQuartzExtensions |
|||
{ |
|||
/// <summary>
|
|||
/// Registers the OpenIddict Quartz.NET integration in the DI container.
|
|||
/// </summary>
|
|||
/// <param name="builder">The services builder used by OpenIddict to register new services.</param>
|
|||
/// <remarks>This extension can be safely called multiple times.</remarks>
|
|||
/// <returns>The <see cref="OpenIddictQuartzBuilder"/> instance.</returns>
|
|||
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<OpenIddictQuartzJob>(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<OpenIddictQuartzJob>(); |
|||
#endif
|
|||
|
|||
// Note: TryAddEnumerable() is used here to ensure the initializer is registered only once.
|
|||
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton< |
|||
IPostConfigureOptions<OpenIddictQuartzOptions>, OpenIddictQuartzConfiguration>()); |
|||
|
|||
return new OpenIddictQuartzBuilder(builder.Services); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Registers the OpenIddict Quartz.NET integration in the DI container.
|
|||
/// </summary>
|
|||
/// <param name="builder">The services builder used by OpenIddict to register new services.</param>
|
|||
/// <param name="configuration">The configuration delegate used to configure the Quartz.NET services.</param>
|
|||
/// <remarks>This extension can be safely called multiple times.</remarks>
|
|||
/// <returns>The <see cref="OpenIddictCoreBuilder"/> instance.</returns>
|
|||
public static OpenIddictCoreBuilder UseQuartz( |
|||
this OpenIddictCoreBuilder builder, Action<OpenIddictQuartzBuilder> configuration) |
|||
{ |
|||
ArgumentNullException.ThrowIfNull(builder); |
|||
ArgumentNullException.ThrowIfNull(configuration); |
|||
|
|||
configuration(builder.UseQuartz()); |
|||
|
|||
return builder; |
|||
} |
|||
} |
|||
@ -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; |
|||
|
|||
/// <summary>
|
|||
/// Represents a Quartz.NET job performing scheduled tasks for OpenIddict.
|
|||
/// </summary>
|
|||
[DisallowConcurrentExecution, EditorBrowsable(EditorBrowsableState.Advanced)] |
|||
public sealed class OpenIddictQuartzJob : IJob |
|||
{ |
|||
private readonly IServiceProvider _provider; |
|||
|
|||
#if !NET
|
|||
/// <summary>
|
|||
/// Creates a new instance of the <see cref="OpenIddictQuartzJob"/> class.
|
|||
/// </summary>
|
|||
public OpenIddictQuartzJob() => throw new InvalidOperationException(SR.GetResourceString(SR.ID0082)); |
|||
#endif
|
|||
|
|||
/// <summary>
|
|||
/// Creates a new instance of the <see cref="OpenIddictQuartzJob"/> class.
|
|||
/// </summary>
|
|||
/// <param name="provider">The service provider.</param>
|
|||
public OpenIddictQuartzJob(IServiceProvider provider) |
|||
=> _provider = provider ?? throw new ArgumentNullException(nameof(provider)); |
|||
|
|||
/// <summary>
|
|||
/// Gets the default identity assigned to this job.
|
|||
/// </summary>
|
|||
public static JobKey Identity { get; } = new JobKey( |
|||
name: SR.GetResourceString(SR.ID8003), |
|||
group: SR.GetResourceString(SR.ID8005)); |
|||
|
|||
/// <inheritdoc/>
|
|||
#if NET
|
|||
public async ValueTask Execute(IJobExecutionContext context, CancellationToken cancellationToken = default) |
|||
#else
|
|||
public async Task Execute(IJobExecutionContext context) |
|||
#endif
|
|||
{ |
|||
ArgumentNullException.ThrowIfNull(context); |
|||
|
|||
List<Exception>? exceptions = null; |
|||
|
|||
await using var scope = _provider.CreateAsyncScope(); |
|||
|
|||
var options = scope.ServiceProvider.GetRequiredService<IOptionsMonitor<OpenIddictQuartzOptions>>().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<IOpenIddictTokenManager>() |
|||
?? 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<Exception>(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<Exception>(capacity: 1); |
|||
exceptions.Add(exception); |
|||
} |
|||
} |
|||
|
|||
if (!options.DisableAuthorizationPruning) |
|||
{ |
|||
var manager = scope.ServiceProvider.GetService<IOpenIddictAuthorizationManager>() |
|||
?? 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<Exception>(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<Exception>(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<IOpenIddictSessionManager>() |
|||
?? 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<Exception>(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<Exception>(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 |
|||
}; |
|||
} |
|||
} |
|||
} |
|||
@ -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; |
|||
|
|||
/// <summary>
|
|||
/// Provides various settings needed to configure the OpenIddict Quartz.NET integration.
|
|||
/// </summary>
|
|||
public sealed class OpenIddictQuartzOptions |
|||
{ |
|||
/// <summary>
|
|||
/// Gets or sets a boolean indicating whether authorizations pruning should be disabled.
|
|||
/// </summary>
|
|||
public bool DisableAuthorizationPruning { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets a boolean indicating whether sessions pruning should be disabled.
|
|||
/// </summary>
|
|||
public bool DisableSessionPruning { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets a boolean indicating whether tokens pruning should be disabled.
|
|||
/// </summary>
|
|||
public bool DisableTokenPruning { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
public int MaximumRefireCount { get; set; } = 2; |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
public TimeSpan MinimumAuthorizationLifespan { get; set; } = TimeSpan.FromDays(14); |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
public TimeSpan MinimumSessionLifespan { get; set; } = TimeSpan.FromDays(14); |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
public TimeSpan MinimumTokenLifespan { get; set; } = TimeSpan.FromDays(14); |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the time provider.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// 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, <see cref="TimeProvider.System"/> is used.
|
|||
/// </remarks>
|
|||
public TimeProvider TimeProvider { get; set; } = default!; |
|||
} |
|||
@ -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<ArgumentNullException>(() => new OpenIddictCoreBackgroundService( |
|||
parameter is "logger" ? null! : Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), |
|||
parameter is "options" ? null! : Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(), |
|||
parameter is "provider" ? null! : Mock.Of<IServiceProvider>())); |
|||
|
|||
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<IServiceScopeFactory>(); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory.Object); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
var options = new OpenIddictCoreOptions { TimeProvider = clock.Object }; |
|||
var scope = new Mock<IServiceScope>(); |
|||
var factory = new Mock<IServiceScopeFactory>(); |
|||
var manager = new Mock<IOpenIddictSessionManager>(); |
|||
var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Callback(() => completion.SetResult()).Returns(new ValueTask<long>(0)); |
|||
var scoped = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() && |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() && |
|||
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<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory.Object); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions |
|||
{ |
|||
DisableAutomaticTokenPruning = true, |
|||
TimeProvider = clock.Object |
|||
}; |
|||
|
|||
var tokens = new Mock<IOpenIddictTokenManager>(); |
|||
var authorizations = new Mock<IOpenIddictAuthorizationManager>(); |
|||
var sessions = new Mock<IOpenIddictSessionManager>(); |
|||
var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
|
|||
sessions.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Callback(() => completion.SetResult()).Returns(new ValueTask<long>(0)); |
|||
|
|||
var scoped = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Never()); |
|||
authorizations.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
sessions.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_SkipsAuthorizationPruningWhenDisabled() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions |
|||
{ |
|||
DisableAutomaticAuthorizationPruning = true, |
|||
TimeProvider = clock.Object |
|||
}; |
|||
|
|||
var tokens = new Mock<IOpenIddictTokenManager>(); |
|||
var authorizations = new Mock<IOpenIddictAuthorizationManager>(); |
|||
var sessions = new Mock<IOpenIddictSessionManager>(); |
|||
var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
|
|||
sessions.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Callback(() => completion.SetResult()).Returns(new ValueTask<long>(0)); |
|||
|
|||
var scoped = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
authorizations.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Never()); |
|||
sessions.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_SkipsSessionPruningWhenDisabled() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions |
|||
{ |
|||
DisableAutomaticSessionPruning = true, |
|||
TimeProvider = clock.Object |
|||
}; |
|||
|
|||
var tokens = new Mock<IOpenIddictTokenManager>(); |
|||
var authorizations = new Mock<IOpenIddictAuthorizationManager>(); |
|||
var sessions = new Mock<IOpenIddictSessionManager>(); |
|||
var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
|
|||
authorizations.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Callback(() => completion.SetResult()).Returns(new ValueTask<long>(0)); |
|||
|
|||
var scoped = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
authorizations.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
sessions.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Never()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_PrunesTokensBeforeAuthorizationsAndSessionsUsingConfiguredThresholds() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.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<IOpenIddictTokenManager>(); |
|||
var authorizations = new Mock<IOpenIddictAuthorizationManager>(); |
|||
var sessions = new Mock<IOpenIddictSessionManager>(); |
|||
var calls = new List<string>(); |
|||
var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
tokens.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Callback<DateTimeOffset, CancellationToken>((date, _) => |
|||
{ |
|||
Assert.Equal(options.TimeProvider.GetUtcNow() - options.MinimumTokenLifespan, date); |
|||
calls.Add("token"); |
|||
}).Returns(new ValueTask<long>(0)); |
|||
authorizations.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Callback<DateTimeOffset, CancellationToken>((date, _) => |
|||
{ |
|||
Assert.Equal(options.TimeProvider.GetUtcNow() - options.MinimumAuthorizationLifespan, date); |
|||
calls.Add("authorization"); |
|||
}).Returns(new ValueTask<long>(0)); |
|||
sessions.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Callback<DateTimeOffset, CancellationToken>((date, _) => |
|||
{ |
|||
Assert.Equal(options.TimeProvider.GetUtcNow() - options.MinimumSessionLifespan, date); |
|||
calls.Add("session"); |
|||
completion.SetResult(); |
|||
}).Returns(new ValueTask<long>(0)); |
|||
var scoped = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
var options = new OpenIddictCoreOptions { TimeProvider = clock.Object }; |
|||
options.DisableAutomaticAuthorizationPruning = true; |
|||
options.DisableAutomaticSessionPruning = true; |
|||
var tokens = new Mock<IOpenIddictTokenManager>(); |
|||
var first = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
var second = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
var count = 0; |
|||
tokens.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Callback(() => (Interlocked.Increment(ref count) is 1 ? first : second).SetResult()) |
|||
.Returns(new ValueTask<long>(0)); |
|||
var factory = new Mock<IServiceScopeFactory>(); |
|||
factory.Setup(factory => factory.CreateScope()) |
|||
.Returns(() => Mock.Of<IServiceScope>(scope => scope.ServiceProvider == |
|||
Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object))); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory.Object); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<DateTimeOffset>(), It.IsAny<CancellationToken>()), |
|||
Times.Exactly(2)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_LogsNonFatalTokenPruningErrorsAndContinues() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions { TimeProvider = clock.Object }; |
|||
var tokens = new Mock<IOpenIddictTokenManager>(); |
|||
var authorizations = new Mock<IOpenIddictAuthorizationManager>(); |
|||
var sessions = new Mock<IOpenIddictSessionManager>(); |
|||
var logger = new Mock<ILogger<OpenIddictCoreBackgroundService>>(); |
|||
var error = new ApplicationException(); |
|||
var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
|
|||
tokens.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(error); |
|||
sessions.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Callback(() => completion.SetResult()).Returns(new ValueTask<long>(0)); |
|||
|
|||
var scoped = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(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<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
sessions.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_LogsNonFatalAuthorizationPruningErrorsAndContinues() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions { TimeProvider = clock.Object }; |
|||
var tokens = new Mock<IOpenIddictTokenManager>(); |
|||
var authorizations = new Mock<IOpenIddictAuthorizationManager>(); |
|||
var sessions = new Mock<IOpenIddictSessionManager>(); |
|||
var logger = new Mock<ILogger<OpenIddictCoreBackgroundService>>(); |
|||
var error = new ApplicationException(); |
|||
var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
|
|||
authorizations.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(error); |
|||
sessions.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Callback(() => completion.SetResult()).Returns(new ValueTask<long>(0)); |
|||
|
|||
var scoped = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(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<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_LogsNonFatalSessionPruningErrorsAndContinues() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions { TimeProvider = clock.Object }; |
|||
var tokens = new Mock<IOpenIddictTokenManager>(); |
|||
var authorizations = new Mock<IOpenIddictAuthorizationManager>(); |
|||
var sessions = new Mock<IOpenIddictSessionManager>(); |
|||
var logger = new Mock<ILogger<OpenIddictCoreBackgroundService>>(); |
|||
var error = new ApplicationException(); |
|||
var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
|
|||
sessions.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Callback(() => completion.SetResult()).Throws(error); |
|||
|
|||
var scoped = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == tokens.Object && |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == authorizations.Object && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == sessions.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(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<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_RethrowsOutOfMemoryExceptionsThrownDuringTokenPruning() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions |
|||
{ |
|||
DisableAutomaticAuthorizationPruning = true, |
|||
DisableAutomaticSessionPruning = true, |
|||
TimeProvider = clock.Object |
|||
}; |
|||
|
|||
var manager = new Mock<IOpenIddictTokenManager>(); |
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(new OutOfMemoryException()); |
|||
|
|||
var scoped = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<OutOfMemoryException>(async () => |
|||
await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_RethrowsOutOfMemoryExceptionsThrownDuringAuthorizationPruning() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions |
|||
{ |
|||
DisableAutomaticTokenPruning = true, |
|||
DisableAutomaticSessionPruning = true, |
|||
TimeProvider = clock.Object |
|||
}; |
|||
|
|||
var manager = new Mock<IOpenIddictAuthorizationManager>(); |
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(new OutOfMemoryException()); |
|||
|
|||
var scoped = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<OutOfMemoryException>(async () => |
|||
await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_RethrowsOutOfMemoryExceptionsThrownDuringSessionPruning() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions |
|||
{ |
|||
DisableAutomaticTokenPruning = true, |
|||
DisableAutomaticAuthorizationPruning = true, |
|||
TimeProvider = clock.Object |
|||
}; |
|||
|
|||
var manager = new Mock<IOpenIddictSessionManager>(); |
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(new OutOfMemoryException()); |
|||
|
|||
var scoped = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<OutOfMemoryException>(async () => |
|||
await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System)); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_StopsWhenTokenPruningIsCanceled() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions |
|||
{ |
|||
DisableAutomaticAuthorizationPruning = true, |
|||
DisableAutomaticSessionPruning = true, |
|||
TimeProvider = clock.Object |
|||
}; |
|||
|
|||
var manager = new Mock<IOpenIddictTokenManager>(); |
|||
var started = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
var canceled = new TaskCompletionSource<long>(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
|
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Returns((DateTimeOffset _, CancellationToken token) => |
|||
{ |
|||
token.Register(() => canceled.TrySetCanceled(token)); |
|||
started.SetResult(); |
|||
return new ValueTask<long>(canceled.Task); |
|||
}); |
|||
|
|||
var scoped = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_StopsWhenAuthorizationPruningIsCanceled() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions |
|||
{ |
|||
DisableAutomaticTokenPruning = true, |
|||
DisableAutomaticSessionPruning = true, |
|||
TimeProvider = clock.Object |
|||
}; |
|||
|
|||
var manager = new Mock<IOpenIddictAuthorizationManager>(); |
|||
var started = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
var canceled = new TaskCompletionSource<long>(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
|
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Returns((DateTimeOffset _, CancellationToken token) => |
|||
{ |
|||
token.Register(() => canceled.TrySetCanceled(token)); |
|||
started.SetResult(); |
|||
return new ValueTask<long>(canceled.Task); |
|||
}); |
|||
|
|||
var scoped = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_StopsWhenSessionPruningIsCanceled() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions |
|||
{ |
|||
DisableAutomaticTokenPruning = true, |
|||
DisableAutomaticAuthorizationPruning = true, |
|||
TimeProvider = clock.Object |
|||
}; |
|||
|
|||
var manager = new Mock<IOpenIddictSessionManager>(); |
|||
var started = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
var canceled = new TaskCompletionSource<long>(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
|
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Returns((DateTimeOffset _, CancellationToken token) => |
|||
{ |
|||
token.Register(() => canceled.TrySetCanceled(token)); |
|||
started.SetResult(); |
|||
return new ValueTask<long>(canceled.Task); |
|||
}); |
|||
|
|||
var scoped = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task ExecuteAsync_FailsWhenTokenManagerIsMissing() |
|||
{ |
|||
// Arrange
|
|||
var clock = new Mock<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions |
|||
{ |
|||
DisableAutomaticAuthorizationPruning = true, |
|||
DisableAutomaticSessionPruning = true, |
|||
TimeProvider = clock.Object |
|||
}; |
|||
|
|||
var scoped = new Mock<IServiceProvider>(); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped.Object); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<InvalidOperationException>(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<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions |
|||
{ |
|||
DisableAutomaticTokenPruning = true, |
|||
DisableAutomaticSessionPruning = true, |
|||
TimeProvider = clock.Object |
|||
}; |
|||
|
|||
var scoped = new Mock<IServiceProvider>(); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped.Object); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<InvalidOperationException>(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<FakeTimeProvider> { CallBase = true }; |
|||
var timer = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); |
|||
clock.Setup(clock => clock.CreateTimer(It.IsAny<TimerCallback>(), It.IsAny<object?>(), |
|||
It.IsAny<TimeSpan>(), It.IsAny<TimeSpan>())) |
|||
.CallBase().Callback(() => timer.TrySetResult()); |
|||
|
|||
var options = new OpenIddictCoreOptions |
|||
{ |
|||
DisableAutomaticTokenPruning = true, |
|||
DisableAutomaticAuthorizationPruning = true, |
|||
TimeProvider = clock.Object |
|||
}; |
|||
|
|||
var scoped = new Mock<IServiceProvider>(); |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == scoped.Object); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
var provider = Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory); |
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictCoreOptions>>(monitor => monitor.CurrentValue == options); |
|||
using var service = new OpenIddictCoreBackgroundService( |
|||
Mock.Of<ILogger<OpenIddictCoreBackgroundService>>(), 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<InvalidOperationException>(async () => |
|||
await service.ExecuteTask!.WaitAsync(TimeSpan.FromSeconds(5), TimeProvider.System)); |
|||
scoped.Verify(provider => provider.GetService(typeof(IOpenIddictSessionManager)), Times.Once()); |
|||
} |
|||
#endif
|
|||
} |
|||
@ -1,22 +0,0 @@ |
|||
<Project Sdk="Microsoft.NET.Sdk"> |
|||
|
|||
<PropertyGroup> |
|||
<TargetFrameworks>$(NetFrameworkTargetFrameworks);$(NetCoreTargetFrameworks)</TargetFrameworks> |
|||
</PropertyGroup> |
|||
|
|||
<ItemGroup> |
|||
<PackageReference Include="Moq" /> |
|||
<PackageReference Include="Microsoft.Extensions.DependencyInjection" /> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup> |
|||
<ProjectReference Include="..\..\src\OpenIddict.Quartz\OpenIddict.Quartz.csproj" /> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup> |
|||
<Using Include="OpenIddict.Abstractions" /> |
|||
<Using Include="OpenIddict.Abstractions.OpenIddictConstants" Static="true" /> |
|||
<Using Include="OpenIddict.Abstractions.OpenIddictResources" Alias="SR" /> |
|||
</ItemGroup> |
|||
|
|||
</Project> |
|||
@ -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<ArgumentNullException>(() => 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<OpenIddictQuartzOptions>(options => { }); |
|||
|
|||
// Act
|
|||
builder.Configure(configuration); |
|||
|
|||
// Assert
|
|||
Assert.Contains(services, service => service.ServiceType == typeof(IConfigureOptions<OpenIddictQuartzOptions>) && |
|||
service.ImplementationInstance is ConfigureNamedOptions<OpenIddictQuartzOptions> 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<ArgumentNullException>(() => 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<ArgumentOutOfRangeException>(() => 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<ArgumentOutOfRangeException>(() => 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<ArgumentOutOfRangeException>(() => 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<ArgumentOutOfRangeException>(() => 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<IOptions<OpenIddictQuartzOptions>>(); |
|||
return options.Value; |
|||
} |
|||
} |
|||
@ -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<ArgumentNullException>(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<ArgumentNullException>(() => 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<OpenIddictQuartzOptions>) && |
|||
service.ImplementationType == typeof(OpenIddictQuartzConfiguration)); |
|||
} |
|||
} |
|||
@ -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<InvalidOperationException>(() => new OpenIddictQuartzJob()); |
|||
|
|||
Assert.Equal(SR.GetResourceString(SR.ID0082), exception.Message); |
|||
} |
|||
#endif
|
|||
|
|||
[Fact] |
|||
public async Task Execute_UsesServiceScope() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of<IOpenIddictSessionManager>() && |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == provider); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
|
|||
var job = new OpenIddictQuartzJob(Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory)); |
|||
|
|||
// Act
|
|||
await job.Execute(Mock.Of<IJobExecutionContext>()); |
|||
|
|||
Mock.Get(factory).Verify(factory => factory.CreateScope(), Times.Once()); |
|||
Mock.Get(scope).Verify(scope => scope.Dispose(), Times.Once()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_IgnoresPruningWhenTokenPruningIsDisabled() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
DisableTokenPruning = true, |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var manager = new Mock<IOpenIddictAuthorizationManager>(); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of<IOpenIddictSessionManager>() && |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act
|
|||
await job.Execute(Mock.Of<IJobExecutionContext>()); |
|||
|
|||
// Assert
|
|||
manager.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Never()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_IgnoresPruningWhenAuthorizationPruningIsDisabled() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
DisableAuthorizationPruning = true, |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var manager = new Mock<IOpenIddictAuthorizationManager>(); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of<IOpenIddictSessionManager>() && |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act
|
|||
await job.Execute(Mock.Of<IJobExecutionContext>()); |
|||
|
|||
// Assert
|
|||
manager.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Never()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_IgnoresPruningWhenSessionPruningIsDisabled() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
DisableSessionPruning = true, |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var manager = new Mock<IOpenIddictSessionManager>(); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object && |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act
|
|||
await job.Execute(Mock.Of<IJobExecutionContext>()); |
|||
|
|||
// Assert
|
|||
manager.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Never()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_UnschedulesTriggersWhenTokenManagerIsMissing() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of<IOpenIddictSessionManager>() && |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == null && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act and assert
|
|||
var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => |
|||
await job.Execute(Mock.Of<IJobExecutionContext>())); |
|||
|
|||
Assert.False(exception.RefireImmediately); |
|||
Assert.True(exception.UnscheduleAllTriggers); |
|||
Assert.True(exception.UnscheduleFiringTrigger); |
|||
|
|||
Assert.IsType<InvalidOperationException>(exception.InnerException); |
|||
Assert.Equal(SR.GetResourceString(SR.ID0278), exception.InnerException!.Message); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_UnschedulesTriggersWhenAuthorizationManagerIsMissing() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == null && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act and assert
|
|||
var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => |
|||
await job.Execute(Mock.Of<IJobExecutionContext>())); |
|||
|
|||
Assert.False(exception.RefireImmediately); |
|||
Assert.True(exception.UnscheduleAllTriggers); |
|||
Assert.True(exception.UnscheduleFiringTrigger); |
|||
|
|||
Assert.IsType<InvalidOperationException>(exception.InnerException); |
|||
Assert.Equal(SR.GetResourceString(SR.ID0278), exception.InnerException!.Message); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_UnschedulesTriggersWhenSessionManagerIsMissing() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == null && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act and assert
|
|||
var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => |
|||
await job.Execute(Mock.Of<IJobExecutionContext>())); |
|||
|
|||
Assert.False(exception.RefireImmediately); |
|||
Assert.True(exception.UnscheduleAllTriggers); |
|||
Assert.True(exception.UnscheduleFiringTrigger); |
|||
|
|||
Assert.IsType<InvalidOperationException>(exception.InnerException); |
|||
Assert.Equal(SR.GetResourceString(SR.ID0278), exception.InnerException!.Message); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_RethrowsOutOfMemoryExceptionsThrownDuringTokenPruning() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var manager = new Mock<IOpenIddictTokenManager>(); |
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(new OutOfMemoryException()); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() && |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act and assert
|
|||
await Assert.ThrowsAsync<OutOfMemoryException>(async () => await job.Execute(Mock.Of<IJobExecutionContext>())); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_RethrowsOutOfMemoryExceptionsThrownDuringAuthorizationPruning() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var manager = new Mock<IOpenIddictAuthorizationManager>(); |
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(new OutOfMemoryException()); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object && |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act and assert
|
|||
await Assert.ThrowsAsync<OutOfMemoryException>(async () => await job.Execute(Mock.Of<IJobExecutionContext>())); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_RethrowsOutOfMemoryExceptionsThrownDuringSessionPruning() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var manager = new Mock<IOpenIddictSessionManager>(); |
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(new OutOfMemoryException()); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() && |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act and assert
|
|||
await Assert.ThrowsAsync<OutOfMemoryException>(async () => await job.Execute(Mock.Of<IJobExecutionContext>())); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_DisablesRefiringWhenJobIsCanceledDuringTokenPruning() |
|||
{ |
|||
// Arrange
|
|||
var token = new CancellationToken(canceled: true); |
|||
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var manager = new Mock<IOpenIddictTokenManager>(); |
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(new OperationCanceledException(token)); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() && |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var context = Mock.Of<IJobExecutionContext>(context => context.CancellationToken == token); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act and assert
|
|||
var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => await job.Execute(context)); |
|||
|
|||
Assert.False(exception.RefireImmediately); |
|||
|
|||
manager.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_DisablesRefiringWhenJobIsCanceledDuringAuthorizationPruning() |
|||
{ |
|||
// Arrange
|
|||
var token = new CancellationToken(canceled: true); |
|||
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var manager = new Mock<IOpenIddictAuthorizationManager>(); |
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(new OperationCanceledException(token)); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object && |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var context = Mock.Of<IJobExecutionContext>(context => context.CancellationToken == token); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act and assert
|
|||
var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => await job.Execute(context)); |
|||
|
|||
Assert.False(exception.RefireImmediately); |
|||
|
|||
manager.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_DisablesRefiringWhenJobIsCanceledDuringSessionPruning() |
|||
{ |
|||
// Arrange
|
|||
var token = new CancellationToken(canceled: true); |
|||
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var manager = new Mock<IOpenIddictSessionManager>(); |
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(new OperationCanceledException(token)); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() && |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == manager.Object && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var context = Mock.Of<IJobExecutionContext>(context => context.CancellationToken == token); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act and assert
|
|||
var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => await job.Execute(context)); |
|||
|
|||
Assert.False(exception.RefireImmediately); |
|||
|
|||
manager.Verify(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>()), Times.Once()); |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_AllowsRefiringWhenExceptionsAreThrown() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var provider = new Mock<IServiceProvider>(); |
|||
provider.Setup(provider => provider.GetService(typeof(IOpenIddictAuthorizationManager))) |
|||
.Returns(CreateAuthorizationManager(new ApplicationException())); |
|||
|
|||
provider.Setup(provider => provider.GetService(typeof(IOpenIddictSessionManager))) |
|||
.Returns(CreateSessionManager(new ApplicationException())); |
|||
|
|||
provider.Setup(provider => provider.GetService(typeof(IOpenIddictTokenManager))) |
|||
.Returns(CreateTokenManager(new ApplicationException())); |
|||
|
|||
provider.Setup(provider => provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>))) |
|||
.Returns(monitor); |
|||
|
|||
var context = Mock.Of<IJobExecutionContext>(context => context.RefireCount == 0); |
|||
|
|||
var job = CreateJob(provider.Object); |
|||
|
|||
// Act and assert
|
|||
var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => await job.Execute(context)); |
|||
|
|||
Assert.True(exception.RefireImmediately); |
|||
Assert.IsType<AggregateException>(exception.InnerException); |
|||
Assert.Equal(3, ((AggregateException) exception.InnerException!).InnerExceptions.Count); |
|||
Assert.IsType<ApplicationException>(((AggregateException) exception.InnerException!).InnerExceptions[0]); |
|||
Assert.IsType<ApplicationException>(((AggregateException) exception.InnerException!).InnerExceptions[1]); |
|||
Assert.IsType<ApplicationException>(((AggregateException) exception.InnerException!).InnerExceptions[2]); |
|||
|
|||
static IOpenIddictAuthorizationManager CreateAuthorizationManager(Exception exception) |
|||
{ |
|||
var mock = new Mock<IOpenIddictAuthorizationManager>(); |
|||
mock.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(exception); |
|||
|
|||
return mock.Object; |
|||
} |
|||
|
|||
static IOpenIddictSessionManager CreateSessionManager(Exception exception) |
|||
{ |
|||
var mock = new Mock<IOpenIddictSessionManager>(); |
|||
mock.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(exception); |
|||
|
|||
return mock.Object; |
|||
} |
|||
|
|||
static IOpenIddictTokenManager CreateTokenManager(Exception exception) |
|||
{ |
|||
var mock = new Mock<IOpenIddictTokenManager>(); |
|||
mock.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(exception); |
|||
|
|||
return mock.Object; |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_AllowsRefiringWhenAggregateExceptionsAreThrown() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var provider = new Mock<IServiceProvider>(); |
|||
provider.Setup(provider => provider.GetService(typeof(IOpenIddictAuthorizationManager))) |
|||
.Returns(CreateAuthorizationManager(new AggregateException( |
|||
new InvalidOperationException(), new ApplicationException()))); |
|||
|
|||
provider.Setup(provider => provider.GetService(typeof(IOpenIddictSessionManager))) |
|||
.Returns(CreateSessionManager(new AggregateException( |
|||
new InvalidOperationException(), new ApplicationException()))); |
|||
|
|||
provider.Setup(provider => provider.GetService(typeof(IOpenIddictTokenManager))) |
|||
.Returns(CreateTokenManager(new AggregateException( |
|||
new InvalidOperationException(), new ApplicationException()))); |
|||
|
|||
provider.Setup(provider => provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>))) |
|||
.Returns(monitor); |
|||
|
|||
var context = Mock.Of<IJobExecutionContext>(context => context.RefireCount == 0); |
|||
|
|||
var job = CreateJob(provider.Object); |
|||
|
|||
// Act and assert
|
|||
var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => await job.Execute(context)); |
|||
|
|||
Assert.True(exception.RefireImmediately); |
|||
Assert.IsType<AggregateException>(exception.InnerException); |
|||
Assert.Equal(6, ((AggregateException) exception.InnerException!).InnerExceptions.Count); |
|||
Assert.IsType<InvalidOperationException>(((AggregateException) exception.InnerException!).InnerExceptions[0]); |
|||
Assert.IsType<ApplicationException>(((AggregateException) exception.InnerException!).InnerExceptions[1]); |
|||
Assert.IsType<InvalidOperationException>(((AggregateException) exception.InnerException!).InnerExceptions[2]); |
|||
Assert.IsType<ApplicationException>(((AggregateException) exception.InnerException!).InnerExceptions[3]); |
|||
Assert.IsType<InvalidOperationException>(((AggregateException) exception.InnerException!).InnerExceptions[4]); |
|||
Assert.IsType<ApplicationException>(((AggregateException) exception.InnerException!).InnerExceptions[5]); |
|||
|
|||
static IOpenIddictAuthorizationManager CreateAuthorizationManager(Exception exception) |
|||
{ |
|||
var mock = new Mock<IOpenIddictAuthorizationManager>(); |
|||
mock.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(exception); |
|||
|
|||
return mock.Object; |
|||
} |
|||
|
|||
static IOpenIddictSessionManager CreateSessionManager(Exception exception) |
|||
{ |
|||
var mock = new Mock<IOpenIddictSessionManager>(); |
|||
mock.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(exception); |
|||
|
|||
return mock.Object; |
|||
} |
|||
|
|||
static IOpenIddictTokenManager CreateTokenManager(Exception exception) |
|||
{ |
|||
var mock = new Mock<IOpenIddictTokenManager>(); |
|||
mock.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(exception); |
|||
|
|||
return mock.Object; |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public async Task Execute_DisallowsRefiringWhenMaximumRefireCountIsReached() |
|||
{ |
|||
// Arrange
|
|||
var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>( |
|||
monitor => monitor.CurrentValue == new OpenIddictQuartzOptions |
|||
{ |
|||
MaximumRefireCount = 5, |
|||
TimeProvider = TimeProvider.System |
|||
}); |
|||
|
|||
var manager = new Mock<IOpenIddictAuthorizationManager>(); |
|||
manager.Setup(manager => manager.PruneAsync(It.IsAny<DateTimeOffset>(), It.IsAny<CancellationToken>())) |
|||
.Throws(new ApplicationException()); |
|||
|
|||
var provider = Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object && |
|||
provider.GetService(typeof(IOpenIddictSessionManager)) == Mock.Of<IOpenIddictSessionManager>() && |
|||
provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>() && |
|||
provider.GetService(typeof(IOptionsMonitor<OpenIddictQuartzOptions>)) == monitor); |
|||
|
|||
var context = Mock.Of<IJobExecutionContext>(context => context.RefireCount == 5); |
|||
|
|||
var job = CreateJob(provider); |
|||
|
|||
// Act and assert
|
|||
var exception = await Assert.ThrowsAsync<JobExecutionException>(async () => await job.Execute(context)); |
|||
|
|||
Assert.False(exception.RefireImmediately); |
|||
} |
|||
|
|||
private static OpenIddictQuartzJob CreateJob(IServiceProvider provider) |
|||
{ |
|||
var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == provider); |
|||
var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope); |
|||
|
|||
return new OpenIddictQuartzJob(Mock.Of<IServiceProvider>(provider => |
|||
provider.GetService(typeof(IServiceScopeFactory)) == factory)); |
|||
} |
|||
} |
|||
Loading…
Reference in new issue