Initial commit

Author: vladisnut

.gitignore

@@ -0,0 +1,29 @@
+# JetBrains IDE specific files:
+.idea/
+*.iml
+*.ipr
+*.iws
+
+# Python specific:
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environment:
+venv/
+env/
+.venv/
+
+# Environments:
+.env
+.venv
+
+# VS Code:
+.vscode/
+
+# Database files:
+*.db
+*.sqlite
+
+# Log files:
+*.log

main.py

@@ -0,0 +1,18 @@
+from settings import TEST_TYPE
+from testing.general import testing
+from testing.test_type import TestType
+
+
+def main():
+    """
+    Тесты должны быть разделены хотя бы одной пустой строкой.
+    Первые N строк теста – входные параметры тестируемой функции.
+    (N + 1)-я строка содержит ожидаемое возвращаемое значение
+    тестируемой функции (необязательно).
+    """
+    with open('tests.txt', 'r', encoding='utf-8') as f:
+        testing(getattr(TestType, TEST_TYPE.upper()), f.read())
+
+
+if __name__ == '__main__':
+    main()

settings.py

@@ -0,0 +1,12 @@
+# Тип тестирования: классический или через команды.
+# Значения: 'classic', 'commands'.
+TEST_TYPE = 'classic'
+
+# Показать время выполнения каждого теста.
+SHOW_EXECUTION_TIME = False
+
+# Выводить результат выполнения каждой команды в командном типе тестирования.
+DEBUG_COMMANDS = False
+
+# Указание ожидаемого результата теста обязательно.
+REQUIRED_EXPECTED_RESULT = False

solution.py

@@ -0,0 +1,13 @@
+from typing import List
+
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        index_map = {}
+
+        for i, num in enumerate(nums):
+            complement = target - num
+            if complement in index_map:
+                return [index_map[complement], i]
+
+            index_map[num] = i

testing/abstract_test.py

@@ -0,0 +1,31 @@
+from abc import abstractmethod
+from typing import Sequence
+
+from testing.result import Result
+
+
+class AbstractTest:
+    """
+    Абстрактный класс типа тестирования.
+    """
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    @classmethod
+    @abstractmethod
+    def parse(cls, lines: Sequence) -> tuple['AbstractTest', list]:
+        """
+        :param lines: Строки данных одного теста.
+        Каждый элемент перечисляется через запятую.
+        """
+        pass
+
+    @abstractmethod
+    def run(self) -> Result:
+        """
+        Выполнить тест.
+
+        :return: Объект результата теста.
+        """
+        pass

testing/classic_test.py

