Apresentando o teste em Python. Parte 3

Amigos, temos ótimas notícias para você. Em primeiro lugar, o sol está finalmente brilhando nas ruas, o que significa que a primavera está começando a assumir completamente seus direitos. A segunda notícia é mais especializada - em 20 de março, a primeira lição começa em um novo tópico no curso "Desenvolvedor Python" . Em conexão com isso, publicamos a parte final do artigo "Introdução ao teste em Python", cujas partes anteriores podem ser lidas aqui e aqui .

Testando em Vários Ambientes

Até agora, você estava testando uma versão do Python usando um ambiente virtual com um conjunto específico de dependências. Mas sempre pode ser necessário testar o aplicativo em várias versões do Python ou em várias versões do pacote. O Tox é um aplicativo que automatiza testes em vários ambientes.



Instalação Tox

O Tox está disponível no PyPl como um pacote para instalação via pip:

$ pip install tox 

Após a instalação, você pode prosseguir para configurar o Tox.

Personalizando o Tox para suas dependências

O Tox é configurado através do arquivo de configuração no diretório do projeto. Ele contém o seguinte:

• O comando a ser executado para executar os testes;
• Quaisquer pacotes adicionais necessários para execução;
• Versões de destino do Python selecionadas para teste.

Em vez de aprender a sintaxe para configurar o Tox, você pode iniciar iniciando um aplicativo de início rápido.

 $ tox-quickstart 

A ferramenta de configuração do Tox fará perguntas e criará um arquivo semelhante ao seguinte no tox.ini :

 [tox] envlist = py27, py36 [testenv] deps = commands = python -m unittest discover 

Antes de iniciar o Tox, verifique se o setup.py com as etapas de instalação do pacote está na pasta do aplicativo. Caso contrário, use o guia de criação setup.py .

E se o seu projeto não se destina à distribuição no PyPl, você pode pular esse requisito adicionando a seguinte linha ao arquivo tox.ini no cabeçalho tox :

 [tox] envlist = py27, py36 skipsdist=True 

Se você não criar o setup.py e o aplicativo tiver algumas dependências no PyPl, será necessário esclarecê-las na seção testenv . Por exemplo, o Django exigirá o seguinte:

 [testenv] deps = django 

No final desta etapa, você pode executar os testes.

Agora você pode executar o Tox, e ele criará dois ambientes virtuais: um para o Python 2.7 e outro para o Python 3.6. O diretório Tox é chamado .tox/ . Nele, o Tox executará -m unittest discover para cada ambiente virtual.

Você pode iniciar esse processo chamando o Tox na linha de comando:

 $ tox 

O Tox produzirá resultados de teste para cada ambiente. Quando você inicia o Tox pela primeira vez, leva tempo para criar ambientes virtuais, mas quando você executa o Tox pela segunda vez, tudo funciona muito mais rápido.
Os resultados de Tox são bem simples. Ambientes são criados para cada versão, dependências são instaladas e, em seguida, comandos de teste são executados.

Há algumas opções adicionais de linha de comando que vale a pena lembrar.
Executando um único ambiente, por exemplo, Python 3.6:

 $ tox -e py36 

Recrie o ambiente virtual quando a dependência for alterada ou os pacotes secundários forem corrompidos:

 $ tox -r 

Executando o Tox com descobertas menos detalhadas:

 $ tox -q 

Executando o Tox com saída mais detalhada:

 $ tox -v 

Você pode ler mais sobre o Tox no site de documentação do Tox .

Automação de Teste

Até o momento, você executou testes manualmente executando o comando Mas existem ferramentas para executar testes automaticamente quando as alterações são feitas e as comprometem em um repositório com um sistema de controle de versão, por exemplo, Git. As ferramentas de automação de teste geralmente são chamadas de ferramentas de CI / CD, o que significa "Integração Contínua / Implantação Contínua". Eles podem executar testes, compilar e publicar aplicativos e até implantá-los na produção.
O Travis CI é um dos muitos serviços de CI disponíveis.

O Travis CI funciona bem com o Python, e agora você pode automatizar a execução de todos os testes criados na nuvem! O Travis CI é gratuito para qualquer projeto de código aberto no GitHub e GitLab e está disponível por uma taxa para projetos privados.

