When unit-testing should common methods put in static class or in base class?

Question

I have a few methods that are used from different class tests. Also, some other common methods are used for preparing the test data.

What is the common practice to handle this in tests? Should I handle this like any other case by having either base class or some static class (e.g. Utils.CommonMethod())? I use static class, since I don't really like the base class in this situation as it will imply that ClassTest1 and ClassTestN are interchangeable.

[TestClass]
public class ClassTest1
{
   [TestMethod]
   [DynamicData...]
   public void Method(TestData data)
   {
       ...
       CommonMethod1();
   }

   public static IEnumerable<object[]> GetTestData()
   {
      CommonMethod2();
      ...
   }
}

[TestClass]
public class ClassTestN
{
   [TestMethod]
   [DynamicData...]
   public void Method(TestData data)
   {
       ...
       CommonMethod1();
   }

   public static IEnumerable<object[]> GetTestData()
   {
      CommonMethod2();
      ...
   }
}

Answer 1

Using inheritance to reuse functionality can lead to the following problem (in languages, like C#, that do not support multiple inheritance).

Let test classes A and B use some common functionality AB. Let test classes B and C use some other common functionality BC.
When we use base classes to access this functionality, B should derive from both AB and BC. C# does not support this.

Therefore, my advise would be to move the common functionality to separate classes whenever possible.
(This fits with the "composition over inheritance"-principle.)

For the specific case of DynamicDataAttribute and GetTestData() you can abstract this data into a class of its own: a custom data source attribute (derive from System.Attribute and implement ITestDataSource). Meziantou's blog gives an example implementation and how to attach the attribute to the test method:

public class MyCustomDataSourceAttribute: Attribute, ITestDataSource
{
    public static IEnumerable<object[]> GetTestData(MethodInfo testMethod)
    {
        yield return new object[] { new TestData(1) };
        yield return new object[] { new TestData(2) };
        yield return new object[] { new TestData(3) };
    }

    public string GetDisplayName(MethodInfo methodInfo, object[] data)
    {
        if (data != null && data.Count == 1 && data data[0] is TestData testData)
        {
            return $"Custom - {methodInfo.Name}, {testData});
        }
        else
        {
            return null;
        }
    }
}

and

[TestClass]
public class ClassTest1
{
   [TestMethod]
   [MyCustomDataSource]
   public void Method(TestData data)
   {
       ...
       CommonMethod1();
   }
}