@@ -0,0 +1,58 @@
+import copy
+import time
+from typing import Sequence
+
+from settings import REQUIRED_EXPECTED_RESULT
+from testing.abstract_test import AbstractTest
+from testing.result import Result
+from testing.general import proc_args_by_func, Solution, proc_result, solution_method_names, get_params_signature, \
+    TestDataError
+
+
+class ClassicTest(AbstractTest):
+    """
+    Классический класс тестирования.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.__args = args
+        self.__kwargs = kwargs
+
+    @classmethod
+    def parse(cls, lines: Sequence) -> tuple[AbstractTest, list]:
+        """
+        1..N строки: Аргументы (в каждой строке свой аргумент).
+        N+1 строка: Ожидаемое значение (необязательно).
+        N – количество параметров тестируемой функции.
+        """
+        func = getattr(Solution(), solution_method_names[0])
+        count_params = len(get_params_signature(func))
+        if len(lines) < count_params:
+            raise TestDataError('Incorrect number of arguments')
+
+        args = lines[:count_params]
+        expected = lines[count_params] if len(lines) > count_params else None
+
+        if REQUIRED_EXPECTED_RESULT and not expected:
+            raise TestDataError('Expected result not specified')
+
+        args = proc_args_by_func(args, func)
+
+        return cls(*args), expected
+
+    def run(self):
+        args = copy.deepcopy(self.__args)
+        kwargs = copy.deepcopy(self.__kwargs)
+
+        start_time = time.time()
+        solution = Solution()
+        func = getattr(solution, solution_method_names[0])
+        result = func(*args, **kwargs)
+
+        return Result(
+            proc_result(result),
+            time.time() - start_time,
+            *self.__args,
+            **self.__kwargs
+        )

testing/command_test.py

@@ -0,0 +1,79 @@
+import copy
+import sys
+import time
+from typing import Sequence
+
+from settings import DEBUG_COMMANDS, REQUIRED_EXPECTED_RESULT
+from testing.abstract_test import AbstractTest
+from testing.result import Result
+from testing.general import TestDataError, proc_args_by_func
+from utils.style import Style
+
+
+class CommandTest(AbstractTest):
+    """
+    Класс тестирования для команд
+    (когда нужно создать объект тестируемого класса и вызывать его методы).
+    """
+
+    def __init__(self, commands, args_list, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.__commands = commands
+        self.__args_list = args_list
+
+    @classmethod
+    def parse(cls, lines: Sequence) -> tuple[AbstractTest, list]:
+        """
+        1 строка: Список строковых команд
+        (первая – название класса из файла solution.py, остальные – названия методов).
+        2 строка: Списки аргументов каждой команды.
+        3 строка: Список ожидаемых значений для каждой команды (необязательно).
+        """
+        if len(lines) not in (2, 3):
+            raise TestDataError('Incorrect data format')
+
+        commands = lines[0]
+        args_list = lines[1]
+        expectations = lines[2] if len(lines) >= 3 else None
+
+        if REQUIRED_EXPECTED_RESULT and not expectations:
+            raise TestDataError('Expected result not specified')
+
+        return cls(commands, args_list), expectations
+
+    def run(self):
+        if (not isinstance(self.__commands, list) or
+                tuple(x for x in self.__commands if not isinstance(x, str))):
+            raise TestDataError('Incorrect command format: commands must be a list of strings')
+
+        if not isinstance(self.__args_list, list):
+            raise TestDataError('Incorrect command argument format: arguments must be in a list')
+
+        try:
+            cls = getattr(sys.modules['solution'], self.__commands[0])
+        except AttributeError:
+            raise NameError(self.__commands[0])
+
+        commands = copy.deepcopy(self.__commands)
+        args_list = copy.deepcopy(self.__args_list)
+
+        start_time = time.time()
+        obj = cls(*self.__args_list[0])
+        results = [None]
+
+        for command, args in zip(commands[1:], args_list[1:]):
+            func = getattr(obj, command)
+            args = proc_args_by_func(args, func)
+            result = func(*args)
+
+            if DEBUG_COMMANDS:
+                print(Style.BLUE + f'{command}({", ".join(map(str, args))}): {result}')
+
+            results.append(result)
+
+        return Result(
+            results,
+            time.time() - start_time,
+            self.__commands,
+            self.__args_list
+        )

testing/general.py

@@ -0,0 +1,132 @@
+import importlib
+import json
+from inspect import signature
+from types import FunctionType
+from typing import Type, Iterable
+
+from testing.abstract_test import AbstractTest
+from testing.result import Result
+from utils.list_node import ListNode, list_to_linked_list, linked_list_to_list
+from utils.style import Style
+from utils.tree_node import TreeNode, list_to_binary_tree, binary_tree_to_list
+
+
+SOLUTION_MODULE_NAME = 'solution'
+solution_module = importlib.import_module(SOLUTION_MODULE_NAME)
+
+Solution = tuple(v for v in vars(solution_module).values() if type(v) is type and v.__module__ == SOLUTION_MODULE_NAME)
+if not Solution:
+    raise NotImplementedError(f'Module {SOLUTION_MODULE_NAME} has no class')
+
+Solution = Solution[0]
+solution_method_names = tuple(
+    v.__name__ for v in Solution.__dict__.values()
+    if type(v) == FunctionType and v.__name__[0] != '_'
+)
+if not solution_method_names:
+    raise NotImplementedError(f'Class {Solution.__name__} from module {SOLUTION_MODULE_NAME} has no methods')
+
+
+class TestDataError(Exception):
+    def __init__(self, msg: str):
+        self.msg = msg
+        super().__init__()
+
+    def __str__(self):
+        return self.msg
+
+
+def get_params_signature(func):
+    return tuple(signature(func).parameters.items())
+
+
+def proc_args_by_func(args: Iterable, func) -> list:
+    proc_args = []
+    signatures = get_params_signature(func)
+
+    for arg, (_, param_type) in zip(args, signatures):
+        if ListNode.__name__ in str(param_type):
+            if isinstance(arg, list):
+                if len(arg) and isinstance(arg[0], list):
+                    arg = [list_to_linked_list(el) or [] for el in arg]
+                else:
+                    arg = list_to_linked_list(arg) or []
+
+        if TreeNode.__name__ in str(param_type):
+            if isinstance(arg, list):
+                if len(arg) and isinstance(arg[0], list):
+                    arg = [list_to_binary_tree(el) or [] for el in arg]
+                else:
+                    arg = list_to_binary_tree(arg) or []
+
+        proc_args.append(arg)
+
+    return proc_args
+
+
+def proc_result(result):
+    if isinstance(result, ListNode):
+        return linked_list_to_list(result) or []
+
+    if isinstance(result, TreeNode):
+        return binary_tree_to_list(result) or []
+
+    return result
+
+
+def print_test_results():
+    style = Style.BOLD + Style.UNDERLINE
+    if Result.count_passed() == Result.count_runs():
+        style += Style.GREEN
+    else:
+        style += Style.YELLOW
+
+    print(f'{style}Tests passed: {Result.count_passed()}/{Result.count_runs()}')
+
+
+def testing(
+        cls: Type[AbstractTest],
+        tests_data: str
+):
+    """
+    Тестирование класса, находящегося в solution.py.
+
+    :param cls: Тестирующий класс.
+    :param tests_data: Текст с тестовыми данными.
+    Его парсинг определяется тестирующим классом.
+    """
+    lines = [line.strip() for line in tests_data.strip().splitlines()]
+    lines = [lines[i] for i in range(len(lines))
+             if i == 0 or not(lines[i] == '' and lines[i-1] == '')]
+
+    tests_data = '\n'.join(lines).split('\n\n')
+    for data in tests_data:
+        lines = [json.loads(line) for line in data.splitlines()]
+        obj, expected = cls.parse(lines)
+        obj.run().validate(expected)
+
+    print_test_results()
+
+
+def generate_and_testing(
+        cls: Type[AbstractTest],
+        generate_args_func,
+        validation_func,
+        count: int
+):
+    """
+    Генерация тестовых данных и тестирование ими класса,
+    находящегося в solution.py.
+
+    :param cls: Тестирующий класс.
+    :param generate_args_func: Функция генерации аргументов.
+    Ничего не принимает, возвращает итерируемый объект с аргументами.
+    :param validation_func: Функция валидации возвращенного результата.
+    Принимает результат работы функции, возвращает логическое значение.
+    :param count: Количество тестов.
+    """
+    for _ in range(count):
+        args = generate_args_func()
+        cls(*args).run().validate(validation_func)
+
+    print_test_results()