Introduce non-generic SetDefaultApplicationEntity/SetDefaultAuthorizationEntity/SetDefaultScopeEntity/SetDefaultTokenEntity

src/OpenIddict.Core/OpenIddictCoreBuilder.cs

@@ -651,32 +651,108 @@ namespace Microsoft.Extensions.DependencyInjection
         /// Configures OpenIddict to use the specified entity as the default application entity.
         /// </summary>
         /// <returns>The <see cref="OpenIddictCoreBuilder"/>.</returns>
-        public OpenIddictCoreBuilder SetDefaultApplicationEntity<TApplication>()
-            where TApplication : class, new()
-            => Configure(options => options.DefaultApplicationType = typeof(TApplication));
+        public OpenIddictCoreBuilder SetDefaultApplicationEntity<TApplication>() where TApplication : class
+            => SetDefaultApplicationEntity(typeof(TApplication));
+
+        /// <summary>
+        /// Configures OpenIddict to use the specified entity as the default application entity.
+        /// </summary>
+        /// <param name="type">The application entity type.</param>
+        /// <returns>The <see cref="OpenIddictCoreBuilder"/>.</returns>
+        public OpenIddictCoreBuilder SetDefaultApplicationEntity([NotNull] Type type)
+        {
+            if (type == null)
+            {
+                throw new ArgumentNullException(nameof(type));
+            }
+
+            if (type.IsValueType)
+            {
+                throw new ArgumentException("The specified type is invalid.", nameof(type));
+            }
+
+            return Configure(options => options.DefaultApplicationType = type);
+        }
 
         /// <summary>
         /// Configures OpenIddict to use the specified entity as the default authorization entity.
         /// </summary>
         /// <returns>The <see cref="OpenIddictCoreBuilder"/>.</returns>
-        public OpenIddictCoreBuilder SetDefaultAuthorizationEntity<TAuthorization>()
-            where TAuthorization : class, new()
-            => Configure(options => options.DefaultAuthorizationType = typeof(TAuthorization));
+        public OpenIddictCoreBuilder SetDefaultAuthorizationEntity<TAuthorization>() where TAuthorization : class
+            => SetDefaultAuthorizationEntity(typeof(TAuthorization));
+
+        /// <summary>
+        /// Configures OpenIddict to use the specified entity as the default authorization entity.
+        /// </summary>
+        /// <param name="type">The authorization entity type.</param>
+        /// <returns>The <see cref="OpenIddictCoreBuilder"/>.</returns>
+        public OpenIddictCoreBuilder SetDefaultAuthorizationEntity([NotNull] Type type)
+        {
+            if (type == null)
+            {
+                throw new ArgumentNullException(nameof(type));
+            }
+
+            if (type.IsValueType)
+            {
+                throw new ArgumentException("The specified type is invalid.", nameof(type));
+            }
+
+            return Configure(options => options.DefaultAuthorizationType = type);
+        }
+
+        /// <summary>
+        /// Configures OpenIddict to use the specified entity as the default scope entity.
+        /// </summary>
+        /// <returns>The <see cref="OpenIddictCoreBuilder"/>.</returns>
+        public OpenIddictCoreBuilder SetDefaultScopeEntity<TScope>() where TScope : class
+            => SetDefaultScopeEntity(typeof(TScope));
 
         /// <summary>
         /// Configures OpenIddict to use the specified entity as the default scope entity.
         /// </summary>
+        /// <param name="type">The scope entity type.</param>
+        /// <returns>The <see cref="OpenIddictCoreBuilder"/>.</returns>
+        public OpenIddictCoreBuilder SetDefaultScopeEntity([NotNull] Type type)
+        {
+            if (type == null)
+            {
+                throw new ArgumentNullException(nameof(type));
+            }
+
+            if (type.IsValueType)
+            {
+                throw new ArgumentException("The specified type is invalid.", nameof(type));
+            }
+
+            return Configure(options => options.DefaultScopeType = type);
+        }
+
+        /// <summary>
+        /// Configures OpenIddict to use the specified entity as the default token entity.
+        /// </summary>
         /// <returns>The <see cref="OpenIddictCoreBuilder"/>.</returns>
