¿Cómo podemos 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á seis veces:

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

Estamos usando MSTest ahora, pero ¿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 versiones anteriores de MSTest. Aparentemente hay un modelo de extensibilidad y puede implementarlo usted mismo . Otra opción sería utilizar pruebas basadas en datos .

Sin embargo, mi opinión personal sería seguir con NUnit ...

A partir de Visual Studio 2012, actualización 1, MSTest tiene una característica similar. Ver la respuesta de McAden .

EDITAR 4 : Parece que esto se completa en MSTest V2 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 Update 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 prueba de unidad para WinRT / Metro . Gorrón

EDITAR 2 : Los siguientes son los metadatos encontrados usando "Ir a la 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);
    }
}

EDITAR 3 : Este problema se mencionó en los foros UserVoice de Visual Studio. Última actualización dice:

INICIADO · Equipo de Visual Studio ADMIN El equipo de Visual Studio (Equipo de producto, Microsoft Visual Studio) respondió · 25 de abril de 2016 Gracias por los comentarios. Hemos empezado 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 característica está en prelanzamiento ahora y funciona con Visual Studio 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);
    }
}

No es exactamente lo mismo que los atributos de NUnit Value(o TestCase), pero MSTest tiene el DataSourceatributo, que le permite hacer algo similar.

Puede conectarlo a la base de datos o al archivo XML; no es tan sencillo como la función de NUnit, pero hace el trabajo.

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

• Pruebas unitarias con VSTS 2008 (Parte 3)
• Cómo: Crear una prueba de unidad basada en datos
• Tutorial: uso de un archivo de configuración para definir un origen de datos

Es muy sencillo de implementar: debe usar la TestContextpropiedad y TestPropertyAttribute.

Ejemplo

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();
    //...
}

EDITAR:

Preparé algunos métodos de extensión para simplificar el acceso a la TestContextpropiedad y actuar como si tuviéramos varios casos de prueba. Vea el ejemplo con el procesamiento de propiedades de prueba simples aquí:

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

y ejemplo con la creación de objetos de prueba complejos:

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

Eche un vistazo a los métodos de extensión y al conjunto de muestras para obtener más detalles.

Por supuesto, hay otra forma de hacer esto que no se ha discutido en este hilo, es decir, a través de la herencia de la clase que contiene el 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 el 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.

Eche un vistazo a Habilitar pruebas parametrizadas en MSTest usando PostSharp .

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

[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 usar NUnit (a menos que esté atascado en MSTest como lo estoy en esta instancia en particular).