add IgnoreClassArguments (#1702)

Author: SimonCropp

docs/mdsource/ignore-class-arguments.include.md

@@ -0,0 +1,17 @@
+### Ignore class arguments
+
+`VerifierSettings.IgnoreClassArguments()` can be used to globally ignore class constructor arguments from the verified filename. This is useful when infrastructure fixtures (e.g. TUnit's `ClassConstructor` or NUnit's `TestFixtureSource`) are injected via the constructor and should not affect snapshot file names. It must be called before any test runs, typically in a `[ModuleInitializer]`.
+
+The received files still contain all class argument values.
+
+```cs
+[ModuleInitializer]
+public static void Init() =>
+    VerifierSettings.IgnoreClassArguments();
+```
+
+`IgnoreClassArguments` can also be used at the test level:
+
+```cs
+await Verify(result).IgnoreClassArguments();
+```

docs/mdsource/parameterised-nunit.source.md

@@ -68,6 +68,11 @@ snippet: IgnoreParametersForVerifiedNunit
 snippet: IgnoreParametersForVerifiedFluentNunit
 
 
+## Ignore class arguments for verified filename
+
+include: ignore-class-arguments
+
+
 ## IgnoreParametersForVerified with override parameters
 
 The parameters passed to IgnoreParametersForVerified can be used pass custom parameters to [UseParameters](#UseParameters).

docs/mdsource/parameterised-tunit.source.md

@@ -56,6 +56,11 @@ snippet: IgnoreParametersForVerifiedTUnit
 snippet: IgnoreParametersForVerifiedFluentTUnit
 
 
+## Ignore class arguments for verified filename
+
+include: ignore-class-arguments
+
+
 ## IgnoreParametersForVerified with override parameters
 
 The parameters passed to IgnoreParametersForVerified can be used pass custom parameters to [UseParameters](#UseParameters).

docs/parameterised-nunit.md

@@ -250,6 +250,28 @@ public Task IgnoreParametersForVerifiedFluent(string arg) =>
 <!-- endSnippet -->
 
 
+## Ignore class arguments for verified filename
+
+### Ignore class arguments<!-- include: ignore-class-arguments. path: /docs/mdsource/ignore-class-arguments.include.md -->
+
+`VerifierSettings.IgnoreClassArguments()` can be used to globally ignore class constructor arguments from the verified filename. This is useful when infrastructure fixtures (e.g. TUnit's `ClassConstructor` or NUnit's `TestFixtureSource`) are injected via the constructor and should not affect snapshot file names. It must be called before any test runs, typically in a `[ModuleInitializer]`.
+
+The received files still contain all class argument values.
+
+```cs
+[ModuleInitializer]
+public static void Init() =>
+    VerifierSettings.IgnoreClassArguments();
+```
+
+`IgnoreClassArguments` can also be used at the test level:
+
+```cs
+await Verify(result).IgnoreClassArguments();
+```
+<!-- endInclude -->
+
+
 ## IgnoreParametersForVerified with override parameters
 
 The parameters passed to IgnoreParametersForVerified can be used pass custom parameters to [UseParameters](#UseParameters).

docs/parameterised-tunit.md

@@ -197,6 +197,28 @@ public Task IgnoreParametersForVerifiedFluent(string arg) =>
 <!-- endSnippet -->
 
 
+## Ignore class arguments for verified filename
+
+### Ignore class arguments<!-- include: ignore-class-arguments. path: /docs/mdsource/ignore-class-arguments.include.md -->
+
+`VerifierSettings.IgnoreClassArguments()` can be used to globally ignore class constructor arguments from the verified filename. This is useful when infrastructure fixtures (e.g. TUnit's `ClassConstructor` or NUnit's `TestFixtureSource`) are injected via the constructor and should not affect snapshot file names. It must be called before any test runs, typically in a `[ModuleInitializer]`.
+
+The received files still contain all class argument values.
+
+```cs
+[ModuleInitializer]
+public static void Init() =>
+    VerifierSettings.IgnoreClassArguments();
+```
+
+`IgnoreClassArguments` can also be used at the test level:
+
+```cs
+await Verify(result).IgnoreClassArguments();
+```
+<!-- endInclude -->
+
+
 ## IgnoreParametersForVerified with override parameters
 
 The parameters passed to IgnoreParametersForVerified can be used pass custom parameters to [UseParameters](#UseParameters).

src/StaticSettingsTests/IgnoreClassArgumentsTests.IgnoreClassArguments.verified.txt

@@ -0,0 +1 @@
+value

src/StaticSettingsTests/IgnoreClassArgumentsTests.cs

@@ -0,0 +1,17 @@
+public class IgnoreClassArgumentsTests :
+    BaseTest
+{
+    public IgnoreClassArgumentsTests() =>
+        VerifierSettings.IgnoreClassArguments();
+
+    [Theory]
+    [InlineData("One")]
+    [InlineData("Two")]
+    public Task IgnoreClassArguments(string classArg)
+    {
+        var settings = new VerifySettings();
+        settings.UseParameters(classArg);
+        settings.SetClassArgumentCount(1);
+        return Verify("value", settings);
+    }
+}

src/Verify.NUnit/Verifier.cs

@@ -36,8 +36,9 @@ public static InnerVerifier BuildVerifier(string sourceFile, VerifySettings sett
         }
         else
         {
-            (parameterNames, var parameters) = GetParametersAndNames(method, adapter);
+            (parameterNames, var parameters, var classArgumentCount) = GetParametersAndNames(method, adapter);
             settings.SetParameters(parameters);
+            settings.SetClassArgumentCount(classArgumentCount);
         }
 
         VerifierSettings.AssignTargetAssembly(type.Assembly);
@@ -58,29 +59,30 @@ public static InnerVerifier BuildVerifier(string sourceFile, VerifySettings sett
         return adapter.GetParameterNames(methodParameterNames);
     }
 
-    static (IReadOnlyList<string>? names, object?[] parameters) GetParametersAndNames(MethodInfo method, TestAdapter adapter)
+    static (IReadOnlyList<string>? names, object?[] parameters, int classArgumentCount) GetParametersAndNames(MethodInfo method, TestAdapter adapter)
     {
         var methodParameterNames = method.ParameterNames();
         var parameterNames = adapter.GetParameterNames(methodParameterNames);
         if (!adapter.TryGetParent(out var parent))
         {
-            return (parameterNames, adapter.Arguments);
+            return (parameterNames, adapter.Arguments, 0);
         }
 
         var argumentsLength = parent.Arguments.Length;
         if (argumentsLength == 0)
         {
-            return (parameterNames, adapter.Arguments);
+            return (parameterNames, adapter.Arguments, 0);
         }
 
         if (methodParameterNames == null)
         {
-            return (parameterNames, parent.Arguments);
+            return (parameterNames, parent.Arguments, argumentsLength);
         }
 
         return (
             parameterNames,
-            [.. parent.Arguments, .. adapter.Arguments]);
+            [.. parent.Arguments, .. adapter.Arguments],
+            argumentsLength);
     }
 
     static SettingsTask Verify(

src/Verify.TUnit/Verifier.cs

@@ -37,6 +37,7 @@ public static InnerVerifier BuildVerifier(string sourceFile, VerifySettings sett
              methodArguments.Length > 0))
         {
             settings.SetParameters([.. classArguments, .. methodArguments]);
+            settings.SetClassArgumentCount(classArguments.Length);
         }
 
         VerifierSettings.AssignTargetAssembly(type.Assembly);

src/Verify/Naming/FileNameBuilder.cs

@@ -67,6 +67,23 @@ public static (Action<StringBuilder>?, Action<StringBuilder>?) GetParameterText(
             }
         }
 
+        if (settings.ignoreClassArguments || VerifierSettings.GlobalIgnoreClassArguments)
+        {
+            var classArgCount = settings.classArgumentCount;
+            if (classArgCount > 0)
+            {
+                var classParamNames = methodParameters.Take(classArgCount);
+                if (ignored is not null)
+                {
+                    ignored = [..ignored, ..classParamNames];
+                }
+                else
+                {
+                    ignored = classParamNames.ToHashSet();
+                }
+            }
+        }
+
         var verifiedValues = GetVerifiedValues(ignored, allValues);
 
         if (settings.ParametersAppender == null)