-        public OpenIddictCoreBuilder SetDefaultScopeEntity<TScope>()
-            where TScope : class, new()
-            => Configure(options => options.DefaultScopeType = typeof(TScope));
+        public OpenIddictCoreBuilder SetDefaultTokenEntity<TToken>() where TToken : class
+            => SetDefaultTokenEntity(typeof(TToken));
 
         /// <summary>
         /// Configures OpenIddict to use the specified entity as the default token entity.
         /// </summary>
+        /// <param name="type">The token entity type.</param>
         /// <returns>The <see cref="OpenIddictCoreBuilder"/>.</returns>
-        public OpenIddictCoreBuilder SetDefaultTokenEntity<TToken>()
-            where TToken : class, new()
-            => Configure(options => options.DefaultTokenType = typeof(TToken));
+        public OpenIddictCoreBuilder SetDefaultTokenEntity([NotNull] Type type)
+        {
+            if (type == null)
+            {
+                throw new ArgumentNullException(nameof(type));
+            }
+
+            if (type.IsValueType)
+            {
+                throw new ArgumentException("The specified type is invalid.", nameof(type));
+            }
+
+            return Configure(options => options.DefaultTokenType = type);
+        }
     }
 }

test/OpenIddict.Core.Tests/OpenIddictCoreBuilderTests.cs

@@ -356,27 +356,202 @@ namespace OpenIddict.Core.Tests
         }
 
         [Fact]
