Como aumentar a confiança do desenvolvedor com um ótimo pacote de testes Django

Os testes adequados no Django são rápidos de escrever, mais rápidos de executar e podem oferecer a você uma solução de integração contínua perfeita para tomar o pulso de seu aplicativo de desenvolvimento.

Com testes abrangentes, os desenvolvedores têm mais confiança ao realizar mudanças. Eu vi em primeira mão em minhas próprias equipes que bons testes podem aumentar a velocidade de desenvolvimento como resultado direto de uma melhor experiência do desenvolvedor.

Neste artigo, compartilharei minhas próprias experiências na construção de testes úteis para aplicativos Django, desde o básico até a melhor execução possível. Se você estiver usando Django ou construindo com ele em sua organização, talvez queira ler meu Série Django em Victoria.dev.

O que testar

Os testes são extremamente importantes. Muito além de simplesmente deixar você saber se uma função funciona, os testes podem formar a base do entendimento de sua equipe sobre como seu aplicativo está pretendido trabalhar.

Este é o objetivo principal: se você bateu com a cabeça e esqueceu tudo sobre como seu aplicativo funciona amanhã, você deve ser capaz de recuperar a maior parte de sua compreensão lendo e executando os testes que escreve hoje.

Aqui estão algumas perguntas que podem ser úteis para você decidir o que testar:

• O que seu cliente deve ser capaz de fazer?
• Qual é o seu cliente não deveria ser capaz de fazer?
• O que esse método, visão ou fluxo lógico deve alcançar?
• Quando, como ou onde esse recurso deve ser executado?

Os testes que fazem sentido para seu aplicativo podem ajudar a aumentar a confiança do desenvolvedor.

Com essas proteções sensatas em vigor, os desenvolvedores fazem melhorias mais prontamente e se sentem confiantes para apresentar soluções inovadoras às necessidades do produto. O resultado é um aplicativo que chega mais rápido e recursos que são enviados com freqüência e confiança.

Onde colocar testes

Se você tiver apenas alguns testes, você pode organizar seus arquivos de teste de forma semelhante a Modelo de aplicativo padrão do Django colocando todos eles em um arquivo chamado tests.py. Essa abordagem direta é melhor para aplicativos menores.

Conforme seu aplicativo cresce, você pode querer dividir seus testes em diferentes arquivos ou módulos de teste. Um método é usar um diretório para organizar seus arquivos, como projectroot/app/tests/. O nome de cada arquivo de teste dentro desse diretório deve começar com test, por exemplo, test_models.py.

Além de ser nomeado apropriadamente, o Django encontrará esses arquivos usando descoberta de teste integrada com base no unittest módulo. Todos os arquivos em seu aplicativo com nomes que começam com test serão coletados em um conjunto de testes.

Esta descoberta de teste conveniente permite que você coloque arquivos de teste em qualquer lugar que faça sentido para seu aplicativo. Contanto que eles sejam nomeados corretamente, o utilitário de teste do Django pode localizá-los e executá-los.

Como documentar um teste

Usar docstrings para explicar o que um teste pretende verificar em alto nível. Por exemplo:

def test_create_user(self):    """Creating a new user object should also create an associated profile object"""    # ...

Essas docstrings ajudam você a entender rapidamente o que um teste deve fazer. Além de navegar na base de código, isso ajuda a tornar óbvio quando um teste não verifica o que a docstring diz que deveria.

As docstrings também são mostradas quando os testes estão sendo executados, o que pode ser útil para registro e depuração.

O que um teste precisa para funcionar

Os testes do Django podem ser rapidamente configurados usando dados criados no setUpTestData() método. Você pode usar várias abordagens para criar seus dados de teste, como a utilização de arquivos externos ou até mesmo a codificação de frases bobas ou os nomes de sua equipe.

Pessoalmente, prefiro muito mais usar uma biblioteca de geração de dados falsos, como faker.

A configuração apropriada de dados de teste arbitrários pode ajudá-lo a garantir que você está testando a funcionalidade do aplicativo em vez de testar acidentalmente os dados de teste. Porque geradores gostam faker adicionar algum grau de inesperado às suas entradas, pode ser mais representativo do uso no mundo real.

Aqui está um exemplo configurado para um teste:

from django.test import TestCasefrom faker import Fakerfrom app.models import MyModel, AnotherModelfake = Faker()class MyModelTest(TestCase):    def setUpTestData(cls):        """Quickly set up data for the whole TestCase"""        cls.user_first = fake.first_name()        cls.user_last = fake.last_name()    def test_create_models(self):        """Creating a MyModel object should also create AnotherModel object"""        # In test methods, use the variables created above        test_object = MyModel.objects.create(            first_name=self.user_first,            last_name=self.user_last,            # ...        )        another_model = AnotherModel.objects.get(my_model=test_object)        self.assertEqual(another_model.first_name, self.user_first)        # ...

Os testes são aprovados ou reprovados com base no resultado dos métodos de afirmação. Você pode usar Python’s unittest métodos, e Métodos de asserção do Django.

Para obter mais orientações sobre como escrever testes, consulte Testando em Django.

Melhor execução possível para executar seus testes

O conjunto de testes do Django é executado manualmente com:

./manage.py test

Raramente executo meus testes de Django dessa maneira.

A melhor, ou mais eficiente, prática de teste é aquela que ocorre sem que você ou seus desenvolvedores pensem: “Preciso executar os testes primeiro”.

A beleza da configuração quase sem esforço do conjunto de testes do Django é que ele pode ser executado perfeitamente como parte das atividades regulares do desenvolvedor. Isso pode ser em um gancho de pré-confirmação ou em uma integração contínua ou fluxo de trabalho de implantação.

Já escrevi anteriormente sobre como usar ganchos de pré-confirmação para melhore a ergonomia de seu desenvolvedor e poupe a sua equipe algum poder intelectual. Os testes rápidos do Django podem ser executados dessa maneira e se tornam especialmente eficientes se você puder executar testes em paralelo.

Testes executados como parte de um fluxo de trabalho de CI / CD, por exemplo, em solicitações pull com ações GitHub, não exija nenhum esforço regular de seus desenvolvedores para se lembrar de executar os testes. Não tenho certeza de como posso dizer isso – este é literalmente um acéfalo.

Testando seu caminho para um ótimo aplicativo Django

Os testes são extremamente importantes e pouco apreciados. Eles podem detectar erros lógicos em seu aplicativo. Eles podem ajudar a explicar e validar como os conceitos e recursos do seu produto realmente funcionam. O melhor de tudo é que os testes podem aumentar a confiança do desenvolvedor e a velocidade de desenvolvimento como resultado.

Os melhores testes são aqueles que são relevantes, ajudam a explicar e definir sua aplicação e são executados continuamente sem pensar duas vezes. Espero ter mostrado agora como os testes em Django podem ajudá-lo a atingir esses objetivos para sua equipe!