Resolve #63 - Alter DI to avoid enumerating the container

.github/workflows/dotnetCi.yml

@@ -56,6 +56,11 @@ jobs:
         run: dotnet tool install --global dotnet-sonarscanner
       - name: Install Coverlet console
         run: dotnet tool install --global coverlet.console --version 8.0.1
+      - name: Install Java JDK for SonarScanner
+        uses: actions/setup-java@v5.1.0
+        with:
+          java-version: 21
+          distribution: zulu
       - name: Install DocFX
         run: dotnet tool install --global docfx
       # See https://chromium.googlesource.com/chromium/src/+/main/docs/security/apparmor-userns-restrictions.md

CSF.Extensions.WebDriver.Tests/Factories/WebDriverCreationConfigureOptionsTests.cs

@@ -203,7 +203,7 @@ public async Task ConfigureShouldNotThrowForARemoteDriverWithoutOptionsType([Sta
     [Test,AutoMoqData]
     public async Task ConfigureShouldBeAbleToSetupRemoteDriverWithSimpleOptionsFromJsonConfiguration([StandardTypes] IGetsDriverType driverTypeProvider,
                                                                                                      [StandardTypes] IGetsOptionsType optionsTypeProvider,
-                                                                                                     [TestLogger] ILogger<WebDriverCreationConfigureOptions> logger)
+                                                                                                     [TestLogger(LoggerType = typeof(WebDriverCreationConfigureOptions))] IGetsLogger loggerProvider)
     {
         var type = typeof(SafariOptions);
         Mock.Get(optionsTypeProvider)
@@ -214,7 +214,7 @@ public async Task ConfigureShouldBeAbleToSetupRemoteDriverWithSimpleOptionsFromJ
     ""DriverConfigurations"": {
         ""Test"": { ""DriverType"": ""RemoteWebDriver"", ""OptionsType"": ""SafariOptions"" }
     }
-}", logger: logger);
+}", loggerProvider: loggerProvider);
 
         Assert.That(options.DriverConfigurations, Is.Not.Empty);
     }
@@ -230,16 +230,16 @@ public async Task ConfigureShouldBeAbleToSetupRemoteDriverWithSimpleOptionsFromJ
     static async Task<WebDriverCreationOptionsCollection> GetOptionsAsync(IGetsDriverType driverTypeProvider,
                                                                           IGetsOptionsType optionsTypeProvider,
                                                                           string json,
-                                                                          ILogger<WebDriverCreationConfigureOptions>? logger = null)
+                                                                          IGetsLogger? loggerProvider = null)
     {
         var options = new WebDriverCreationOptionsCollection();
         var config = await ConfigurationFactory.GetConfigurationAsync(json);
         ICreatesDriverOptions optionsFactory = new ActivatorDriverOptionsFactory();
         optionsFactory = new ConfigBindingDriverOptionsFactoryDecorator(optionsFactory);
-        var parser = new WebDriverConfigurationItemParser(driverTypeProvider, optionsTypeProvider, optionsFactory, Mock.Of<ILogger<WebDriverConfigurationItemParser>>());
+        var parser = new WebDriverConfigurationItemParser(driverTypeProvider, optionsTypeProvider, optionsFactory, Mock.Of<IGetsLogger>());
         var sut = new WebDriverCreationConfigureOptions(parser,
                                                         config,
-                                                        logger ?? Mock.Of<ILogger<WebDriverCreationConfigureOptions>>(),
+                                                        loggerProvider ?? Mock.Of<IGetsLogger>(),
                                                         c => {});
         sut.Configure(options);
         return options;

CSF.Extensions.WebDriver.Tests/Factories/WebDriverFactoryIntegrationTests.cs

@@ -80,6 +80,18 @@ public void GetWebDriverShouldReturnADriverWithTheCorrectQuirksForFirefox()
         });
     }
 
