Testes de unidade de manuseio

Observação

Este conteúdo é aplicável ao SDK herdado do Power Query no Visual Studio. Hoje, o novo SDK do Power Query no Visual Studio Code contém uma estrutura de teste completa que incentivamos você a testar e aprender mais.

Para conectores simples e complexos, adicionar testes de unidade é uma prática recomendada e altamente recomendada.

O teste de unidade é realizado no contexto do SDK do Power Query do Visual Studio. Cada teste é definido como um Fact que tem um nome, um valor esperado e um valor real. Na maioria dos casos, o "valor real" é uma expressão M que testa parte da sua expressão.

Considere uma extensão que exporta três funções:

section Unittesting;

shared UnitTesting.ReturnsABC = () => "ABC";
shared UnitTesting.Returns123 = () => "123";
shared UnitTesting.ReturnTableWithFiveRows = () => Table.Repeat(#table({"a"},{{1}}),5);

Este código de teste de unidade é composto por muitos Facts e uma série de códigos comuns para a estrutura de teste de unidade (ValueToText, Fact, Facts, Facts.Summarize). O código a seguir fornece um conjunto de exemplo de fatos (vá para UnitTesting.query.pq para o código comum):

section UnitTestingTests;

shared MyExtension.UnitTest = 
[
    // Put any common variables here if you only want them to be evaluated once

    // Fact(<Name of the Test>, <Expected Value>, <Actual Value>)
    facts = 
    {
        Fact("Check that this function returns 'ABC'",  // name of the test
            "ABC",                                      // expected value
            UnitTesting.ReturnsABC()                    // expression to evaluate (let or single statement)
        ),
        Fact("Check that this function returns '123'",
            "123",
            UnitTesting.Returns123()
        ),
        Fact("Result should contain 5 rows",
            5,
            Table.RowCount(UnitTesting.ReturnTableWithFiveRows())
        ),
        Fact("Values should be equal (using a let statement)",
            "Hello World",
            let
                a = "Hello World"
            in
                a
        )
    },
    report = Facts.Summarize(facts)
][report];

A execução do exemplo no Visual Studio avalia todos os fatos e fornece um resumo visual das taxas de aprovação:

A implementação do teste de unidade no início do processo de desenvolvimento do conector permite que você siga os princípios do desenvolvimento orientado a testes. Imagine que você precisa escrever uma função chamada Uri.GetHost que retorna apenas os dados do host de um URI. Você pode começar escrevendo um caso de teste para verificar se a função executa adequadamente a função esperada:

Fact("Returns host from URI",
    "https://bing.com",
    Uri.GetHost("https://bing.com/subpath/query?param=1&param2=hello")
),
Fact("Handles port number appropriately",
    "https://bing.com:8080",
    Uri.GetHost("https://bing.com:8080/subpath/query?param=1&param2=hello")
)

Mais testes podem ser escritos para garantir que a função trate adequadamente de casos extremos.

Uma versão inicial da função pode passar em alguns testes, mas não em todos:

Uri.GetHost = (url) =>
    let
        parts = Uri.Parts(url)
    in
        parts[Scheme] & "://" & parts[Host]

A versão final da função deve passar em todos os testes de unidade. Esta versão também torna mais fácil garantir que futuras atualizações da função não removam acidentalmente nenhuma de suas funcionalidades básicas.