Comment exécuter une méthode de test avec plusieurs parameters dans MSTest?

NUnit a une fonctionnalité appelée Valeurs, comme ci-dessous:

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

Cela signifie que la méthode de test sera exécutée 6 fois:

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

Nous utilisons MSTest maintenant, y a-t-il un équivalent pour que je puisse exécuter le même test avec plusieurs parameters?

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

Il n’est malheureusement pas pris en charge dans MSTest. Apparemment, il existe un modèle d’extensibilité et vous pouvez l’implémenter vous-même . Une autre option consisterait à utiliser des tests basés sur des données .

Mon opinion personnelle serait de restr avec NUnit si …

EDIT: à partir de Visual Studio 2012, mise à jour 1, MSTest possède une fonctionnalité similaire. Voir la réponse de @ McAden ci-dessous.

EDIT 4 : On dirait que ceci est terminé dans MSTest V2 17 juin 2016: https://blogs.msdn.microsoft.com/visualstudioalm/2016/06/17/taking-the-mstest-framework-forward-with-mstest- v2 /

Réponse originale :

Il y a environ une semaine, dans Visual Studio 2012 Update 1, quelque chose de similaire est désormais possible:

 [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 ); } 

EDIT : Il semble que ce ne soit disponible que dans le projet de test unitaire pour WinRT / Metro . Dommage

EDIT 2 : Les métadonnées trouvées avec “Aller à la définition” dans Visual Studio sont les suivantes:

 #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 { [AtsortingbuteUsage(AtsortingbuteTargets.Method, AllowMultiple = false)] public class DataTestMethodAtsortingbute : TestMethodAtsortingbute { public DataTestMethodAtsortingbute(); public override TestResult[] Execute(ITestMethod testMethod); } } 

EDIT 3 : Ce problème a été soulevé dans les forums UserVoice de Visual Studio. La dernière mise à jour indique:

COMMENCÉ · L’équipe Visual Studio Team ADMIN de Visual Studio (équipe produit, Microsoft Visual Studio) a répondu · 25 avril 2016 Merci pour vos commentaires. Nous avons commencé à travailler là-dessus.

Pratap Lakshman Visual Studio

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

Cette fonctionnalité est en pré-version et fonctionne avec VS 2015.

Par exemple:

 [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); } } 

Puisque personne n’a mentionné – pas exactement les mêmes que les atsortingbuts Value (ou TestCase ) de NUnit, mais MSTest a l’atsortingbut DataSource , qui vous permet de faire la même chose. Vous pouvez le connecter à une firebase database ou à un fichier XML – pas aussi simple que la fonctionnalité de NUnit, mais fait l’affaire.

MSTest possède un atsortingbut puissant appelé DataSource , qui vous permet d’effectuer des tests basés sur les données, comme vous l’avez demandé. Vous pouvez avoir vos données de test en XML, CSV ou dans une firebase database. Voici quelques liens qui vous guideront

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

J’espère que ceci vous aidera.

Il y a bien sûr une autre manière de faire cela qui n’a pas été discutée dans ce sujet, c’est-à-dire par inheritance de la classe contenant la méthode TestMethod. Dans l’exemple suivant, un seul TestMethod a été défini, mais deux scénarios de test ont été réalisés.

Dans Visual Studio 2012, il crée deux tests dans TestExplorer:

  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 ne prend pas en charge cette fonctionnalité mais vous pouvez implémenter votre propre atsortingbut pour y parvenir. jetez un oeil à ce qui suit:

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

C’est très simple à implémenter – vous devez utiliser la propriété TestPropertyAtsortingbute et TestPropertyAtsortingbute .

Exemple

 public TestContext TestContext { get; set; } private List GetProperties() { return TestContext.Properties .Cast>() .Where(_ => _.Key.StartsWith("par")) .Select(_ => _.Value as ssortingng) .ToList(); } //usage [TestMethod] [TestProperty("par1", "http://getbootstrap.com/components/")] [TestProperty("par2", "http://www.wsj.com/europe")] public void SomeTest() { var pars = GetProperties(); //... } 

Je ne pouvais pas faire fonctionner le DataRowAtsortingbute dans Visual Studio 2015, c’est ce que j’ai fini par:

 [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; } } 

La vraie solution est d’utiliser NUnit (sauf si vous êtes bloqué dans MSTest comme je le suis dans ce cas particulier).