Teste de regressão com o comando compare

O comando PQTest compare é uma ferramenta poderosa para testes de regressão, permitindo-lhe avaliar minuciosamente as funções do conector e a geração do texto do comando. Para ilustrar a sua versatilidade, as secções seguintes fornecerão uma variedade de exemplos adaptados a diferentes cenários.

Consultas básicas

A forma mais simples de teste é adicionar uma única expressão de consulta a um ficheiro .query.pq, que pode executar usando o comando compare . O PQTest avalia a expressão e gera um ficheiro .pqout (saída) com o mesmo nome. Para quaisquer execuções subsequentes, compara a saída gerada pela avaliação do ficheiro .query.pq com o ficheiro pqout (output) com o mesmo nome e devolve a saída da avaliação.

Exemplo 1 - Executar o comando compare para um ficheiro de consulta quando um ficheiro de saída não existe

O exemplo seguinte executa um único ficheiro de teste de consulta usando a extensão Power Query especificada e gera ficheiro de saída para comparar.

<Path to PQTest.exe>.\PQTest.exe compare -e contoso.mez -q contoso.query.pq

[
  {
    "Details": "Contoso.Contents(\"TestEndpoint\")",
    "EndTime": "2020-12-11T18:04:14.8991822+00:00",
    "Method": "Compare.TestFiles",
    "Name": "contoso.query.pq",
    "StartTime": "2020-12-11T18:04:11.1532388+00:00",
    "Output": [
      {
        "SourceFilePath": "contoso.query.pq",
        "OutputFilePath": "contoso.query.pqout",
        "Status": "Output File Generated",
        "SerializedSource": null,
        "SourceError": null,
        "OutputError": null
      }
    ],
    "Status": "Passed",
    "Type": "PQTest.Expression"
  }
]

Exemplo 2 - Executar o comando compare para um ficheiro de consulta quando um ficheiro de saída não existe e a flag FailOnMissingOutputFile está definida

<Path to PQTest.exe>.\PQTest.exe compare -e contoso.mez -q contoso.query.pq -fomof

[
  {
    "Details": "Contoso.Contents(\"TestEndpoint\")",
    "EndTime": "2020-12-11T18:04:14.8991822+00:00",
    "Method": "Compare.TestFiles",
    "Name": "contoso.query.pq",
    "StartTime": "2020-12-11T18:04:11.1532388+00:00",
    "Output": [
      {
        "SourceFilePath": "contoso.query.pq",
        "OutputFilePath": "contoso.query.pqout",
        "Status": "Missing Output File",
        "SerializedSource": "Output of contoso.query.pq",
        "SourceError": null,
        "OutputError": null
      }
    ],
    "Status": "Failed"
    "Type": "PQTest.Expression"
  }
]

Exemplo 3 - Executar o comando compare para um ficheiro de consulta com um ficheiro de saída presente

O exemplo seguinte executa um único ficheiro de teste de consulta usando a extensão Power Query especificada, compara-o com o ficheiro de saída e devolve o resultado.

<Path to PQTest.exe>.\PQTest.exe compare -e contoso.mez -q contoso.query.pq

[
  {
    "Details": "Contoso.Contents(\"TestEndpoint\")",
    "EndTime": "2020-12-11T18:04:14.8991822+00:00",
    "Method": "Compare.TestFiles",
    "Name": "contoso.query.pq",
    "StartTime": "2020-12-11T18:04:11.1532388+00:00",
    "Output": [
      {
        "SourceFilePath": "contoso.query.pq",
        "OutputFilePath": "contoso.query.pqout",
        "Status": "Passed",
        "SerializedSource": null,
        "SourceError": null,
        "OutputError": null
      }
    ],
    "Status": "Passed",
    "Type": "PQTest.Expression"
  }
]

Testes com consulta de parâmetros

Consulta de parâmetros é uma consulta que é combinada com uma consulta de teste em tempo de execução, com a consulta de parâmetros a ser executada primeiro. Esta funcionalidade permite dividir o ficheiro de consulta PQ/teste em duas partes: o ficheiro de consulta de parâmetros e o ficheiro de consulta de teste.

Teste de fonte de dados independente com formato de consulta por parâmetros e testes

Um exemplo de caso de uso em que esta funcionalidade seria útil é criar um conjunto de testes independente da fonte de dados. Depois, podes usar a tua consulta de parâmetros para recuperar dados da fonte de dados, e fazer com que a consulta de teste seja genérica M. Se quiseres executar os testes para outro conector, só precisas de adicionar/atualizar a consulta de parâmetros para apontar para essa fonte de dados específica.

Uma diferença fundamental ao usar uma consulta de parâmetros é que a consulta de teste segue um formato diferente. Em vez de ser uma expressão de fórmula, deve ser uma função M que recebe um parâmetro de entrada, que representa a tabela devolvida da consulta de parâmetros.

Vamos supor que tem a seguinte consulta de teste:

let
    Source = Snowflake.Databases("...", "..."),
    Database = Source{[Name="...",Kind="Database"]}[Data],
    SelectColumns = Table.RemoveColumns(Database, { "Data" })
in
    SelectColumns

Para o converter numa consulta de teste e parâmetro, precisa de os dividir da seguinte forma:

Consulta de Parâmetros:

let
    Source = Snowflake.Databases("...", "..."),
    Database = Source{[Name="...",Kind="Database"]}[Data],
    Schema = Database{[Name="...",Kind="Schema"]}[Data],
    Taxi_Table = Schema{[Name="...",Kind="Table"]}[Data],
in
    Taxi_Table

Consulta de Teste:

(Source) => let
    SelectColumns = Table.RemoveColumns(Source, { "VendorID" })