Para começar, faça login e autentique usando suas credenciais do GitHub ou GitLab. Em seguida, crie um arquivo chamado .travis.yml com o seguinte conteúdo:

 language: python python: - "2.7" - "3.7" install: - pip install -r requirements.txt script: - python -m unittest discover 

Essa configuração fornece ao Travis CI as seguintes instruções:

• Teste para Python 2.7 e 3.7 (Opcionalmente, você pode substituí-los por outros.)
• Instalando todos os pacotes listados em requirements.txt (Você pode remover esta seção se não tiver dependências.)
• A execução de python -m unittest discover para executar testes.

Após confirmar e enviar esse arquivo, o Travis CI executará esses comandos toda vez que você enviar para o repositório Git remoto. Os resultados podem ser visualizados em seu site.

O que vem a seguir

Agora você sabe como escrever testes, adicioná-los ao seu projeto, executá-los e até mesmo fazê-lo automaticamente, para que você possa se familiarizar com os métodos avançados que podem ser úteis à medida que a biblioteca de testes cresce.

Introdução ao aplicativo Linter

Tox e Travis CI têm uma configuração de equipe de teste. Neste tutorial, usamos o python -m unittest discover como uma equipe de teste.

Você pode fornecer um ou mais comandos nessas ferramentas, que adicionarão novas ferramentas para melhorar a qualidade do aplicativo.

Uma dessas aplicações é o linter. Ele analisará seu código e deixará comentários. Assim, ele pode dar conselhos sobre erros, corrigir espaços finais e até antecipar possíveis erros.

Para saber mais sobre linters, consulte o Tutorial de qualidade de código Python .

Fiapos passivos com flocos8

O flake8 é um linter popular que deixa comentários sobre o estilo do seu código, de acordo com a especificação do PEP 8 .

Você pode instalar o flake8 usando o pip:

 $ pip install flake8 

Em seguida, você pode executar o flake8 para um único arquivo, pasta ou modelo:

 $ flake8 test.py test.py:6:1: E302 expected 2 blank lines, found 1 test.py:23:1: E305 expected 2 blank lines after class or function definition, found 1 test.py:24:20: W292 no newline at end of file 

Você verá uma lista de erros e avisos no seu código encontrados por flake8 .
flake8 pode ser configurado na linha de comando ou no arquivo de configuração do projeto. Se você deseja ignorar algumas regras, por exemplo, E305, mostradas acima, é possível definir isso na configuração. flake8 irá verificar o arquivo flake8 na pasta do projeto ou no arquivo setup.cfg . Se você deseja usar o Tox, pode adicionar a flake8 configuração do tox.ini ao tox.ini .

Este exemplo ignora os diretórios .git e __pycache__ , bem como a regra E305. Além disso, o comprimento máximo da string é aumentado de 80 caracteres para 90. Em algum momento, você perceberá que o limite padrão de 79 caracteres por linha não é adequado para testes que podem conter nomes longos de métodos, literais de string com valores de teste e outros longos dados. Normalmente, para testes, aumente o comprimento da string para 120 caracteres:

 [flake8] ignore = E305 exclude = .git,__pycache__ max-line-length = 90 

Como alternativa, você pode fornecer estas opções na linha de comando:

 $ flake8 --ignore E305 --exclude .git,__pycache__ --max-line-length=90 

Uma lista completa de configurações pode ser encontrada no site de documentação .
Agora você pode adicionar flake8 à sua configuração de IC. Para o Travis CI, será assim:

 matrix: include: - python: "2.7" script: "flake8" 

Travis lerá a configuração em .flake8 e não poderá concluir a compilação se houver erros de cotão. Certifique-se de adicionar a dependência flake8 ao arquivo requirements.txt .

Linting agressivo com o Formatador de Código

flake8 é um linter passivo que recomenda apenas edições; você precisará inseri-las no código por conta própria. O formatador de código é uma abordagem mais agressiva. Ele altera o código automaticamente de acordo com estilos e layouts.

black é um formatador muito inexorável. Não possui configurações e é muito meticuloso. O que a torna uma ótima ferramenta para inserir em seu pipeline de teste.

