C#, NUnit TestCaseSource Parameter Übergeben

Wenn man sich TestCaseSourceAttribute doc Sie werden sehen, es gibt keine Methode zum übergeben der parameter an die Methode, die Renditen Testfälle.

Die Methode, die Testfälle, sollte parameterlosen.

So, angenommen, du gehst zu vermeiden code-Duplizierung, und Sie müssen, um die Wiederverwendung der gleichen Methode zum generieren von ein paar test-case-Listen, würd ich dir empfehlen, Folgendes zu tun:

1. Schreiben parametrisierte Methode, die tatsächlich generiert test Fälle setzt:
   
   (PrepareTestCases() bereits tut)

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

2. Schreiben parameterlosen Wrapper, die rufen Testfälle generator und übergeben Sie die gewünschten parameter gibt es:

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

3. Schreiben von test-Methoden und übergeben paremeterless-Wrapper gibt es als test-Fall Quellen:

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

InformationsquelleAutor Alexander Stepaniuk

In meinem Fall würde ich gerne das laden von Daten aus einer CSV-Datei, aber ich konnte nicht übergeben Sie den Dateinamen, um die "datasource".
Nachdem wir ein bisschen herum komme ich an diese zwei-cent-Lösung.

Zuerst habe ich geerbt 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")
    { }
}

dann habe ich die Daten-Schicht, in meinem Fall eine 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);
        }
}

Dann habe ich eine Klasse angelegt, nur mit dem Rahmen, um Eigenschaften zu enthalten, die mit den Dateipfaden. Es gibt eine namens-Konvention über die Eigenschaft, dass die ClassTypeName + "Filename".

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

Zu diesem Zeitpunkt nur schmücken entsprechend dem test, mit der Art von Klassen für die Zuordnung der Daten und die Klasse enthalten, dass der Datei-Pfad.

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

Hoffe das kann ein wenig helfen.

InformationsquelleAutor Andrea Celin