Browse Source

Replace OpenIddict.Quartz with a BackgroundService and make the pruning mechanism opt-out by default

pull/2559/head
Kévin Chalet 2 months ago
parent
commit
b48729eace
  1. 5
      Directory.Packages.props
  2. 2
      OpenIddict.slnx
  3. 12
      sandbox/OpenIddict.Sandbox.AspNet.Client/Web.config
  4. 1
      sandbox/OpenIddict.Sandbox.AspNetCore.Client/OpenIddict.Sandbox.AspNetCore.Client.csproj
  5. 21
      sandbox/OpenIddict.Sandbox.AspNetCore.Client/Program.cs
  6. 1
      sandbox/OpenIddict.Sandbox.AspNetCore.Server/OpenIddict.Sandbox.AspNetCore.Server.csproj
  7. 21
      sandbox/OpenIddict.Sandbox.AspNetCore.Server/Program.cs
  8. 8
      sandbox/OpenIddict.Sandbox.Console.Client/Program.cs
  9. 30
      src/OpenIddict.Abstractions/OpenIddictResources.resx
  10. 1
      src/OpenIddict.Core/OpenIddict.Core.csproj
  11. 144
      src/OpenIddict.Core/OpenIddictCoreBackgroundService.cs
  12. 57
      src/OpenIddict.Core/OpenIddictCoreBuilder.cs
  13. 2
      src/OpenIddict.Core/OpenIddictCoreExtensions.cs
  14. 33
      src/OpenIddict.Core/OpenIddictCoreOptions.cs
  15. 31
      src/OpenIddict.Quartz/OpenIddict.Quartz.csproj
  16. 138
      src/OpenIddict.Quartz/OpenIddictQuartzBuilder.cs
  17. 35
      src/OpenIddict.Quartz/OpenIddictQuartzConfiguration.cs
  18. 83
      src/OpenIddict.Quartz/OpenIddictQuartzExtensions.cs
  19. 207
      src/OpenIddict.Quartz/OpenIddictQuartzJob.cs
  20. 62
      src/OpenIddict.Quartz/OpenIddictQuartzOptions.cs
  21. 4
      test/OpenIddict.Core.Tests/OpenIddict.Core.Tests.csproj
  22. 861
      test/OpenIddict.Core.Tests/OpenIddictCoreBackgroundServiceTests.cs
  23. 116
      test/OpenIddict.Core.Tests/OpenIddictCoreBuilderTests.cs
  24. 36
      test/OpenIddict.Core.Tests/OpenIddictCoreExtensionsTests.cs
  25. 22
      test/OpenIddict.Quartz.Tests/OpenIddict.Quartz.Tests.csproj
  26. 226
      test/OpenIddict.Quartz.Tests/OpenIddictQuartzBuilderTests.cs
  27. 75
      test/OpenIddict.Quartz.Tests/OpenIddictQuartzExtensionsTests.cs
  28. 571
      test/OpenIddict.Quartz.Tests/OpenIddictQuartzJobTests.cs

5
Directory.Packages.props

