Ejemplo de prueba controlada por datos simple

En esta sección se describen varios ejemplos de pruebas controladas por datos y se tratan características específicas en cada ejemplo.

El primer ejemplo es una prueba básica controlada por datos, denominada SimpleDataDrivenExample.

En el ejemplo administrado, encontrará un archivo XML similar al siguiente:

    1  <?xml version="1.0"?>
    2  <Data>
    3    <Table Id="Table1">
    4      <ParameterTypes>
    5        <ParameterType Name="Size">Int32</ParameterType>
    6        <ParameterType Name="Color">String</ParameterType>
    7      </ParameterTypes>
    8      <Row>
    9        <Parameter Name="Size">4</Parameter>
    10       <Parameter Name="Color">White</Parameter>
    11     </Row>
    12     <Row>
    13       <Parameter Name="Size">10</Parameter>
    14       <Parameter Name="Color">Black</Parameter>
    15     </Row>
    16     <Row>
    17       <Parameter Name="Size">9</Parameter>
    18       <Parameter Name="Color">Orange</Parameter>
    19     </Row>
    20     <Row>
    21       <Parameter Name="Size">9</Parameter>
    22       <Parameter Name="Color">Blue</Parameter>
    23     </Row>
    24   </Table>
    25 </Data>

Este archivo XML define los parámetros de datos que va a consumir nuestra prueba controlada por datos. El nodo XML superior es la <etiqueta Data> , que puede contener una o varias <etiquetas table> definidas en él. Cada tabla debe asociarse con un atributo "ID" único. Las funciones de prueba usan el valor de id. de tabla para identificar la tabla determinada que usarán en el archivo XML.

Dentro de la <etiqueta Table>, usted tiene una sección opcional <ParameterTypes>. Aquí puede especificar explícitamente el tipo de datos para un parámetro determinado mediante <etiquetas ParameterTypes> . En el ejemplo anterior, se especifica explícitamente que el parámetro "Size" es de tipo "Int32" y El parámetro "Color" es una cadena. Para resumir: la sección ParameterTypes es opcional. De forma predeterminada, si no se proporciona información de tipo de parámetro, se guardará como una cadena.

Si compara los ejemplos administrados y nativos, observará que la única diferencia entre los dos es el <bloque ParameterTypes> . El archivo XML nativo especifica Size para que sea del tipo entero nativo "int" y usa el tipo predeterminado WEX::Common::String para que sea el tipo de Color sin especificarlo. Para mayor comodidad, en el ejemplo siguiente se muestra el archivo XML del ejemplo nativo.

    1  <?xml version="1.0"?>
    2  <Data>
    3    <Table Id="SimpleTable">
    4      <ParameterTypes>
    5        <ParameterType Name="Size">int</ParameterType>
    6      </ParameterTypes>
    7      <Row>
    8        <Parameter Name="Size">4</Parameter>
    9        <Parameter Name="Color">White</Parameter>
    10     </Row>
    11     <Row>
    12       <Parameter Name="Size">10</Parameter>
    13       <Parameter Name="Color">Black</Parameter>
    14     </Row>
    15     <Row>
    16       <Parameter Name="Size">9</Parameter>
    17       <Parameter Name="Color">Orange</Parameter>
    18     </Row>
    19     <Row>
    20       <Parameter Name="Size">9</Parameter>
    21       <Parameter Name="Color">Blue</Parameter>
    22     </Row>
    23   </Table>
    24 </Data>

Los tipos de parámetro admitidos en código nativo y administrado se enumeran en Tipos de parámetros en orígenes de datos de tabla.

Si se especifica cualquier otro tipo de datos, la prueba producirá una advertencia y la considerará como una cadena.

Continuando con los archivos XML, después del <ParameterTypes> en ambos archivos XML, tienes un conjunto idéntico de <filas>, que cada una corresponde a conjuntos de datos en nuestros ejemplos administrados, y nativos. En este caso concreto, tiene 4 conjuntos de datos definidos por medio de 4 <bloques row> , cada uno especificando los valores de los parámetros mediante las <etiquetas Parameter> .

Esto abarca los conceptos básicos de las distintas partes del archivo de origen de datos. Ahora veamos cómo puede recuperar los valores que especificó en el archivo XML anterior.

Creación de pruebas para ser una prueba controlada por datos

Ahora que se especifican los datos, necesita una manera de asociar el código o el método de prueba que consumirá los datos con estos datos en el archivo XML. Para ello, en los ejemplos administrados y nativos, especifique los metadatos "DataSource ". Los metadatos de DataSource tienen tres partes:

'Table:': identifica el origen de datos como una tabla XML.
'DataDrivenTests.xml' : este es el archivo que contiene la tabla XML.
'#Table2': después del delimeter '#', el valor 'Table2' identifica la tabla concreta dentro del documento XML que se va a usar. Un único origen de datos de tabla XML puede contener varias tablas. TAEF buscará en el archivo XML un elemento de tabla con un atributo 'Id' que coincida con el valor especificado.

Una vez más, echemos un vistazo rápido al código que cubre los aspectos anteriores.

Código nativo

