Verify/docs/parameterised-fixie.md

Fixie Parameterised Tests

UseParameters()

UseParameters() controls what parameters are used when naming files.

Verify.Fixie automatically detects the method parameters via a custom ITestProject.

Usage:

[TestCase("Value1")]
[TestCase("Value2")]
public Task UseParametersUsage(string arg)
{
    var somethingToVerify = $"{arg} some text";
    return Verify(somethingToVerify)
        .UseParameters(arg);
}

^{snippet source | anchor}

If not all parameters are required, a subset can be passed in. In this scenario, the parameters passed in will match with the method parameter names from the start. For example the following will result in a file named ParametersSample.UseParametersSubSet_arg1=Value1_arg2=Value2.verified.txt

[TestCase("Value1", "Value2", "Value3")]
public Task UseParametersSubSet(string arg1, string arg2, string arg3)
{
    var somethingToVerify = $"{arg1} {arg2} {arg3} some text";
    return Verify(somethingToVerify)
        .UseParameters(arg1, arg2);
}

^{snippet source | anchor}

If the number of parameters passed to UseParameters() is greater than the number of parameters in the test method, an exception will be thrown.

Custom parameterisation

Fixie has no build in test parameterisation. Test parameterisation need to be implemented by the consuming library. See Attribute-Based Parameterization for an example.

Verify.Fixie requires some customisation of the above example.

• Inside ITestProject.Configure call VerifierSettings.AssignTargetAssembly(environment.Assembly);
• Inside IExecution.Run wrap test.Run in using (ExecutionState.Set(testClass, test, parameters))

Example implementation:

public class TestProject :
    ITestProject,
    IExecution
{
    public void Configure(TestConfiguration configuration, TestEnvironment environment)
    {
        VerifierSettings.AssignTargetAssembly(environment.Assembly);
        configuration.Conventions.Add<DefaultDiscovery, TestProject>();
    }

    public async Task Run(TestSuite testSuite)
    {
        foreach (var testClass in testSuite.TestClasses)
        {
            foreach (var test in testClass.Tests)
            {
                if (test.HasParameters)
                {
                    foreach (var parameters in test
                                 .GetAll<TestCase>()
                                 .Select(_ => _.Parameters))
                    {
                        using (ExecutionState.Set(testClass, test, parameters))
                        {
                            await test.Run(parameters);
                        }
                    }
                }
                else
                {
                    using (ExecutionState.Set(testClass, test, null))
                    {
                        await test.Run();
                    }
                }
            }
        }
    }
}

^{snippet source | anchor}

Resulting usage:

[TestCase("Value1")]
[TestCase("Value2")]
public Task TestCaseUsage(string arg) =>
    Verify(arg);

^{snippet source | anchor}

Overriding text used for parameters

UseTextForParameters() can be used to override the substitution text used for the {Parameters} part of the file convention.

{Directory}/{TestClassName}.{TestMethodName}_{Parameters}_{UniqueFor1}_{UniqueFor2}_{UniqueForX}.verified.{extension}

The below samples produce:

For the instance case:

• TheTest.UseTextForParameters_Value1.verified.txt
• TheTest.UseTextForParameters_Value2.verified.txt

For the fluent case:

• TheTest.UseTextForParametersFluent_Value1.verified.txt
• TheTest.UseTextForParametersFluent_Value2.verified.txt

Instance

[TestCase("Value1")]
[TestCase("Value2")]
public Task UseTextForParameters(string arg)
{
    var settings = new VerifySettings();
    settings.UseTextForParameters(arg);
    return Verify(arg + "UseTextForParameters", settings);
}

^{snippet source | anchor}

Fluent

[TestCase("Value1")]
[TestCase("Value2")]
public Task UseTextForParametersFluent(string arg) =>
    Verify(arg + "UseTextForParametersFluent")
        .UseTextForParameters(arg);

^{snippet source | anchor}

Ignore parameters for verified filename

By default, Verify expects every parameterized case to have a unique file name with the parameters appended to the file name. This behavior can be overridden by using IgnoreParametersForVerified(). In this case, the verified file name does not contain the parameter values, meaning it is the same for each testcase.

IgnoreParametersForVerified accepts an array for passing through the parameters. These values are passed to UseParameters. This is required for MSTest, and xUnit. Parameters should not be passed for NUnit, TUnit and Fixie since they are automatically detected.

The below samples produce:

For the instance case:

• NamerTests.IgnoreParametersForVerified_arg=One.received.txt
• NamerTests.IgnoreParametersForVerified_arg=Two.received.txt
• NamerTests.IgnoreParametersForVerified.verified.txt

For the fluent case:

• NamerTests.IgnoreParametersForVerifiedFluent_arg=One.received.txt
• NamerTests.IgnoreParametersForVerifiedFluent_arg=Two.received.txt
• NamerTests.IgnoreParametersForVerifiedFluent.verified.txt

IgnoreParametersForVerified with override parameters

The parameters passed to IgnoreParametersForVerified can be used pass custom parameters to UseParameters.

Hashing parameters

Parameters can be hashed as an alternative to being stringified. This is useful when the parameters are large and could potentially generate file names that exceed allowances of the OS.

Hashing parameter is achieved by using HashParameters.

Overriding text used for parameters is respected when generating the hash.

XxHash64 is used to perform the hash.