@ -48,8 +48,6 @@
<PackageVersion Include="MongoDB.Driver" Version="3.11.0" />
<PackageVersion Include="MSBuild.Microsoft.VisualStudio.Web.targets" Version="14.0.0.3" />
<PackageVersion Include="NuGet.Build.Tasks.Pack" Version="6.14.0" />
<PackageVersion Include="Quartz" Version="[3.20.1, 4.0.0)" />
<PackageVersion Include="Quartz.Extensions.DependencyInjection" Version="[3.20.1, 4.0.0)" />
<PackageVersion Include="SharpCompress" Version="1.0.0" />
<PackageVersion Include="Snappier" Version="1.3.1" />
<PackageVersion Include="System.Buffers" Version="4.6.1" />
@ -93,7 +91,6 @@
<PackageVersion Include="Microsoft.Owin.Security.OAuth" Version="4.2.3" />
<PackageVersion Include="Microsoft.Web.Infrastructure" Version="2.0.1" />
<PackageVersion Include="Newtonsoft.Json" Version="13.0.4" />
<PackageVersion Include="Quartz.Extensions.Hosting" Version="[3.20.1, 4.0.0)" />
<PackageVersion Include="SourceGear.sqlite3" Version="3.53.4" />
<PackageVersion Include="Spectre.Console" Version="0.57.2" />
<PackageVersion Include="SQLite.CodeFirst" Version="1.8.0" />
@ -127,7 +124,6 @@
<PackageVersion Include="Microsoft.Extensions.Primitives" Version="10.0.11" />
<PackageVersion Include="MongoDB.Bson" Version="3.11.0" />
<PackageVersion Include="MongoDB.Driver" Version="3.11.0" />
<PackageVersion Include="Quartz" Version="4.0.0" />
<PackageVersion Include="SharpCompress" Version="1.0.0" />
<PackageVersion Include="Snappier" Version="1.3.1" />
<PackageVersion Include="System.Security.Cryptography.Xml" Version="10.0.11" />
@ -140,6 +136,7 @@
<PackageVersion Include="MartinCostello.Logging.XUnit" Version="0.7.1" />
<PackageVersion Include="Microsoft.AspNetCore.TestHost" Version="10.0.11" />
<PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.11" />
<PackageVersion Include="Microsoft.Extensions.TimeProvider.Testing" Version="10.9.0" />
<PackageVersion Include="Moq" Version="4.18.4" />
<PackageVersion Include="Xunit.SkippableFact" Version="1.5.61" />

2
OpenIddict.slnx

@ -66,7 +66,6 @@
<Project Path="src/OpenIddict.MongoDb.Models/OpenIddict.MongoDb.Models.csproj" />
<Project Path="src/OpenIddict.MongoDb/OpenIddict.MongoDb.csproj" />
<Project Path="src/OpenIddict.Owin/OpenIddict.Owin.csproj" />
<Project Path="src/OpenIddict.Quartz/OpenIddict.Quartz.csproj" />
<Project Path="src/OpenIddict.Server.AspNetCore/OpenIddict.Server.AspNetCore.csproj" />
<Project Path="src/OpenIddict.Server.DataProtection/OpenIddict.Server.DataProtection.csproj" />
<Project Path="src/OpenIddict.Server.Owin/OpenIddict.Server.Owin.csproj" />
@ -95,7 +94,6 @@
<Project Path="test/OpenIddict.EntityFramework.Tests/OpenIddict.EntityFramework.Tests.csproj" />
<Project Path="test/OpenIddict.EntityFrameworkCore.Tests/OpenIddict.EntityFrameworkCore.Tests.csproj" />
<Project Path="test/OpenIddict.MongoDb.Tests/OpenIddict.MongoDb.Tests.csproj" />
<Project Path="test/OpenIddict.Quartz.Tests/OpenIddict.Quartz.Tests.csproj" />
<Project Path="test/OpenIddict.Server.AspNetCore.IntegrationTests/OpenIddict.Server.AspNetCore.IntegrationTests.csproj" />
<Project Path="test/OpenIddict.Server.AspNetCore.Tests/OpenIddict.Server.AspNetCore.Tests.csproj" Id="21d81c43-35e2-4a09-8866-448b86d3c710" />
<Project Path="test/OpenIddict.Server.DataProtection.Tests/OpenIddict.Server.DataProtection.Tests.csproj" />

12
sandbox/OpenIddict.Sandbox.AspNet.Client/Web.config

@ -172,18 +172,6 @@
<bindingRedirect oldVersion="0.0.0.0-7.4.0.0" newVersion="7.4.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Quartz" publicKeyToken="f6b8c98a402cc8a4" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-3.13.0.0" newVersion="3.13.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Quartz.Extensions.DependencyInjection" publicKeyToken="f6b8c98a402cc8a4" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-3.13.0.0" newVersion="3.13.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.Bcl.AsyncInterfaces" culture="neutral" publicKeyToken="cc7b13ffcd2ddd51" />

1
sandbox/OpenIddict.Sandbox.AspNetCore.Client/OpenIddict.Sandbox.AspNetCore.Client.csproj

@ -7,7 +7,6 @@
<ItemGroup>
<ProjectReference Include="..\..\src\OpenIddict.AspNetCore\OpenIddict.AspNetCore.csproj" />
<ProjectReference Include="..\..\src\OpenIddict.EntityFrameworkCore\OpenIddict.EntityFrameworkCore.csproj" />
<ProjectReference Include="..\..\src\OpenIddict.Quartz\OpenIddict.Quartz.csproj" />
</ItemGroup>
<ItemGroup>

