Set individual formatters with key-value based environment variables

Reqnroll/EnvironmentAccess/EnvironmentWrapper.cs

@@ -1,5 +1,8 @@
-using System;
 using Reqnroll.CommonModels;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace Reqnroll.EnvironmentAccess
 {
@@ -36,5 +39,17 @@ public void SetEnvironmentVariable(string name, string value)
         }
 
         public string GetCurrentDirectory() => Environment.CurrentDirectory;
+
+        public IDictionary<string, string> GetEnvironmentVariables(string prefix)
+        {
+            if (string.IsNullOrEmpty(prefix))
+                throw new ArgumentException("Argument cannot be null or empty", nameof(prefix));
+
+            return Environment.GetEnvironmentVariables()
+                              .OfType<DictionaryEntry>()
+                              .Select(e => (Key: e.Key?.ToString() ?? "", Value: e.Value?.ToString() ?? ""))
+                              .Where(e => e.Key.StartsWith(prefix, StringComparison.InvariantCultureIgnoreCase))
+                              .ToDictionary(e => e.Key, e => e.Value);
+        }
     }
 }

Reqnroll/EnvironmentAccess/IEnvironmentWrapper.cs

@@ -1,4 +1,5 @@
 using Reqnroll.CommonModels;
+using System.Collections.Generic;
 
 namespace Reqnroll.EnvironmentAccess
 {
@@ -10,6 +11,8 @@ public interface IEnvironmentWrapper
 
         IResult<string> GetEnvironmentVariable(string name);
 
+        IDictionary<string,string> GetEnvironmentVariables(string prefix);
+
         void SetEnvironmentVariable(string name, string value);
 
         string GetCurrentDirectory();

Reqnroll/Formatters/Configuration/FileBasedConfigurationResolver.cs

@@ -7,7 +7,7 @@
 
 namespace Reqnroll.Formatters.Configuration;
 
-public class FileBasedConfigurationResolver : FormattersConfigurationResolverBase, IFormattersConfigurationResolver
+public class FileBasedConfigurationResolver : FormattersConfigurationResolverBase, IFileBasedConfigurationResolver
 {
     private readonly IReqnrollJsonLocator _configFileLocator;
     private readonly IFileSystem _fileSystem;

Reqnroll/Formatters/Configuration/FormattersConfigurationConstants.cs

@@ -3,5 +3,6 @@
 public static class FormattersConfigurationConstants
 {
     public const string REQNROLL_FORMATTERS_ENVIRONMENT_VARIABLE = "REQNROLL_FORMATTERS";
+    public const string REQNROLL_FORMATTERS_ENVIRONMENT_VARIABLE_PREFIX = "REQNROLL_FORMATTERS_";
     public const string REQNROLL_FORMATTERS_DISABLED_ENVIRONMENT_VARIABLE = "REQNROLL_FORMATTERS_DISABLED";
 }

Reqnroll/Formatters/Configuration/FormattersConfigurationProvider.cs

@@ -11,7 +11,7 @@ namespace Reqnroll.Formatters.Configuration;
 /// the class will resolve the configuration (only once).
 /// 
 /// One or more profiles may be read from the configuration file (<see cref="FileBasedConfigurationResolver"/>)
-/// then environment variable overrides are applied (<see cref="EnvironmentConfigurationResolver"/>).
+/// then environment variable overrides are applied (first <see cref="JsonEnvironmentConfigurationResolver"/>, then <see cref="KeyValueEnvironmentConfigurationResolver"/>).
 /// </summary>
 public class FormattersConfigurationProvider : IFormattersConfigurationProvider
 {
@@ -20,10 +20,9 @@ public class FormattersConfigurationProvider : IFormattersConfigurationProvider
     private readonly IFormattersConfigurationDisableOverrideProvider _envVariableDisableFlagProvider;
     public bool Enabled => _resolvedConfiguration.Value.Enabled;
 
-    public FormattersConfigurationProvider(IDictionary<string, IFormattersConfigurationResolver> resolvers, IFormattersEnvironmentOverrideConfigurationResolver environmentOverrideConfigurationResolver, IFormattersConfigurationDisableOverrideProvider envVariableDisableFlagProvider)
+    public FormattersConfigurationProvider(IFileBasedConfigurationResolver fileBasedConfigurationResolver, IJsonEnvironmentConfigurationResolver jsonEnvironmentConfigurationResolver, IKeyValueEnvironmentConfigurationResolver keyValueEnvironmentConfigurationResolver, IFormattersConfigurationDisableOverrideProvider envVariableDisableFlagProvider)
     {
-        var fileResolver = resolvers["fileBasedResolver"];
-        _resolvers = [fileResolver, environmentOverrideConfigurationResolver];
+        _resolvers = [fileBasedConfigurationResolver, jsonEnvironmentConfigurationResolver, keyValueEnvironmentConfigurationResolver];
         _resolvedConfiguration = new Lazy<FormattersConfiguration>(ResolveConfiguration);
         _envVariableDisableFlagProvider = envVariableDisableFlagProvider;
     }
@@ -38,13 +37,16 @@ public IDictionary<string, object> GetFormatterConfigurationByName(string format
 
     private FormattersConfiguration ResolveConfiguration()
     {
-        var combinedConfig = new Dictionary<string, IDictionary<string, object>>();
+        var combinedConfig = new Dictionary<string, IDictionary<string, object>>(StringComparer.InvariantCultureIgnoreCase);
 
         foreach (var resolver in _resolvers)
         {
             foreach (var entry in resolver.Resolve())
             {
-                combinedConfig[entry.Key] = entry.Value;
+                if (entry.Value == null) 
+                    combinedConfig.Remove(entry.Key);
+                else 
+                    combinedConfig[entry.Key] = entry.Value;
             }
         }
         bool enabled = combinedConfig.Count > 0 && !_envVariableDisableFlagProvider.Disabled();
@@ -55,4 +57,4 @@ private FormattersConfiguration ResolveConfiguration()
             Enabled = enabled
         };
     }
-}
+}

Reqnroll/Formatters/Configuration/FormattersConfigurationResolverBase.cs

@@ -29,19 +29,20 @@ protected virtual void ProcessJsonDocument(JsonDocument jsonDocument, Dictionary
             foreach(JsonProperty formatterProperty in formatters.EnumerateObject())
             {
                 var configValues = new Dictionary<string, object>();
-                
+
                 if (formatterProperty.Value.ValueKind == JsonValueKind.Object)
                 {
                     foreach (JsonProperty configProperty in formatterProperty.Value.EnumerateObject())
                     {
-                            configValues.Add(configProperty.Name, GetConfigValue(configProperty.Value));
+                        configValues.Add(configProperty.Name, GetConfigValue(configProperty.Value));
                     }
                 }
-                
+
                 result.Add(formatterProperty.Name, configValues);
             }
         }
     }
