C # NUnit TestCaseSource Passing Parameter

Si vous regardez TestCaseSourceAttribute doc vous verrez il n'y a pas de toute façon de passer le paramètre de la méthode qui retourne des cas de test.

De la méthode, qui génère des cas de test, devrait être sans paramètre.

Donc, en supposant que vous allez éviter la duplication de code et vous avez besoin de réutiliser la même méthode pour générer un peu de cas de test listes, je vous recommande de faire ce qui suit:

1. Écrire paramétrée méthode qui génère des cas de test de jeux:
   
   (PrepareTestCases() déjà fait)

   public IEnumerable<ResultsOfCallMyMethod> PrepareTestCases(string param)
   {
       foreach (string entry in entries)
       {
           yield return CallMyMethod(param);
       }
   }

2. Écrire sans paramètre wrappers qui appellent des cas de test de générateur et de passer le paramètre de votre choix:

   public IEnumerable<ResultsOfCallMyMethod> PrepareTestCases_Param1()
   {
       return PrepareTestCases("param1");
   }
   
   public IEnumerable<ResultsOfCallMyMethod> PrepareTestCases_Param2()
   {
       return PrepareTestCases("param2");
   }

3. Écrire des méthodes d'essai et passer paremeterless wrappers il y a tant de cas de test sources:

   [TestCaseSource("PrepareTestCases_Param1")]
   public void TestRun1(ResultsOfCallMyMethod data)
   {
   }
   
   [TestCaseSource("PrepareTestCases_Param2")]
   public void TestRun2(ResultsOfCallMyMethod data)
   {
   }

Dans mon cas, je voudrais charger des données depuis un fichier CSV, mais je ne pouvais pas laisser passer le nom du fichier à la "source de données".
Après avoir lutté un peu autour de moi, je viens à ce à deux cent solution.

Au premier abord, j'ai hérité de TestCaseSourceAttirbute

///<summary>
///FactoryAttribute indicates the source to be used to provide test cases for a test method.
///</summary>
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
public class TestCaseCsvAttribute : TestCaseSourceAttribute 
{
    public TestCaseCsvAttribute(Type mapped, Type config) : base(typeof(TestCsvReader<,>).MakeGenericType(mapped, config), "Data")
    { }
}

puis j'ai créé la couche de données, dans mon cas, un CSV reader.

    ///<summary>
///Test data provider
///</summary>
///<typeparam name="T">Type to return in enumerable</typeparam>
///<typeparam name="C">Configuration type that provide Filenames</typeparam>
public sealed class TestCsvReader<T, C>
{
///<summary>
///Initializes a new instance of the <see cref="TestCsvReader{T, C}"/> class.
///</summary>
public TestCsvReader()
{
this.Config = (C)Activator.CreateInstance<C>();
}
///<summary>
///Gets or sets the configuration.
///</summary>
///<value>
///The configuration.
///</value>
private C Config { get; set; }
///<summary>
///Gets the filename.
///</summary>
///<value>
///The filename.
///</value>
///<exception cref="System.Exception">
///</exception>
private string Filename
{
get
{
try
{
string result = Convert.ToString(typeof(C).GetProperty(string.Format("{0}Filename", typeof(T).Name)).GetValue(this.Config));
if (!File.Exists(result))
throw new Exception(string.Format("Unable to find file '{0}' specified in property '{1}Filename' in class '{1}'", result, typeof(C).Name));
return result;
}
catch
{
throw new Exception(string.Format("Unable to find property '{0}Filename' in class '{1}'", typeof(T).Name, typeof(C).Name));
}
}
}
///<summary>
///Yields values from source
///</summary>
///<returns></returns>
public IEnumerable Data()
{
string file = this.Filename;
T[] result = null;
using (StreamReader reader = File.OpenText(file))
{
//TODO: do it here your magic
}
yield return new TestCaseData(result);
}
}

Puis j'ai créé une classe avec la seule étendue pour contenir des propriétés avec les chemins d'accès aux fichiers. Il y a un nom de convention sur les biens, c'est ClassTypeName + "nom de fichier".

public class Configurations
{
public string ConflictDataFilename
{
get
{
return @"C:\test.csv";
}
}
}

À ce point tout à décorer en conséquence le test, avec le type de classe de la carte de données et la classe qui contient le chemin du fichier.

[Test(Description="Try this one")]
[TestCaseCsv(typeof(ClassMappedToData), typeof(Configurations))]
public void Infinite(ClassMappedToData[] data)
{
}

J'espère que cela peut aider un peu.