使用不同数据类型的相同参数调用测试方法两次

Question

I'm trying to reduce the duplicate code by combining two tests validation methods. Both test methods pass three parameters (actualResponse, expectedReponse, filterParams) but the problem is that even if the two methods have define the same name for parameters their datatype are different.

Here is the summary of the script:

TestSteps.cs class where these methods are called:

public class TestSteps : BaseTest
{

     // _result holds the actual results coming from context get cal
     private Context _result = new();

     // _SolutionExpectedResponse have expected response from json file.
     private readonly Context _SolutionExpectedResponse = new();

    public TestSteps()
      {
        string jsonstring = File.ReadAllText(@Path of response.json file);
        _SolutionExpectedResponse = JsonConvert.DeserializeObject<Context>(jsonstring);
      }
      [When(@Call context api)]
      public void WhenCallContextAPI()
      {
        _result = Context.GetAsync(token,resource).Result;
      }

      [Then(@Verify the response Values)]
      public void ThenVerifyTheResponseValues()
      {
        ValidateDataValues(_result.Data, _SolutionExpectedResponse.Data, new string[] {"data"})

        ValidateSensitiveDataValues(_result.SensitiveData, _SolutionExpectedResponse.SensitiveData, new string[] {"sensitiveData"})
      }
}

BaseTest.cs class where validate methods were wrote:

Method #1:

Protected void ValidateDataValues(List<DataReadable> actualResponse,  List <DataReadable> expectedResponse,  string[] filterParams)

{

  if (filterParams.contains("data"))
  {
    if(actualResponse !=null)
    {
        for(int i=0; i < expectedResponse.Count; i++)
        {
           if((actualResponse[i].Key !=null)
                      {
                actualResponse[i].Key.Value.ToString().Should.BeEquivalentTo(expectedResponse[i].Key.Value.ToString());
              }
        }
        return;
    }
    else
    {
       actualResponse.Should().BeNull();
    }
  }

}

Method #2:

Protected void ValidateSensitiveDataValues(List<SensitiveDataReadable> actualResponse,  List <SensitiveDataReadable> expectedResponse,  string[] filterParams)

{

  if (filterParams.contains("sensitiveData"))
  {
    if(actualResponse !=null)
    {
        for(int i=0; i < expectedResponse.Count; i++)
        {
           if((actualResponse[i].Key !=null)
                      {
                actualResponse[i].Key.Value.ToString().Should.BeEquivalentTo(expectedResponse[i].Key.Value.ToString());
              }
        }
        return;
    }
    else
    {
       actualResponse.Should().BeNull();
    }
  }

}

Is it possible for me to reduce the duplicate code by adding method#2 parameters in method#1 and eliminating method #2?

OR

By calling method #1 from the method #2 by converting the datatype?

Answer 1

A typical approach would be to use generics, this lets you define a method that can take any type, or some subset of types as parameters:

public bool ValidateSensitiveDataValues<T>(IEnumerable<T> actual, IEnumerable<T> expected, IEqualityComparer<T> comparer){
    return actual.SequenceEqual(expected, comparer);
}

Note that if T is a class you either need to give the method a EqualityComparer-object, or restrict the method to only work if T implements IEquatable: ValidateSensitiveDataValues<T>(IEnumerable<T> actual, IEnumerable<T> expected) where T: IEquatable<T> . I tend to prefer the former since it is more flexible. If you do not do this any reference objects will use reference equality, and that is probably not what you want.

You might also want to use a unit test library. NUnit is a poppular one that has Assert-methods like CollectionAssert.AreEqual and CollectionAssert.AreEquivalent . Where only the former care about ordering of the items.