Testes

Os testes do pacote em python da basedosdados foram implementados usando o módulo pytest. Neste documento, apresentamos convenções e padrões utilizados na nossa implementação dos testes:

No âmbito do pytest, as fixtures são valores que o usuário define com o decorador @pytest.fixture que ficam globalmente disponíveis para os outros testes definidos no módulo. É importante notar que, no caso do repositório mais, todas as fixtures devem ficar no arquivo chamado connftests.py. Dessa forma, precisamos declarar as fixtures apenas uma vez e elas ficam automaticamente disponíveis para todos os arquivos de teste, sem necessidade de importação.

Um exemplo de fixture é dado por:

import pytest
@pytest.fixture
def input_value():
 input = 39
 return input
def test_divisible_by_3(input_value):
 assert input_value % 3 == 0

Ocorre que, pelo nosso coding standard, evitamos sobrescrever variáveis locais com nomes globais em uso. Para manter o uso das fixtures e compatibilizar os arquivos dos módulos de testes com nosso coding standard, adotamos a convenção sugerida na documentação do pytest:

If a fixture is used in the same module in which it is defined, the function name of the fixture will be shadowed by the function arg that requests the fixture; one way to resolve this is to name the decorated function fixture_ and then use @pytest.fixture(name='').

Para o exemplo mostrado acima, temos:

@pytest.fixture(name="input_value")
def fixture_input_vallue():

Os testes da CLI são um tipo específico de teste e, por essa razão, comentamos aqui sobre as limitações da implementação atual e possíveis frentes de melhoria.

Para se testar uma CLI o ideal seria rodar os comandos em uma máquina isolada com apenas a versão atual do pacote (em teste) instalada. Para isso o click, módulo utilizado na implementação da CLI da BD, disponibiliza um sub-módulo de teste chamado de click.testing. A documentação do módulo, contudo, mostra apenas o caso simples em que o teste é feito para um comando isoladamente. No nosso caso, o teste deve ser feito para grupos de comandos, com o contexto adicionado. A seguir mostramos um exemplo da implementação de um teste para um sub-comando do grupo table

'''
Tests for the CLI module.
'''
from pathlib import Path
import shutil
import os
from click.core import Context
from basedosdados.cli.cli import cli_table
from importlib_metadata import metadata
from more_itertools import bucket
import pytest
import click.testing
from basedosdados import Storage, Dataset, Table
import basedosdados as bd
from basedosdados.exceptions import BaseDosDadosException
from google.api_core.exceptions import NotFound
DATASET_ID = "pytest"
TABLE_ID = "pytest"
TABLE_FILES = ["publish.sql", "table_config.yaml"]
templates=Path(__file__).parent / "templates"
bucket_name = "basedosdados-dev"
metadata_path = Path(__file__).parent / "tmp_bases"
ctx = Context(command=cli_table.commands['create'], obj=dict(templates=templates,bucket_name=bucket_name,metadata_path=metadata_path))
def test_create_no_path_error(testdir):
 """
 Teste if error is raised when no path is provided
 """
 shutil.rmtree(testdir / DATASET_ID / TABLE_ID, ignore_errors=True)
 runner = click.testing.CliRunner()
 result = runner.invoke(cli=cli_table.get_command(ctx=ctx, cmd_name='create'), args=f'''--if_table_exists=replace {DATASET_ID} {TABLE_ID}''')
 assert isinstance(result.exception, BaseDosDadosException)

Ocorre que o snippet acima não funciona como esperado e o comando gera um retorno diferente do que seria obtido se o comando rodasse diretamente do terminal. Não está claro qual o problema dessa implementação, mas como ela não reproduz o comportamento que obserrvamos no uso direto da CLI, esse modelo de teste foi descartado.

O modelo de teste implementado, então, foi o que faz os testes do comando usando o módullo subprocess e uma instalaçao local do python:

def _run_command(command, output="err"):
 """
 Run a command and return the output | error
 """
 current_dir = os.getcwd()
 os.chdir(cli_dir)
 proc = subprocess.Popen(
 [command],
 stdout=subprocess.PIPE,
 stderr=subprocess.PIPE,
 shell=True,
 )
 out, err = proc.communicate()
 os.chdir(current_dir)
 if output == "err":
 return err
 if output == "out":
 return out
 raise ValueError("output must be either err or out")
def test_cli_create_no_path_error(testdir, python_path):
 """
 Teste if error is raised when no path is provided
 """
 err = _run_command(
 f"{python_path} -m cli --metadata_path={testdir} table create --if_table_exists=pass {DATASET_ID} {TABLE_ID}",
 output="err",
 )
 assert b"You must provide a path to correctly create config files" in err

Esse formato de teste, contudo, não é o ideal, já que ele utiliza a versão do pacote basedosdados instalado na máquina e não a versão em desenvolvimento.