+    [Test]
+    public void AddWebDriverFactoryWithoutOptionsPatternShouldNotEnumerateServiceCollection()
+    {
+        var serviceCollectionMock = new Mock<IServiceCollection>();
+        serviceCollectionMock.Setup(x => x.GetEnumerator()).Returns(Enumerable.Empty<ServiceDescriptor>().GetEnumerator());
+        var serviceCollection = serviceCollectionMock.Object;
+
+        serviceCollection.AddWebDriverFactoryWithoutOptionsPattern();
+
+        Mock.Get(serviceCollection).Verify(x => x.GetEnumerator(), Times.Never);
+    }
+
     Quirks.QuirksData GetCommonBrowserQuirks()
     {
         return new ()

CSF.Extensions.WebDriver.Tests/TestLoggerAttribute.cs

@@ -18,13 +18,23 @@ namespace CSF.Extensions.WebDriver;
 /// </remarks>
 public sealed class TestLoggerAttribute : CustomizeAttribute
 {
+    public Type? LoggerType { get; set; }
+
     public override ICustomization GetCustomization(ParameterInfo parameter)
     {
-        if (!parameter.ParameterType.IsGenericType
-            || parameter.ParameterType.GetGenericTypeDefinition() != typeof(ILogger<>))
-            throw new ArgumentException($"The parameter type must be an {nameof(ILogger)}<T>", nameof(parameter));
-
-        return new TestLoggerCustomization(parameter.ParameterType.GenericTypeArguments.Single());
+        var loggerType = GetLoggerType(parameter);
+        return new TestLoggerCustomization(loggerType);
+    }
+
+    Type GetLoggerType(ParameterInfo parameter)
+    {
+        if(LoggerType is not null) return LoggerType;
+
+        if (parameter.ParameterType.IsGenericType
+            && parameter.ParameterType.GetGenericTypeDefinition() == typeof(ILogger<>))
+            return parameter.ParameterType.GenericTypeArguments.Single();
+
+        throw new ArgumentException($"Either {nameof(LoggerType)} must be set or the parameter type must be an {nameof(ILogger)}<T>", nameof(parameter));
     }
 }
 

CSF.Extensions.WebDriver/Factories/DriverTypeProvider.cs

@@ -10,7 +10,7 @@
     /// </summary>
     public class DriverTypeProvider : IGetsDriverType
     {
-        readonly ILogger<DriverTypeProvider> logger;
+        readonly ILogger logger;
         readonly IGetsWebDriverAndOptionsTypes typeProvider;
 
         /// <inheritdoc/>
@@ -50,12 +50,14 @@
         /// <summary>
         /// Initialises a new instance of <see cref="DriverTypeProvider"/>.
         /// </summary>
-        /// <param name="logger">A logger</param>
+        /// <param name="loggerProvider">A logger provider</param>
         /// <param name="typeProvider">A provider for the concrete types of web driver and options</param>
         /// <exception cref="ArgumentNullException">If any parameter is <see langword="null"/></exception>
-        public DriverTypeProvider(ILogger<DriverTypeProvider> logger, IGetsWebDriverAndOptionsTypes typeProvider)
+        public DriverTypeProvider(IGetsLogger loggerProvider, IGetsWebDriverAndOptionsTypes typeProvider)
         {
-            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            if (loggerProvider is null) throw new ArgumentNullException(nameof(loggerProvider));
+
+            logger = loggerProvider.GetLogger<DriverTypeProvider>();
             this.typeProvider = typeProvider ?? throw new ArgumentNullException(nameof(typeProvider));
         }
     }

CSF.Extensions.WebDriver/Factories/OptionsTypeProvider.cs

@@ -10,7 +10,7 @@
     /// </summary>
     public class OptionsTypeProvider : IGetsOptionsType
     {
-        readonly ILogger<OptionsTypeProvider> logger;
+        readonly ILogger logger;
         readonly IGetsWebDriverAndOptionsTypes typeProvider;
         readonly ICreatesDriverOptions optionsFactory;
 
@@ -62,13 +62,15 @@
         /// <summary>
         /// Initialises a new instance of <see cref="DriverTypeProvider"/>.
         /// </summary>
-        /// <param name="logger">A logger</param>
+        /// <param name="loggerProvider">A logger provider</param>
         /// <param name="typeProvider">A provider for the concrete types of web driver and options</param>
         /// <param name="optionsFactory">A factory for instances of <see cref="DriverOptions"/></param>
         /// <exception cref="ArgumentNullException">If any parameter is <see langword="null"/></exception>
-        public OptionsTypeProvider(ILogger<OptionsTypeProvider> logger, IGetsWebDriverAndOptionsTypes typeProvider, ICreatesDriverOptions optionsFactory)
+        public OptionsTypeProvider(IGetsLogger loggerProvider, IGetsWebDriverAndOptionsTypes typeProvider, ICreatesDriverOptions optionsFactory)
         {
-            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            if (loggerProvider is null) throw new ArgumentNullException(nameof(loggerProvider));
+
+            logger = loggerProvider.GetLogger<OptionsTypeProvider>();
             this.typeProvider = typeProvider ?? throw new ArgumentNullException(nameof(typeProvider));
             this.optionsFactory = optionsFactory ?? throw new ArgumentNullException(nameof(optionsFactory));
         }

CSF.Extensions.WebDriver/Factories/ProxyWrappingWebDriverFactoryDecorator.cs

@@ -42,15 +42,17 @@
         /// </summary>
         /// <param name="wrapped">The wrapped factory</param>
         /// <param name="proxyFactory">A proxy factory implementation</param>
-        /// <param name="logger">A logger</param>
+        /// <param name="loggerProvider">A logger provider</param>
         /// <exception cref="ArgumentNullException">If any parameter is <see langword="null" />.</exception>
         public ProxyWrappingWebDriverFactoryDecorator(ICreatesWebDriverFromOptions wrapped,
                                                       IGetsProxyWebDriver proxyFactory,
-                                                      ILogger<ProxyWrappingWebDriverFactoryDecorator> logger)
+                                                      IGetsLogger loggerProvider)
         {
+            if (loggerProvider is null) throw new ArgumentNullException(nameof(loggerProvider));
+
+            logger = loggerProvider.GetLogger<ProxyWrappingWebDriverFactoryDecorator>();
             this.wrapped = wrapped ?? throw new ArgumentNullException(nameof(wrapped));
             this.proxyFactory = proxyFactory ?? throw new ArgumentNullException(nameof(proxyFactory));
-            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
     }
 }