+
     private object GetConfigValue(JsonElement valueElement)
     {
         switch (valueElement.ValueKind)

Reqnroll/Formatters/Configuration/IFileBasedConfigurationResolver.cs

@@ -0,0 +1,3 @@
+namespace Reqnroll.Formatters.Configuration;
+
+public interface IFileBasedConfigurationResolver : IFormattersConfigurationResolverBase;

Reqnroll/Formatters/Configuration/IFormattersConfigurationResolverBase.cs

@@ -5,8 +5,4 @@ namespace Reqnroll.Formatters.Configuration;
 public interface IFormattersConfigurationResolverBase
 {
     IDictionary<string, IDictionary<string, object>> Resolve();
-}
-
-public interface IFormattersConfigurationResolver : IFormattersConfigurationResolverBase;
-
-public interface IFormattersEnvironmentOverrideConfigurationResolver : IFormattersConfigurationResolverBase;
+}

Reqnroll/Formatters/Configuration/IJsonEnvironmentConfigurationResolver.cs

@@ -0,0 +1,3 @@
+namespace Reqnroll.Formatters.Configuration;
+
+public interface IJsonEnvironmentConfigurationResolver : IFormattersConfigurationResolverBase;

Reqnroll/Formatters/Configuration/IKeyValueEnvironmentConfigurationResolver.cs