21
sandbox/OpenIddict.Sandbox.AspNetCore.Client/Program.cs

@ -6,7 +6,6 @@ using Microsoft.IdentityModel.Tokens;
using OpenIddict.Client;
using OpenIddict.Client.WebIntegration;
using OpenIddict.Sandbox.AspNetCore.Client.Models;
using Quartz;
using static OpenIddict.Abstractions.OpenIddictConstants;
var builder = WebApplication.CreateBuilder(args);
@ -36,17 +35,6 @@ builder.Services.AddAuthentication(options =>
options.SlidingExpiration = false;
});
// OpenIddict offers native integration with Quartz.NET to perform scheduled tasks
// (like pruning orphaned authorizations from the database) at regular intervals.
builder.Services.AddQuartz(options =>
{
options.UseSimpleTypeLoader();
options.UseInMemoryStore();
});
// Register the Quartz.NET service and configure it to block shutdown until jobs are complete.
builder.Services.AddQuartzHostedService(options => options.WaitForJobsToComplete = true);
builder.Services.AddOpenIddict()
// Register the OpenIddict core components.
@ -61,8 +49,13 @@ builder.Services.AddOpenIddict()
// options.UseMongoDb()
// .UseDatabase(new MongoClient().GetDatabase("openiddict"));
// Enable Quartz.NET integration.
options.UseQuartz();
// Note: by default, OpenIddict automatically prunes authorizations, sessions and tokens
// that are no longer valid at regular intervals. For those who prefer using their own
// pruning mechanism (e.g based on Quartz.NET or Hangfire), automatic pruning can be disabled.
//
// options.DisableAutomaticAuthorizationPruning()
// .DisableAutomaticSessionPruning()
// .DisableAutomaticTokenPruning();
})
// Register the OpenIddict client components.

1
sandbox/OpenIddict.Sandbox.AspNetCore.Server/OpenIddict.Sandbox.AspNetCore.Server.csproj

@ -9,7 +9,6 @@
<ProjectReference Include="..\..\src\OpenIddict.AspNetCore\OpenIddict.AspNetCore.csproj" />
<ProjectReference Include="..\..\src\OpenIddict.EntityFrameworkCore\OpenIddict.EntityFrameworkCore.csproj" />
<ProjectReference Include="..\..\src\OpenIddict.MongoDb\OpenIddict.MongoDb.csproj" />
<ProjectReference Include="..\..\src\OpenIddict.Quartz\OpenIddict.Quartz.csproj" />
</ItemGroup>
<ItemGroup>

21
sandbox/OpenIddict.Sandbox.AspNetCore.Server/Program.cs

@ -10,7 +10,6 @@ using Microsoft.IdentityModel.Tokens;
using OpenIddict.Abstractions;
using OpenIddict.Sandbox.AspNetCore.Server.Models;
using OpenIddict.Sandbox.AspNetCore.Server.Services;
using Quartz;
using static OpenIddict.Abstractions.OpenIddictConstants;
var builder = WebApplication.CreateBuilder(args);
@ -50,17 +49,6 @@ builder.Services.Configure<SecurityStampValidatorOptions>(options => options.OnR
return Task.CompletedTask;
});
// OpenIddict offers native integration with Quartz.NET to perform scheduled tasks
// (like pruning orphaned authorizations/tokens from the database) at regular intervals.
builder.Services.AddQuartz(options =>
{
options.UseSimpleTypeLoader();
options.UseInMemoryStore();
});
// Register the Quartz.NET service and configure it to block shutdown until jobs are complete.
builder.Services.AddQuartzHostedService(options => options.WaitForJobsToComplete = true);
builder.Services.AddOpenIddict()
// Register the OpenIddict core components.
@ -75,8 +63,13 @@ builder.Services.AddOpenIddict()
// options.UseMongoDb()
// .UseDatabase(new MongoClient().GetDatabase("openiddict"));
// Enable Quartz.NET integration.
options.UseQuartz();
// Note: by default, OpenIddict automatically prunes authorizations, sessions and tokens
// that are no longer valid at regular intervals. For those who prefer using their own
// pruning mechanism (e.g based on Quartz.NET or Hangfire), automatic pruning can be disabled.
//
// options.DisableAutomaticAuthorizationPruning()
// .DisableAutomaticSessionPruning()
// .DisableAutomaticTokenPruning();
})
// Register the OpenIddict client components.

