import unittest
import importlib
import re

class TestUserCode(unittest.TestCase):

    def setUp(self):
        # Import the user's code as a module
        self.module = importlib.import_module('user_code')

    def test_remaining_tasks_is_declared(self):
        """Check if `remaining_tasks` variable is declared"""
        self.assertTrue(hasattr(self.module, 'remaining_tasks'), 
                        "Expected `remaining_tasks` variable to be declared.")

    def test_required_time_is_declared(self):
        """Check if `required_time` variable is declared"""
        self.assertTrue(hasattr(self.module, 'required_time'), 
                        "Expected `required_time` variable to be declared.")

    def test_remaining_tasks_is_integer(self):
        """Check if `remaining_tasks` is an integer"""
        self.assertIsInstance(self.module.remaining_tasks, int, 
                              "Expected `remaining_tasks` to be an integer.")

    def test_required_time_is_integer(self):
        """Check if `required_time` is an integer"""
        self.assertIsInstance(self.module.required_time, int, 
                              "Expected `required_time` to be an integer.")

    def test_remaining_tasks_correct_value(self):
        """Check if `remaining_tasks` has the correct value"""
        completed = 60 // 7  # Completed transactions
        expected_value = 10 - completed  # Remaining tasks
        self.assertEqual(self.module.remaining_tasks, expected_value, 
                         f"Expected `remaining_tasks` to be `{expected_value}`.")

    def test_required_time_correct_value(self):
        """Check if `required_time` has the correct value"""
        expected_value = 10 * 7  # Total time needed for all transactions
        self.assertEqual(self.module.required_time, expected_value, 
                         f"Expected `required_time` to be `{expected_value}`.")

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

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

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

test_main.py

This course is going to help you dive deeper into data types and try to work with them. Here you will learn basic operations and all ins and outs of numbers, boolean data type, and strings. This course consists of a lot of practical tasks after which you will become a skillful programmer.

Numerical data types are fundamental in Python, forming the backbone of many computational tasks. In this section, you'll dive into the essentials of working with integers and floating-point numbers, performing basic mathematical operations, and understanding the real-world applications of numerical data. You'll also explore critical concepts such as immutability and gain hands-on experience with Python’s built-in functions and tools for handling numbers effectively.

The main goal of this section is to clarify the boolean data types; it's a sub type of numeric data, but indeed it is more challenging. Since it is always better to excel in the more difficult topics, this section is a valuable part of your curriculum.

Strings are a way for us to implement your phrases in Python, that is, to give instructions to users who are the target audience of your program. Indeed, it is always better to be able to work with strings because they should be used in your code. You'll understand why soon.

This chapter consists of practical tasks that combine all the examined topics together with a bit of theory.

Challenge: Time Calculation in Python

Ratkaisu

Challenge: Time Calculation in Python

Ratkaisu