Repeating a [TestCase] 100 times in NUnit

nunitrepeatunit testingwebtest

I'm converting a webtest that loops 100 times (fires the request and validates the response 100 times) to NUnit. It seems that the [Repeat] attribute only works for [Test], not [TestCase] or any other decoration/attribute. What is the cleanest way to do this? I want to fire that one test case with those parameters 100 times, and I'd like to do it without adding a loopCount parameter to my test case and nesting my act and assert sections in a for loop.

The below code only runs once.

[TestCase("arg1", "arg2"), Repeat(100)]
public void testing(string arg1, string arg2)
{
    //Arrange

    //Act
    var response = RequestSender.SendGetRequest();

    //Assert
    AssertStuff(arg1, arg2);
}

Best Answer

From the online NUnit documentation for Repeat, it would appear that this behaviour is deliberate.

Notes:

It is not currently possible to use RepeatAttribute on a TestFixture or any other type of test suite. Only single tests may be repeated. Since a parameterized test method represents a suite, RepeatAttribute is ignored when it appears on such a method.

With the assumption that TestCase is obviously regarded as a parameterized test. The loop looks inevitable, without some additional customization?

What you could do instead is use use a test case source and feed it an enumerable of 100 repeated items:

private static readonly IEnumerable<Tuple<string, string>> _oneHundredCases = 
  Enumerable.Range(0, 100)
   .Select(_ => Tuple.Create("arg1", "arg2"));

[TestCaseSource(nameof(_oneHundredCases))]
public void testing(Tuple<string, string> theArgs)
{
    ...
    AssertStuff(theArgs.Item1, theArgs.Item2);
}

But for the same price, you may as well vary the arguments a bit?, e.g.

_oneHundredCases = 
  Enumerable.Range(0, 100)
   .Select(n => Tuple.Create(n.ToString(), $"arg{n}"));

Related Solutions

Javascript – Repeat a string in JavaScript a number of times

These days, the repeat string method is implemented almost everywhere. (It is not in Internet Explorer.) So unless you need to support older browsers, you can simply write:

"a".repeat(10)

Before repeat, we used this hack:

Array(11).join("a") // create string with 10 a's: "aaaaaaaaaa"

(Note that an array of length 11 gets you only 10 "a"s, since Array.join puts the argument between the array elements.)

Simon also points out that according to this benchmark, it appears that it's faster in Safari and Chrome (but not Firefox) to repeat a character multiple times by simply appending using a for loop (although a bit less concise).

C# – NUnit TestCase with Generics

NUnit test methods actually can be generic as long as the generic type arguments can be inferred from parameters:

[TestCase(42)]
[TestCase("string")]
[TestCase(double.Epsilon)]
public void GenericTest<T>(T instance)
{
    Console.WriteLine(instance);
}

If the generic arguments cannot be inferred, the test runner will not have a clue how to resolve type arguments:

[TestCase(42)]
[TestCase("string")]
[TestCase(double.Epsilon)]
public void GenericTest<T>(object instance)
{
    Console.WriteLine(instance);
}

But in this case you can implement a custom attribute:

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public class TestCaseGenericAttribute : TestCaseAttribute, ITestBuilder
{
    public TestCaseGenericAttribute(params object[] arguments)
        : base(arguments)
    {
    }

    public Type[] TypeArguments { get; set; }

    IEnumerable<TestMethod> ITestBuilder.BuildFrom(IMethodInfo method, Test suite)
    {
        if (!method.IsGenericMethodDefinition)
            return base.BuildFrom(method, suite);

        if (TypeArguments == null || TypeArguments.Length != method.GetGenericArguments().Length)
        {
            var parms = new TestCaseParameters { RunState = RunState.NotRunnable };
            parms.Properties.Set("_SKIPREASON", $"{nameof(TypeArguments)} should have {method.GetGenericArguments().Length} elements");
            return new[] { new NUnitTestCaseBuilder().BuildTestMethod(method, suite, parms) };
        }

        var genMethod = method.MakeGenericMethod(TypeArguments);
        return base.BuildFrom(genMethod, suite);
    }
}

Usage:

[TestCaseGeneric("Some response", TypeArguments = new[] { typeof(IMyInterface), typeof(MyConcreteClass) }]
public void MyMethod_GenericCall_MakesGenericCall<T1, T2>(string expectedResponse)
{
    // whatever
}

And a similar customization for TestCaseSourceAttribute:

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public class TestCaseSourceGenericAttribute : TestCaseSourceAttribute, ITestBuilder
{
    public TestCaseSourceGenericAttribute(string sourceName)
        : base(sourceName)
    {
    }

    public Type[] TypeArguments { get; set; }

    IEnumerable<TestMethod> ITestBuilder.BuildFrom(IMethodInfo method, Test suite)
    {
        if (!method.IsGenericMethodDefinition)
            return base.BuildFrom(method, suite);

        if (TypeArguments == null || TypeArguments.Length != method.GetGenericArguments().Length)
        {
            var parms = new TestCaseParameters { RunState = RunState.NotRunnable };
            parms.Properties.Set("_SKIPREASON", $"{nameof(TypeArguments)} should have {method.GetGenericArguments().Length} elements");
            return new[] { new NUnitTestCaseBuilder().BuildTestMethod(method, suite, parms) };
        }

        var genMethod = method.MakeGenericMethod(TypeArguments);
        return base.BuildFrom(genMethod, suite);
    }
}

Usage:

[TestCaseSourceGeneric(nameof(mySource)), TypeArguments = new[] { typeof(IMyInterface), typeof(MyConcreteClass) }]

Best Answer

Related Solutions

Javascript – Repeat a string in JavaScript a number of times

C# – NUnit TestCase with Generics

Related Topic