-        public void RegisterDefaultModels_CustomEntitiesAreCorrectlySet()
+        public void SetDefaultApplicationEntity_ThrowsAnExceptionForNullType()
+        {
+            // Arrange
+            var services = CreateServices();
+            var builder = CreateBuilder(services);
+
+            // Act and assert
+            var exception = Assert.Throws<ArgumentNullException>(delegate
+            {
+                return builder.SetDefaultApplicationEntity(type: null);
+            });
+
+            Assert.Equal("type", exception.ParamName);
+        }
+
+        [Fact]
+        public void SetDefaultApplicationEntity_ThrowsAnExceptionForInvalidType()
+        {
+            // Arrange
+            var services = CreateServices();
+            var builder = CreateBuilder(services);
+
+            // Act and assert
+            var exception = Assert.Throws<ArgumentException>(delegate
+            {
+                return builder.SetDefaultApplicationEntity(typeof(long));
+            });
+
+            Assert.Equal("type", exception.ParamName);
+            Assert.StartsWith("The specified type is invalid.", exception.Message);
+        }
+
+        [Fact]
+        public void SetDefaultApplicationEntity_EntityIsCorrectlySet()
         {
             // Arrange
             var services = CreateServices();
             var builder = CreateBuilder(services);
 
             // Act
-            services.AddOpenIddict()
-                .AddCore()
-                    .SetDefaultApplicationEntity<CustomApplication>()
-                    .SetDefaultAuthorizationEntity<CustomAuthorization>()
-                    .SetDefaultScopeEntity<CustomScope>()
-                    .SetDefaultTokenEntity<CustomToken>();
+            builder.SetDefaultApplicationEntity<CustomApplication>();
 
             // Assert
             var provider = services.BuildServiceProvider();
             var options = provider.GetRequiredService<IOptionsMonitor<OpenIddictCoreOptions>>().CurrentValue;
 
             Assert.Equal(typeof(CustomApplication), options.DefaultApplicationType);
+        }
+
+        [Fact]
+        public void SetDefaultAuthorizationEntity_ThrowsAnExceptionForNullType()
+        {
+            // Arrange
+            var services = CreateServices();
+            var builder = CreateBuilder(services);
+
+            // Act and assert
+            var exception = Assert.Throws<ArgumentNullException>(delegate
+            {
+                return builder.SetDefaultAuthorizationEntity(type: null);
+            });
+
+            Assert.Equal("type", exception.ParamName);
+        }
+
+        [Fact]
+        public void SetDefaultAuthorizationEntity_ThrowsAnExceptionForInvalidType()
+        {
+            // Arrange
+            var services = CreateServices();
+            var builder = CreateBuilder(services);
+
+            // Act and assert
+            var exception = Assert.Throws<ArgumentException>(delegate
+            {
+                return builder.SetDefaultAuthorizationEntity(typeof(long));
+            });
+
+            Assert.Equal("type", exception.ParamName);
+            Assert.StartsWith("The specified type is invalid.", exception.Message);
+        }
+
+        [Fact]
+        public void SetDefaultAuthorizationEntity_EntityIsCorrectlySet()
+        {
+            // Arrange
+            var services = CreateServices();
+            var builder = CreateBuilder(services);
+
+            // Act
+            builder.SetDefaultAuthorizationEntity<CustomAuthorization>();
+
+            // Assert
+            var provider = services.BuildServiceProvider();
+            var options = provider.GetRequiredService<IOptionsMonitor<OpenIddictCoreOptions>>().CurrentValue;
+
             Assert.Equal(typeof(CustomAuthorization), options.DefaultAuthorizationType);
+        }
+
+        [Fact]
+        public void SetDefaultScopeEntity_ThrowsAnExceptionForNullType()
+        {
+            // Arrange
+            var services = CreateServices();
+            var builder = CreateBuilder(services);
+
+            // Act and assert
+            var exception = Assert.Throws<ArgumentNullException>(delegate
+            {
+                return builder.SetDefaultScopeEntity(type: null);
+            });
+
+            Assert.Equal("type", exception.ParamName);
+        }
+
+        [Fact]
+        public void SetDefaultScopeEntity_ThrowsAnExceptionForInvalidType()
+        {
+            // Arrange
+            var services = CreateServices();
+            var builder = CreateBuilder(services);
+
+            // Act and assert
+            var exception = Assert.Throws<ArgumentException>(delegate
+            {
+                return builder.SetDefaultScopeEntity(typeof(long));
+            });
+
+            Assert.Equal("type", exception.ParamName);
+            Assert.StartsWith("The specified type is invalid.", exception.Message);
+        }
+
+        [Fact]
+        public void SetDefaultScopeEntity_EntityIsCorrectlySet()
+        {
+            // Arrange
+            var services = CreateServices();
+            var builder = CreateBuilder(services);
+
+            // Act
+            builder.SetDefaultScopeEntity<CustomScope>();
+
+            // Assert
+            var provider = services.BuildServiceProvider();
+            var options = provider.GetRequiredService<IOptionsMonitor<OpenIddictCoreOptions>>().CurrentValue;
+
             Assert.Equal(typeof(CustomScope), options.DefaultScopeType);
+        }
+
+        [Fact]
+        public void SetDefaultTokenEntity_ThrowsAnExceptionForNullType()
+        {
+            // Arrange
+            var services = CreateServices();
+            var builder = CreateBuilder(services);
+
+            // Act and assert
+            var exception = Assert.Throws<ArgumentNullException>(delegate
+            {
+                return builder.SetDefaultTokenEntity(type: null);
+            });
+
+            Assert.Equal("type", exception.ParamName);
+        }
+
+        [Fact]
+        public void SetDefaultTokenEntity_ThrowsAnExceptionForInvalidType()
+        {
+            // Arrange
+            var services = CreateServices();
+            var builder = CreateBuilder(services);
+
+            // Act and assert
+            var exception = Assert.Throws<ArgumentException>(delegate
+            {
+                return builder.SetDefaultTokenEntity(typeof(long));
+            });
+
+            Assert.Equal("type", exception.ParamName);
+            Assert.StartsWith("The specified type is invalid.", exception.Message);
+        }
+
+        [Fact]
+        public void SetDefaultTokenEntity_EntityIsCorrectlySet()
+        {
+            // Arrange
+            var services = CreateServices();
+            var builder = CreateBuilder(services);
+
+            // Act
+            builder.SetDefaultTokenEntity<CustomToken>();
+
+            // Assert
+            var provider = services.BuildServiceProvider();
+            var options = provider.GetRequiredService<IOptionsMonitor<OpenIddictCoreOptions>>().CurrentValue;
+
             Assert.Equal(typeof(CustomToken), options.DefaultTokenType);
         }