Big refactoring. Fixed several bugs. Removed sensitive data

Author: Ryize

main.py

@@ -3,8 +3,8 @@
 Пример программы:
 
 if __name__ == '__main__':
-    stress = StressTest('https://coursemc.space')
-    stress.timeout = 0.1
+    stress = StressTest('http://127.0.0.1:8000')
+    stress.timeout = 0.5
     stress.max_execution_time = 60
     stress.max_thread_count = 100
     monitor = ChartMonitor(stress)
@@ -16,9 +16,9 @@
     from stress_test import StressTest
     from monitor import ChartMonitor
 
-    stress = StressTest('https://coursemc.space')
-    stress.timeout = 0.1
-    stress.max_execution_time = 60
+    stress = StressTest('http://127.0.0.1:8000')
+    stress.timeout = 0.5
+    stress.max_execution_time = 10
     stress.max_thread_count = 100
     monitor = ChartMonitor(stress)
     monitor.start()

monitor.py

@@ -1,4 +1,5 @@
 import time
+from statistics import mean
 from typing import Optional, Union, Tuple
 
 from matplotlib import pyplot as plt
@@ -11,25 +12,49 @@ class BaseMonitor(AbstractMonitor):
     def __init__(self, stress: AbstractStressTest):
         self._stress = stress
 
-    def start(self, timeout: Union[int, float] = 0.2):
+    def start(self, timeout: Union[int, float] = 0.2) -> None:
+        """
+        Запускает тест.
+        :param timeout: Union[int, float] (время задержки, используется при создании потоков и отправки запросов)
+        :return: None
+        """
         self._stress.auto_create_connection()
         for _ in self._stress.auto_get_stats(timeout):
-            print(f'Запросов всего: {len(self._stress.stats)}')
+            print(f'Всего запросов: {len(self._stress.stats)}')
 
     def set_params(self, kill: Optional[bool] = None, timeout: Optional[Union[float, int]] = None,
-                   max_thread_count: Optional[int] = None, max_execution_time: Optional[int] = None):
+                   max_thread_count: Optional[int] = None, max_execution_time: Optional[int] = None) -> None:
+        """
+        Устанавливает параметры стресс-теста.
+        :param kill: bool (True - убить потоки, False - продолжить тестирование)
+        :param timeout: Union[int, float] (время задержки, используется при создании потоков и отправки запросов)
+        :param max_thread_count: int (максимальное кол-во потоков,
+        реальное кол-во может незначительно отличаться от заданного)
+        :param max_execution_time: int (максимальное время выполнения теста)
+        :return: None
+        """
         self._stress.kill = kill or self._stress.kill
         self._stress.timeout = timeout or self._stress.timeout
         self._stress.max_thread_count = max_thread_count or self._stress.max_thread_count
         self._stress.max_execution_time = max_execution_time or self._stress.max_execution_time
 
-    def stop(self):
+    def stop(self) -> None:
+        """
+        Останавливает работу теста и запускает построение статистики.
+        :return: None
+        """
         self._stress.kill_all_connections()
         self.build_graph()
 
 
 class ChartMonitor(BaseMonitor):
-    def build_graph(self):
+    def build_graph(self) -> None:
+        """
+        Построить статистику в виде графика. Используется matplotlib.
+        Первый график - зависимость времени выполнения запроса от кол-ва запросов.
+        Второй график - зависимость кол-ва ошибок от кол-ва запросов.
+        :return: None
+        """
         stats = sorted(self._stress.stats.items(), key=lambda i: i[0])
         x_time_request = list(map(lambda i: round(time.time() - i[0], 4), stats))
         y_time_request = list(map(lambda i: round(i[1], 4), stats))
@@ -42,6 +67,14 @@ def build_graph(self):
         plt.show()
 
     def _get_x_y_error_coord(self) -> Tuple[list, list]:
+        """
+        Получение кортежа с координатами ошибок x, y.
+        tuple[0] - list (координата x)
+        tuple[1] - list (координата y)
+        В качестве координат x, идёт время, когда проищошла ошибка.
+        В качестве координат y, идёт кол-во ошибок, которое проищошло за время указанное в x (по умолчанию за 1 секунду)
+        :return: Tuple[list, list]
+        """
         res = [[]]
         x_error = y_error = []
         if len(self._stress.errors) > 0:
@@ -57,12 +90,22 @@ def _get_x_y_error_coord(self) -> Tuple[list, list]:
                     res.append([i])
                     back = i[0]
             # Получаем время когда проихошла ошибка
-            x_error = list(map(lambda i: round(time.time() - i, 4), [i[0][0] for i in res]))
+            x_error = list(map(lambda el: round(time.time() - el, 4), [i[0][0] for i in res]))
             # Получаем кол-во ошибок
             y_error = [len(i) for i in res]
         return x_error, y_error
 
