¿Cómo ejecutar un método de prueba con múltiples parámetros en MSTest?

NUnit tiene una característica llamada Valores, como a continuación:

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

Esto significa que el método de prueba se ejecutará 6 veces:

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

Estamos usando MSTest ahora, ¿hay algún equivalente para esto para que pueda ejecutar la misma prueba con múltiples parámetros?

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

    Desafortunadamente no es compatible con MSTest. Aparentemente hay un modelo de extensibilidad y puedes implementarlo tú mismo . Otra opción sería usar pruebas basadas en datos .

    Mi opinión personal sería simplemente seguir con NUnit …

    EDITAR: A partir de Visual Studio 2012, actualización 1, MSTest tiene una función similar. Ver la respuesta de @Macden a continuación.

    EDIT 4 : Parece que esto se completa en MSTest V2 el 17 de junio de 2016: https://blogs.msdn.microsoft.com/visualstudioalm/2016/06/17/taking-the-mstest-framework-forward-with-mstest- v2 /

    Respuesta Original :

    Desde hace aproximadamente una semana en Visual Studio 2012 Actualización 1 algo similar ahora es posible:

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

    EDITAR : Parece que esto solo está disponible dentro del proyecto de pruebas de unidad para WinRT / Metro . Gorrón

    EDIT 2 : El siguiente es el metadato encontrado usando “Ir a Definición” dentro de Visual Studio:

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

    EDIT 3 : Este problema se mencionó en los foros UserVoice de Visual Studio. La última actualización dice:

    INICIADO · Equipo de Visual Studio ADMIN Visual Studio Team (Equipo de producto, Microsoft Visual Studio) respondió · 25 de abril de 2016 Gracias por los comentarios. Hemos comenzado a trabajar en esto.

    Pratap Lakshman Visual Studio

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

    Esta función está en prelanzamiento ahora y funciona con VS 2015.

    Por ejemplo:

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

    Como nadie mencionó, no es exactamente lo mismo que los atributos NUnit’s Value (o TestCase ), pero MSTest tiene el atributo DataSource , que le permite hacer algo similar. Puede conectarlo a una base de datos o archivo XML, no tan sencillo como la función de NUnit, pero cumple su función.

    MSTest tiene un poderoso atributo llamado DataSource , con esto puede realizar pruebas basadas en datos como lo pidió. Puede tener sus datos de prueba en XML, CSV o en una base de datos. Aquí hay algunos enlaces que te guiarán

    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

    Espero que esto te ayudará.

    Hay, por supuesto, otra forma de hacer esto que no se ha discutido en este hilo, es decir, a modo de herencia de la clase que contiene TestMethod. En el siguiente ejemplo, solo se ha definido un TestMethod pero se han realizado dos casos de prueba.

    En Visual Studio 2012, crea dos pruebas en 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 no es compatible con esa característica, pero puede implementar su propio atributo para lograrlo. Echa un vistazo a lo siguiente:

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

    Es muy simple de implementar: debe usar la propiedad TestPropertyAttribute y TestPropertyAttribute .

    Ejemplo

     public TestContext TestContext { get; set; } private List GetProperties() { return TestContext.Properties .Cast>() .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(); //... } 

    No pude hacer que The DataRowAttribute funcionara en Visual Studio 2015, esto es con lo que terminé:

     [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 solución real aquí es simplemente usar NUnit (a menos que estés atrapado en MSTest como en esta instancia particular).