Renamed configuration property names per review feedback.

clrudolphi · clrudolphi · commit 5db751f980a6 · 2026-01-26T09:39:34.000-06:00
diff --git a/Reqnroll/Formatters/Configuration/FormattersConfigurationResolverBase.cs b/Reqnroll/Formatters/Configuration/FormattersConfigurationResolverBase.cs
@@ -8,6 +8,9 @@ namespace Reqnroll.Formatters.Configuration;
 public abstract class FormattersConfigurationResolverBase : IFormattersConfigurationResolverBase
 {
     protected const string FORMATTERS_KEY = "formatters";
+    public const string ATTACHMENT_HANDLING_SECTION = "attachmentHandling";
+    public const string ATTACHMENT_HANDLING_MODE = "mode";
+    public const string ATTACHMENT_EXTERNAL_STORAGE_PATH = "attachmentsStoragePath";
 
     public IDictionary<string, IDictionary<string, object>> Resolve()
     {
@@ -45,19 +48,19 @@ protected virtual void ProcessJsonDocument(JsonDocument jsonDocument, Dictionary
     private object GetConfigValue(JsonElement element, string propertyName = null)
     {
         // Check if this property is the AttachmentHandlingOptions section
-        if (propertyName != null && propertyName.Equals("attachmentHandlingOptions", StringComparison.OrdinalIgnoreCase) &&
+        if (propertyName != null && propertyName.Equals(ATTACHMENT_HANDLING_SECTION, StringComparison.OrdinalIgnoreCase) &&
             element.ValueKind == JsonValueKind.Object)
         {
             var dict = GetConfigValue(element) as IDictionary<string, object>;
             if (dict != null)
             {
                 AttachmentHandlingOption attachmentHandlingOption = AttachmentHandlingOption.None;
                 string externalPath = null;
-                if (dict.TryGetValue("attachmentHandling", out var handlingObj) && handlingObj is AttachmentHandlingOption)
+                if (dict.TryGetValue(ATTACHMENT_HANDLING_MODE, out var handlingObj) && handlingObj is AttachmentHandlingOption)
                 {
                     attachmentHandlingOption = (AttachmentHandlingOption)handlingObj;
                 }
-                if (dict.TryGetValue("externalAttachmentsStoragePath", out var pathObj) && pathObj is string pathStr)
+                if (dict.TryGetValue(ATTACHMENT_EXTERNAL_STORAGE_PATH, out var pathObj) && pathObj is string pathStr)
                 {
                     externalPath = pathStr;
                 }
@@ -89,7 +92,7 @@ protected virtual bool TryParseAsEnum(JsonElement element, string propertyName,
     {
         enumValue = null;
 
-        if (propertyName.Equals("attachmentHandling", StringComparison.OrdinalIgnoreCase) &&
+        if (propertyName.Equals(ATTACHMENT_HANDLING_MODE, StringComparison.OrdinalIgnoreCase) &&
             element.ValueKind == JsonValueKind.String)
         {
             var stringValue = element.GetString();
diff --git a/Reqnroll/Formatters/FormatterBase.cs b/Reqnroll/Formatters/FormatterBase.cs
@@ -81,7 +81,7 @@ bool IsFormatterEnabled(out IDictionary<string, object> configuration)
 
     public virtual AttachmentHandlingOptions GetAttachmentHandlingOptionValues(IDictionary<string, object> formatterConfiguration)
     {
-        if (formatterConfiguration.TryGetValue("attachmentHandlingOptions", out var options)
+        if (formatterConfiguration.TryGetValue(FormattersConfigurationResolverBase.ATTACHMENT_HANDLING_SECTION, out var options)
             && options is AttachmentHandlingOptions attachmentHandlingOptions)
         {
             _logger.WriteMessage($"DEBUG: Formatters: Formatter plugin: {Name} setting AttachmentHandlingOption to {attachmentHandlingOptions.AttachmentHandlingOption.ToString()} from configuration.");
diff --git a/Tests/Reqnroll.Formatters.Tests/reqnroll_withExternalAttachments.json b/Tests/Reqnroll.Formatters.Tests/reqnroll_withExternalAttachments.json
@@ -6,9 +6,9 @@
   "formatters": {
     "message": {
       "outputFilePath": "[BaseDirectory]/CucumberMessages/reqnroll_externalAttachments_report.ndjson",
-      "attachmentHandlingOptions": {
-        "attachmentHandling": "External",
-        "externalAttachmentsStoragePath": "path/to/CucumberMessages/Attachments"
+      "attachmentHandling": {
+        "mode": "External",
+        "attachmentsStoragePath": "path/to/CucumberMessages/Attachments"
       }
     }
   }
diff --git a/Tests/Reqnroll.RuntimeTests/Formatters/Configuration/FileBasedConfigurationResolverTests.cs b/Tests/Reqnroll.RuntimeTests/Formatters/Configuration/FileBasedConfigurationResolverTests.cs
@@ -199,15 +199,15 @@ public void Resolve_Should_Return_Formatter_Of_Multiple_Levels_Of_Settings()
 
 
     [Fact]
-    public void Resolve_Should_Parse_AttachmentHandling_As_Enum_Embed()
+    public void Resolve_Should_Parse_AttachmentHandling_Mode_As_Enum_Embed()
     {
         // Arrange
         var filePath = "config.json";
         var fileContent = @"
             {
                 ""formatters"": {
                     ""cucumberMessages"": {
-                        ""attachmentHandling"": ""Embed""
+                        ""mode"": ""Embed""
                     }
                 }
             }";
@@ -221,19 +221,19 @@ public void Resolve_Should_Parse_AttachmentHandling_As_Enum_Embed()
 
         // Assert
         result.Should().HaveCount(1);
-        result["cucumberMessages"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.Embed);
+        result["cucumberMessages"]["mode"].Should().Be(AttachmentHandlingOption.Embed);
     }
 
     [Fact]
-    public void Resolve_Should_Parse_AttachmentHandling_As_Enum_External()
+    public void Resolve_Should_Parse_AttachmentHandling_Mode_As_Enum_External()
     {
         // Arrange
         var filePath = "config.json";
         var fileContent = @"
             {
                 ""formatters"": {
                     ""cucumberMessages"": {
-                        ""attachmentHandling"": ""External""
+                        ""mode"": ""External""
                     }
                 }
             }";
@@ -247,19 +247,19 @@ public void Resolve_Should_Parse_AttachmentHandling_As_Enum_External()
 
         // Assert
         result.Should().HaveCount(1);
-        result["cucumberMessages"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.External);
+        result["cucumberMessages"]["mode"].Should().Be(AttachmentHandlingOption.External);
     }
 
     [Fact]
-    public void Resolve_Should_Parse_AttachmentHandling_As_Enum_None()
+    public void Resolve_Should_Parse_AttachmentHandling_Mode_As_Enum_None()
     {
         // Arrange
         var filePath = "config.json";
         var fileContent = @"
             {
                 ""formatters"": {
                     ""cucumberMessages"": {
-                        ""attachmentHandling"": ""None""
+                        ""mode"": ""None""
                     }
                 }
             }";
@@ -273,19 +273,19 @@ public void Resolve_Should_Parse_AttachmentHandling_As_Enum_None()
 
         // Assert
         result.Should().HaveCount(1);
-        result["cucumberMessages"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.None);
+        result["cucumberMessages"]["mode"].Should().Be(AttachmentHandlingOption.None);
     }
 
     [Fact(Skip = "Skip while deciding on proper behavior for invalid configurations")]
-    public void Resolve_Should_Parse_AttachmentHandling_CaseInsensitive()
+    public void Resolve_Should_Parse_AttachmentHandling_Mode_CaseInsensitive()
     {
         // Arrange
         var filePath = "config.json";
         var fileContent = @"
             {
                 ""formatters"": {
                     ""cucumberMessages"": {
-                        ""attachmentHandling"": ""embed""
+                        ""mode"": ""embed""
                     }
                 }
             }";
@@ -299,19 +299,19 @@ public void Resolve_Should_Parse_AttachmentHandling_CaseInsensitive()
 
         // Assert
         result.Should().HaveCount(1);
-        result["cucumberMessages"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.Embed);
+        result["cucumberMessages"]["mode"].Should().Be(AttachmentHandlingOption.Embed);
     }
 
     [Fact]
-    public void Resolve_Should_Keep_String_When_AttachmentHandling_Value_Is_Invalid()
+    public void Resolve_Should_Keep_String_When_AttachmentHandling_Mode_Value_Is_Invalid()
     {
         // Arrange
         var filePath = "config.json";
         var fileContent = @"
             {
                 ""formatters"": {
                     ""cucumberMessages"": {
-                        ""attachmentHandling"": ""INVALID_VALUE""
+                        ""mode"": ""INVALID_VALUE""
                     }
                 }
             }";
@@ -325,11 +325,11 @@ public void Resolve_Should_Keep_String_When_AttachmentHandling_Value_Is_Invalid(
 
         // Assert
         result.Should().HaveCount(1);
-        result["cucumberMessages"]["attachmentHandling"].Should().Be("INVALID_VALUE");
+        result["cucumberMessages"]["mode"].Should().Be("INVALID_VALUE");
     }
 
     [Fact]
-    public void Resolve_Should_Parse_AttachmentHandling_In_Nested_Configuration()
+    public void Resolve_Should_Parse_AttachmentHandling_Mode_In_Nested_Configuration()
     {
         // Arrange
         var filePath = "config.json";
@@ -338,7 +338,7 @@ public void Resolve_Should_Parse_AttachmentHandling_In_Nested_Configuration()
                 ""formatters"": {
                     ""cucumberMessages"": {
                         ""outputPath"": ""output/results.ndjson"",
-                        ""attachmentHandling"": ""External"",
+                        ""mode"": ""External"",
                         ""otherSettings"": {
                             ""enabled"": true
                         }
@@ -356,7 +356,7 @@ public void Resolve_Should_Parse_AttachmentHandling_In_Nested_Configuration()
         // Assert
         result.Should().HaveCount(1);
         result["cucumberMessages"]["outputPath"].Should().Be("output/results.ndjson");
-        result["cucumberMessages"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.External);
+        result["cucumberMessages"]["mode"].Should().Be(AttachmentHandlingOption.External);
         
         var otherSettings = result["cucumberMessages"]["otherSettings"];
         otherSettings.Should().BeOfType<Dictionary<string, object>>();
@@ -373,10 +373,10 @@ public void Resolve_Should_Parse_Multiple_Formatters_With_Different_AttachmentHa
             {
                 ""formatters"": {
                     ""formatter1"": {
-                        ""attachmentHandling"": ""Embed""
+                        ""mode"": ""Embed""
                     },
                     ""formatter2"": {
-                        ""attachmentHandling"": ""External""
+                        ""mode"": ""External""
                     }
                 }
             }";
@@ -390,8 +390,8 @@ public void Resolve_Should_Parse_Multiple_Formatters_With_Different_AttachmentHa
 
         // Assert
         result.Should().HaveCount(2);
-        result["formatter1"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.Embed);
-        result["formatter2"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.External);
+        result["formatter1"]["mode"].Should().Be(AttachmentHandlingOption.Embed);
+        result["formatter2"]["mode"].Should().Be(AttachmentHandlingOption.External);
     }
 
     [Fact]
@@ -403,9 +403,9 @@ public void Resolve_Should_Parse_Formatter_With_AttachmentOptions()
             {
                 ""formatters"": {
                     ""formatter1"": {
-                        ""attachmentHandlingOptions"": {
-                            ""attachmentHandling"": ""External"",
-                            ""externalAttachmentsStoragePath"": ""/path/to/attachments""
+                        ""attachmentHandling"": {
+                            ""mode"": ""External"",
+                            ""attachmentsStoragePath"": ""/path/to/attachments""
                         }
                     }
                 }
@@ -419,8 +419,8 @@ public void Resolve_Should_Parse_Formatter_With_AttachmentOptions()
         var result = _sut.Resolve();
 
         // Assert
-        result["formatter1"]["attachmentHandlingOptions"].Should().BeOfType<AttachmentHandlingOptions>();
-        var attachmentOptions = (AttachmentHandlingOptions)result["formatter1"]["attachmentHandlingOptions"];
+        result["formatter1"]["attachmentHandling"].Should().BeOfType<AttachmentHandlingOptions>();
+        var attachmentOptions = (AttachmentHandlingOptions)result["formatter1"]["attachmentHandling"];
         attachmentOptions.AttachmentHandlingOption.Should().Be(AttachmentHandlingOption.External);
         attachmentOptions.ExternalAttachmentsStoragePath.Should().Be("/path/to/attachments");
     }
diff --git a/reqnroll-config.json b/reqnroll-config.json
@@ -141,7 +141,7 @@
               "type": "string",
               "description": "File path where the HTML report will be output."
             },
-            "attachmentHandlingOptions": {
+            "attachmentHandling": {
               "$ref": "#/definitions/FormatterAttachmentHandlingOptions"
             }
           },
@@ -155,7 +155,7 @@
               "type": "string",
               "description": "File path where the message ndjson output will be saved."
             },
-            "attachmentHandlingOptions": {
+            "attachmentHandling": {
               "$ref": "#/definitions/FormatterAttachmentHandlingOptions"
             }
           },
@@ -334,13 +334,13 @@
       "type": "object",
       "additionalProperties": true,
       "properties": {
-        "attachmentHandling": {
+        "mode": {
           "description": "Specifies how attachments will be reported.",
           "type": "string",
           "default": "Embed",
           "enum": [ "None", "Embed", "External" ]
         },
-        "externalAttachmentsStoragePath": {
+        "attachmentsStoragePath": {
           "description": "The file system path where external attachments will be stored by the executing test framework. This setting is required if 'attachmentHandling' is set to 'External'.",
           "type": "string"
         }

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,9 @@ namespace Reqnroll.Formatters.Configuration;`
`8`	`8`	`public abstract class FormattersConfigurationResolverBase : IFormattersConfigurationResolverBase`
`9`	`9`	`{`
`10`	`10`	`protected const string FORMATTERS_KEY = "formatters";`
	`11`	`+ public const string ATTACHMENT_HANDLING_SECTION = "attachmentHandling";`
	`12`	`+ public const string ATTACHMENT_HANDLING_MODE = "mode";`
	`13`	`+ public const string ATTACHMENT_EXTERNAL_STORAGE_PATH = "attachmentsStoragePath";`
`11`	`14`
`12`	`15`	`public IDictionary<string, IDictionary<string, object>> Resolve()`
`13`	`16`	`{`
`@@ -45,19 +48,19 @@ protected virtual void ProcessJsonDocument(JsonDocument jsonDocument, Dictionary`
`45`	`48`	`private object GetConfigValue(JsonElement element, string propertyName = null)`
`46`	`49`	`{`
`47`	`50`	`// Check if this property is the AttachmentHandlingOptions section`
`48`		`- if (propertyName != null && propertyName.Equals("attachmentHandlingOptions", StringComparison.OrdinalIgnoreCase) &&`
	`51`	`+ if (propertyName != null && propertyName.Equals(ATTACHMENT_HANDLING_SECTION, StringComparison.OrdinalIgnoreCase) &&`
`49`	`52`	`element.ValueKind == JsonValueKind.Object)`
`50`	`53`	`{`
`51`	`54`	`var dict = GetConfigValue(element) as IDictionary<string, object>;`
`52`	`55`	`if (dict != null)`
`53`	`56`	`{`
`54`	`57`	`AttachmentHandlingOption attachmentHandlingOption = AttachmentHandlingOption.None;`
`55`	`58`	`string externalPath = null;`
`56`		`- if (dict.TryGetValue("attachmentHandling", out var handlingObj) && handlingObj is AttachmentHandlingOption)`
	`59`	`+ if (dict.TryGetValue(ATTACHMENT_HANDLING_MODE, out var handlingObj) && handlingObj is AttachmentHandlingOption)`
`57`	`60`	`{`
`58`	`61`	`attachmentHandlingOption = (AttachmentHandlingOption)handlingObj;`
`59`	`62`	`}`
`60`		`- if (dict.TryGetValue("externalAttachmentsStoragePath", out var pathObj) && pathObj is string pathStr)`
	`63`	`+ if (dict.TryGetValue(ATTACHMENT_EXTERNAL_STORAGE_PATH, out var pathObj) && pathObj is string pathStr)`
`61`	`64`	`{`
`62`	`65`	`externalPath = pathStr;`
`63`	`66`	`}`
`@@ -89,7 +92,7 @@ protected virtual bool TryParseAsEnum(JsonElement element, string propertyName,`
`89`	`92`	`{`
`90`	`93`	`enumValue = null;`
`91`	`94`
`92`		`- if (propertyName.Equals("attachmentHandling", StringComparison.OrdinalIgnoreCase) &&`
	`95`	`+ if (propertyName.Equals(ATTACHMENT_HANDLING_MODE, StringComparison.OrdinalIgnoreCase) &&`
`93`	`96`	`element.ValueKind == JsonValueKind.String)`
`94`	`97`	`{`
`95`	`98`	`var stringValue = element.GetString();`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ bool IsFormatterEnabled(out IDictionary<string, object> configuration)`
`81`	`81`
`82`	`82`	`public virtual AttachmentHandlingOptions GetAttachmentHandlingOptionValues(IDictionary<string, object> formatterConfiguration)`
`83`	`83`	`{`
`84`		`- if (formatterConfiguration.TryGetValue("attachmentHandlingOptions", out var options)`
	`84`	`+ if (formatterConfiguration.TryGetValue(FormattersConfigurationResolverBase.ATTACHMENT_HANDLING_SECTION, out var options)`
`85`	`85`	`&& options is AttachmentHandlingOptions attachmentHandlingOptions)`
`86`	`86`	`{`
`87`	`87`	`_logger.WriteMessage($"DEBUG: Formatters: Formatter plugin: {Name} setting AttachmentHandlingOption to {attachmentHandlingOptions.AttachmentHandlingOption.ToString()} from configuration.");`
Original file line number	Diff line number	Diff line change
`@@ -6,9 +6,9 @@`
`6`	`6`	`"formatters": {`
`7`	`7`	`"message": {`
`8`	`8`	`"outputFilePath": "[BaseDirectory]/CucumberMessages/reqnroll_externalAttachments_report.ndjson",`
`9`		`- "attachmentHandlingOptions": {`
`10`		`- "attachmentHandling": "External",`
`11`		`- "externalAttachmentsStoragePath": "path/to/CucumberMessages/Attachments"`
	`9`	`+ "attachmentHandling": {`
	`10`	`+ "mode": "External",`
	`11`	`+ "attachmentsStoragePath": "path/to/CucumberMessages/Attachments"`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -199,15 +199,15 @@ public void Resolve_Should_Return_Formatter_Of_Multiple_Levels_Of_Settings()`
`199`	`199`
`200`	`200`
`201`	`201`	`[Fact]`
`202`		`- public void Resolve_Should_Parse_AttachmentHandling_As_Enum_Embed()`
	`202`	`+ public void Resolve_Should_Parse_AttachmentHandling_Mode_As_Enum_Embed()`
`203`	`203`	`{`
`204`	`204`	`// Arrange`
`205`	`205`	`var filePath = "config.json";`
`206`	`206`	`var fileContent = @"`
`207`	`207`	`{`
`208`	`208`	`""formatters"": {`
`209`	`209`	`""cucumberMessages"": {`
`210`		`- ""attachmentHandling"": ""Embed""`
	`210`	`+ ""mode"": ""Embed""`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`	`}";`
`@@ -221,19 +221,19 @@ public void Resolve_Should_Parse_AttachmentHandling_As_Enum_Embed()`
`221`	`221`
`222`	`222`	`// Assert`
`223`	`223`	`result.Should().HaveCount(1);`
`224`		`- result["cucumberMessages"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.Embed);`
	`224`	`+ result["cucumberMessages"]["mode"].Should().Be(AttachmentHandlingOption.Embed);`
`225`	`225`	`}`
`226`	`226`
`227`	`227`	`[Fact]`
`228`		`- public void Resolve_Should_Parse_AttachmentHandling_As_Enum_External()`
	`228`	`+ public void Resolve_Should_Parse_AttachmentHandling_Mode_As_Enum_External()`
`229`	`229`	`{`
`230`	`230`	`// Arrange`
`231`	`231`	`var filePath = "config.json";`
`232`	`232`	`var fileContent = @"`
`233`	`233`	`{`
`234`	`234`	`""formatters"": {`
`235`	`235`	`""cucumberMessages"": {`
`236`		`- ""attachmentHandling"": ""External""`
	`236`	`+ ""mode"": ""External""`
`237`	`237`	`}`
`238`	`238`	`}`
`239`	`239`	`}";`
`@@ -247,19 +247,19 @@ public void Resolve_Should_Parse_AttachmentHandling_As_Enum_External()`
`247`	`247`
`248`	`248`	`// Assert`
`249`	`249`	`result.Should().HaveCount(1);`
`250`		`- result["cucumberMessages"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.External);`
	`250`	`+ result["cucumberMessages"]["mode"].Should().Be(AttachmentHandlingOption.External);`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`[Fact]`
`254`		`- public void Resolve_Should_Parse_AttachmentHandling_As_Enum_None()`
	`254`	`+ public void Resolve_Should_Parse_AttachmentHandling_Mode_As_Enum_None()`
`255`	`255`	`{`
`256`	`256`	`// Arrange`
`257`	`257`	`var filePath = "config.json";`
`258`	`258`	`var fileContent = @"`
`259`	`259`	`{`
`260`	`260`	`""formatters"": {`
`261`	`261`	`""cucumberMessages"": {`
`262`		`- ""attachmentHandling"": ""None""`
	`262`	`+ ""mode"": ""None""`
`263`	`263`	`}`
`264`	`264`	`}`
`265`	`265`	`}";`
`@@ -273,19 +273,19 @@ public void Resolve_Should_Parse_AttachmentHandling_As_Enum_None()`
`273`	`273`
`274`	`274`	`// Assert`
`275`	`275`	`result.Should().HaveCount(1);`
`276`		`- result["cucumberMessages"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.None);`
	`276`	`+ result["cucumberMessages"]["mode"].Should().Be(AttachmentHandlingOption.None);`
`277`	`277`	`}`
`278`	`278`
`279`	`279`	`[Fact(Skip = "Skip while deciding on proper behavior for invalid configurations")]`
`280`		`- public void Resolve_Should_Parse_AttachmentHandling_CaseInsensitive()`
	`280`	`+ public void Resolve_Should_Parse_AttachmentHandling_Mode_CaseInsensitive()`
`281`	`281`	`{`
`282`	`282`	`// Arrange`
`283`	`283`	`var filePath = "config.json";`
`284`	`284`	`var fileContent = @"`
`285`	`285`	`{`
`286`	`286`	`""formatters"": {`
`287`	`287`	`""cucumberMessages"": {`
`288`		`- ""attachmentHandling"": ""embed""`
	`288`	`+ ""mode"": ""embed""`
`289`	`289`	`}`
`290`	`290`	`}`
`291`	`291`	`}";`
`@@ -299,19 +299,19 @@ public void Resolve_Should_Parse_AttachmentHandling_CaseInsensitive()`
`299`	`299`
`300`	`300`	`// Assert`
`301`	`301`	`result.Should().HaveCount(1);`
`302`		`- result["cucumberMessages"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.Embed);`
	`302`	`+ result["cucumberMessages"]["mode"].Should().Be(AttachmentHandlingOption.Embed);`
`303`	`303`	`}`
`304`	`304`
`305`	`305`	`[Fact]`
`306`		`- public void Resolve_Should_Keep_String_When_AttachmentHandling_Value_Is_Invalid()`
	`306`	`+ public void Resolve_Should_Keep_String_When_AttachmentHandling_Mode_Value_Is_Invalid()`
`307`	`307`	`{`
`308`	`308`	`// Arrange`
`309`	`309`	`var filePath = "config.json";`
`310`	`310`	`var fileContent = @"`
`311`	`311`	`{`
`312`	`312`	`""formatters"": {`
`313`	`313`	`""cucumberMessages"": {`
`314`		`- ""attachmentHandling"": ""INVALID_VALUE""`
	`314`	`+ ""mode"": ""INVALID_VALUE""`
`315`	`315`	`}`
`316`	`316`	`}`
`317`	`317`	`}";`
`@@ -325,11 +325,11 @@ public void Resolve_Should_Keep_String_When_AttachmentHandling_Value_Is_Invalid(`
`325`	`325`
`326`	`326`	`// Assert`
`327`	`327`	`result.Should().HaveCount(1);`
`328`		`- result["cucumberMessages"]["attachmentHandling"].Should().Be("INVALID_VALUE");`
	`328`	`+ result["cucumberMessages"]["mode"].Should().Be("INVALID_VALUE");`
`329`	`329`	`}`
`330`	`330`
`331`	`331`	`[Fact]`
`332`		`- public void Resolve_Should_Parse_AttachmentHandling_In_Nested_Configuration()`
	`332`	`+ public void Resolve_Should_Parse_AttachmentHandling_Mode_In_Nested_Configuration()`
`333`	`333`	`{`
`334`	`334`	`// Arrange`
`335`	`335`	`var filePath = "config.json";`
`@@ -338,7 +338,7 @@ public void Resolve_Should_Parse_AttachmentHandling_In_Nested_Configuration()`
`338`	`338`	`""formatters"": {`
`339`	`339`	`""cucumberMessages"": {`
`340`	`340`	`""outputPath"": ""output/results.ndjson"",`
`341`		`- ""attachmentHandling"": ""External"",`
	`341`	`+ ""mode"": ""External"",`
`342`	`342`	`""otherSettings"": {`
`343`	`343`	`""enabled"": true`
`344`	`344`	`}`
`@@ -356,7 +356,7 @@ public void Resolve_Should_Parse_AttachmentHandling_In_Nested_Configuration()`
`356`	`356`	`// Assert`
`357`	`357`	`result.Should().HaveCount(1);`
`358`	`358`	`result["cucumberMessages"]["outputPath"].Should().Be("output/results.ndjson");`
`359`		`- result["cucumberMessages"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.External);`
	`359`	`+ result["cucumberMessages"]["mode"].Should().Be(AttachmentHandlingOption.External);`
`360`	`360`
`361`	`361`	`var otherSettings = result["cucumberMessages"]["otherSettings"];`
`362`	`362`	`otherSettings.Should().BeOfType<Dictionary<string, object>>();`
`@@ -373,10 +373,10 @@ public void Resolve_Should_Parse_Multiple_Formatters_With_Different_AttachmentHa`
`373`	`373`	`{`
`374`	`374`	`""formatters"": {`
`375`	`375`	`""formatter1"": {`
`376`		`- ""attachmentHandling"": ""Embed""`
	`376`	`+ ""mode"": ""Embed""`
`377`	`377`	`},`
`378`	`378`	`""formatter2"": {`
`379`		`- ""attachmentHandling"": ""External""`
	`379`	`+ ""mode"": ""External""`
`380`	`380`	`}`
`381`	`381`	`}`
`382`	`382`	`}";`
`@@ -390,8 +390,8 @@ public void Resolve_Should_Parse_Multiple_Formatters_With_Different_AttachmentHa`
`390`	`390`
`391`	`391`	`// Assert`
`392`	`392`	`result.Should().HaveCount(2);`
`393`		`- result["formatter1"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.Embed);`
`394`		`- result["formatter2"]["attachmentHandling"].Should().Be(AttachmentHandlingOption.External);`
	`393`	`+ result["formatter1"]["mode"].Should().Be(AttachmentHandlingOption.Embed);`
	`394`	`+ result["formatter2"]["mode"].Should().Be(AttachmentHandlingOption.External);`
`395`	`395`	`}`
`396`	`396`
`397`	`397`	`[Fact]`
`@@ -403,9 +403,9 @@ public void Resolve_Should_Parse_Formatter_With_AttachmentOptions()`
`403`	`403`	`{`
`404`	`404`	`""formatters"": {`
`405`	`405`	`""formatter1"": {`
`406`		`- ""attachmentHandlingOptions"": {`
`407`		`- ""attachmentHandling"": ""External"",`
`408`		`- ""externalAttachmentsStoragePath"": ""/path/to/attachments""`
	`406`	`+ ""attachmentHandling"": {`
	`407`	`+ ""mode"": ""External"",`
	`408`	`+ ""attachmentsStoragePath"": ""/path/to/attachments""`
`409`	`409`	`}`
`410`	`410`	`}`
`411`	`411`	`}`
`@@ -419,8 +419,8 @@ public void Resolve_Should_Parse_Formatter_With_AttachmentOptions()`
`419`	`419`	`var result = _sut.Resolve();`
`420`	`420`
`421`	`421`	`// Assert`
`422`		`- result["formatter1"]["attachmentHandlingOptions"].Should().BeOfType<AttachmentHandlingOptions>();`
`423`		`- var attachmentOptions = (AttachmentHandlingOptions)result["formatter1"]["attachmentHandlingOptions"];`
	`422`	`+ result["formatter1"]["attachmentHandling"].Should().BeOfType<AttachmentHandlingOptions>();`
	`423`	`+ var attachmentOptions = (AttachmentHandlingOptions)result["formatter1"]["attachmentHandling"];`
`424`	`424`	`attachmentOptions.AttachmentHandlingOption.Should().Be(AttachmentHandlingOption.External);`
`425`	`425`	`attachmentOptions.ExternalAttachmentsStoragePath.Should().Be("/path/to/attachments");`
`426`	`426`	`}`