Python 中的睾丸 - 第 1 部分：简介

由 Mux 赞助的 DEV 全球展示挑战赛：展示你的项目！

这是 Python 中睾丸系列的第一部分。

本文首先介绍了 Python 原生框架的自动化测试。 Aqui，veremos alguns conceitos primordiais para escrever os primeiros casos de teste。

前提条件

• Python 基础知识

罗泰罗

1. O que são testes
2. Teste unitário (de unidade)
3. 康塞托斯
4. 示例
5. 附加考虑因素
6. 结论

1. O que são testes

1.1 动机

请编写我们的计划，并确认产品的正确结果。

最初的程序是这样的，正常情况下，我们的代码和验证的各种值都可以验证。所有这些都不是一个问题，但我们必须注意以下事项。 Pode ter sido exibido algum erro ou exceção ao usuário ou o programa retornar o valor errado e não exibir erro nenhum (ocasionado por erro de lógica na maioria das vezes)。 Nos dois casos, podemos usar or modo debug (que s facilitados por uma IDE1) or adicionar alguns returns noterminal usando a função print. Com isso, podemos identificar 问题a 和corrigir nosso código para retornar o que é esperado。Isso é um teste 手册。

IDE（集成开发环境）用于集成开发环境。在环境中，我们可以使用文本编辑器来发送信息，以便于执行、调试和集成。 Em Python 或Pycharm是一个可以同时使用和使用的 IDE。

修复这个极端的问题，并确保其有效。阿西姆，不保证我们的程序符合执行程序和验证实际情况的条件。

1.2 自动化测试

睾丸自动执行一系列操作，以模拟睾丸操作的方式进行操作。 Poupando assim tempo 和 esforço nessas verificações。

自动化测试会自动执行一些测试，以验证您的测试结果。 O teste Também nos ajuda a:

• Deixar o código mais limpo （ajuda na remoção de代码气味）
• 保护主要设备
• 提供文档服务：以视觉效果为基础，探讨实际情况和测试错误或测试结果
• Evitar trabalho 手册（um teste automatizado é muito melhor do que um teste 手册 com打印）
• 避免漏洞
• 证明者的反馈是为了开发应用程序：使用程序来返回或改变程序主体的逻辑。

2. 单元测试

Um teste unitário é a maneira de você testar as pequenas unidades em seu codigo. Também é chamado de teste de unidade。

对于测试用例，请使用内置框架 (nativo) 执行 Python chamado unittest。

示例 1：

from unittest import main, TestCase

def square(x):
    return x ** 2

class TestSquare(TestCase):
    def test_if_returns_square_of_2(self):
        result = square(2)
        expected = 4

        self.assertEqual(result, expected)

if __name__ == '__main__':
    main()

没有任何例子，我们的测试是统一的，我们的测试是在查马达广场上进行的。

修复测试环境中的待办事项，然后使用该类进行发送。

Mas，para entender melhor como funciona o exemplo acima，vamos primeiro entender alguns conceitos。

3. 康塞托斯

3.1 测试准备

请为测试环境做好准备。准备好固定装置和执行所需的一切。

• 示例：para conseguir testar uma função que lê um minated arquivo precisamos de um arquivo no nossoambiente de teste para ser possível fazer a validação

请参阅setUp() 和 TeaDown()的使用方法。这是在测试前和测试中执行的具体情况。

3.2 测试案例

与 queremos testar 的场景相结合。
我们测试了一些有关以下情况的测试，以验证形式单位的有效性，并了解上下文的情况。

com o 框架单元测试，usamos uma classe 基础 chamada TestCase。

3.3 断言

确认服务是否有效，以验证您的能力。

O断言um comando 内置 (nativo) 执行 Python。 E Podemos usar da seguinte forma:

修复最初的问题并与 1+1 和 2 进行比较。但结果与实际情况相同，但没有控制台。

如果继续进行断言，则会发生断言错误(erro de Asserção)。

框架单元测试有助于进行准确的判断。作为完整的声明，我们将在适当的文档中提供视图。