8
sandbox/OpenIddict.Sandbox.Console.Client/Program.cs

@ -32,6 +32,14 @@ builder.Services.AddOpenIddict()
options.UseEntityFramework()
.UseDbContext<ApplicationDbContext>();
#endif
// Note: by default, OpenIddict automatically prunes authorizations, sessions and tokens
// that are no longer valid at regular intervals. For those who prefer using their own
// pruning mechanism (e.g based on Quartz.NET or Hangfire), automatic pruning can be disabled.
//
// options.DisableAutomaticAuthorizationPruning()
// .DisableAutomaticSessionPruning()
// .DisableAutomaticTokenPruning();
})
// Register the OpenIddict client components.

30
src/OpenIddict.Abstractions/OpenIddictResources.resx

@ -383,10 +383,6 @@ Consider using 'options.AddSigningCredentials(SigningCredentials)' instead.</val
<data name="ID0081" xml:space="preserve">
<value>Endpoint URIs cannot start with '{0}'.</value>
</data>
<data name="ID0082" xml:space="preserve">
<value>Dependency injection support must be enabled in Quartz.NET when using the OpenIddict integration.
To enable DI support, call 'services.AddQuartz(options =&gt; options.UseMicrosoftDependencyInjectionJobFactory())' or 'services.AddQuartz(options =&gt; options.UseMicrosoftDependencyInjectionScopedJobFactory())'.</value>
</data>
<data name="ID0083" xml:space="preserve">
<value>Reference tokens cannot be used when disabling token storage.</value>
</data>
@ -896,10 +892,6 @@ To apply configuration responses, create a class implementing 'IOpenIddictServer
<data name="ID0277" xml:space="preserve">
<value>The Entity Framework 6.x stores cannot be used with generic types.
Consider creating non-generic classes derived from the default entities for the application, authorization, scope and token entities.</value>
</data>
<data name="ID0278" xml:space="preserve">
<value>The core services must be registered when enabling the OpenIddict Quartz.NET integration.
To register the OpenIddict core services, reference the 'OpenIddict.Core' package and call 'services.AddOpenIddict().AddCore()' from 'ConfigureServices'.</value>
</data>
<data name="ID0279" xml:space="preserve">
<value>The maximum refire count cannot be negative.</value>
@ -3287,22 +3279,16 @@ This may indicate that the hashed entry is corrupted or malformed.</value>
<data name="ID6297" xml:space="preserve">
<value>The session '{Identifier}' was no longer valid.</value>
</data>
<data name="ID8000" xml:space="preserve">
<value>https://documentation.openiddict.com/errors/{0}</value>
<data name="ID6298" xml:space="preserve">
<value>A non-fatal error occurred while pruning tokens from the database.</value>
</data>
<data name="ID8001" xml:space="preserve">
<value>Removes orphaned tokens and authorizations from the database.</value>
<data name="ID6299" xml:space="preserve">
<value>A non-fatal error occurred while pruning authorizations from the database.</value>
</data>
<data name="ID8002" xml:space="preserve">
<value>Starts the scheduled task at regular intervals.</value>
<data name="ID6300" xml:space="preserve">
<value>A non-fatal error occurred while pruning sessions from the database.</value>
</data>
<data name="ID8003" xml:space="preserve">
<value>OpenIddict job</value>
</data>
<data name="ID8004" xml:space="preserve">
<value>Built-in automatic trigger</value>
</data>
<data name="ID8005" xml:space="preserve">
<value>OpenIddict/Quartz.NET integration</value>
<data name="ID8000" xml:space="preserve">
<value>https://documentation.openiddict.com/errors/{0}</value>
</data>
</root>

1
src/OpenIddict.Core/OpenIddict.Core.csproj

@ -15,6 +15,7 @@
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.Caching.Memory" />
<PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" />
<PackageReference Include="Microsoft.Extensions.Logging" />
<PackageReference Include="Microsoft.Extensions.Options" />
</ItemGroup>

