import unittest
import importlib
import re

# Helper function to dynamically generate test names and assertions
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message  # Rename the test for better readability
        test_case.assertTrue(True, success_message)  # Pass the test with a success message
    else:
        test_case._testMethodName = failure_message  # Rename the test with a failure description
        test_case.fail(failure_message)  # Fail the test with a failure message

class TestUserCode(unittest.TestCase):

    def setUp(self):
        # Reload the module to make sure we are testing the latest code
        self.module = importlib.import_module('user_code')
        importlib.reload(self.module)

    # Test if `remaining_tasks` is declared
    def test_remaining_tasks_is_declared(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'remaining_tasks'),
            "The `remaining_tasks` variable is declared.",
            "Expected `remaining_tasks` variable to be declared."
        )

    # Test if `required_time` is declared
    def test_required_time_is_declared(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'required_time'),
            "The `required_time` variable is declared.",
            "Expected `required_time` variable to be declared."
        )

    # Test if `remaining_tasks` is an integer
    def test_remaining_tasks_is_integer(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'remaining_tasks') and isinstance(self.module.remaining_tasks, int),
            "The `remaining_tasks` is of type `int`.",
            "Expected `remaining_tasks` to be of type `int`."
        )

    # Test if `required_time` is an integer
    def test_required_time_is_integer(self):
        _dynamic_test(
            self,
            hasattr(self.module, 'required_time') and isinstance(self.module.required_time, int),
            "The `required_time` is of type `int`.",
            "Expected `required_time` to be of type `int`."
        )

    # Test if `remaining_tasks` has the correct value
    def test_remaining_tasks_correct_value(self):
        completed = 60 // 7  # Completed transactions
        expected_value = 10 - completed  # Remaining tasks
        _dynamic_test(
            self,
            hasattr(self.module, 'remaining_tasks') and self.module.remaining_tasks == expected_value,
            f"The `remaining_tasks` is `{expected_value}`.",
            f"Expected `remaining_tasks` to be `{expected_value}`, but got `{getattr(self.module, 'remaining_tasks', 'undefined')}`."
        )

    # Test if `required_time` has the correct value
    def test_required_time_correct_value(self):
        expected_value = 10 * 7  # Total time needed for all transactions
        _dynamic_test(
            self,
            hasattr(self.module, 'required_time') and self.module.required_time == expected_value,
            f"The `required_time` is `{expected_value}`.",
            f"Expected `required_time` to be `{expected_value}`, but got `{getattr(self.module, 'required_time', 'undefined')}`."
        )

    # Test if subtraction is used for `remaining_tasks`
    def test_subtraction_used_for_remaining_tasks(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'remaining_tasks\s*=\s*10\s*-\s*[\w_]+', user_code_source),
            "Subtraction is used for `remaining_tasks`.",
            "Expected subtraction to be used for `remaining_tasks`."
        )

    # Test if multiplication is used for `required_time`
    def test_multiplication_used_for_required_time(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'required_time\s*=\s*10\s*\*\s*7', user_code_source),
            "Multiplication is used for `required_time`.",
            "Expected multiplication to be used for `required_time`."
        )

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

test_main.py

Neste curso iremos nos aprofundar nos tipos de dados e seus usos. Aqui você aprenderá operações básicas e todos os detalhes sobre números, dados booleanos e strings. Este curso consiste em uma série de tarefas práticas, após as quais você se tornará um programador habilidoso.

Os tipos de dados numéricos são cruciais em Python, por isso é importante começar por eles. Aqui você trabalhará com operações matemáticas simples e descobrirá o propósito de aprender diferentes tipos de dados numéricos.






O principal objetivo desta seção é esclarecer os tipos de dados booleanos; é um subtipo de dados numéricos, mas um pouco mais desafiador. Como sempre é bom se destacar nos tópicos mais difíceis, esta seção é uma parte valiosa do seu currículo.

As strings são uma maneira de implementarmos frases em Python, ou seja, de fornecer instruções aos usuários que são o público-alvo do seu programa. De fato, é sempre melhor poder trabalhar com strings, pois elas devem ser utilizadas no seu código. Você entenderá o motivo em breve.

Este capítulo consiste em tarefas práticas que combinam todos os tópicos examinados juntamente com um pouco de teoria.

Tipos de Dados em Python

Challenge: Time Calculation in Python

Solução

Challenge: Time Calculation in Python

Solução