3.4 测试运行器

允许执行睾丸手术。测试运行者需要执行测试并输出结果。

单元测试的测试运行程序的使用与pytest 的使用类似。

3.5 覆盖范围

覆盖范围涉及睾丸的Cobertura de testes、ou seja、o quanto o seu código está sendo testado。

执行覆盖范围后，将在 testados 和 não foram 上进行测试。

注意： 100% de cobertura é different de ter todos os cenários testados！ Além de testar o Fluxo main do programa também precisamos testar casos inesperados (veremos mais adiante na série“Testes em Python”)。

3.6 模拟

模拟图书馆利用睾丸来模拟和确定演奏。模拟英语和字面意思“imitar”。该工具可使用外部通讯元素，例如：连接银行和 HTTP 银行。

对于使用模拟，没有执行任何命令的时刻，例如在银行中进行操作（例如“Python Testes”）。

4. 示例

猫咪写着：给我看看代码！

4.1 示例 1 的功能说明

from unittest import main, TestCase

def square(x):
    return x ** 2

class TestSquare(TestCase):
    def test_if_returns_square_of_2(self):
        result = square(2)
        expected = 4

        self.assertEqual(result, expected)

if __name__ == '__main__':
    main()

这是框架单元测试所必需的重要内容。

main()⇒ chamamos o Test Runner da biblioteca para a rodar nosso código Python (python meu_arquivo.py)。

TestCase⇒ Fornece a estrutura necessária para montar o caso de teste.

from unittest import main, TestCase

O próximo bloco se Refere a nosso código com o trecho que queremos validar

def square(x):
    return x ** 2

Criamos 提供了一系列的测试方法TestCase和单元测试方法以及测试方法。

修复类 escrevemos de modo descritivo o cenário que está sendo testado (estamos testando se o nosso código retorna oquadrado de dois)。您可以使用比较功能assertEqual来查找功能，然后进行操作，如 4 所示。

class TestSquare(TestCase):
    def test_if_returns_square_of_2(self):
        result = square(2)
        expected = 4

        self.assertEqual(result, expected)

注：修复 que o nome da classe eo cenário começam palavra“测试”。 O nome "test" é obrigatório ser iniciado para as funções de teste, mas opcionais para a classe (no entanto é recomendado por questões de clareza)。

为此，请使用main()进行单元测试或使用 python 来执行。

if __name__ == '__main__':
    main()

Para rodar o exemplo basta rodar como um arquivo python normalmente (no meu caso eu salvei em um arquivo my_first_test.py)

python my_first_test.py

没有控制台，请执行 1 次测试，然后状态正常，然后再测试。

Vamos 模拟错误测试场景的结尾

from unittest import main, TestCase

def square(x):
    return x ** 2

class TestSquare(TestCase):
    def test_if_returns_square_of_2(self):
        result = square(2)
        expected = 4

        self.assertEqual(result, expected)

    def test_if_returns_square_of_4(self):
        result = square(4)
        expected = 4

        self.assertEqual(result, expected)

if __name__ == '__main__':
    main()

新执行或后续操作：

修复测试方案test_if_returns_square_of_4执行中没有总共 2 个睾丸的辅助操作，并调整该方案。启动 16 号旋转功能后，将在 4 号旋转中获得有效效果。

请注意以下事项：

from unittest import main, TestCase

def square(x):
    return x ** 2

class TestSquare(TestCase):
    def test_if_returns_square_of_2(self):
        result = square(2)
        expected = 4

        self.assertEqual(result, expected)

    def test_if_returns_square_of_4(self):
        result = square(4)
        expected = 16

        self.assertEqual(result, expected)

if __name__ == '__main__':
    main()

观察：睾丸不存在明显的问题，因为没有任何主要因素，所以睾丸本身可能会出现错误。开发者始终验证测试是在escritto 中进行的，并且是真实的测试或实际情况。

观察 2：注意计算或数字之外存在的形式。没有任何例子x*x表明计算结果与x ** 2睾丸的结果有关。我们将继续执行新的场景。