144
src/OpenIddict.Core/OpenIddictCoreBackgroundService.cs

@ -0,0 +1,144 @@
/*
* Licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
* See https://github.com/openiddict/openiddict-core for more information concerning
* the license and the contributors participating to this project.
*/
using System.ComponentModel;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
namespace OpenIddict.Core;
/// <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));
}
}

57
src/OpenIddict.Core/OpenIddictCoreBuilder.cs

@ -57,6 +57,27 @@ public sealed class OpenIddictCoreBuilder
return this;
}
/// <summary>
/// Disables automatic authorizations pruning.
/// </summary>
/// <returns>The <see cref="OpenIddictCoreBuilder"/> instance.</returns>
public OpenIddictCoreBuilder DisableAutomaticAuthorizationPruning()
=> Configure(options => options.DisableAutomaticAuthorizationPruning = true);
/// <summary>
/// Disables automatic sessions pruning.
/// </summary>
/// <returns>The <see cref="OpenIddictCoreBuilder"/> instance.</returns>
public OpenIddictCoreBuilder DisableAutomaticSessionPruning()
=> Configure(options => options.DisableAutomaticSessionPruning = true);
/// <summary>
/// Disables automatic tokens pruning.
/// </summary>
/// <returns>The <see cref="OpenIddictCoreBuilder"/> instance.</returns>
public OpenIddictCoreBuilder DisableAutomaticTokenPruning()
=> Configure(options => options.DisableAutomaticTokenPruning = true);
/// <summary>
/// Replaces the application manager by the specified type.
/// </summary>
@ -719,6 +740,42 @@ public sealed class OpenIddictCoreBuilder
return Configure(options => options.EntityCacheLimit = limit);
}
/// <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="OpenIddictCoreBuilder"/> instance.</returns>
public OpenIddictCoreBuilder 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="OpenIddictCoreBuilder"/> instance.</returns>
public OpenIddictCoreBuilder 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="OpenIddictCoreBuilder"/> instance.</returns>
public OpenIddictCoreBuilder 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);

2
src/OpenIddict.Core/OpenIddictCoreExtensions.cs

@ -59,6 +59,8 @@ public static class OpenIddictCoreExtensions
builder.Services.TryAddScoped<IOpenIddictTokenManager>(static provider =>
throw new InvalidOperationException(SR.GetResourceString(SR.ID0472)));
builder.Services.AddHostedService<OpenIddictCoreBackgroundService>();
// Note: TryAddEnumerable() is used here to ensure the initializers are registered only once.
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<
IPostConfigureOptions<OpenIddictCoreOptions>, OpenIddictCoreConfiguration>());

33
src/OpenIddict.Core/OpenIddictCoreOptions.cs

@ -63,6 +63,21 @@ public sealed class OpenIddictCoreOptions
[EditorBrowsable(EditorBrowsableState.Advanced)]
public bool DisableEntityCaching { get; set; }
/// <summary>
/// Gets or sets a boolean indicating whether authorizations pruning should be disabled.
/// </summary>
public bool DisableAutomaticAuthorizationPruning { get; set; }
/// <summary>
/// Gets or sets a boolean indicating whether sessions pruning should be disabled.
/// </summary>
public bool DisableAutomaticSessionPruning { get; set; }
/// <summary>
/// Gets or sets a boolean indicating whether tokens pruning should be disabled.
/// </summary>
public bool DisableAutomaticTokenPruning { get; set; }
/// <summary>
/// Gets or sets the maximum number of cached entries allowed. When the threshold
/// is reached, the cache is automatically compacted to ensure it doesn't grow
@ -72,6 +87,24 @@ public sealed class OpenIddictCoreOptions
[EditorBrowsable(EditorBrowsableState.Advanced)]
public int EntityCacheLimit { get; set; } = 250;
/// <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>

31
src/OpenIddict.Quartz/OpenIddict.Quartz.csproj

@ -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>

138
src/OpenIddict.Quartz/OpenIddictQuartzBuilder.cs

@ -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();
}

35
src/OpenIddict.Quartz/OpenIddictQuartzConfiguration.cs

@ -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;
}
}

