Teste controlado por dados leve

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

Os dados do teste controlado por dados leve são expressos como um conjunto de metadados (no nível de teste, classe ou módulo). Para cada um dos valores nesse conjunto, os métodos de teste em questão, juntamente com os métodos de configuração e de teardown associados, serão executados para cada valor no conjunto. Vamos dar uma olhada em como criar isso no 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 de parâmetro para TEST_METHOD_PROPERTY na linha 14. O valor dos metadados de teste começa com um "{" e termina com um "}" indicando que uma lista separada por vírgula ou ponto-e-vírgula de valores foi especificada. O TAEF executará novamente o método de teste em questão, SetsOfDataTest() uma vez para cada valor neste conjunto.

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

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 semelhantes ao exemplo nativo. Vamos dar uma olhada.

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 baseados em dados baseados em tabela, conjuntos de dados especificados como metadados permitirão a recuperação por meio de TestContext.DataRow. Observe que, para manter o peso leve do teste controlado por dados, o tipo de parâmetro sempre será WEX::Common::String (em código nativo) e String(no 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.

Ainda é 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, uma expansão combinatória de todos os conjuntos de metadados e conjuntos de dados será produzida pelo TAEF e os métodos de teste em questão serão invocados a cada combinação.

Casos especiais – teste controlado por dados com conjuntos de metadados ou dados

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

Executando testes com conjuntos de dados/metadados

A execução de testes que contêm 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 é acrescentado a cada invocação do método de teste com o valor no conjunto de dados. Esse índice é do formulário:

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

As linhas 8, 13 e 18 mostram o conjunto de metadados especificado para esse suporte de teste controlado por dados leve. Nesse caso, o conjunto consiste em cores roxas, marrons e marrons. 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 o nome de dados da mesma forma que pôde em testes baseados em 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