CSF.Extensions.WebDriver/Factories/RemoteWebDriverFromOptionsFactory.cs

@@ -47,15 +47,17 @@
         /// Initialises a new instance of <see cref="RemoteWebDriverFromOptionsFactory"/>.
         /// </summary>
         /// <param name="typeProvider">A type-providing service</param>
-        /// <param name="logger">A logger</param>
+        /// <param name="loggerProvider">A logger provider</param>
         /// <param name="next">The next service in the chain of responsibility.</param>
         /// <exception cref="ArgumentNullException">If any parameters is <see langword="null" />.</exception>
         public RemoteWebDriverFromOptionsFactory(IGetsWebDriverAndOptionsTypes typeProvider,
-                                                 ILogger<RemoteWebDriverFromOptionsFactory> logger,
+                                                 IGetsLogger loggerProvider,
                                                  ICreatesWebDriverFromOptions next)
         {
+            if (loggerProvider is null) throw new ArgumentNullException(nameof(loggerProvider));
+
+            logger = loggerProvider.GetLogger<RemoteWebDriverFromOptionsFactory>();
             this.typeProvider = typeProvider ?? throw new ArgumentNullException(nameof(typeProvider));
-            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
             this.next = next ?? throw new ArgumentNullException(nameof(next));
         }
     }

CSF.Extensions.WebDriver/Factories/WebDriverConfigurationItemParser.cs

@@ -13,7 +13,7 @@
         readonly IGetsDriverType driverTypeProvider;
         readonly IGetsOptionsType optionsTypeProvider;
         readonly ICreatesDriverOptions optionsFactory;
-        readonly ILogger<WebDriverConfigurationItemParser> logger;
+        readonly ILogger logger;
 
         /// <inheritdoc/>
         public WebDriverCreationOptions GetDriverConfiguration(IConfigurationSection configuration)
@@ -86,16 +86,18 @@
         /// <param name="driverTypeProvider">A service to get the driver type</param>
         /// <param name="optionsTypeProvider">A service to get the options type</param>
         /// <param name="optionsFactory">A service to get the driver options</param>
-        /// <param name="logger">The logger for this parser.</param>
+        /// <param name="loggerProvider">A logger provider</param>
         public WebDriverConfigurationItemParser(IGetsDriverType driverTypeProvider,
                                                 IGetsOptionsType optionsTypeProvider,
                                                 ICreatesDriverOptions optionsFactory,
-                                                ILogger<WebDriverConfigurationItemParser> logger)
+                                                IGetsLogger loggerProvider)
         {
+            if (loggerProvider is null) throw new ArgumentNullException(nameof(loggerProvider));
+
+            logger = loggerProvider.GetLogger<WebDriverConfigurationItemParser>();
             this.driverTypeProvider = driverTypeProvider ?? throw new ArgumentNullException(nameof(driverTypeProvider));
             this.optionsTypeProvider = optionsTypeProvider ?? throw new ArgumentNullException(nameof(optionsTypeProvider));
             this.optionsFactory = optionsFactory ?? throw new ArgumentNullException(nameof(optionsFactory));
-            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
     }
 }