83
src/OpenIddict.Quartz/OpenIddictQuartzExtensions.cs

@ -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;
}
}

207
src/OpenIddict.Quartz/OpenIddictQuartzJob.cs

@ -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
};
}
}
}

62
src/OpenIddict.Quartz/OpenIddictQuartzOptions.cs

@ -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!;
}

4
test/OpenIddict.Core.Tests/OpenIddict.Core.Tests.csproj

@ -13,6 +13,10 @@
<PackageReference Include="Moq" />
</ItemGroup>
<ItemGroup Condition=" '$(TargetFrameworkIdentifier)' == '.NETCoreApp' ">
<PackageReference Include="Microsoft.Extensions.TimeProvider.Testing" />
</ItemGroup>
<ItemGroup Condition=" '$(TargetFrameworkIdentifier)' == '.NETFramework' ">
<PackageReference Include="System.Linq.Async" />
</ItemGroup>

861
test/OpenIddict.Core.Tests/OpenIddictCoreBackgroundServiceTests.cs

@ -0,0 +1,861 @@
/*
* Licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
* See https://github.com/openiddict/openiddict-core for more information concerning
* the license and the contributors participating to this project.
*/
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Moq;
using Xunit;
#if NET
using Microsoft.Extensions.Time.Testing;
#endif
namespace OpenIddict.Core.Tests;
public class OpenIddictCoreBackgroundServiceTests
{
[Theory]
[InlineData("logger")]
[InlineData("options")]
[InlineData("provider")]
public void Constructor_ThrowsAnExceptionForNullDependencies(string parameter)
{
// Act and assert
var exception = Assert.Throws<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
}

116
test/OpenIddict.Core.Tests/OpenIddictCoreBuilderTests.cs

@ -25,6 +25,122 @@ public class OpenIddictCoreBuilderTests
Assert.Equal("services", exception.ParamName);
}
[Fact]
public void Configure_DelegateIsCorrectlyRegistered()
{
// Arrange
var services = CreateServices();
var builder = CreateBuilder(services);
var configuration = new Action<OpenIddictCoreOptions>(options => { });
// Act
builder.Configure(configuration);
// Assert
Assert.Contains(services, service => service.ServiceType == typeof(IConfigureOptions<OpenIddictCoreOptions>) &&
service.ImplementationInstance is ConfigureNamedOptions<OpenIddictCoreOptions> options &&
options.Action == configuration && string.IsNullOrEmpty(options.Name));
}
[Fact]
public void Configure_ThrowsAnExceptionWhenConfigurationIsNull()
{
// Arrange
var builder = CreateBuilder(CreateServices());
// Act and assert
var exception = Assert.Throws<ArgumentNullException>(() => builder.Configure(configuration: null!));
Assert.Equal("configuration", exception.ParamName);
}
[Fact]
public void DisableAutomaticAuthorizationPruning_AuthorizationPruningIsDisabled()
{
var services = CreateServices();
CreateBuilder(services).DisableAutomaticAuthorizationPruning();
Assert.True(services.BuildServiceProvider().GetRequiredService<IOptions<OpenIddictCoreOptions>>().Value.DisableAutomaticAuthorizationPruning);
}
[Fact]
public void DisableAutomaticSessionPruning_SessionPruningIsDisabled()
{
var services = CreateServices();
CreateBuilder(services).DisableAutomaticSessionPruning();
Assert.True(services.BuildServiceProvider().GetRequiredService<IOptions<OpenIddictCoreOptions>>().Value.DisableAutomaticSessionPruning);
}
[Fact]
public void DisableAutomaticTokenPruning_TokenPruningIsDisabled()
{
var services = CreateServices();
CreateBuilder(services).DisableAutomaticTokenPruning();
Assert.True(services.BuildServiceProvider().GetRequiredService<IOptions<OpenIddictCoreOptions>>().Value.DisableAutomaticTokenPruning);
}
[Theory]
[InlineData(0)]
[InlineData(9)]
public void SetMinimumAuthorizationLifespan_ThrowsAnExceptionForInvalidLifespan(int minutes)
{
var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>
CreateBuilder(CreateServices()).SetMinimumAuthorizationLifespan(TimeSpan.FromMinutes(minutes)));
Assert.Equal("lifespan", exception.ParamName);
}
[Theory]
[InlineData(0)]
[InlineData(9)]
public void SetMinimumSessionLifespan_ThrowsAnExceptionForInvalidLifespan(int minutes)
{
var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>
CreateBuilder(CreateServices()).SetMinimumSessionLifespan(TimeSpan.FromMinutes(minutes)));
Assert.Equal("lifespan", exception.ParamName);
}
[Theory]
[InlineData(0)]
[InlineData(9)]
public void SetMinimumTokenLifespan_ThrowsAnExceptionForInvalidLifespan(int minutes)
{
var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>
CreateBuilder(CreateServices()).SetMinimumTokenLifespan(TimeSpan.FromMinutes(minutes)));
Assert.Equal("lifespan", exception.ParamName);
}
[Fact]
public void SetMinimumAuthorizationLifespan_MinimumAuthorizationLifespanIsSet()
{
var services = CreateServices();
CreateBuilder(services).SetMinimumAuthorizationLifespan(TimeSpan.FromDays(42));
Assert.Equal(TimeSpan.FromDays(42), services.BuildServiceProvider().GetRequiredService<IOptions<OpenIddictCoreOptions>>().Value.MinimumAuthorizationLifespan);
}
[Fact]
public void SetMinimumSessionLifespan_MinimumSessionLifespanIsSet()
{
var services = CreateServices();
CreateBuilder(services).SetMinimumSessionLifespan(TimeSpan.FromDays(42));
Assert.Equal(TimeSpan.FromDays(42), services.BuildServiceProvider().GetRequiredService<IOptions<OpenIddictCoreOptions>>().Value.MinimumSessionLifespan);
}
[Fact]
public void SetMinimumTokenLifespan_MinimumTokenLifespanIsSet()
{
var services = CreateServices();
CreateBuilder(services).SetMinimumTokenLifespan(TimeSpan.FromDays(42));
Assert.Equal(TimeSpan.FromDays(42), services.BuildServiceProvider().GetRequiredService<IOptions<OpenIddictCoreOptions>>().Value.MinimumTokenLifespan);
}
[Fact]
public void ReplaceApplicationManager_ThrowsAnExceptionForClosedSourceManager()
{

36
test/OpenIddict.Core.Tests/OpenIddictCoreExtensionsTests.cs

@ -5,6 +5,7 @@
*/
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Xunit;
@ -66,6 +67,41 @@ public class OpenIddictCoreExtensionsTests
Assert.Contains(services, service => service.ServiceType == typeof(IOptions<>));
}
[Fact]
public void AddCore_RegistersBackgroundService()
{
// Arrange
var services = new ServiceCollection();
// Act
new OpenIddictBuilder(services).AddCore();
// Assert
Assert.Contains(services, service => service.ServiceType == typeof(IHostedService) &&
service.ImplementationType == typeof(OpenIddictCoreBackgroundService) &&
service.Lifetime is ServiceLifetime.Singleton);
}
[Fact]
public void AddCore_CanBeSafelyInvokedMultipleTimes()
{
// Arrange
var services = new ServiceCollection();
var builder = new OpenIddictBuilder(services);
// Act
builder.AddCore();
builder.AddCore();
builder.AddCore();
// Assert
Assert.Single(services, service => service.ServiceType == typeof(IHostedService) &&
service.ImplementationType == typeof(OpenIddictCoreBackgroundService));
Assert.Single(services, service => service.ServiceType == typeof(IPostConfigureOptions<OpenIddictCoreOptions>) &&
service.ImplementationType == typeof(OpenIddictCoreConfiguration));
}
[Theory]
[InlineData(typeof(OpenIddictApplicationManager<>))]
[InlineData(typeof(OpenIddictAuthorizationManager<>))]

22
test/OpenIddict.Quartz.Tests/OpenIddict.Quartz.Tests.csproj

@ -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>

226
test/OpenIddict.Quartz.Tests/OpenIddictQuartzBuilderTests.cs

@ -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;
}
}

75
test/OpenIddict.Quartz.Tests/OpenIddictQuartzExtensionsTests.cs

@ -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));
}
}

571
test/OpenIddict.Quartz.Tests/OpenIddictQuartzJobTests.cs

@ -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…
Cancel
Save