Testes leves orientados por dados

É provável que haja cenários em que uma fonte de dados XML completa e um teste controlado por dados baseado em tabela podem ser muito pesados para suas necessidades de cenário de teste. O teste leve orientado por dados permite uma maneira rápida e fácil de obter suporte a testes orientados por dados quando os dados para o seu teste são simples e podem ser facilmente expressos como metadados. Vamos usar um exemplo e ver como.

Os dados para o teste leve orientado por dados são expressos como um conjunto de metadados (no nível de teste, classe ou módulo). Para cada um dos valores neste conjunto, os métodos de teste em questão, juntamente com os métodos de configuração e desmontagem associados serão executados para cada valor no conjunto. Vamos dar uma olhada em como criar isso em código nativo:

1  #include "WexString.h"
2  #include "WexTestClass.h"
3
4  using namespace WEX::Common;
5  using namespace WEX::TestExecution;
6  using namespace WEX::Logging;

7  namespace WEX { namespace TestExecution { namespace Examples
8  {
9      class SimpleDataDrivenExample
10     {
11         TEST_CLASS(SimpleDataDrivenExample);
12         ...
13         BEGIN_TEST_METHOD(SetsOfDataTest)
14             TEST_METHOD_PROPERTY(L"Data:Color", L"{Purple, Maroon, Brown}")
15         END_TEST_METHOD()
16     };

Observe os valores dos parâmetros para TEST_METHOD_PROPERTY na linha 14. O valor de metadados de teste começa com um "{" e termina com um "}" indicando que uma lista de valores separados por vírgula ou ponto-e-vírgula foi especificada. O TAEF executará novamente o método de teste em questão, SetsOfDataTest() uma vez para cada valor desse conjunto.

Observe também que o nome dos metadados começa com um "Dados:". Isso implica que o conjunto de metadados está realmente especificando variações para os parâmetros de teste orientados por dados e estaria disponível para o método de teste real, muito parecido com os parâmetros de dados de um teste orientado por dados baseado em tabela, assim:

11     ...
12
13     void SimpleDataDrivenExample::SetsOfDataTest()
14     {
15         String color;
16         if (SUCCEEDED(TestData::TryGetValue(L"color", color)))
17         {
18             Log::Comment(L"Color retrieved was " + color);
19         }
20     }
21 } /* namespace Examples */ } /* namespace TestExecution */ } /* namespace WEX */

Ao trabalhar com código gerenciado, a especificação e a recuperação do conjunto de dados são muito parecidas com o exemplo nativo. Vejamos:

1  namespace WEX.Examples
2  {
3      using Microsoft.VisualStudio.TestTools.UnitTesting;
4      using System;
5      using System.Collections;
6      using System.Data;
7      using WEX.Logging.Interop;
8      using WEX.TestExecution;
9
10     [TestClass]
11     public class CSharpDataDrivenSimpleExample
12     {
13         ...
14         [TestMethod]
15         [TestProperty("Data:Color", "{Red, Green, Blue}")]
16         public void SetsOfMetadataTest()
17         {
18             Log.Comment("Color is " + m_testContext.DataRow["Color"]);
19         }
20
21         public TestContext TestContext
22         {
23             get { return m_testContext; }
24             set { m_testContext = value; }
25         }
26
27         private TestContext m_testContext;
28     }
29 }

Assim como no caso de testes orientados por dados baseados em tabela, conjuntos de dados especificados como metadados permitirão a recuperação via TestContext.DataRow. Observe que, para manter o teste orientado por dados leve, o tipo de parâmetro sempre será WEX::Common::String (em código nativo) e String(em código gerenciado)

Se vários valores de dados forem especificados, um produto cartesiano de todos os valores possíveis será obtido e o método de teste será invocado para cada combinação.

Além disso, é possível ter alguns conjuntos de metadados (como conjuntos de metadados ThreadingModel), bem como conjuntos de dados especificados para o mesmo método de teste. Nesse caso, o TAEF produzirá uma expansão combinatória de todos os conjuntos de metadados e conjuntos de dados e os métodos de ensaio em questão serão invocados com cada combinação.

Casos especiais - teste orientado por dados com um conjunto de metadados ou dados

Você pode ter um método de teste dependente do teste orientado por dados baseado em tabela, bem como especificar um conjunto de dados ou metadados para ele. Por exemplo, um método de teste pode ter os parâmetros "size" e "color" especificados no teste orientado por dados baseado em tabela e desejar que todas as linhas sejam executadas uma vez com o parâmetro "transparency" definido como true e, em seguida, definido como false. Nesse caso, "transparência" poderia ser especificado como um conjunto "{true, false}" para o teste orientado por dados. É importante observar que, em caso de conflitos de parâmetro em um conjunto de metadados versos tabela baseada em linha orientada por dados, o tipo e o valor do parâmetro Nível da linha substituirão o valor do conjunto de metadados.

Execução de testes com conjuntos de dados / metadados

A execução de testes contendo conjuntos de dados é bastante intuitiva. Vamos dar uma olhada na saída /listproperties para nossos testes de exemplo:

1   te Examples\CPP.DataDriven.Example.dll /name:*SetsOfDataTest* /listproperties
2
3   Test Authoring and Execution Framework v2.9.3k for x64
4
5           f:\ Examples\CPP.SimpleDataDriven.Example.dll
6               WEX::TestExecution::Examples::SimpleDataDrivenExample<
7                   WEX::TestExecution::Examples::SimpleDataDrivenExample::SetsOfDataTest#metadataSet0
8                           Property[Data:Color] = {Purple, Maroon, Brown}
9
10                          Data[Color] = Purple
11
12                  WEX::TestExecution::Examples::SimpleDataDrivenExample::SetsOfDataTest#metadataSet1
13                          Property[Data:Color] = {Purple, Maroon, Brown}
14
15                          Data[Color] = Maroon
16
17                  WEX::TestExecution::Examples::SimpleDataDrivenExample::SetsOfDataTest#metadataSet2
18                          Property[Data:Color] = {Purple, Maroon, Brown}
19
20                          Data[Color] = Brown

Observe as linhas 7, 12 e 17 no exemplo acima. Um índice de conjunto de metadados é anexado a cada invocação do método de teste com o valor no conjunto de dados. Este índice tem a seguinte forma:

<namespace qualified test method name>#metadataSet<metadataIndex>

As linhas 8, 13 e 18 mostram o conjunto de metadados que foi especificado para esse suporte a testes leves orientados por dados. Neste caso o conjunto é composto pelas cores roxo, marrom e marrom. As linhas 10, 15 e 20 mostram o valor real desse conjunto que está ativo para a invocação atual do teste. No caso de SetsOfMetadataTest#metadataSet1, a segunda invocação desse método, o valor do parâmetro ativo do conjunto é "Maroon"

Você pode selecionar o valor ou nome de dados da mesma forma que faria em testes controlados por dados baseados em tabela. Por exemplo, você pode selecionar SetsOfDataTest#metadataSet1 por uma consulta de seleção como /select:@Data:Color='Maroon' ou /name:*#metadataSet1

Para referência rápida, a saída /listproperties do exemplo de teste gerenciado é mostrada abaixo:

te Examples\CSharp.DataDriven.Example.dll /name:*SetsOfMetadataTest* /listproperties

Test Authoring and Execution Framework v2.9.3k for x64

        f:\ Examples\CSharp.DataDrivenSimple.Example.dll
            WEX.Examples.CSharpDataDrivenSimpleExample
                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