CSF.Extensions.WebDriver/Factories/WebDriverCreationConfigureOptions.cs

@@ -24,7 +24,7 @@
     {
         readonly IParsesSingleWebDriverConfigurationSection configParser;
         readonly IConfiguration configuration;
-        readonly ILogger<WebDriverCreationConfigureOptions> logger;
+        readonly ILogger logger;
         readonly Action<WebDriverCreationOptionsCollection> configureOptions;
 
         /// <inheritdoc/>
@@ -64,17 +64,19 @@
         /// </summary>
         /// <param name="configParser">A parser for a single configuration item.</param>
         /// <param name="configuration">The app configuration.</param>
-        /// <param name="logger">A logging implementation.</param>
+        /// <param name="loggerProvider">A logger provider</param>
         /// <param name="configureOptions">An optional configuration action/callback to further configure the options</param>
         /// <exception cref="ArgumentNullException">If either parameter is <see langword="null" />.</exception>
         public WebDriverCreationConfigureOptions(IParsesSingleWebDriverConfigurationSection configParser,
                                                  IConfiguration configuration,
-                                                 ILogger<WebDriverCreationConfigureOptions> logger,
+                                                 IGetsLogger loggerProvider,
                                                  Action<WebDriverCreationOptionsCollection> configureOptions)
         {
+            if (loggerProvider is null) throw new ArgumentNullException(nameof(loggerProvider));
+
+            logger = loggerProvider.GetLogger<WebDriverCreationConfigureOptions>();
             this.configParser = configParser ?? throw new ArgumentNullException(nameof(configParser));
             this.configuration = configuration;
-            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
             this.configureOptions = configureOptions;
         }
     }

CSF.Extensions.WebDriver/Factories/WebDriverFromOptionsFactory.cs

@@ -11,7 +11,7 @@
     /// </summary>
     public class WebDriverFromOptionsFactory : ICreatesWebDriverFromOptions
     {
         static readonly MethodInfo customizeGenericMethod = typeof(WebDriverFromOptionsFactory).GetMethod(nameof(CuztomizeOptionsGeneric), BindingFlags.NonPublic | BindingFlags.Static);
 
         readonly IGetsWebDriverAndOptionsTypes typeProvider;
         readonly ILogger logger;
@@ -59,13 +59,15 @@
         /// Initialises a new instance of <see cref="WebDriverFromOptionsFactory"/>.
         /// </summary>
         /// <param name="typeProvider">A type provider</param>
-        /// <param name="logger">A logger</param>
+        /// <param name="loggerProvider">A logger provider</param>
         /// <exception cref="ArgumentNullException">If any parameter is <see langword="null" />.</exception>
         public WebDriverFromOptionsFactory(IGetsWebDriverAndOptionsTypes typeProvider,
-                                           ILogger<WebDriverFromOptionsFactory> logger)
+                                           IGetsLogger loggerProvider)
         {
+            if (loggerProvider is null) throw new ArgumentNullException(nameof(loggerProvider));
+
+            logger = loggerProvider.GetLogger<WebDriverFromOptionsFactory>();
             this.typeProvider = typeProvider ?? throw new ArgumentNullException(nameof(typeProvider));
-            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
     }
 }

CSF.Extensions.WebDriver/Factories/WebDriverFromThirdPartyFactory.cs

@@ -54,17 +54,19 @@
         /// <param name="next">The next implementation in the chain of responsibility.</param>
         /// <param name="typeProvider">A type-providing service.</param>
         /// <param name="services">The DI service provider.</param>
-        /// <param name="logger">A logger</param>
+        /// <param name="loggerProvider">A logger provider</param>
         /// <exception cref="ArgumentNullException">If any parameter is <see langword="null" />.</exception>
         public WebDriverFromThirdPartyFactory(ICreatesWebDriverFromOptions next,
                                               IGetsWebDriverAndOptionsTypes typeProvider,
                                               IServiceProvider services,
-                                              ILogger<WebDriverFromThirdPartyFactory> logger)
+                                              IGetsLogger loggerProvider)
         {
+            if (loggerProvider is null) throw new ArgumentNullException(nameof(loggerProvider));
+
+            logger = loggerProvider.GetLogger<WebDriverFromThirdPartyFactory>();
             this.next = next ?? throw new ArgumentNullException(nameof(next));
             this.typeProvider = typeProvider ?? throw new ArgumentNullException(nameof(typeProvider));
             this.services = services ?? throw new ArgumentNullException(nameof(services));
-            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
     }
 }