Leer en inglés

Compartir a través de


Control de las pruebas unitarias

Nota

Este contenido es aplicable al SDK de Power Query heredado en Visual Studio. En la actualidad, el nuevo SDK de Power Query en Visual Studio Code contiene un marco de pruebas completo que le animamos a probar y obtener más información.

Agregar pruebas unitarias es un procedimiento muy recomendado para conectores tanto simples como complejos.

Las pruebas unitarias se realizan en el contexto del SDK de Power Query para Visual Studio. Cada prueba se define como un elemento Fact que tiene un nombre, un valor esperado y un valor real. En la mayoría de los casos, el "valor real" es una expresión de M que prueba parte de la expresión.

Considere una extensión sencilla que exporta tres funciones:

section Unittesting;

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

Este código de prueba unitaria se compone de varios elementos Fact y código común para el marco de pruebas unitarias (ValueToText, Fact, Facts, Facts.Summarize). El siguiente código proporciona un conjunto de elementos Fact de ejemplo (vaya a UnitTesting.query.pq para ver el código común):

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];

La ejecución del ejemplo en Visual Studio evalúa todos los elementos Fact y proporciona un resumen visual de las tasas de superación de las pruebas:

Ejemplo de índices de superación.

La implementación de pruebas unitarias al principio del proceso de desarrollo de un conector permite seguir los principios del desarrollo controlado por pruebas. Imagine que tiene que escribir una función denominada Uri.GetHost que devuelve solo los datos del host de un URI. Puede empezar escribiendo un caso de prueba para comprobar que la función realiza correctamente la función 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")
)

Se pueden escribir más pruebas para asegurarse de que la función controla correctamente los casos extremos.

Puede que una versión temprana de la función supere algunas pruebas, pero no todas:

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

Se produce un error en algunas pruebas.

La versión final de la función debe superar todas las pruebas unitarias. Esto ayuda también a asegurarse de que las actualizaciones futuras de la función no quiten accidentalmente nada de su funcionalidad básica.

Todas las pruebas se superan.