Make the Quartz.NET integration an OpenIddict.Core extension

OpenIddict.sln

@@ -107,9 +107,9 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{
 		.github\workflows\build.yml = .github\workflows\build.yml
 	EndProjectSection
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenIddict.Server.Quartz", "src\OpenIddict.Server.Quartz\OpenIddict.Server.Quartz.csproj", "{FD150A90-1997-45C7-9EBE-7C6E62E464E8}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenIddict.Quartz", "src\OpenIddict.Quartz\OpenIddict.Quartz.csproj", "{FD150A90-1997-45C7-9EBE-7C6E62E464E8}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenIddict.Server.Quartz.Tests", "test\OpenIddict.Server.Quartz.Tests\OpenIddict.Server.Quartz.Tests.csproj", "{01420929-33B8-4B60-A618-8C8B5F139630}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenIddict.Quartz.Tests", "test\OpenIddict.Quartz.Tests\OpenIddict.Quartz.Tests.csproj", "{01420929-33B8-4B60-A618-8C8B5F139630}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

samples/Mvc.Server/Mvc.Server.csproj

@@ -11,7 +11,7 @@
     <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.Server.Quartz\OpenIddict.Server.Quartz.csproj" />
+    <ProjectReference Include="..\..\src\OpenIddict.Quartz\OpenIddict.Quartz.csproj" />
   </ItemGroup>
 
   <ItemGroup>

samples/Mvc.Server/Startup.cs

@@ -73,6 +73,9 @@ namespace Mvc.Server
                     // and configure OpenIddict to use the specified MongoDB database:
                     // options.UseMongoDb()
                     //        .UseDatabase(new MongoClient().GetDatabase("openiddict"));
+
+                    // Enable Quartz.NET integration.
+                    options.UseQuartz();
                 })
 
                 // Register the OpenIddict server components.
@@ -110,9 +113,6 @@ namespace Mvc.Server
                            .EnableVerificationEndpointPassthrough()
                            .DisableTransportSecurityRequirement(); // During development, you can disable the HTTPS requirement.
 
-                    // Enable Quartz.NET integration.
-                    options.UseQuartz();
-
                     // Note: if you don't want to specify a client_id when sending
                     // a token or revocation request, uncomment the following line:
                     //

src/OpenIddict.Abstractions/Resources/OpenIddictResources.resx

@@ -481,7 +481,7 @@ Consider using 'options.AddSigningCredentials(SigningCredentials)' instead.</val
     <comment>{Locked}</comment>
   </data>
   <data name="ID0082" xml:space="preserve">
-    <value>Dependency injection support must be enabled in Quartz.NET when using the OpenIddict server integration.
+    <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>
     <comment>{Locked}</comment>
   </data>
@@ -1369,7 +1369,7 @@ Consider creating non-generic classes derived from the default entities for the
     <comment>{Locked}</comment>
   </data>
   <data name="ID0278" xml:space="preserve">
-    <value>The core services must be registered when enabling the OpenIddict server Quartz.NET integration.
+    <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>
     <comment>{Locked}</comment>
   </data>

src/OpenIddict.Server.Quartz/OpenIddict.Server.Quartz.csproj → src/OpenIddict.Quartz/OpenIddict.Quartz.csproj

@@ -7,12 +7,12 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <Description>Quartz.NET integration package for the OpenIddict server services.</Description>
-    <PackageTags>$(PackageTags);quartz;server</PackageTags>
+    <Description>Quartz.NET integration package for OpenIddict.</Description>
+    <PackageTags>$(PackageTags);quartz</PackageTags>
   </PropertyGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\OpenIddict.Server\OpenIddict.Server.csproj" />
+    <ProjectReference Include="..\OpenIddict.Core\OpenIddict.Core.csproj" />
   </ItemGroup>
 
   <ItemGroup>

src/OpenIddict.Server.Quartz/OpenIddictServerQuartzBuilder.cs → src/OpenIddict.Quartz/OpenIddictQuartzBuilder.cs

@@ -6,22 +6,21 @@
 
 using System;
 using System.ComponentModel;