-    def _draw_plot(self, x: list, y: list, coord: Optional[list] = None, title: Optional[str] = None, color: str = 'b'):
+    def _draw_plot(self, x: list, y: list, coord: Optional[list] = None, title: Optional[str] = None,
+                   color: str = 'b') -> None:
+        """
+        Строит график по указанным координатам x, y.
+        :param x: list (координаты x (работает при условии len(x) == len(y)))
+        :param y: list (координаты y (работает при условии len(x) == len(y)))
+        :param coord: Optional[list] (координаты разбивания графика (matplotlib.subplot))
+        :param title: Optional[str] (название графика (matplotlib.title))
+        :param color: str (цвет графика)
+        :return: None
+        """
         if coord:
             plt.subplot(*coord)
         plt.plot(x, y, c=color)
@@ -72,7 +115,12 @@ def _draw_plot(self, x: list, y: list, coord: Optional[list] = None, title: Opti
 
 
 class CMDMonitor(BaseMonitor):
-    def start(self, timeout: Union[int, float] = 0.2):
+    def start(self, timeout: Union[int, float] = 0.2) -> None:
+        """
+        Запускает тест, отобрадение статистики происходит в терминале.
+        :param timeout: Union[int, float] (время задержки, используется при создании потоков и отправки запросов)
+        :return: None
+        """
         self._stress.auto_create_connection()
         for i in self._stress.auto_get_stats(0.2):
             if isinstance(i, int):
@@ -82,12 +130,19 @@ def start(self, timeout: Union[int, float] = 0.2):
             print(f'Запросов всего: {len(self._stress.stats)}')
             print(f'Ошибок: {len(self._stress.errors)}', end='\n\n\n')
 
-    def build_graph(self):
+    def build_graph(self) -> None:
+        """
+        Строит график в терминале.
+        Параметры вывода:
+        1) Всего потоков
+        2) Всего запросов
+        3) Среднее время на запрос
+        4) Всего ошибок
+        :return: None
+        """
         stats = self._stress.stats.items()
-        total_runtime = 0
-        for i in stats:
-            total_runtime += i[1]
+        average_time_per_request = mean([i[1] for i in stats])
         print(f'\n\n\nВсего потоков: {len(self._stress.thread)}')
         print(f'Всего запросов: {len(stats)}')
-        print(f'Среднее время на запрос: {len(stats) / total_runtime}')
+        print(f'Среднее время на запрос: {average_time_per_request}')
         print(f'Всего ошибок: {len(self._stress.errors)}', end='\n\n\n')

stress_test.py

@@ -1,13 +1,11 @@
 import time
 import threading
 import warnings
-from pprint import pprint
 from typing import Optional, NoReturn, Union
 
 import requests
 
 from abstarct.stress_test import AbstractStressTest
-from monitor import ChartMonitor, CMDMonitor
 
 
 class StressTest(AbstractStressTest):
@@ -142,7 +140,7 @@ def _start_connection_stress_test(self, connection_type: str) -> None:
             self._check_response_status_code(response)
             time.sleep(self._timeout)
 
-    def _check_response_status_code(self, response):
+    def _check_response_status_code(self, response) -> None:
         """
         Если код ответа != 200, записывает в self._errors
         (см. в __init__, что записывается в self._errors).
@@ -181,7 +179,11 @@ def _get_runtime(func, *args, **kwargs) -> tuple:
         response = func(*args, **kwargs)
         return response, time.time() - time_start
 
-    def _get_last_number_errors(self):
+    def _get_last_number_errors(self) -> int:
+        """
+        Получить последние ошибки.
+        :return: None
+        """
         result = len(self._errors) - self._previous_count_errors
         self._previous_count_errors = len(self._errors)
         return result
@@ -216,6 +218,11 @@ def max_execution_time(self) -> Union[int, float]:
 
     @max_execution_time.setter
     def max_execution_time(self, value: Union[int, float]) -> None:
+        """
+        Устанавливает максимальное время тестирования.
+        :param value: Union[int, float](value >= 0)
+        :return: None
+        """
         if not isinstance(value, (int, float)) or value <= 0:
             raise ValueError('Значение max_execution_time может быть только типа int, float > 0')
         self._max_execution_time = value
@@ -228,8 +235,7 @@ def max_thread_count(self):
     def max_thread_count(self, value: int):
         """
         Устанавливает максимальное кол-во потоков.
-        Должно быть int и > 20.
-        :param value: int
+        :param value: int (value > 20)
         :return: None
         """
         if not isinstance(value, int) or value != abs(value) or value < 20: