Ejecución de pruebas unitarias seleccionadas

Con el comando dotnet test en .NET Core, se puede usar una expresión de filtro para ejecutar las pruebas seleccionadas. En este artículo se explica cómo filtrar las pruebas. En los ejemplos se usa dotnet test. Si está usando vstest.console.exe, reemplace --filter por --testcasefilter:.

Note

La --filter sintaxis descrita en las secciones siguientes se aplica a MSTest, NUnit y xUnit. TUnit usa una sintaxis diferente; Seleccione TUnit en la parte superior de este artículo para obtener más información.

Sintaxis

dotnet test --filter <Expression>

  • Expression tiene el formato <Property><Operator><Value>[|&<Expression>].

    Las expresiones se pueden unir con operadores booleanos: | para el booleano or y & para el booleano and.

    Las expresiones pueden incluirse entre paréntesis. Por ejemplo: (Name~MyClass) | (Name~MyClass2).

    Una expresión sin ningún operador se interpreta como elemento contains en la propiedad FullyQualifiedName. Por ejemplo, dotnet test --filter xyz es lo mismo que dotnet test --filter FullyQualifiedName~xyz.

  • Property es un atributo de Test Case. Por ejemplo, las propiedades siguientes son compatibles con los marcos de pruebas unitarias populares.

    Marco de prueba Propiedades admitidas
    MSTest FullyQualifiedName
    Name
    ClassName
    Priority
    TestCategory
    Id
    NUnit FullyQualifiedName
    Name
    Priority
    TestCategory
    Category
    Property
    xUnit FullyQualifiedName
    DisplayName
    Traits

  • Operadores

    • = coincidencia exacta
    • != coincidencia no exacta
    • ~ contiene
    • !~ no contiene

  • Value es una cadena. Todas las búsquedas distinguen mayúsculas de minúsculas.

Escape de caracteres

Use secuencias de escape para representar caracteres de operador de filtro en un valor de filtro. Estas secuencias de escape son independientes de cualquier escape que requiera el shell.

Secuencia de escape Representa
\\ \
\( (
\) )
\& &
\| |
\= =
\! !
\~ ~

Para escapar los valores de filtro mediante programación, use la Microsoft.VisualStudio.TestPlatform.ObjectModel.Utilities.FilterHelper.Escape API del Microsoft.VisualStudio.TestPlatform.ObjectModel paquete NuGet.

Para usar un signo de exclamación (!) en una expresión de filtro, aplíquele una secuencia de escape en algún shell de Linux o macOS mediante la colocación de una barra diagonal inversa delante (\!). Por ejemplo, el filtro siguiente omite todas las pruebas de un espacio de nombres que contiene IntegrationTests:

dotnet test --filter FullyQualifiedName\!~IntegrationTests

En el caso de los valores FullyQualifiedName que incluyen una coma para los parámetros de tipo genérico, escape la coma con %2C. Por ejemplo:

dotnet test --filter "FullyQualifiedName=MyNamespace.MyTestsClass<ParameterType1%2CParameterType2>.MyTestMethod"

Dado que el shell también analiza la expresión de filtro, cita todo el --filter valor cada vez que contiene caracteres que el shell trata especialmente, como <, >o ,. El entrecomillado es necesario en PowerShell, donde la coma es el operador de matriz.

Para Name o DisplayName, use la codificación url para los caracteres especiales. Por ejemplo, para ejecutar una prueba con el nombre MyTestMethod y un valor de cadena "text", use el siguiente filtro:

dotnet test --filter "Name=MyTestMethod \(%22text%22\)"

Ejemplos de MSTest

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace MSTestNamespace
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod, Priority(1), TestCategory("CategoryA")]
        public void TestMethod1()
        {
        }

        [TestMethod, Priority(2)]
        public void TestMethod2()
        {
        }
    }
}
Expresión Resultado
dotnet test --filter Method Ejecuta pruebas cuyo FullyQualifiedName contenga Method.
dotnet test --filter Name~TestMethod1 Ejecuta pruebas cuyo nombre contenga TestMethod1.
dotnet test --filter ClassName=MSTestNamespace.UnitTest1 Ejecuta pruebas que están en la clase MSTestNamespace.UnitTest1.
Nota: El valor ClassName debe tener un espacio de nombres, por lo que ClassName=UnitTest1 no funcionará.
dotnet test --filter FullyQualifiedName!=MSTestNamespace.UnitTest1.TestMethod1 Ejecuta todas las pruebas excepto MSTestNamespace.UnitTest1.TestMethod1.
dotnet test --filter TestCategory=CategoryA Ejecuta pruebas anotadas con [TestCategory("CategoryA")].
dotnet test --filter Priority=2 Ejecuta pruebas anotadas con [Priority(2)].
dotnet test --filter "Id=<guid>" Ejecuta el caso de prueba cuyo valor detectado TestCase.Id coincide exactamente con el GUID.

Id el filtrado requiere MSTest.TestAdapter 3.6 o posterior. Obtenga el GUID del caso de prueba que devuelve la detección de VSTest en TestCase.Id. Este filtro puede seleccionar una iteración controlada por datos desarrollada sin coincidir ni escapar su nombre para mostrar. Cada fila debe detectarse como caso de prueba individual; Una prueba controlada por datos plegada expone solo una identidad primaria.

Ejemplos de uso de los operadores condicionales | y &:

Ejemplos de xUnit

using Xunit;

namespace XUnitNamespace
{
    public class TestClass1
    {
        [Fact, Trait("Priority", "1"), Trait("Category", "CategoryA")]
        public void Test1()
        {
        }

        [Fact, Trait("Priority", "2")]
        public void Test2()
        {
        }
    }
}
Expresión Resultado
dotnet test --filter DisplayName=XUnitNamespace.TestClass1.Test1 Ejecuta solo una prueba, XUnitNamespace.TestClass1.Test1.
dotnet test --filter FullyQualifiedName!=XUnitNamespace.TestClass1.Test1 Ejecuta todas las pruebas excepto XUnitNamespace.TestClass1.Test1.
dotnet test --filter DisplayName~TestClass1 Ejecuta pruebas cuyo nombre para mostrar contenga TestClass1.

En el ejemplo de código, los rasgos definidos con claves "Category" y "Priority" pueden usarse para filtrar.

Expresión Resultado
dotnet test --filter XUnit Ejecuta pruebas cuyo FullyQualifiedName contenga XUnit.
dotnet test --filter Category=CategoryA Ejecuta pruebas que tienen [Trait("Category", "CategoryA")].

Ejemplos de uso de los operadores condicionales | y &:

  • Para ejecutar pruebas que tienen TestClass1 en su FullyQualifiedNameo tienen un elemento Trait con una clave de "Category" y el valor de "CategoryA".

    dotnet test --filter "FullyQualifiedName~TestClass1|Category=CategoryA"

  • Para ejecutar pruebas que tienen TestClass1 en su FullyQualifiedNamey tienen un elemento Trait con una clave de "Category" y un valor de "CategoryA".

    dotnet test --filter "FullyQualifiedName~TestClass1&Category=CategoryA"

  • Para ejecutar pruebas que tienen FullyQualifiedName con TestClass1y tienen un elemento Trait con una clave de "Category" y un valor de "CategoryA"o tienen un elemento Trait con una clave de "Priority" y un valor de 1.

    dotnet test --filter "(FullyQualifiedName~TestClass1&Category=CategoryA)|Priority=1"

Ejemplos de NUnit

Para NUnit, TestCategory y Category son nombres de propiedad de filtro intercambiables. Ambos filtran las categorías que se asignan con el Category atributo , por lo que los comandos NUnit existentes que usan --filter Category=MyCategory no necesitan cambiar.

using NUnit.Framework;

namespace NUnitNamespace
{
    public class UnitTest1
    {
        [Test, Property("Priority", 1), Category("CategoryA")]
        public void TestMethod1()
        {
        }

        [Test, Property("Priority", 2)]
        public void TestMethod2()
        {
        }
    }
}
Expresión Resultado
dotnet test --filter Method Ejecuta pruebas cuyo FullyQualifiedName contenga Method.
dotnet test --filter Name~TestMethod1 Ejecuta pruebas cuyo nombre contenga TestMethod1.
dotnet test --filter FullyQualifiedName~NUnitNamespace.UnitTest1 Ejecuta pruebas que están en la clase NUnitNamespace.UnitTest1.
dotnet test --filter FullyQualifiedName!=NUnitNamespace.UnitTest1.TestMethod1 Ejecuta todas las pruebas excepto NUnitNamespace.UnitTest1.TestMethod1.
dotnet test --filter TestCategory=CategoryA Ejecuta pruebas anotadas con [Category("CategoryA")].
dotnet test --filter Category=CategoryA Ejecuta las mismas pruebas que TestCategory=CategoryA.
dotnet test --filter Priority=2 Ejecuta pruebas anotadas con [Priority(2)].