1   class SimpleDataDrivenExample
2   {
3      BEGIN_TEST_CLASS(SimpleDataDrivenExample)
4        TEST_CLASS_PROPERTY(L"Description", L"Simple example in table-based data-driven tests")
5      END_TEST_CLASS()
6   
7      TEST_METHOD_CLEANUP(TestCleanup);
8      TEST_METHOD_SETUP(TestSetup);
9    
10     BEGIN_TEST_METHOD(DataDrivenTest)
11       TEST_METHOD_PROPERTY(L"DataSource", L"Table:SimpleDataDrivenExample.xml#SimpleTable")
11     END_TEST_METHOD()
12     ...

Código administrado

    1 [TestMethod]
    2 [DataSource("Table:CSharpDataDrivenSimpleExample.xml#SimpleTable")]
    3 public void DataDrivenTest()
    4 {
    5  ...
    6 }

"DataSource" es una propiedad conocida en Microsoft.VisualStudio.TestTools.UnitTesting.

Además de lo anterior, necesita algunos pasos adicionales para las pruebas controladas por datos en código administrado. También debe definir una propiedad TestContext privada. Para obtener más información, vea TestContext (clase). También se establecen evaluadores públicos para esta propiedad. TAEF establece internamente esta propiedad TestContext para que pueda acceder a los datos a través de él. Echemos un vistazo rápido a esta parte del código:

    1 public TestContext TestContext
    2 {
    3     get;
    4     set;
    5 }

Recuperación de datos en el método Test

Las API de recuperación son diferentes en código administrado y nativo. Comencemos con la comprensión de la API de recuperación nativa:

    1  void SimpleDataDrivenExample::DataDrivenTest()
    2  {
    3          int size;
    4          if (SUCCEEDED(TestData::TryGetValue(L"size", size)))
    5          {
    6              VERIFY_ARE_NOT_EQUAL(size, 0);
    7              Log::Comment(String().Format(L"Size retrieved was %d", size));
    8          }
    9
    10         String color;
    11         if (SUCCEEDED(TestData::TryGetValue(L"color", color)))
    12         {
    13             Log::Comment(L"Size retrieved was " + color);
    14         }
    15
    16         unsigned int index;
    17         if (SUCCEEDED(TestData::TryGetValue(L"index", index)))
    18         {
    19             Log::Comment(String().Format(L"At index %d", index));
    20         }
    21 }

Preste especial atención a las líneas 4, 11 y 17. Antes de cada una de estas líneas, defina una variable local para guardar los datos que recuperará. Es importante acertar con el tipo aquí. Dado que definió "Size" para que sea un tipo "int" en el archivo XML, debe definir una variable local de tipo int para recuperarla. La API de recuperación toma el nombre del parámetro que se va a recuperar como un valor string como primer parámetro. El segundo parámetro es la variable local pasada por referencia y establecida por código TAEF.

Esta API de recuperación está definida en TestData.h y está incluida por el encabezado WexTestClass.h, que todas las pruebas de TAEF incluyen.

Para recuperar los datos en código administrado, use la propiedad TestContext que definió. Eche un vistazo al código siguiente (o en el ejemplo):

    1  public void DataDrivenTest()
    2  {
    3     int size = (int)m_testContext.DataRow["Size"];
    4     Verify.AreNotEqual(size, 0);
    5     Log.Comment("Size is " + size.ToString());
    6
    7     Log.Comment("Color is " + m_testContext.DataRow["Color"]);
    8     UInt32 index = (UInt32)m_testContext.DataRow["Index"];
    9     Log.Comment("At index " + index.ToString());
    10 }

Si está familiarizado con VSTS, verá que el ejemplo anterior es similar. Use DataRow y especifique el nombre de columna como el nombre del parámetro que está intentando recuperar.

Si observa en el ejemplo, también hay una prueba no controlada por datos en la misma clase. En otras palabras, tiene la flexibilidad de combinar pruebas DataDriven y NonDataDriven en la misma clase de prueba.

Ejecución de SimpleDataDrivenExample con TAEF

Asegúrese de que conoce cómo crear pruebas controladas por datos y cómo ejecutar pruebas con TAEF antes de empezar con sugerencias y trucos para ejecutar DataDrivenTests con TAEF. Puede ser útil actualizar la memoria sobre cómo funciona Selection con TAEF.

El símbolo del sistema para ejecutar pruebas basadas en datos no es muy diferente de ejecutar cualquier prueba genérica con TAEF. Para ejecutar ambos ejemplos (nativos y administrados) que se describen anteriormente, solo tiene que ejecutar el siguiente comando:

ejemplos deTE.exe\CPP.DataDriven.Example.dll Examples\CSharp.DataDriven.Example.dll /name:*Simple*

El '/name' agrega un criterio de selección basado en el nombre y elige solo las clases que le interesan. Para seleccionar las pruebas que se van a ejecutar desde las clases, primero debe enumerar todas las propiedades del archivo dll. A continuación, puede decidir qué propiedades usar para los criterios de selección.

TE.exe Examples\CPP.DataDriven.Example.dll Examples\CSharp.DataDriven.Example.dll /name:*Simple* /listproperties
f:\Examples\CPP.DataDriven.Example.dll
        WEX::TestExecution::Examples::SimpleDataDrivenExample
                Property[Description] = Simple example in table-based data-driven tests

            WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#0
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[DataSource] = Table:SimpleDataDrivenExample.xml#SimpleTable

                    Data[Color] = White
                    Data[Size] = 4

            WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#1
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[DataSource] = Table:SimpleDataDrivenExample.xml#SimpleTable

                    Data[Color] = Black
                    Data[Size] = 10

            WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#2
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[DataSource] = Table:SimpleDataDrivenExample.xml#SimpleTable

                    Data[Color] = Orange
                    Data[Size] = 9

            WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#3
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[DataSource] = Table:SimpleDataDrivenExample.xml#SimpleTable

                    Data[Color] = Blue
                    Data[Size] = 9

            WEX::TestExecution::Examples::SimpleDataDrivenExample::FirstNonDataDrivenTest
                    Setup: TestSetup
                    Teardown: TestCleanup

            WEX::TestExecution::Examples::SimpleDataDrivenExample::SetsOfDataTest#metadataSet0
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[Data:Color] = {Purple, Maroon, Brown}

                    Data[Color] = Purple

            WEX::TestExecution::Examples::SimpleDataDrivenExample::SetsOfDataTest#metadataSet1
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[Data:Color] = {Purple, Maroon, Brown}

                    Data[Color] = Maroon

            WEX::TestExecution::Examples::SimpleDataDrivenExample::SetsOfDataTest#metadataSet2
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[Data:Color] = {Purple, Maroon, Brown}

                    Data[Color] = Brown

            WEX::TestExecution::Examples::SimpleDataDrivenExample::SecondNonDataDrivenTest
                    Setup: TestSetup
                    Teardown: TestCleanup


        f:\Examples\CSharp.DataDriven.Example.dll
        WEX.Examples.CSharpDataDrivenSimpleExample
                Setup: MyClassInitialize
                Property[Description] = Simple example in table-based data-driven tests

            WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#0
                    Property[DataSource] = Table:CSharpDataDrivenSimpleExample.xml#SimpleTable

                    Data[Color] = White
                    Data[Size] = 4

            WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#1
                    Property[DataSource] = Table:CSharpDataDrivenSimpleExample.xml#SimpleTable

                    Data[Color] = Black
                    Data[Size] = 10

            WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#2
                    Property[DataSource] = Table:CSharpDataDrivenSimpleExample.xml#SimpleTable

                    Data[Color] = Orange
                    Data[Size] = 9

            WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#3
                    Property[DataSource] = Table:CSharpDataDrivenSimpleExample.xml#SimpleTable

                    Data[Color] = Blue
                    Data[Size] = 9

            WEX.Examples.CSharpDataDrivenSimpleExample.NonDataDrivenTest
            WEX.Examples.CSharpDataDrivenSimpleExample.SetsOfMetadataTest#metadataSet0
                    Property[Data:Color] = {Red, Green, Blue}

                    Data[Color] = Red

            WEX.Examples.CSharpDataDrivenSimpleExample.SetsOfMetadataTest#metadataSet1
                    Property[Data:Color] = {Red, Green, Blue}

                    Data[Color] = Green

            WEX.Examples.CSharpDataDrivenSimpleExample.SetsOfMetadataTest#metadataSet2
                    Property[Data:Color] = {Red, Green, Blue}

                    Data[Color] = Blue

Por ahora, omitamos los valores SetsOfMetadataTest y SetsOfDataTest enumerados anteriormente. Si tiene curiosidad sobre estas pruebas, lea más sobre las pruebas controladas por datos ligeras. Ahora que conoce las distintas propiedades y el nombre y los valores del parámetro Data, puede seleccionar pruebas específicas en función de eso. Pruébelos y siga para confirmar lo que seleccione.

Para ejecutar solo las pruebas no controladas por datos, ejecute:

TE.exe Ejemplos\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select:"@Name='*Simple*' And not(@DataSource=*)"

Ahora, para ejecutar solo esas pruebas controladas por datos, donde el color se especifica como "Negro", ejecute:

TE.exe Ejemplos\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select:"@Name='*Simple*' y @Data:Color='Negro'"

Al igual que lo hizo con "Color", @Data:<DataDrivenParameterName>=<DataDrivenParameterValue> ejecutará datos específicos basados en el valor del parámetro DataDriven especificado. En el caso anterior, ejecutará WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#1 y WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#1

Observe los índices de prueba en las propiedades de lista anteriores. También puede seleccionar lo anterior en función del índice.

TE.exe Ejemplos\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select:"@Name='*Simple*' y @Data:Index=1"

Lo anterior ejecutará las mismas dos pruebas que @Data:Color='Negro' seleccionó. Incluso se agregan guardias a la selección de índice con @Data:Index > lowerGuardValue y @Data:index< upperGuardValue

Si comprende los conceptos básicos de las pruebas controladas por datos con TAEF, siga junto con la siguiente clase en los mismos ejemplos: Invalidación de metadatos en el nivel de fila, Especificación de tipos de parámetros de matriz.

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-07-18