Ejemplo de prueba sencilla controlada por datos
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 para que se consuman las pruebas controladas por datos. El nodo XML superior es la <etiqueta Data> , que puede contener una o varias <etiquetas table> definidas dentro de ella. Cada tabla debe estar asociada a 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>, tiene una sección ParameterTypes> opcional<. Aquí puede especificar explícitamente el tipo de datos de 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 Parameter "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 color al no especificarlo. Para su 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á una cadena.
Continuando con los archivos XML, después del <bloque ParameterTypes> en ambos archivos XML, tiene un conjunto idéntico de <filas>, que cada uno corresponde a un conjunto 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 esenciales 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.
Prueba de creación 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 determinada dentro del documento XML que se va a usar. Un único origen de datos de tabla XML puede contener varias tablas. TAEF examinará el archivo XML de un elemento Table con un atributo 'Id' que coincida con el valor especificado.
Una vez más, echemos un vistazo rápido al código que abarca 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 de 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 definen 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 obtener el tipo aquí mismo. Puesto que ha definido "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 se define en TestData.h e incluye el encabezado WexTestClass.h que incluyen todas las pruebas DE TAEF.
Para recuperar los datos en código administrado, use la propiedad TestContext que ha definido. 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 la 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 las 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 su memoria sobre cómo funciona Selection con TAEF.
El símbolo del sistema para ejecutar pruebas controladas por datos no es muy diferente de ejecutar ninguna prueba genérica con TAEF. Para ejecutar ambos ejemplos (nativos y administrados) descritos anteriormente, ejecute el siguiente comando:
TE.exe Examples\CPP.DataDriven.Example.dll Examples\CSharp.DataDriven.Example.dll /name:*Simple*
"/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 dentro de 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, vamos a omitir setsOfMetadataTest y SetsOfDataTest enumerados anteriormente. Si tiene curiosidad por esto, 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 los pasos para confirmar lo que seleccione.
Para ejecutar solo las pruebas no controladas por datos, ejecute:
TE.exe Examples\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select:"@Name='*Simple*' And not(@DataSource=*)"
Ahora, para ejecutar solo las pruebas controladas por datos, donde el color se especifica como "Negro", ejecute:
TE.exe Examples\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select:"@Name='*Simple*" y @Data:Color='Negro'"
Al igual que 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::D ataDrivenTest#1 y WEX. Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#1
Observe los índices de prueba de las propiedades listproperties anteriores. También puede seleccionar lo anterior en función del índice.
TE.exe Examples\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select:"@Name='*Simple*' y @Data:Index=1"
El anterior ejecutará las mismas dos pruebas que @Data:Color="Negro" seleccionados. 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.