Wie führe ich eine Testmethode mit mehreren Parametern in MSTest aus?

NUnit hat eine Funktion namens Werte, wie unten:

[Test]
public void MyTest(
    [Values(1,2,3)] int x,
    [Values("A","B")] string s)
{
    // ...
}

Dies bedeutet, dass die Testmethode sechsmal ausgeführt wird:

MyTest(1, "A")
MyTest(1, "B")
MyTest(2, "A")
MyTest(2, "B")
MyTest(3, "A")
MyTest(3, "B")

Wir verwenden jetzt MSTest. Gibt es dafür ein Äquivalent, damit ich denselben Test mit mehreren Parametern ausführen kann?

[TestMethod]
public void Mytest()
{
    // ...
}

Es wird in MSTest leider nicht unterstützt. Anscheinend gibt es ein Erweiterungsmodell, das Sie selbst implementieren können . Eine andere Möglichkeit wäre die Verwendung datengesteuerter Tests .

Meine persönliche Meinung wäre jedoch, einfach bei NUnit zu bleiben ...

BEARBEITEN: Ab Visual Studio 2012, Update 1, verfügt MSTest über eine ähnliche Funktion. Siehe @ McAdens Antwort unten.

BEARBEITEN 4 : Dies scheint in MSTest V2 am 17. Juni 2016 abgeschlossen zu sein: https://blogs.msdn.microsoft.com/visualstudioalm/2016/06/17/taking-the-mstest-framework-forward-with-mstest- v2 /

Ursprüngliche Antwort :

Seit ungefähr einer Woche ist in Visual Studio 2012 Update 1 etwas Ähnliches möglich:

[DataTestMethod]
[DataRow(12,3,4)]
[DataRow(12,2,6)]
[DataRow(12,4,3)]
public void DivideTest(int n, int d, int q)
{
  Assert.AreEqual( q, n / d );
}

BEARBEITEN : Dies scheint nur im Unit-Test-Projekt für WinRT / Metro verfügbar zu sein . Schade

BEARBEITEN 2 : Die folgenden Metadaten werden mit "Gehe zu Definition" in Visual Studio gefunden:

#region Assembly Microsoft.VisualStudio.TestPlatform.UnitTestFramework.dll, v11.0.0.0
// C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0\ExtensionSDKs\MSTestFramework\11.0\References\CommonConfiguration\neutral\Microsoft.VisualStudio.TestPlatform.UnitTestFramework.dll
#endregion

using System;

namespace Microsoft.VisualStudio.TestPlatform.UnitTestFramework
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
    public class DataTestMethodAttribute : TestMethodAttribute
    {
        public DataTestMethodAttribute();

        public override TestResult[] Execute(ITestMethod testMethod);
    }
}

BEARBEITEN 3 : Dieses Problem wurde in den UserVoice-Foren von Visual Studio angesprochen. Letzte Aktualisierung besagt:

STARTED · Visual Studio-Team ADMIN Visual Studio-Team (Produktteam, Microsoft Visual Studio) hat geantwortet · 25. April 2016 Vielen Dank für das Feedback. Wir haben begonnen, daran zu arbeiten.

Pratap Lakshman Visual Studio

https://visualstudio.uservoice.com/forums/330519-team-services/suggestions/3865310-allow-use-of-datatestmethod-datarow-in-all-unit

Diese Funktion ist jetzt in der Vorabversion und funktioniert mit VS 2015.

Beispielsweise:

[TestClass]
public class UnitTest1
{
    [DataTestMethod]
    [DataRow(1, 2, 2)]
    [DataRow(2, 3, 5)]
    [DataRow(3, 5, 8)]
    public void AdditionTest(int a, int b, int result)
    {
        Assert.AreEqual(result, a + b);
    }
}

Da niemand erwähnt hat - nicht genau das gleiche wie die Value(oder TestCase) Attribute von NUnit , aber MSTest hat DataSourceAttribute, mit denen Sie ähnliche Dinge tun können. Sie können es an eine Datenbank oder eine XML-Datei anschließen - nicht so einfach wie die Funktion von NUnit, erledigt aber die Aufgabe.

MSTest verfügt über ein leistungsstarkes Attribut namens DataSource . Mit diesem Attribut können Sie nach Bedarf einen datengesteuerten Test durchführen. Sie können Ihre Testdaten in XML, CSV oder in einer Datenbank haben. Hier sind einige Links, die Sie führen

http://visualstudiomagazine.com/articles/2009/09/15/unit-testing-with-vsts2008-part-3.aspx http://msdn.microsoft.com/en-us/library/ms182527.aspx
http: //msdn.microsoft.com/en-us/library/ms243192.aspx

Hoffe das wird dir helfen.

Es ist sehr einfach zu implementieren - Sie sollten TestContextEigenschaft und verwenden TestPropertyAttribute.

Beispiel

public TestContext TestContext { get; set; }
private List<string> GetProperties()
{
    return TestContext.Properties
        .Cast<KeyValuePair<string, object>>()
        .Where(_ => _.Key.StartsWith("par"))
        .Select(_ => _.Value as string)
        .ToList();
}

