Datengetriebenes Testen in NUnit?

Question

In MSTest Sie können so etwas tun:

[TestMethod]
[DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV", 
            "testdata.csv", "testdata#csv", DataAccessMethod.Sequential)]
public void TestSomething()
{
    double column1 = Convert.ToDouble(TestContext.DataRow["column1"]);
    ...
    Assert.AreEqual(...);
}

Was ist der entsprechende Code in NUnit 2.5?

Answer 1

ich an der parametrisierte testet Dokumentation in NUnit 2.5 und sehen, wenn Sie tun können, so etwas wie, was Sie da tun. Ich weiß nicht NUnit erinnere an ein integriertes in CSV mit Attribute Lese parametrisiert Tests zu fahren. Es kann jedoch eine Gemeinschaft Plug-in irgendwo sein.

Ich möchte auch darauf hinweisen, dass, wenn Sie schauen nur für Nicht-MS Unit Testing Framework-Bibliotheken Um Ihnen zu helfen, tut xUnit.net diese Funktionalität. Sehen Sie sich diese Blog-Post von Ben Hall

Answer 2

Ich habe csv basierte Datengetriebenes Testen in NUnit arbeitet wie folgt:

Mit dem csv Leser von Code-Projekt , in einer privaten Methode Rückkehr IEnumerable in Ihrem Test eingewickelt Klasse, und diese dann mit einem TestCaseSource Attribute auf Ihren Testfällen verweisen. Fügen Sie Ihre CSV-Datei in Ihrem Projekt und Satz " kopiert Ausgabeverzeichnis " auf " Immer kopieren" .

using System.Collections.Generic;
using System.IO;
using LumenWorks.Framework.IO.Csv;
using NUnit.Framework;

namespace mytests
{
    class MegaTests
    {
        [Test, TestCaseSource("GetTestData")]
        public void MyExample_Test(int data1, int data2, int expectedOutput)
        {
            var methodOutput = MethodUnderTest(data2, data1);
            Assert.AreEqual(expectedOutput, methodOutput, string.Format("Method failed for data1: {0}, data2: {1}", data1, data2));
        }

        private int MethodUnderTest(int data2, int data1)
        {
            return 42; //todo: real implementation
        }

        private IEnumerable<int[]> GetTestData()
        {
            using (var csv = new CsvReader(new StreamReader("test-data.csv"), true))
            {
                while (csv.ReadNextRecord())
                {
                    int data1 = int.Parse(csv[0]);
                    int data2 = int.Parse(csv[1]);
                    int expectedOutput = int.Parse(csv[2]);
                    yield return new[] { data1, data2, expectedOutput };
                }
            }
        }
    }
}

Original-Beitrag an: http: //timwise.blogspot .com / 2011/05 / data-driven-Test-in-nunit-mit-csv.html

Answer 3

Hier ist ein weiteres Beispiel sehr ähnlich Tim Abell hat jedoch keinen Rahmen für die CSV-Reader und die Besonderheiten des Tests zeigt. Hinweis, wenn Sie die TestCaseAttribute die TestAttribute können weggelassen werden.

        [TestCaseSource("GetDataFromCSV")]
    public void TestDataFromCSV(int num1,int num2,int num3)
    {
        Assert.AreEqual(num1 + num2 ,num3);
    }

    private IEnumerable<int[]> GetDataFromCSV()
    {
        CsvReader reader = new CsvReader(path);
        while (reader.Next())
        {
            int column1 = int.Parse(reader[0]);
            int column2 = int.Parse(reader[1]);
            int column3 = int.Parse(reader[2]);
            yield return new int[] { column1, column2, column3 };
        }
    }


public class CsvReader : IDisposable
{
    private string path;
    private string[] currentData;
    private StreamReader reader;

    public CsvReader(string path)
    {
        if (!File.Exists(path)) throw new InvalidOperationException("path does not exist");
        this.path = path;
        Initialize();
    }

    private void Initialize()
    {
        FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read);
        reader = new StreamReader(stream);
    }

    public bool Next()
    {
        string current = null;
        if ((current = reader.ReadLine()) == null) return false;
        currentData = current.Split(',');
        return true;
    }

    public string this[int index]
    {
        get { return currentData[index]; }
    }


    public void Dispose()
    {
        reader.Close();
    }
}

CSV-Daten:

10200210 20190210 30180210 40170210 50160210 60150210 70140210 80130210 90120210 100110210

. Hinweis: Die dritte Säule ist eine Summe aus den ersten beiden Spalten, und dies wird in dem Unit-Test geltend gemacht werden

Ergebnisse:

Unten finden Sie eine Alternative mit TestCaseData Objekte und Einstellen eines Rückgabetyp (die off-Kurs obligatorisch)

        [TestCaseSource("GetDataFromCSV2")]
    public int TestDataFromCSV2(int num1, int num2)
    {
        return num1 + num2;
    }

    private IEnumerable GetDataFromCSV2()
    {
        CsvReader reader = new CsvReader(path);
        while (reader.Next())
        {
            int column1 = int.Parse(reader[0]);
            int column2 = int.Parse(reader[1]);
            int column3 = int.Parse(reader[2]);
            yield return new TestCaseData(column1, column2).Returns(column3);
        }
    }

Answer 4

MS Test stellt einen Mechanismus Ihre Testdaten aus verschiedenen Quellen zu haben. Dies ist jedoch nicht verfügbar aus der Box von NUnit.

Ich bin für Verwendung der Daten und Code für die Tests zu trennen, die von einer beträchtlichen Größe. Wenn ich beide trennen, meine Erwartungen sind 1. Ablesbarkeit von Testdaten 2. Testdaten sollten leicht zu ändern 3. Die Unit-Tests sollte bequem in lokaler und Build-Umgebung ausführen

Die JsonSectionReader unten verfügt über alle Funktionen, dass ich möchte. Das Werkzeug ist in der Lage Anteile von Daten aus eingebetteten json-Dateien zu lesen. Es bietet auch einen sehr bequemen Mechanismus deserialize.

https://www.nuget.org/packages/WonderTools.JsonSectionReader/

P. S. Ich bin der Betreuer des Projekts, und dieses Projekt erstellt wurde, weil ich kein anderes Werkzeug, das löst dieses Problem in dem Maße gefunden, die ich wollte.

Answer 5

Ich denke, die Nunit equivilent ist ein Verfahren als Setup-Methode zu markieren und dann die Daten in ein Feld laden, um in nachfolgenden Tests verwendet werden.

Sie müssen Code es sich, mehr oder weniger.