我们测试并羡慕它的形式和实现。如果您的睾丸恢复正常，请确保睾丸与前部的睾丸保持一致。

Refatoração² é o efeito de você mudar a Implementação do código sem afetar o seu retorno (comportamento externo)。一个实施组织、实施和改进的形式的工具。

注意： 与睾丸的主要成分不同，veremos isso no próximo exemplo。

4.2 分割检测

例如，我们可以检测到分区的功能。可能的情况是这样的，但如果没有的话，也可能会发生这样的情况。

Essa função está armazenada dentro de um arquivo chamado division_detect.py

def division_detect(numerator: int, denominator: int) -> bool:
    if numerator / denominator:
        return True
    return False

代码 4.2.1

Vamos escrever um cenário de testes para essa função. Para isso, vamos criar um arquivo chamado test_division_detect.py

注： Apesar dos testes rodarem Independente do nome do arquivo，é uma boa prática escrever o arquivo de teste começando com a palavra “test” assim como nossa classe。

O arquivo de teste possui o seguinte esqueleto：

from unittest import TestCase

class TestDivisionDetect(TestCase):

    def test_it_returns_true_if_division_by_number_is_successful(self):
        pass

代码 4.2.2

在测试过程中，您将获得division_detect成功true的功能。

一个问题： 哪些数字可以帮助您测试？随机数为 10 个分子和 2 个分母。重要的功能和比较、结果恢复和验证以及断言和assertTrue后续测试场景：

from unittest import TestCase

from division_detect import division_detect

class TestDivisionDetect(TestCase):
    def test_it_returns_true_if_division_by_number_is_successful(self):
        result = division_detect(
            numerator=10, denominator=2
        )
        self.assertTrue(result)

代码 4.2.3

没有测试，请考虑有效的划分10/2。

Vamos rodar 或 arquivo de teste com 或 comando abaixo：

python -m unittest test_division_detect.py

Como sabemos，o resultado da operação é 5 e bool(5)verdadeiro

Veremos que um teste rodou eo resultado foi OK (o cenário de teste passou)

Mas，o que aconteceria se a gente mudasse o código main no arquivo division_detect.py para esse código:

def division_detect(numerator: int, denominator: int) -> bool:
    if numerator == 10:
        return True
    return False

代码 4.2.4

Claro que aqui estamos forçando um pouco a barra e alterando completamente a lógica do codigo prime, ma se os testes forem executados novamente o teste vai passar.

请注意，我们不保证您的测试结果是正确的。保证所有数字都可以从分子到分母进行任意分配。 Python 的使用方法randint

from random import randint
from unittest import TestCase

from division_detect import division_detect

class TestDivisionDetect(TestCase):
    def test_it_returns_true_if_division_by_number_is_successful(self):
        result = division_detect(
            numerator=randint(0, 100000), denominator=randint(0, 100000)
        )
        self.assertTrue(result)

代码 4.2.5

修复 0 和 100000 中的数字或分母，并执行 novamente 或 arquivo Division_detect.py写入Código 4.2.4中，然后将其写入未通过的代码。 Vamos voltar 或 código para que fique 或 mesmo do Código 4.2.1。

Olhando novamente para o cenário de teste，o que aconteceria se o deminador sorteado fosse 0？

É，aqui temos um Problema。零和不确定的数字划分！*

*零的划分是无限和无限的操作。

Vamos adicionar um novo cenário de teste para validar isso, dessa vez forçar que o deminador seja zero.

from random import randint
from unittest import TestCase

from division_detect import division_detect

class TestDivisionDetect(TestCase):
    def test_it_returns_true_if_division_by_number_is_successful(self):
        result = division_detect(
            numerator=randint(0, 100000), denominator=randint(0, 100000)
        )
        self.assertTrue(result)

    def test_it_returns_false_if_division_by_number_is_not_possible(self):
        result = division_detect(numerator=randint(0, 100000), denominator=0)
        self.assertFalse(result)

代码 4.2.6

Rodando novamente esse arquivo de testes, vamos receber o seguinte retorno