@@ -0,0 +1,3 @@
+namespace Reqnroll.Formatters.Configuration;
+
+public interface IKeyValueEnvironmentConfigurationResolver : IFormattersConfigurationResolverBase;

Reqnroll/Formatters/Configuration/EnvironmentConfigurationResolver.cs → Reqnroll/Formatters/Configuration/JsonEnvironmentConfigurationResolver.cs

@@ -6,30 +6,42 @@
 
 namespace Reqnroll.Formatters.Configuration;
 
-public class EnvironmentConfigurationResolver : FormattersConfigurationResolverBase, IFormattersEnvironmentOverrideConfigurationResolver
+public class JsonEnvironmentConfigurationResolver : FormattersConfigurationResolverBase, IJsonEnvironmentConfigurationResolver
 {
     private readonly IEnvironmentWrapper _environmentWrapper;
     private readonly IFormatterLog _log;
+    private readonly string _environmentVariableName; 
 
-    public EnvironmentConfigurationResolver(
+    public JsonEnvironmentConfigurationResolver(
         IEnvironmentWrapper environmentWrapper,
         IFormatterLog log = null)
     {
         _environmentWrapper = environmentWrapper;
         _log = log;
+        _environmentVariableName = FormattersConfigurationConstants.REQNROLL_FORMATTERS_ENVIRONMENT_VARIABLE;
+    }
+
+    internal JsonEnvironmentConfigurationResolver(
+        IEnvironmentWrapper environmentWrapper,
+        string environmentVariableName,
+        IFormatterLog log = null)
+    {
+        _environmentWrapper = environmentWrapper ?? throw new ArgumentNullException(nameof(environmentWrapper));
+        _log = log;
+        _environmentVariableName = environmentVariableName ?? throw new ArgumentNullException(nameof(environmentVariableName));
     }
 
     protected override JsonDocument GetJsonDocument()
     {
         try
         {
-            var formatters = _environmentWrapper.GetEnvironmentVariable(FormattersConfigurationConstants.REQNROLL_FORMATTERS_ENVIRONMENT_VARIABLE);
+            var formatters = _environmentWrapper.GetEnvironmentVariable(_environmentVariableName);
 
             if (formatters is Success<string> formattersSuccess)
             {
                 if (string.IsNullOrWhiteSpace(formattersSuccess.Result))
                 {
-                    _log?.WriteMessage($"Environment variable {FormattersConfigurationConstants.REQNROLL_FORMATTERS_ENVIRONMENT_VARIABLE} is empty");
+                    _log?.WriteMessage($"Environment variable {_environmentVariableName} is empty");
                     return null;
                 }
 
@@ -43,12 +55,12 @@ protected override JsonDocument GetJsonDocument()
                 }
                 catch (JsonException ex)
                 {
-                    _log?.WriteMessage($"Failed to parse JSON from environment variable {FormattersConfigurationConstants.REQNROLL_FORMATTERS_ENVIRONMENT_VARIABLE}: {ex.Message}");
+                    _log?.WriteMessage($"Failed to parse JSON from environment variable {_environmentVariableName}: {ex.Message}");
                 }
             }
             else if (formatters is Failure<string> failure)
             {
-                _log?.WriteMessage($"Could not retrieve environment variable {FormattersConfigurationConstants.REQNROLL_FORMATTERS_ENVIRONMENT_VARIABLE}: {failure.Description}");
+                _log?.WriteMessage($"Could not retrieve environment variable {_environmentVariableName}: {failure.Description}");
             }
         }
         catch (Exception ex) when (ex is not JsonException)

Reqnroll/Formatters/Configuration/KeyValueEnvironmentConfigurationResolver.cs

@@ -0,0 +1,55 @@
+using System;
+using Reqnroll.EnvironmentAccess;
+using Reqnroll.Formatters.RuntimeSupport;
+using System.Collections.Generic;
+
+namespace Reqnroll.Formatters.Configuration;
+
+internal class KeyValueEnvironmentConfigurationResolver(IEnvironmentWrapper environmentWrapper, IFormatterLog log = null) : IKeyValueEnvironmentConfigurationResolver
+{
+    private readonly IEnvironmentWrapper _environmentWrapper = environmentWrapper ?? throw new ArgumentNullException(nameof(environmentWrapper));
+
+    public IDictionary<string, IDictionary<string, object>> Resolve()
+    {
+        var result = new Dictionary<string, IDictionary<string, object>>(StringComparer.InvariantCultureIgnoreCase);
+
+        var environmentVariables = _environmentWrapper.GetEnvironmentVariables(FormattersConfigurationConstants.REQNROLL_FORMATTERS_ENVIRONMENT_VARIABLE_PREFIX);
+        foreach (var formatterEnvironmentVariable in environmentVariables)
+        {
+            var formatterName = formatterEnvironmentVariable.Key.Substring(FormattersConfigurationConstants.REQNROLL_FORMATTERS_ENVIRONMENT_VARIABLE_PREFIX.Length);
+            var formatterConfiguration = formatterEnvironmentVariable.Value?.Trim();
+            if (string.IsNullOrEmpty(formatterConfiguration))
+                continue;
+
+            log?.WriteMessage($"Configuring formatter '{formatterName}' via environment variable {formatterEnvironmentVariable.Key}={formatterEnvironmentVariable.Value}");
+
+            if (formatterConfiguration.Equals("true", StringComparison.InvariantCultureIgnoreCase))
+            {
+                result[formatterName] = new Dictionary<string, object>();
+                continue;
+            }
+
+            if (formatterConfiguration.Equals("false", StringComparison.InvariantCultureIgnoreCase))
+            {
+                result[formatterName] = null;
+                continue;
+            }
+
+            var settings = formatterConfiguration.Split(';');
+
+            var configValues = new Dictionary<string, object>();
+            foreach (string setting in settings)
+            {
+                var keyValue = setting.Split(['='], 2);
+                if (keyValue.Length == 1)
+                    throw new ReqnrollException($"Could not parse setting '{setting}' for formatter '{formatterName}' when processing the environment variable {formatterEnvironmentVariable.Key}. Please use semicolon separated list of 'key=value' settings or 'true'.");
+
+                configValues[keyValue[0].Trim()] = keyValue[1].Trim();
+            }
+
+            result[formatterName] = configValues;
+        }
+
+        return result;
+    }
+}

Reqnroll/Infrastructure/DefaultDependencyProvider.cs

@@ -113,8 +113,9 @@ public virtual void RegisterGlobalContainerDefaults(ObjectContainer container)
             container.RegisterTypeAs<NullFormatterLog, IFormatterLog>();
             container.RegisterTypeAs<FileSystem, IFileSystem>();
             container.RegisterTypeAs<FormattersDisabledOverrideProvider, IFormattersConfigurationDisableOverrideProvider>();
-            container.RegisterTypeAs<FileBasedConfigurationResolver, IFormattersConfigurationResolver>("fileBasedResolver");
-            container.RegisterTypeAs<EnvironmentConfigurationResolver, IFormattersEnvironmentOverrideConfigurationResolver>();
+            container.RegisterTypeAs<FileBasedConfigurationResolver, IFileBasedConfigurationResolver>();
+            container.RegisterTypeAs<JsonEnvironmentConfigurationResolver, IJsonEnvironmentConfigurationResolver>();
+            container.RegisterTypeAs<KeyValueEnvironmentConfigurationResolver, IKeyValueEnvironmentConfigurationResolver>();
             container.RegisterTypeAs<FormattersConfigurationProvider, IFormattersConfigurationProvider>();
             container.RegisterTypeAs<MessageFormatter, ICucumberMessageFormatter>("message");
             container.RegisterTypeAs<HtmlFormatter, ICucumberMessageFormatter>("html");

Tests/Reqnroll.Formatters.Tests/MessagesCompatibilityTestBase.cs

@@ -160,13 +160,16 @@ protected static string ActualResultLocationDirectory()
         var fileSystem = new FileSystem();
         var fileService = new FileService();
         var configFileResolver = new FileBasedConfigurationResolver(jsonConfigFileLocator, fileSystem, fileService);
-        var configEnvResolver = new EnvironmentConfigurationResolver(env);
-        var resolvers = new Dictionary<string, IFormattersConfigurationResolver>
-        {
-            {"fileBasedResolver",  configFileResolver }
-        };
+        var jsonEnvConfigResolver = new JsonEnvironmentConfigurationResolver(env);
+
+        var keyValueEnvironmentConfigurationResolverMock = new Mock<IKeyValueEnvironmentConfigurationResolver>();
+        keyValueEnvironmentConfigurationResolverMock.Setup(r => r.Resolve()).Returns(new Dictionary<string, IDictionary<string, object>>());
 
-        FormattersConfigurationProvider configurationProvider = new FormattersConfigurationProvider(resolvers, configEnvResolver, new FormattersDisabledOverrideProvider(env));
+        FormattersConfigurationProvider configurationProvider = new FormattersConfigurationProvider(
+            configFileResolver,
+                                                                        jsonEnvConfigResolver,
+                                                                        keyValueEnvironmentConfigurationResolverMock.Object,
+                                                                        new FormattersDisabledOverrideProvider(env));
         configurationProvider.GetFormatterConfigurationByName("message").TryGetValue("outputFilePath", out var outputFilePathElement);
 
         var outputFilePath = outputFilePathElement!.ToString();

Tests/Reqnroll.RuntimeTests/EnvironmentWrapperStub.cs

@@ -25,6 +25,8 @@ public IResult<string> GetEnvironmentVariable(string name)
             ? Result<string>.Success(value)
             : Result<string>.Failure($"Environment variable '{name}' not set in stub");
 
+    public IDictionary<string, string> GetEnvironmentVariables(string prefix) => throw new NotSupportedException();
+
     public bool IsEnvironmentVariableSet(string name)
         => EnvironmentVariables.ContainsKey(name);
 

Tests/Reqnroll.RuntimeTests/Formatters/Configuration/CucumberConfigurationTests.cs

@@ -8,22 +8,23 @@ namespace Reqnroll.RuntimeTests.Formatters.Configuration;
 public class CucumberConfigurationTests
 {
     private readonly Mock<IFormattersConfigurationDisableOverrideProvider> _disableOverrideProviderMock;
-    private readonly Mock<IFormattersConfigurationResolver> _fileResolverMock;
-    private readonly Mock<IFormattersEnvironmentOverrideConfigurationResolver> _environmentResolverMock;
+    private readonly Mock<IFileBasedConfigurationResolver> _fileResolverMock;
+    private readonly Mock<IJsonEnvironmentConfigurationResolver> _environmentResolverMock;
     private readonly FormattersConfigurationProvider _sut;
 
     public CucumberConfigurationTests()
     {
         _disableOverrideProviderMock = new Mock<IFormattersConfigurationDisableOverrideProvider>();
-        _fileResolverMock = new Mock<IFormattersConfigurationResolver>();
-        _environmentResolverMock = new Mock<IFormattersEnvironmentOverrideConfigurationResolver>();
-
-        var resolvers = new Dictionary<string, IFormattersConfigurationResolver>
-        {
-            { "fileBasedResolver",  _fileResolverMock.Object }
-        };
-
-        _sut = new FormattersConfigurationProvider(resolvers, _environmentResolverMock.Object, _disableOverrideProviderMock.Object);
+        _fileResolverMock = new Mock<IFileBasedConfigurationResolver>();
+        _environmentResolverMock = new Mock<IJsonEnvironmentConfigurationResolver>();
+        var keyValueEnvironmentConfigurationResolverMock = new Mock<IKeyValueEnvironmentConfigurationResolver>();
+        keyValueEnvironmentConfigurationResolverMock.Setup(r => r.Resolve()).Returns(new Dictionary<string, IDictionary<string, object>>());
+
+        _sut = new FormattersConfigurationProvider(
+            _fileResolverMock.Object,
+            _environmentResolverMock.Object,
+            keyValueEnvironmentConfigurationResolverMock.Object,
+            _disableOverrideProviderMock.Object);
     }
 
     [Fact]