//usage
[TestMethod]
[TestProperty("par1", "http://getbootstrap.com/components/")]
[TestProperty("par2", "http://www.wsj.com/europe")]
public void SomeTest()
{
    var pars = GetProperties();
    //...
}

BEARBEITEN:

Ich habe einige Erweiterungsmethoden vorbereitet, um den Zugriff auf die TestContextImmobilie zu vereinfachen und so zu handeln, als hätten wir mehrere Testfälle. Siehe Beispiel zur Verarbeitung einfacher Testeigenschaften hier:

[TestMethod]
[TestProperty("fileName1", @".\test_file1")]
[TestProperty("fileName2", @".\test_file2")]
[TestProperty("fileName3", @".\test_file3")]
public void TestMethod3()
{
    TestContext.GetMany<string>("fileName").ForEach(fileName =>
    {
        //Arrange
        var f = new FileInfo(fileName);

        //Act
        var isExists = f.Exists;

        //Asssert
        Assert.IsFalse(isExists);
    });
}

und Beispiel zum Erstellen komplexer Testobjekte:

[TestMethod]
//Case 1
[TestProperty(nameof(FileDescriptor.FileVersionId), "673C9C2D-A29E-4ACC-90D4-67C52FBA84E4")]
//...
public void TestMethod2()
{
    //Arrange
    TestContext.For<FileDescriptor>().Fill(fi => fi.FileVersionId).Fill(fi => fi.Extension).Fill(fi => fi.Name).Fill(fi => fi.CreatedOn, new CultureInfo("en-US", false)).Fill(fi => fi.AccessPolicy)
        .ForEach(fileInfo =>
        {
            //Act
            var fileInfoString = fileInfo.ToString();

            //Assert
            Assert.AreEqual($"Id: {fileInfo.FileVersionId}; Ext: {fileInfo.Extension}; Name: {fileInfo.Name}; Created: {fileInfo.CreatedOn}; AccessPolicy: {fileInfo.AccessPolicy};", fileInfoString);
        });
}

Werfen Sie einen Blick auf die Erweiterung Methoden und eine Reihe von Proben für weitere Details.

Es gibt natürlich eine andere Möglichkeit, dies zu tun, die in diesem Thread nicht behandelt wurde, nämlich die Vererbung der Klasse, die die TestMethod enthält. Im folgenden Beispiel wurde nur eine Testmethode definiert, es wurden jedoch zwei Testfälle erstellt.

In Visual Studio 2012 werden zwei Tests im TestExplorer erstellt:

1. DemoTest_B10_A5.test

2. DemoTest_A12_B4.test

   public class Demo
   {
       int a, b;
   
       public Demo(int _a, int _b)
       {
           this.a = _a;
           this.b = _b;
       }
   
       public int Sum()
       {
           return this.a + this.b;
       }
   }
   
   public abstract class DemoTestBase
   {
       Demo objUnderTest;
       int expectedSum;
   
       public DemoTestBase(int _a, int _b, int _expectedSum)
       {
           objUnderTest = new Demo(_a, _b);
           this.expectedSum = _expectedSum;
       }
   
       [TestMethod]
       public void test()
       {
           Assert.AreEqual(this.expectedSum, this.objUnderTest.Sum());
       }
   }
   
   [TestClass]
   public class DemoTest_A12_B4 : DemoTestBase
   {
       public DemoTest_A12_B4() : base(12, 4, 16) { }
   }
   
   public abstract class DemoTest_B10_Base : DemoTestBase
   {
       public DemoTest_B10_Base(int _a) : base(_a, 10, _a + 10) { }
   }
   
   [TestClass]
   public class DemoTest_B10_A5 : DemoTest_B10_Base
   {
       public DemoTest_B10_A5() : base(5) { }
   }

MsTest unterstützt diese Funktion nicht, aber Sie können Ihr eigenes Attribut implementieren, um dies zu erreichen. Schauen Sie sich das Folgende an:

http://blog.drorhelper.com/2011/09/enabling-parameterized-tests-in-mstest.html

Ich konnte The DataRowAttributein Visual Studio 2015 nicht zum Laufen bringen. Am Ende hatte ich Folgendes:

[TestClass]
public class Tests
{
    private Foo _toTest;

    [TestInitialize]
    public void Setup()
    {
        this._toTest = new Foo();       
    }

    [TestMethod]
    public void ATest()
    {
        this.Perform_ATest(1, 1, 2);
        this.Setup();

        this.Perform_ATest(100, 200, 300);
        this.Setup();

        this.Perform_ATest(817001, 212, 817213);
        this.Setup();

    }

    private void Perform_ATest(int a, int b, int expected)
    {
        //Obviously this would be way more complex...

        Assert.IsTrue(this._toTest.Add(a,b) == expected);    
    }
}

public class Foo
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

Die wirkliche Lösung besteht darin, nur NUnit zu verwenden (es sei denn, Sie stecken in MSTest fest, wie ich es in diesem speziellen Fall bin).