修复执行的睾丸孔，或与睾丸中的一些情况相关的信息。 Mas um dos testes，o test_it_returns_false_if_division_by_number_is_not_possible，falhou。这是一个错误ZeroDivisionError（https://docs.python.org/3/library/exceptions.html#ZeroDivisionError）。

如果是主要情况，请注意不要发生任何错误。如果激光雷达出现错误，请使用Python 的 try/ except 语句。

def division_detect(numerator: int, denominator: int) -> bool:
    try:
        numerator / denominator
    except ZeroDivisionError:
        return False
    else:
        return True

代码 4.2.7

没有任何最初的想法会影响到所有参数的划分，因此，如果您想重新进行操作True，ZeroDivisionError请先进行操作Falso。

Rodando novamente os testes com python -m unittest test_division_detect.pyvamos ver que os dois cenários passaram.

注：修复原始代码，为零做好准备。这是一个极端的情况，或者，您可以与世界各地的人联系。这是一个与 Python 类似的附加说明。

没有测试证明，所有的测试结果都是如此，重复的测试结果randint(0, 100000)。如果您想测试所有测试项目的编号，请使用setUp()( https://docs.python.org/3/library/unittest.html#unittest.TestCase.setUp ) 来启动测试。

最后，请注意以下事项：

from random import randint
from unittest import TestCase

from division_detect import division_detect

class TestDivisionDetect(TestCase):
    def setUp(self) -> None:
        self.random_numerator = randint(0, 100000)

    def test_it_returns_true_if_division_by_number_is_successful(self):
        result = division_detect(
            numerator=self.random_numerator, denominator=randint(1, 100000)
        )
        self.assertTrue(result)

    def test_it_returns_false_if_division_by_number_is_not_possible(self):
        result = division_detect(numerator=self.random_numerator, denominator=0)
        self.assertFalse(result)

修复第 1 个和 100000 号中的第一个分值，以确保在一个分区上有效。

5. 附加考虑因素

Aqui，请列出以下内容：

• 征服者的区别：Mantenha a estrutura de arquivosorganizadas。 Se um projeto é grande, é semper uma boa prática dividir em arquivos menores (isso facilita a manutenção e Legibilidade)
• Um teste também deve ser limpo igual ao códigoprincipal (Clean Code - Robert C. Martin)
• 使用 nomes descritivos para 作为 funções de teste, mesmo que seja um nome muito longo
• 思考一些极端情况 (cenários fora do padrão esperado)，igual fizemos na divisão por zero no exemplo 2
• Um teste não deve engessar a Implementação do seu código, igual vimos no exemplo 1 (oquadrado de um número pode ser feito de duas formas)
• Escrever em pequenas unidades ajudam a testar o código ea melhorar sua clareza
• Refatore: Semper que puder melhorar seu código melhore! (Lema de escoteiro)

De acordo com a PEP20 ³:

错误绝不应该悄无声息地过去。

PEP³（英语（Python 增强提案））请参考 Python 的最佳形式的提案：https://www.python.org/dev/peps/

6. 结论

睾丸是确保其恢复程序或结果 的保证。 Além disso, garante maior qualidade no produto que está sendo entregue.睾丸是一种设备，涉及一系列应用场景和针对特定场景的设备。 Testando nosso código，conseguimos encontrar também maneiras de deixar nosso código mais limpo e conso，facilitando assim na manutenção futura ea evitar bugs que possam ocorrer。 É melhor um teste pegue o erro do que o cliente usando o seu produto :)

这是 Python 的第一个睾丸系列，它是关于 Python 的主要介绍和简介，并且是公开的。 Dúvidas podem ser colocadas no commentário and lembre-se que testar faz processo de processo de um bom codigo, segundo o Programador Pete Goodliffe

“Um bom có​​digo não rush do nada。[...]Para ter um bom có​​digo é preciso trabalhar nele。Arduamente。E você só terá um código bom se realmente se importar com có​​digos bons。”

Como Ser Um Programador Melhor: um Manual Para Programadores que se Importam com Código (Pete Goodliffe)