Observe: black requer o Python versão 3.6 e superior.

Você pode instalar o black usando o pip:

 $ pip install black 

Em seguida, para iniciar na linha de comando, especifique o arquivo ou diretório que você deseja formatar:

 $ black test.py 

Mantenha o código de teste limpo

Você pode perceber que, ao escrever testes, você copia e cola fragmentos de código com muito mais frequência do que quando cria aplicativos comuns. De tempos em tempos, os testes podem ser muito monótonos, mas esse não é um motivo para descartar o código de forma imprecisa e fragmentada.

Com o tempo, a dívida técnica se acumulará no seu código de teste e as alterações necessárias para alterações significativas no código do aplicativo nos testes serão muito difíceis apenas por causa da estrutura.

Ao escrever testes, tente seguir o princípio DRY: não se repita.

As instalações e funções de teste são uma ótima maneira de escrever código fácil de manter. Além disso, não se esqueça da facilidade de leitura. Considere a possibilidade de implantar ferramentas de flake8 , como flake8 no seu código de teste:

 $ flake8 --max-line-length=120 tests/ 

Teste para detectar queda de produtividade entre edições

Existem muitas maneiras de comparar o código no Python. A biblioteca padrão possui um módulo timeit que agenda funções várias vezes e mostra a distribuição. Neste exemplo, test () será executado 100 vezes e a saída será fornecida usando print ():

 def test(): # ... your code if __name__ == '__main__': import timeit print(timeit.timeit("test()", setup="from __main__ import test", number=100)) 

Se você decidir usar o pytest como um executor de testes, confira o plugin pytest-benchmark. Ele fornece um dispositivo pytest chamado benchmark. Qualquer objeto chamado pode ser passado como benchmark (), ele analisa o tempo dos resultados do pytest chamados.

Você pode instalar o pytest-benchmark do PyPl usando o pip:

 $ pip install pytest-benchmark 

Em seguida, você pode adicionar um teste usando o dispositivo elétrico e passando o objeto chamado para execução:

 def test_my_function(benchmark): result = benchmark(test) 

A execução do pytest fornecerá resultados de benchmark:



Você pode aprender mais no site de documentação .

Testando para identificar erros de segurança

Outro teste que você deve executar no seu aplicativo está verificando erros comuns e vulnerabilidades de segurança.

Instale o bandit do PyPl usando o pip:

 $ pip install bandit 

Em seguida, você pode passar o nome do seu módulo de aplicativo com o sinalizador -r e obter breves informações:

 $ bandit -r my_sum [main] INFO profile include tests: None [main] INFO profile exclude tests: None [main] INFO cli include tests: None [main] INFO cli exclude tests: None [main] INFO running on Python 3.5.2 Run started:2018-10-08 00:35:02.669550 Test results: No issues identified. Code scanned: Total lines of code: 5 Total lines skipped (#nosec): 0 Run metrics: Total issues (by severity): Undefined: 0.0 Low: 0.0 Medium: 0.0 High: 0.0 Total issues (by confidence): Undefined: 0.0 Low: 0.0 Medium: 0.0 High: 0.0 Files skipped (0): 

Assim como no flake8 , as bandit sinalizador de bandit podem ser configuradas e, se você quiser ignorar algumas delas, poderá adicionar o seguinte fragmento ao arquivo setup.cfg com os parâmetros:

 [bandit] exclude: /test tests: B101,B102,B301 

Mais informações no site do GitHub .

Conclusão

O Python disponibilizou os testes graças aos comandos e bibliotecas integrados necessários para verificar a operação correta dos aplicativos. É fácil iniciar o teste no Python: você pode usar mais unittest e escrever métodos pequenos e fáceis de manter para testar o código.

À medida que você aprender mais sobre como testar e expandir seu aplicativo, considere mudar para uma das estruturas de teste, como pytest, para começar a usar os recursos mais avançados.

Obrigado pela leitura. Tenha um futuro inconfundível com o Python!

E para quem leu o artigo, temos mais uma ótima notícia. No momento, você pode obter o curso Python Developer com um desconto de 10.000 rublos!

Primeira parte
Segunda parte