add IgnoreClassArguments

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)

src/Verify/Naming/VerifierSettings.cs

@@ -361,4 +361,16 @@ public static void IgnoreParameters(params string[] parameterNames)
         InnerVerifier.ThrowIfVerifyHasBeenRun();
         GlobalIgnoredParameters = parameterNames.ToHashSet();
     }
+
+    internal static bool GlobalIgnoreClassArguments;
+
+    /// <summary>
+    /// Ignore class arguments in 'verified' filename resulting in the same verified file regardless of class constructor arguments.
+    /// Note that the 'received' files still contain the class arguments.
+    /// </summary>
+    public static void IgnoreClassArguments()
+    {
+        InnerVerifier.ThrowIfVerifyHasBeenRun();
+        GlobalIgnoreClassArguments = true;
+    }
 }

src/Verify/Naming/VerifySettings_Parameter.cs

@@ -82,6 +82,20 @@ void ThrowIfParametersTextDefined([CallerMemberName] string caller = "")
     public void IgnoreParameters(params string[] parameterNames) =>
         ignoredParameters = parameterNames.ToHashSet();
 
+    internal int classArgumentCount;
+
+    internal void SetClassArgumentCount(int count) =>
+        classArgumentCount = count;
+
+    internal bool ignoreClassArguments;
+
+    /// <summary>
+    /// Ignore class arguments in 'verified' filename resulting in the same verified file regardless of class constructor arguments.
+    /// Note that the 'received' files still contain the class arguments.
+    /// </summary>
+    public void IgnoreClassArguments() =>
+        ignoreClassArguments = true;
+
     internal bool ignoreParametersForVerified;
 
     /// <summary>

src/Verify/Serialization/VerifierSettings.cs

@@ -167,6 +167,7 @@ internal static void Reset()
         addAttachments = true;
         GlobalScrubbers.Clear();
         GlobalIgnoredParameters = null;
+        GlobalIgnoreClassArguments = false;
     }
 
     public static void UseStrictJson()

src/Verify/SettingsTask_Parameters.cs

@@ -10,6 +10,14 @@ public SettingsTask IgnoreParameters(params string[] parameterNames)
         return this;
     }
 
+    /// <inheritdoc cref="VerifySettings.IgnoreClassArguments()"/>
+    [Pure]
+    public SettingsTask IgnoreClassArguments()
+    {
+        CurrentSettings.IgnoreClassArguments();
+        return this;
+    }
+
     /// <inheritdoc cref="VerifySettings.IgnoreParametersForVerified(object?[])"/>
     [Pure]
     public SettingsTask IgnoreParametersForVerified(params object?[] parameters)

src/Verify/VerifySettings.cs

@@ -49,6 +49,8 @@ public VerifySettings(VerifySettings? settings)
         extensionStreamComparers = settings.extensionStreamComparers;
         parameters = settings.parameters;
         ignoredParameters = settings.ignoredParameters;
+        classArgumentCount = settings.classArgumentCount;
+        ignoreClassArguments = settings.ignoreClassArguments;
         ignoreParametersForVerified = settings.ignoreParametersForVerified;
         parametersText = settings.parametersText;
         FileName = settings.FileName;