import unittest
import importlib
import re

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestPriceRounding(unittest.TestCase):

    def test_prices_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'prices'),
            "The `prices` tuple is declared.",
            "Expected `prices` to be declared."
        )

    def test_final_prices_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'final_prices'),
            "The `final_prices` list is declared.",
            "Expected `final_prices` to be declared."
        )

    def test_rounded_prices_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'rounded_prices'),
            "The `rounded_prices` list is declared.",
            "Expected `rounded_prices` to be declared."
        )

    def test_final_prices_correct_values(self):
        import user_code
        expected_final_prices = [round(price, 2) for price in user_code.prices]
        _dynamic_test(
            self,
            user_code.final_prices == expected_final_prices,
            "The `final_prices` list contains correctly rounded values (to 2 decimal places).",
            f"Expected `final_prices` to be `{expected_final_prices}`, but got `{user_code.final_prices}`."
        )

    def test_rounded_prices_correct_values(self):
        import user_code
        expected_rounded_prices = [round(price) for price in user_code.prices]
        _dynamic_test(
            self,
            user_code.rounded_prices == expected_rounded_prices,
            "The `rounded_prices` list contains correctly rounded values (to nearest whole number).",
            f"Expected `rounded_prices` to be `{expected_rounded_prices}`, but got `{user_code.rounded_prices}`."
        )

    def test_for_loop_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'for', user_code_source),
            "The `for` loop is used to iterate over `prices`.",
            "Expected a `for` loop iterating over `prices`."
        )

    def test_round_function_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'round\(\s*\w+\s*,\s*2\s*\)', user_code_source) and re.search(r'round\(\s*\w+\s*\)', user_code_source),
            "The `round()` function is used for both rounding methods.",
            "Expected `round()` to be used for rounding prices to 2 decimal places and to the nearest whole number."
        )

if __name__ == '__main__':
    unittest.main()


test_main.py

Python é uma linguagem de programação interpretada de alto nível e de uso geral. Diferente de HTML, CSS e JavaScript, que são primariamente utilizados para desenvolvimento web, Python é versátil e pode ser usado em diversos campos, incluindo desenvolvimento de software, ciência de dados e desenvolvimento back-end. Neste curso, você explorará os aspectos centrais do Python, e ao final, estará criando suas próprias funções!

Nesta seção, você mergulhará nos fundamentos do Python, se familiarizará com seu ambiente de trabalho, lidará com operações matemáticas simples e exibirá seus resultados.

Aqui, você aprenderá como armazenar itens como números e texto na memória do computador, recuperando-os pelo nome. Você também terá uma noção de manipulação de texto em Python.

Aqui, você se aprofundará no tipo de dados booleano e descobrirá sua função na criação de programas que respondem a condições específicas.

Continuando com os tipos de dados, esta seção ensinará como agrupar atributos variados dentro de uma única variável usando listas, tuplas e dicionários.

Nesta parte, você vai dominar a arte de escrever loops em Python - construções essenciais para iterar sobre listas, tuplas, dicionários e até mesmo dataframes futuros.

Para terminar o nosso curso introdutório, vamos explorar algumas funções incorporadas e, em seguida, começar a criar as suas próprias funções!

Desafio: Convertendo Alturas

Solução

Awesome!

Desafio: Convertendo Alturas

Solução