Ejemplos de uso de los operadores condicionales | y &:

Para ejecutar pruebas que tienen UnitTest1 en su FullyQualifiedNameo tienen un elemento Category de "CategoryA".

dotnet test --filter "FullyQualifiedName~UnitTest1|TestCategory=CategoryA"

Para ejecutar pruebas que tienen UnitTest1 en su FullyQualifiedNamey tienen un elemento Category de "CategoryA".

dotnet test --filter "FullyQualifiedName~UnitTest1&TestCategory=CategoryA"

Para ejecutar pruebas que tienen FullyQualifiedName con UnitTest1y tienen un elemento Category de "CategoryA"o tienen un elemento Property con un valor "Priority" de 1.

dotnet test --filter "(FullyQualifiedName~UnitTest1&TestCategory=CategoryA)|Priority=1"

Para obtener más información, vea Filtro TestCase.

Ejemplos de TUnit

TUnit no admite la --filter opción descrita anteriormente en este artículo. En su lugar, usa la opción MTP --treenode-filter . Un filtro de nodo de árbol es una ruta de acceso con el formato /<Assembly>/<Namespace>/<Class>/<Method>, donde:

  • * coincide con cualquier valor dentro de un único segmento de ruta de acceso y se puede combinar con otro texto, como *Method*.
  • ** coincide con cualquier número de segmentos de ruta de acceso.
  • [<Property>=<Value>] después de que un segmento de ruta de acceso coincida con las pruebas que tienen esa propiedad. [Category("CategoryA")] se expone como la propiedad Categoryy [Property("Priority", "2")] como la propiedad Priority.
  • | (o) y (y & ) combinan alternativas dentro de un único segmento de ruta de acceso o filtro de propiedad. Incluya cada alternativa entre paréntesis, por ejemplo /*/*/(UnitTest1)|(UnitTest2)/* o [(Category=CategoryA)|(Priority=2)].

La --treenode-filter opción es una opción MTP, por lo que dotnet test debe ejecutarse en su modo MTP. Con el SDK de .NET 10 o posterior, agregue la siguiente configuración al archivo global.json en la raíz de la solución:

{
    "test": {
        "runner": "Microsoft.Testing.Platform"
    }
}

Sin ella, dotnet test se ejecuta en el modo VSTest y se produce un error antes MSB1001: Unknown switch de que se ejecute cualquier prueba. Para obtener más información, incluido cómo ejecutar proyectos mtP con SDK anteriores, consulte modo MTP de prueba de dotnet.

En los ejemplos se usa la siguiente clase de prueba:

namespace TUnitNamespace;

public class UnitTest1
{
    [Test, Property("Priority", "1"), Category("CategoryA")]
    public void TestMethod1()
    {
    }

    [Test, Property("Priority", "2")]
    public void TestMethod2()
    {
    }
}
Expresión Resultado
dotnet test --treenode-filter "/*/*/*/*Method*" Ejecuta pruebas cuyo nombre de método contiene Method.
dotnet test --treenode-filter "/*/*/*/TestMethod1" Ejecuta pruebas cuyo nombre es TestMethod1.
dotnet test --treenode-filter "/*/TUnitNamespace/UnitTest1/*" Ejecuta todas las pruebas de la clase TUnitNamespace.UnitTest1.
dotnet test --treenode-filter "/**[Category=CategoryA]" Ejecuta pruebas anotadas con [Category("CategoryA")].
dotnet test --treenode-filter "/**[Priority=2]" Ejecuta pruebas anotadas con [Property("Priority", "2")].

Ejemplos de uso de los operadores condicionales | y &:

Para ejecutar pruebas que están en la clase UnitTest1y tener un Category de "CategoryA":

dotnet test --treenode-filter "/*/*/UnitTest1/*[Category=CategoryA]"

Para ejecutar pruebas que tengan Category o "CategoryA"dePriority"2":

dotnet test --treenode-filter "/**[(Category=CategoryA)|(Priority=2)]"

Para ejecutar pruebas que están en la clase UnitTest1y tener un Category de "CategoryA"o de Priority"2":

dotnet test --treenode-filter "/*/*/UnitTest1/*[(Category=CategoryA)|(Priority=2)]"

Para ejecutar pruebas que tienen un Category de "CategoryA"y un Priority de "1":

dotnet test --treenode-filter "/**[(Category=CategoryA)&(Priority=1)]"

Vea también

Pasos siguientes

Ordenación de pruebas unitarias

  • Última actualización el