-using OpenIddict.Server.Quartz;
+using OpenIddict.Quartz;
 using SR = OpenIddict.Abstractions.OpenIddictResources;
 
 namespace Microsoft.Extensions.DependencyInjection
 {
     /// <summary>
-    /// Exposes the necessary methods required to configure
-    /// the OpenIddict server Quartz.NET integration.
+    /// Exposes the necessary methods required to configure the OpenIddict Quartz.NET integration.
     /// </summary>
-    public class OpenIddictServerQuartzBuilder
+    public class OpenIddictQuartzBuilder
     {
         /// <summary>
-        /// Initializes a new instance of <see cref="OpenIddictServerQuartzBuilder"/>.
+        /// Initializes a new instance of <see cref="OpenIddictQuartzBuilder"/>.
         /// </summary>
         /// <param name="services">The services collection.</param>
-        public OpenIddictServerQuartzBuilder(IServiceCollection services)
+        public OpenIddictQuartzBuilder(IServiceCollection services)
             => Services = services ?? throw new ArgumentNullException(nameof(services));
 
         /// <summary>
@@ -31,12 +30,12 @@ namespace Microsoft.Extensions.DependencyInjection
         public IServiceCollection Services { get; }
 
         /// <summary>
-        /// Amends the default OpenIddict server Quartz.NET configuration.
+        /// 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="OpenIddictServerQuartzBuilder"/>.</returns>
-        public OpenIddictServerQuartzBuilder Configure(Action<OpenIddictServerQuartzOptions> configuration)
+        /// <returns>The <see cref="OpenIddictQuartzBuilder"/>.</returns>
+        public OpenIddictQuartzBuilder Configure(Action<OpenIddictQuartzOptions> configuration)
         {
             if (configuration is null)
             {
@@ -51,23 +50,23 @@ namespace Microsoft.Extensions.DependencyInjection
         /// <summary>
         /// Disables authorizations pruning.
         /// </summary>
-        /// <returns>The <see cref="OpenIddictServerQuartzBuilder"/>.</returns>
-        public OpenIddictServerQuartzBuilder DisableAuthorizationPruning()
+        /// <returns>The <see cref="OpenIddictQuartzBuilder"/>.</returns>
+        public OpenIddictQuartzBuilder DisableAuthorizationPruning()
             => Configure(options => options.DisableAuthorizationPruning = true);
 
         /// <summary>
         /// Disables tokens pruning.
         /// </summary>
-        /// <returns>The <see cref="OpenIddictServerQuartzBuilder"/>.</returns>
-        public OpenIddictServerQuartzBuilder DisableTokenPruning()
+        /// <returns>The <see cref="OpenIddictQuartzBuilder"/>.</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="OpenIddictServerQuartzBuilder"/>.</returns>
-        public OpenIddictServerQuartzBuilder SetMaximumRefireCount(int count)
+        /// <returns>The <see cref="OpenIddictQuartzBuilder"/>.</returns>
+        public OpenIddictQuartzBuilder SetMaximumRefireCount(int count)
         {
             if (count < 0)
             {
@@ -81,8 +80,8 @@ namespace Microsoft.Extensions.DependencyInjection
         /// 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="OpenIddictServerQuartzBuilder"/>.</returns>
-        public OpenIddictServerQuartzBuilder SetMinimumAuthorizationLifespan(TimeSpan lifespan)
+        /// <returns>The <see cref="OpenIddictQuartzBuilder"/>.</returns>
+        public OpenIddictQuartzBuilder SetMinimumAuthorizationLifespan(TimeSpan lifespan)
         {
             if (lifespan < TimeSpan.FromMinutes(10))
             {
@@ -96,8 +95,8 @@ namespace Microsoft.Extensions.DependencyInjection
         /// 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="OpenIddictServerQuartzBuilder"/>.</returns>
-        public OpenIddictServerQuartzBuilder SetMinimumTokenLifespan(TimeSpan lifespan)
+        /// <returns>The <see cref="OpenIddictQuartzBuilder"/>.</returns>
+        public OpenIddictQuartzBuilder SetMinimumTokenLifespan(TimeSpan lifespan)
         {
             if (lifespan < TimeSpan.FromMinutes(10))
             {

src/OpenIddict.Server.Quartz/OpenIddictServerQuartzExtensions.cs → src/OpenIddict.Quartz/OpenIddictQuartzExtensions.cs

@@ -7,24 +7,24 @@
 using System;
 using System.Linq;
 using Microsoft.Extensions.DependencyInjection.Extensions;
-using OpenIddict.Server.Quartz;
+using OpenIddict.Quartz;
 using Quartz;
 using SR = OpenIddict.Abstractions.OpenIddictResources;
 
 namespace Microsoft.Extensions.DependencyInjection
 {
     /// <summary>
-    /// Exposes extensions allowing to register the OpenIddict server Quartz.NET integration.
+    /// Exposes extensions allowing to register the OpenIddict Quartz.NET integration.
     /// </summary>
-    public static class OpenIddictServerQuartzExtensions
+    public static class OpenIddictQuartzExtensions
     {
         /// <summary>
-        /// Registers the OpenIddict server Quartz.NET integration in the DI container.
+        /// 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="OpenIddictServerQuartzBuilder"/>.</returns>
-        public static OpenIddictServerQuartzBuilder UseQuartz(this OpenIddictServerBuilder builder)
+        /// <returns>The <see cref="OpenIddictQuartzBuilder"/>.</returns>
+        public static OpenIddictQuartzBuilder UseQuartz(this OpenIddictCoreBuilder builder)
         {
             if (builder is null)
             {
@@ -34,54 +34,54 @@ namespace Microsoft.Extensions.DependencyInjection
             // Warning: the AddQuartz() method is deliberately not used as it's not idempotent.
             // Calling it at this point may override user-defined services (e.g Quartz DI support).
 
-            builder.Services.TryAddTransient<OpenIddictServerQuartzJob>();
+            builder.Services.TryAddTransient<OpenIddictQuartzJob>();
 
             // To ensure this method can be safely called multiple times, the job details
-            // of the OpenIddict server job are only added if no existing IJobDetail instance
-            // pointing to OpenIddictServerQuartzJob was already registered in the DI container.
+            // of the OpenIddict job are only added if no existing IJobDetail instance
+            // pointing to OpenIddictQuartzJob was already registered in the DI container.
             if (!builder.Services.Any(descriptor => descriptor.ServiceType == typeof(IJobDetail) &&
                                                     descriptor.ImplementationInstance is IJobDetail job &&
-                                                    job.Key.Equals(OpenIddictServerQuartzJob.Identity)))
+                                                    job.Key.Equals(OpenIddictQuartzJob.Identity)))
             {
                 builder.Services.AddSingleton(
-                    JobBuilder.Create<OpenIddictServerQuartzJob>()
+                    JobBuilder.Create<OpenIddictQuartzJob>()
                         .StoreDurably()
-                        .WithIdentity(OpenIddictServerQuartzJob.Identity)
+                        .WithIdentity(OpenIddictQuartzJob.Identity)
                         .WithDescription(SR.GetResourceString(SR.ID8000))
                         .Build());
             }
 
             // To ensure this method can be safely called multiple times, the trigger details
-            // of the OpenIddict server job are only added if no existing ITrigger instance
-            // pointing to OpenIddictServerQuartzJob was already registered in the DI container.
+            // of the OpenIddict job are only added if no existing ITrigger instance
+            // pointing to OpenIddictQuartzJob was already registered in the DI container.
             if (!builder.Services.Any(descriptor => descriptor.ServiceType == typeof(ITrigger) &&
                                                     descriptor.ImplementationInstance is ITrigger trigger &&
-                                                    trigger.JobKey.Equals(OpenIddictServerQuartzJob.Identity)))
+                                                    trigger.JobKey.Equals(OpenIddictQuartzJob.Identity)))
             {
                 // 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 immediately to ensure it's executed at least once.
                 builder.Services.AddSingleton(
                     TriggerBuilder.Create()
-                        .ForJob(OpenIddictServerQuartzJob.Identity)
+                        .ForJob(OpenIddictQuartzJob.Identity)
                         .WithSimpleSchedule(options => options.WithIntervalInHours(1).RepeatForever())
                         .WithDescription(SR.GetResourceString(SR.ID8001))
                         .StartNow()
                         .Build());
             }
 
-            return new OpenIddictServerQuartzBuilder(builder.Services);
+            return new OpenIddictQuartzBuilder(builder.Services);
         }
 
         /// <summary>
-        /// Registers the OpenIddict server Quartz.NET integration in the DI container.
+        /// 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 server 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="OpenIddictServerBuilder"/>.</returns>
-        public static OpenIddictServerBuilder UseQuartz(
-            this OpenIddictServerBuilder builder, Action<OpenIddictServerQuartzBuilder> configuration)
+        /// <returns>The <see cref="OpenIddictCoreBuilder"/>.</returns>
+        public static OpenIddictCoreBuilder UseQuartz(
+            this OpenIddictCoreBuilder builder, Action<OpenIddictQuartzBuilder> configuration)
         {
             if (builder is null)
             {

src/OpenIddict.Server.Quartz/OpenIddictServerQuartzJob.cs → src/OpenIddict.Quartz/OpenIddictQuartzJob.cs

@@ -13,28 +13,28 @@ using OpenIddict.Abstractions;
 using Quartz;
 using SR = OpenIddict.Abstractions.OpenIddictResources;
 
-namespace OpenIddict.Server.Quartz
+namespace OpenIddict.Quartz
 {
     /// <summary>
-    /// Represents a Quartz.NET job performing scheduled tasks for the OpenIddict server feature.
+    /// Represents a Quartz.NET job performing scheduled tasks for OpenIddict.
     /// </summary>
     [DisallowConcurrentExecution]
-    public class OpenIddictServerQuartzJob : IJob
+    public class OpenIddictQuartzJob : IJob
     {
-        private readonly IOptionsMonitor<OpenIddictServerQuartzOptions> _options;
+        private readonly IOptionsMonitor<OpenIddictQuartzOptions> _options;
         private readonly IServiceProvider _provider;
 
         /// <summary>
-        /// Creates a new instance of the <see cref="OpenIddictServerQuartzJob"/> class.
+        /// Creates a new instance of the <see cref="OpenIddictQuartzJob"/> class.
         /// </summary>
-        public OpenIddictServerQuartzJob() => throw new InvalidOperationException(SR.GetResourceString(SR.ID0082));
+        public OpenIddictQuartzJob() => throw new InvalidOperationException(SR.GetResourceString(SR.ID0082));
 
         /// <summary>
-        /// Creates a new instance of the <see cref="OpenIddictServerQuartzJob"/> class.
+        /// Creates a new instance of the <see cref="OpenIddictQuartzJob"/> class.
         /// </summary>
-        /// <param name="options">The OpenIddict server Quartz.NET options.</param>
+        /// <param name="options">The OpenIddict Quartz.NET options.</param>
         /// <param name="provider">The service provider.</param>
-        public OpenIddictServerQuartzJob(IOptionsMonitor<OpenIddictServerQuartzOptions> options, IServiceProvider provider)
+        public OpenIddictQuartzJob(IOptionsMonitor<OpenIddictQuartzOptions> options, IServiceProvider provider)
         {
             _options = options;
             _provider = provider;
@@ -44,8 +44,8 @@ namespace OpenIddict.Server.Quartz
         /// Gets the default identity assigned to this job.
         /// </summary>
         public static JobKey Identity { get; } = new JobKey(
-            name: typeof(OpenIddictServerQuartzJob).Name,
-            group: typeof(OpenIddictServerQuartzJob).Assembly.GetName().Name!);
+            name: typeof(OpenIddictQuartzJob).Name,
+            group: typeof(OpenIddictQuartzJob).Assembly.GetName().Name!);
 
         /// <inheritdoc/>
         public async Task Execute(IJobExecutionContext context)

src/OpenIddict.Server.Quartz/OpenIddictServerQuartzOptions.cs → src/OpenIddict.Quartz/OpenIddictQuartzOptions.cs

@@ -6,12 +6,12 @@
 
 using System;
 
-namespace OpenIddict.Server.Quartz
+namespace OpenIddict.Quartz
 {
     /// <summary>
-    /// Provides various settings needed to configure the OpenIddict Quartz.NET server integration.
+    /// Provides various settings needed to configure the OpenIddict Quartz.NET integration.
     /// </summary>
-    public class OpenIddictServerQuartzOptions
+    public class OpenIddictQuartzOptions
     {
         /// <summary>
         /// Gets or sets a boolean indicating whether authorizations pruning should be disabled.

test/OpenIddict.Server.Quartz.Tests/OpenIddict.Server.Quartz.Tests.csproj → test/OpenIddict.Quartz.Tests/OpenIddict.Quartz.Tests.csproj

@@ -12,7 +12,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\src\OpenIddict.Server.Quartz\OpenIddict.Server.Quartz.csproj" />
+    <ProjectReference Include="..\..\src\OpenIddict.Quartz\OpenIddict.Quartz.csproj" />
   </ItemGroup>
 
 </Project>

test/OpenIddict.Server.Quartz.Tests/OpenIddictServerQuartzBuilderTests.cs → test/OpenIddict.Quartz.Tests/OpenIddictQuartzBuilderTests.cs

@@ -4,9 +4,9 @@ using Microsoft.Extensions.Options;
 using Xunit;
 using SR = OpenIddict.Abstractions.OpenIddictResources;
 
-namespace OpenIddict.Server.Quartz.Tests
+namespace OpenIddict.Quartz.Tests
 {
-    public class OpenIddictServerQuartzBuilderTests
+    public class OpenIddictQuartzBuilderTests
     {
         [Fact]
         public void Constructor_ThrowsAnExceptionForNullServices()
@@ -15,7 +15,7 @@ namespace OpenIddict.Server.Quartz.Tests
             var services = (IServiceCollection) null!;
 
             // Act and assert
-            var exception = Assert.Throws<ArgumentNullException>(() => new OpenIddictServerQuartzBuilder(services));
+            var exception = Assert.Throws<ArgumentNullException>(() => new OpenIddictQuartzBuilder(services));
 
             Assert.Equal("services", exception.ParamName);
         }
@@ -26,14 +26,14 @@ namespace OpenIddict.Server.Quartz.Tests
             // Arrange
             var services = CreateServices();
             var builder = CreateBuilder(services);
-            var configuration = new Action<OpenIddictServerQuartzOptions>(options => { });
+            var configuration = new Action<OpenIddictQuartzOptions>(options => { });
 
             // Act
             builder.Configure(configuration);
 
             // Assert
-            Assert.Contains(services, service => service.ServiceType == typeof(IConfigureOptions<OpenIddictServerQuartzOptions>) &&
-                service.ImplementationInstance is ConfigureNamedOptions<OpenIddictServerQuartzOptions> options &&
+            Assert.Contains(services, service => service.ServiceType == typeof(IConfigureOptions<OpenIddictQuartzOptions>) &&
+                service.ImplementationInstance is ConfigureNamedOptions<OpenIddictQuartzOptions> options &&
                 options.Action == configuration && string.IsNullOrEmpty(options.Name));
         }
 
@@ -174,13 +174,13 @@ namespace OpenIddict.Server.Quartz.Tests
         private static IServiceCollection CreateServices()
             => new ServiceCollection().AddOptions();
 
-        private static OpenIddictServerQuartzBuilder CreateBuilder(IServiceCollection services)
-            => new OpenIddictServerQuartzBuilder(services);
+        private static OpenIddictQuartzBuilder CreateBuilder(IServiceCollection services)
+            => new OpenIddictQuartzBuilder(services);
 
-        private static OpenIddictServerQuartzOptions GetOptions(IServiceCollection services)
+        private static OpenIddictQuartzOptions GetOptions(IServiceCollection services)
         {
             var provider = services.BuildServiceProvider();
-            var options = provider.GetRequiredService<IOptions<OpenIddictServerQuartzOptions>>();
+            var options = provider.GetRequiredService<IOptions<OpenIddictQuartzOptions>>();
             return options.Value;
         }
     }

test/OpenIddict.Server.Quartz.Tests/OpenIddictServerQuartzExtensionsTests.cs → test/OpenIddict.Quartz.Tests/OpenIddictQuartzExtensionsTests.cs

@@ -3,15 +3,15 @@ using Microsoft.Extensions.DependencyInjection;
 using Quartz;
 using Xunit;
 
-namespace OpenIddict.Server.Quartz.Tests
+namespace OpenIddict.Quartz.Tests
 {
-    public class OpenIddictServerQuartzExtensionsTests
+    public class OpenIddictQuartzExtensionsTests
     {
         [Fact]
         public void UseQuartz_ThrowsAnExceptionForNullBuilder()
         {
             // Arrange
-            var builder = (OpenIddictServerBuilder) null!;
+            var builder = (OpenIddictCoreBuilder) null!;
 
             // Act and assert
             var exception = Assert.Throws<ArgumentNullException>(() => builder.UseQuartz());
@@ -24,7 +24,7 @@ namespace OpenIddict.Server.Quartz.Tests
         {
             // Arrange
             var services = new ServiceCollection();
-            var builder = new OpenIddictServerBuilder(services);
+            var builder = new OpenIddictCoreBuilder(services);
 
             // Act and assert
             var exception = Assert.Throws<ArgumentNullException>(() => builder.UseQuartz(configuration: null!));
@@ -37,14 +37,14 @@ namespace OpenIddict.Server.Quartz.Tests
         {
             // Arrange
             var services = new ServiceCollection();
-            var builder = new OpenIddictServerBuilder(services);
+            var builder = new OpenIddictCoreBuilder(services);
 
             // Act
             builder.UseQuartz();
 
             // Assert
-            Assert.Contains(services, service => service.ServiceType == typeof(OpenIddictServerQuartzJob) &&
-                service.ImplementationType == typeof(OpenIddictServerQuartzJob) &&
+            Assert.Contains(services, service => service.ServiceType == typeof(OpenIddictQuartzJob) &&
+                service.ImplementationType == typeof(OpenIddictQuartzJob) &&
                 service.Lifetime == ServiceLifetime.Transient);
         }
 
@@ -53,7 +53,7 @@ namespace OpenIddict.Server.Quartz.Tests
         {
             // Arrange
             var services = new ServiceCollection();
-            var builder = new OpenIddictServerBuilder(services);
+            var builder = new OpenIddictCoreBuilder(services);
 
             // Act
             builder.UseQuartz();
@@ -61,7 +61,7 @@ namespace OpenIddict.Server.Quartz.Tests
             // Assert
             Assert.Contains(services, service => service.ServiceType == typeof(IJobDetail) &&
                 service.ImplementationInstance is IJobDetail job &&
-                job.Key.Equals(OpenIddictServerQuartzJob.Identity));
+                job.Key.Equals(OpenIddictQuartzJob.Identity));
         }
 
         [Fact]
@@ -69,7 +69,7 @@ namespace OpenIddict.Server.Quartz.Tests
         {
             // Arrange
             var services = new ServiceCollection();
-            var builder = new OpenIddictServerBuilder(services);
+            var builder = new OpenIddictCoreBuilder(services);
 
             // Act
             builder.UseQuartz();
@@ -77,7 +77,7 @@ namespace OpenIddict.Server.Quartz.Tests
             // Assert
             Assert.Contains(services, service => service.ServiceType == typeof(ITrigger) &&
                 service.ImplementationInstance is ITrigger trigger &&
-                trigger.JobKey.Equals(OpenIddictServerQuartzJob.Identity));
+                trigger.JobKey.Equals(OpenIddictQuartzJob.Identity));
         }
 
         [Fact]
@@ -85,7 +85,7 @@ namespace OpenIddict.Server.Quartz.Tests
         {
             // Arrange
             var services = new ServiceCollection();
-            var builder = new OpenIddictServerBuilder(services);
+            var builder = new OpenIddictCoreBuilder(services);
 
             // Act
             builder.UseQuartz();
@@ -95,11 +95,11 @@ namespace OpenIddict.Server.Quartz.Tests
             // Assert
             Assert.Single(services, service => service.ServiceType == typeof(IJobDetail) &&
                 service.ImplementationInstance is IJobDetail job &&
-                job.Key.Equals(OpenIddictServerQuartzJob.Identity));
+                job.Key.Equals(OpenIddictQuartzJob.Identity));
 
             Assert.Single(services, service => service.ServiceType == typeof(ITrigger) &&
                 service.ImplementationInstance is ITrigger trigger &&
-                trigger.JobKey.Equals(OpenIddictServerQuartzJob.Identity));
+                trigger.JobKey.Equals(OpenIddictQuartzJob.Identity));
         }
     }
 }

test/OpenIddict.Server.Quartz.Tests/OpenIddictServerQuartzJobTests.cs → test/OpenIddict.Quartz.Tests/OpenIddictQuartzJobTests.cs

@@ -9,15 +9,15 @@ using Quartz;
 using Xunit;
 using SR = OpenIddict.Abstractions.OpenIddictResources;
 
-namespace OpenIddict.Server.Quartz.Tests
+namespace OpenIddict.Quartz.Tests
 {
-    public class OpenIddictServerQuartzJobTests
+    public class OpenIddictQuartzJobTests
     {
         [Fact]
         public void Constructor_ThrowsAnException()
         {
             // Arrange, act and assert
-            var exception = Assert.Throws<InvalidOperationException>(() => new OpenIddictServerQuartzJob());
+            var exception = Assert.Throws<InvalidOperationException>(() => new OpenIddictQuartzJob());
 
             Assert.Equal(SR.GetResourceString(SR.ID0082), exception.Message);
         }
@@ -32,10 +32,10 @@ namespace OpenIddict.Server.Quartz.Tests
 
             var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == provider);
             var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope);
-            var monitor = Mock.Of<IOptionsMonitor<OpenIddictServerQuartzOptions>>(
-                monitor => monitor.CurrentValue == new OpenIddictServerQuartzOptions());
+            var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
+                monitor => monitor.CurrentValue == new OpenIddictQuartzOptions());
 
-            var job = new OpenIddictServerQuartzJob(monitor,
+            var job = new OpenIddictQuartzJob(monitor,
                 Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory));
 
             // Act
@@ -56,7 +56,7 @@ namespace OpenIddict.Server.Quartz.Tests
                 provider.GetService(typeof(IOpenIddictAuthorizationManager)) == Mock.Of<IOpenIddictAuthorizationManager>() &&
                 provider.GetService(typeof(IOpenIddictTokenManager)) == manager.Object);
 
-            var job = CreateJob(provider, new OpenIddictServerQuartzOptions
+            var job = CreateJob(provider, new OpenIddictQuartzOptions
             {
                 DisableTokenPruning = true
             });
@@ -79,7 +79,7 @@ namespace OpenIddict.Server.Quartz.Tests
                 provider.GetService(typeof(IOpenIddictAuthorizationManager)) == manager.Object &&
                 provider.GetService(typeof(IOpenIddictTokenManager)) == Mock.Of<IOpenIddictTokenManager>());
 
-            var job = CreateJob(provider, new OpenIddictServerQuartzOptions
+            var job = CreateJob(provider, new OpenIddictQuartzOptions
             {
                 DisableAuthorizationPruning = true
             });
@@ -324,7 +324,7 @@ namespace OpenIddict.Server.Quartz.Tests
 
             var context = Mock.Of<IJobExecutionContext>(context => context.RefireCount == 5);
 
-            var job = CreateJob(provider, new OpenIddictServerQuartzOptions
+            var job = CreateJob(provider, new OpenIddictQuartzOptions
             {
                 MaximumRefireCount = 5
             });
@@ -335,14 +335,14 @@ namespace OpenIddict.Server.Quartz.Tests
             Assert.False(exception.RefireImmediately);
         }
 
-        private static OpenIddictServerQuartzJob CreateJob(IServiceProvider provider, OpenIddictServerQuartzOptions? options = null)
+        private static OpenIddictQuartzJob CreateJob(IServiceProvider provider, OpenIddictQuartzOptions? options = null)
         {
             var scope = Mock.Of<IServiceScope>(scope => scope.ServiceProvider == provider);
             var factory = Mock.Of<IServiceScopeFactory>(factory => factory.CreateScope() == scope);
-            var monitor = Mock.Of<IOptionsMonitor<OpenIddictServerQuartzOptions>>(
-                monitor => monitor.CurrentValue == (options ?? new OpenIddictServerQuartzOptions()));
+            var monitor = Mock.Of<IOptionsMonitor<OpenIddictQuartzOptions>>(
+                monitor => monitor.CurrentValue == (options ?? new OpenIddictQuartzOptions()));
 
-            return new OpenIddictServerQuartzJob(monitor,
+            return new OpenIddictQuartzJob(monitor,
                 Mock.Of<IServiceProvider>(provider => provider.GetService(typeof(IServiceScopeFactory)) == factory));
         }
     }