in
    SelectColumns

Exemplo 4 - Usar tanto a consulta de parâmetros como a consulta de teste com o comando compare

<Path to PQTest.exe>.\PQTest.exe compare -e contoso.mez -q contoso.query.pq -pa contoso.parameter.pq

[
  {
    "Details": "(Source) => let\r\n    Schemas = Table.RemoveColumns(Source, { \"Data\" })\r\nin\r\n    Schemas",
    "EndTime": "2020-12-11T18:04:14.8991822+00:00",
    "Method": "Compare.TestFiles",
    "Name": "contoso.query.pq",
    "StartTime": "2020-12-11T18:04:11.1532388+00:00",
    "Output": [
      {
        "SourceFilePath": "contoso.query.pq",
        "OutputFilePath": "contoso.query.pqout",
        "Status": "Passed",
        "SerializedSource": null,
        "SourceError": null,
        "OutputError": null
      }
    ],
    "Status": "Passed",
    "Type": "PQTest.Expression"
  }
]

Comparação de diagnósticos

Informação adicional de diagnóstico pode ser avaliada ao usar o comando compare subscrevendo um canal de diagnóstico. Quando o comando compare é executado, o PQTest gera um ficheiro .diagnostics para cada canal subscrito que teve um evento. Para quaisquer execuções subsequentes, compara o evento de diagnóstico com o seu ficheiro .diagnostics, semelhante ao .pqout.

Exemplo 5 - Subscrever o canal de diagnóstico ODBC (Open Database Connectivity) para validar a dobra de consultas

O exemplo seguinte mostra como subscrever o canal ODBC, que captura qualquer SQL gerado pelo driver ODBC quando o dobramento de consulta é utilizado.

<Path to PQTest.exe>.\PQTest.exe compare -e contoso.mez -q contoso.query.pq -dc "Odbc"

O canal de diagnóstico ODBC pode ser usado para verificar se uma consulta está a foldar e se está a gerar o SQL correto.

let
    Source = AzureSpark.Tables("...")
    T1 = Source{[Schema="default",Item="DATABASE"]}[Data],
    SelectColumns = Table.Group(T1, {}, {{"Maximum", each List.Max([number_column]), type number}}),
    FirstN = Table.FirstN(SelectColumns, 1)
in
    FirstN

A consulta agora consolida e gera o seguinte texto de comando ODBC no ficheiro .diagnostics:

[
  {
    "Command": "DESCRIBE default.DATABASE;"
  },
  {
    "Command": "select top 1 max(`number_column`) as `C1` from `SPARK`.`default`.`DATABASE`"
  }
]

Usar um ficheiro de definições

Qualquer parâmetro de entrada de linha de comandos para o comando compare também pode ser passado através de um ficheiro de definições JSON. O JSON pode ter as seguintes opções:

Opção	Tipo	Description
Caminhos de Extensão	matriz	Array de caminhos que apontam para o ficheiro conector (mez/pqx).
FalharNoFicheiroDeSaídaAusente	bool	O Compare não gera um ficheiro PQOut e falha se este não existir.
FalhaNaDobra	bool	A comparação falha se ocorrer um erro de query folding.
ParameterQueryFilePath	cadeia (de caracteres)	Ficheiro de consulta que contém M expressões, que são combinadas em tempo de execução com o ficheiro de consulta de teste. Um caso de uso comum é ter um ficheiro de consulta de parâmetro único para especificar uma expressão M e recuperar os dados para múltiplas consultas de teste.
QueryFilePath	cadeia (de caracteres)	Ficheiro de consulta que contém a expressão M (.pq) a ser testada.
TrxReportPath	cadeia (de caracteres)	Gera um ficheiro de resultados TRX (Visual Studio Test Results File) e ficheiros JSON separados para cada teste num determinado caminho.
DiagnosticChannels	matriz	Nome dos canais de diagnóstico a serem associados à execução de teste (por exemplo, Odbc para capturar instruções de dobragem de consulta).

No caso de serem fornecidas tanto a opção de entrada na linha de comandos como a opção de definições, a entrada na linha de comandos é priorizada.

Exemplo 6 - Usar ficheiro de definições em vez de argumentos de linha de comandos

<Path to PQTest.exe>.\PQTest.exe compare -e contoso.mez -q contoso.query.pq -fomof

O comando acima é equivalente ao seguinte comando:

<Path to PQTest.exe>.\PQTest.exe compare -sf settings.json

Onde settings.json está o seguinte ficheiro JSON:

{
  "ExtensionPaths": ["contoso.mez"],
  "QueryFilePath": "contoso.query.pq",
  "FailOnMissingOutputFile": true
}

Testar baterias com comando compare

Uma bateria de testes é um conjunto de testes que avaliam múltiplos aspetos do seu código. Coloque os ficheiros de consulta na mesma pasta para que o PQTest os possa localizar facilmente. Em vez de passar um nome específico de ficheiro de teste, especifique o caminho da pasta e o PQTest executa todos os ficheiros de consulta de teste .query.pq numa única passagem.

Exemplo 7 - Executar uma bateria de testes

Assumindo uma pasta chamada test que contenha os seguintes ficheiros:

contoso.testa.query.pq
contoso.testb.query.pq
contoso.testc.query.pq

Toda a bateria de teste pode ser executada usando a seguinte linha de comandos:

<Path to PQTest.exe>.\PQTest.exe compare -e contoso.mez -q .\test

Ignorar testes ao executar uma bateria de testes

Um teste pode ser ignorado ao executar uma bateria de testes ao alterar a extensão do ficheiro .query.pq para .query.pq.ignore.

Exemplo 8 - Ignorar um teste ao executar uma bateria de testes