locust 2.20.1.dev28__py3-none-any.whl → 2.20.2__py3-none-any.whl

locust/stats.py

@@ -1,47 +1,44 @@
 from __future__ import annotations
-from abc import abstractmethod
+
+import csv
 import datetime
 import hashlib
 import json
-from tempfile import NamedTemporaryFile
-import time
-from collections import namedtuple, OrderedDict
-from copy import copy
-from itertools import chain
+import logging
 import os
-import csv
 import signal
-import gevent
+import time
+from abc import abstractmethod
+from collections import OrderedDict, namedtuple
+from copy import copy
 from html import escape
-from .util.rounding import proper_round
-
+from itertools import chain
+from tempfile import NamedTemporaryFile
+from types import FrameType
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
+    Callable,
     Iterable,
     NoReturn,
-    Tuple,
-    List,
-    Optional,
-    OrderedDict as OrderedDictType,
-    Callable,
-    TypeVar,
-    cast,
     Protocol,
     TypedDict,
+    TypeVar,
+    cast,
+)
+from typing import (
+    OrderedDict as OrderedDictType,
 )
 
-from types import FrameType
+import gevent
 
-from .exception import CatchResponseError
 from .event import Events
-
-import logging
+from .exception import CatchResponseError
+from .util.rounding import proper_round
 
 if TYPE_CHECKING:
-    from .runners import Runner
     from .env import Environment
+    from .runners import Runner
 
 console_logger = logging.getLogger("locust.stats_logger")
 
@@ -66,18 +63,18 @@ class StatsBaseDict(TypedDict):
 
 
 class StatsEntryDict(StatsBaseDict):
-    last_request_timestamp: Optional[float]
+    last_request_timestamp: float | None
     start_time: float
     num_requests: int
     num_none_requests: int
     num_failures: int
     total_response_time: int
     max_response_time: int
-    min_response_time: Optional[int]
+    min_response_time: int | None
     total_content_length: int
-    response_times: Dict[int, int]
-    num_reqs_per_sec: Dict[int, int]
-    num_fail_per_sec: Dict[int, int]
+    response_times: dict[int, int]
+    num_reqs_per_sec: dict[int, int]
+    num_fail_per_sec: dict[int, int]
 
 
 class StatsErrorDict(StatsBaseDict):
@@ -93,7 +90,7 @@ class StatsHolder(Protocol):
 S = TypeVar("S", bound=StatsHolder)
 
 
-def resize_handler(signum: int, frame: Optional[FrameType]):
+def resize_handler(signum: int, frame: FrameType | None):
     global STATS_NAME_WIDTH
     if STATS_AUTORESIZE:
         try:
@@ -119,18 +116,17 @@ HISTORY_STATS_INTERVAL_SEC = 5
 CSV_STATS_INTERVAL_SEC = 1
 CSV_STATS_FLUSH_INTERVAL_SEC = 10
 
-
 """
 Default window size/resolution - in seconds - when calculating the current
 response time percentile
 """
 CURRENT_RESPONSE_TIME_PERCENTILE_WINDOW = 10
 
-
 CachedResponseTimes = namedtuple("CachedResponseTimes", ["response_times", "num_requests"])
 
 PERCENTILES_TO_REPORT = [0.50, 0.66, 0.75, 0.80, 0.90, 0.95, 0.98, 0.99, 0.999, 0.9999, 1.0]
 
+PERCENTILES_TO_STATISTICS = [0.95, 0.99]
 PERCENTILES_TO_CHART = [0.50, 0.95]
 MODERN_UI_PERCENTILES_TO_CHART = [0.95]
 
@@ -139,7 +135,7 @@ class RequestStatsAdditionError(Exception):
     pass
 
 
-def get_readable_percentiles(percentile_list: List[float]) -> List[str]:
+def get_readable_percentiles(percentile_list: list[float]) -> list[str]:
     """
     Converts a list of percentiles from 0-1 fraction to 0%-100% view for using in console & csv reporting
     :param percentile_list: The list of percentiles in range 0-1
@@ -151,7 +147,7 @@ def get_readable_percentiles(percentile_list: List[float]) -> List[str]:
     ]
 
 
-def calculate_response_time_percentile(response_times: Dict[int, int], num_requests: int, percent: float) -> int:
+def calculate_response_time_percentile(response_times: dict[int, int], num_requests: int, percent: float) -> int:
     """
     Get the response time that a certain number of percent of the requests
     finished within. Arguments:
@@ -172,7 +168,7 @@ def calculate_response_time_percentile(response_times: Dict[int, int], num_reque
     return 0
 
 
-def diff_response_time_dicts(latest: Dict[int, int], old: Dict[int, int]) -> Dict[int, int]:
+def diff_response_time_dicts(latest: dict[int, int], old: dict[int, int]) -> dict[int, int]:
     """
     Returns the delta between two {response_times:request_count} dicts.
 
@@ -212,8 +208,8 @@ class RequestStats:
                                          is not needed.
         """
         self.use_response_times_cache = use_response_times_cache
-        self.entries: Dict[Tuple[str, str], StatsEntry] = EntriesDict(self)
-        self.errors: Dict[str, StatsError] = {}
+        self.entries: dict[tuple[str, str], StatsEntry] = EntriesDict(self)
+        self.errors: dict[str, StatsError] = {}
         self.total = StatsEntry(self, "Aggregated", None, use_response_times_cache=self.use_response_times_cache)
         self.history = []
 
@@ -253,7 +249,7 @@ class RequestStats:
             self.errors[key] = entry
         entry.occurred()
 
-    def get(self, name: str, method: str) -> "StatsEntry":
+    def get(self, name: str, method: str) -> StatsEntry:
         """
         Retrieve a StatsEntry instance by name and method
         """
@@ -278,12 +274,12 @@ class RequestStats:
         self.errors = {}
         self.history = []
 
-    def serialize_stats(self) -> List["StatsEntryDict"]:
+    def serialize_stats(self) -> list[StatsEntryDict]:
         return [
             e.get_stripped_report() for e in self.entries.values() if not (e.num_requests == 0 and e.num_failures == 0)
         ]
 
-    def serialize_errors(self) -> Dict[str, "StatsErrorDict"]:
+    def serialize_errors(self) -> dict[str, StatsErrorDict]:
         return {k: e.serialize() for k, e in self.errors.items()}
 
 
@@ -292,7 +288,7 @@ class StatsEntry:
     Represents a single stats entry (name and method)
     """
 
-    def __init__(self, stats: Optional[RequestStats], name: str, method: str, use_response_times_cache: bool = False):
+    def __init__(self, stats: RequestStats | None, name: str, method: str, use_response_times_cache: bool = False):
         self.stats = stats
         self.name = name
         """ Name (URL) of this stats entry """
@@ -313,15 +309,15 @@ class StatsEntry:
         """ Number of failed request """
         self.total_response_time: int = 0
         """ Total sum of the response times """
-        self.min_response_time: Optional[int] = None
+        self.min_response_time: int | None = None
         """ Minimum response time """
         self.max_response_time: int = 0
         """ Maximum response time """
-        self.num_reqs_per_sec: Dict[int, int] = {}
+        self.num_reqs_per_sec: dict[int, int] = {}
         """ A {second => request_count} dict that holds the number of requests made per second """
-        self.num_fail_per_sec: Dict[int, int] = {}
+        self.num_fail_per_sec: dict[int, int] = {}
         """ A (second => failure_count) dict that hold the number of failures per second """
-        self.response_times: Dict[int, int] = {}
+        self.response_times: dict[int, int] = {}
         """
         A {response_time => count} dict that holds the response time distribution of all
         the requests.
@@ -331,7 +327,7 @@ class StatsEntry:
 
         This dict is used to calculate the median and percentile response times.
         """
-        self.response_times_cache: Optional[OrderedDictType[int, CachedResponseTimes]] = None
+        self.response_times_cache: OrderedDictType[int, CachedResponseTimes] | None = None
         """
         If use_response_times_cache is set to True, this will be a {timestamp => CachedResponseTimes()}
         OrderedDict that holds a copy of the response_times dict for each of the last 20 seconds.
@@ -340,7 +336,7 @@ class StatsEntry:
         """ The sum of the content length of all the responses for this entry """
         self.start_time: float = 0.0
         """ Time of the first request for this entry """
-        self.last_request_timestamp: Optional[float] = None
+        self.last_request_timestamp: float | None = None
         """ Time of the last request for this entry """
         self.reset()
 
@@ -456,7 +452,7 @@ class StatsEntry:
             return 0
         slice_start_time = max(int(self.stats.last_request_timestamp) - 12, int(self.stats.start_time or 0))
 
-        reqs: List[int | float] = [
+        reqs: list[int | float] = [
             self.num_reqs_per_sec.get(t, 0) for t in range(slice_start_time, int(self.stats.last_request_timestamp) - 2)
         ]
         return avg(reqs)
@@ -497,7 +493,7 @@ class StatsEntry:
         except ZeroDivisionError:
             return 0
 
-    def extend(self, other: "StatsEntry") -> None:
+    def extend(self, other: StatsEntry) -> None:
         """
         Extend the data from the current StatsEntry with the stats from another
         StatsEntry instance.
@@ -545,7 +541,7 @@ class StatsEntry:
         return cast(StatsEntryDict, {key: getattr(self, key, None) for key in StatsEntryDict.__annotations__.keys()})
 
     @classmethod
-    def unserialize(cls, data: StatsEntryDict) -> "StatsEntry":
+    def unserialize(cls, data: StatsEntryDict) -> StatsEntry:
         """Return the unserialzed version of the specified dict"""
         obj = cls(None, data["name"], data["method"])
         valid_keys = StatsEntryDict.__annotations__.keys()
@@ -608,7 +604,7 @@ class StatsEntry:
         """
         return calculate_response_time_percentile(self.response_times, self.num_requests, percent)
 
-    def get_current_response_time_percentile(self, percent: float) -> Optional[int]:
+    def get_current_response_time_percentile(self, percent: float) -> int | None:
         """
         Calculate the *current* response time for a certain percentile. We use a sliding
         window of (approximately) the last 10 seconds (specified by CURRENT_RESPONSE_TIME_PERCENTILE_WINDOW)
@@ -626,13 +622,13 @@ class StatsEntry:
         # when trying to fetch the cached response_times. We construct this list in such a way
         # that it's ordered by preference by starting to add t-10, then t-11, t-9, t-12, t-8,
         # and so on
-        acceptable_timestamps: List[int] = []
+        acceptable_timestamps: list[int] = []
         acceptable_timestamps.append(t - CURRENT_RESPONSE_TIME_PERCENTILE_WINDOW)
         for i in range(1, 9):
             acceptable_timestamps.append(t - CURRENT_RESPONSE_TIME_PERCENTILE_WINDOW - i)
             acceptable_timestamps.append(t - CURRENT_RESPONSE_TIME_PERCENTILE_WINDOW + i)
 
-        cached: Optional[CachedResponseTimes] = None
+        cached: CachedResponseTimes | None = None
         if self.response_times_cache is not None:
             for ts in acceptable_timestamps:
                 if ts in self.response_times_cache:
@@ -685,6 +681,11 @@ class StatsEntry:
                 self.response_times_cache.popitem(last=False)
 
     def to_dict(self, escape_string_values=False):
+        response_time_percentiles = {
+            f"response_time_percentile_{percentile}": self.get_response_time_percentile(percentile)
+            for percentile in PERCENTILES_TO_STATISTICS
+        }
+
         return {
             "method": escape(self.method or "") if escape_string_values else self.method,
             "name": escape(self.name) if escape_string_values else self.name,
@@ -697,8 +698,9 @@ class StatsEntry:
             "current_rps": self.current_rps,
             "current_fail_per_sec": self.current_fail_per_sec,
             "median_response_time": self.median_response_time,
-            "ninetieth_response_time": self.get_response_time_percentile(0.9),
-            "ninety_ninth_response_time": self.get_response_time_percentile(0.99),
+            "ninetieth_response_time": self.get_response_time_percentile(0.9),  # for legacy ui
+            "ninety_ninth_response_time": self.get_response_time_percentile(0.99),  # for legacy ui
+            **response_time_percentiles,  # for modern ui
             "avg_content_length": self.avg_content_length,
         }
 
@@ -748,7 +750,7 @@ class StatsError:
         return f"{self.method} {self.name}: {unwrapped_error}"
 
     def serialize(self) -> StatsErrorDict:
-        def _getattr(obj: "StatsError", key: str, default: Optional[Any]) -> Optional[Any]:
+        def _getattr(obj: StatsError, key: str, default: Any | None) -> Any | None:
             value = getattr(obj, key, default)
 
             if key in ["error"]:
@@ -759,7 +761,7 @@ class StatsError:
         return cast(StatsErrorDict, {key: _getattr(self, key, None) for key in StatsErrorDict.__annotations__.keys()})
 
     @classmethod
-    def unserialize(cls, data: StatsErrorDict) -> "StatsError":
+    def unserialize(cls, data: StatsErrorDict) -> StatsError:
         return cls(data["method"], data["name"], data["error"], data["occurrences"])
 
     def to_dict(self, escape_string_values=False):
@@ -771,11 +773,11 @@ class StatsError:
         }
 
 
-def avg(values: List[float | int]) -> float:
+def avg(values: list[float | int]) -> float:
     return sum(values, 0.0) / max(len(values), 1)
 
 
-def median_from_dict(total: int, count: Dict[int, int]) -> int:
+def median_from_dict(total: int, count: dict[int, int]) -> int:
     """
     total is the number of requests made
     count is a dict {response_time: count}
@@ -790,13 +792,13 @@ def median_from_dict(total: int, count: Dict[int, int]) -> int:
 
 
 def setup_distributed_stats_event_listeners(events: Events, stats: RequestStats) -> None:
-    def on_report_to_master(client_id: str, data: Dict[str, Any]) -> None:
+    def on_report_to_master(client_id: str, data: dict[str, Any]) -> None:
         data["stats"] = stats.serialize_stats()
         data["stats_total"] = stats.total.get_stripped_report()
         data["errors"] = stats.serialize_errors()
         stats.errors = {}
 
-    def on_worker_report(client_id: str, data: Dict[str, Any]) -> None:
+    def on_worker_report(client_id: str, data: dict[str, Any]) -> None:
         for stats_data in data["stats"]:
             entry = StatsEntry.unserialize(stats_data)
             request_key = (entry.name, entry.method)
@@ -826,7 +828,7 @@ def print_stats_json(stats: RequestStats) -> None:
     print(json.dumps(stats.serialize_stats(), indent=4))
 
 
-def get_stats_summary(stats: RequestStats, current=True) -> List[str]:
+def get_stats_summary(stats: RequestStats, current=True) -> list[str]:
     """
     stats summary will be returned as list of string
     """
@@ -852,7 +854,7 @@ def print_percentile_stats(stats: RequestStats) -> None:
     console_logger.info("")
 
 
-def get_percentile_stats_summary(stats: RequestStats) -> List[str]:
+def get_percentile_stats_summary(stats: RequestStats) -> list[str]:
     """
     Percentile stats summary will be returned as list of string
     """
@@ -886,7 +888,7 @@ def print_error_report(stats: RequestStats) -> None:
             console_logger.info(line)
 
 
-def get_error_report_summary(stats) -> List[str]:
+def get_error_report_summary(stats) -> list[str]:
     summary = ["Error report"]
     summary.append("%-18s %-100s" % ("# occurrences", "Error"))
     separator = f'{"-" * 18}|{"-" * ((80 + STATS_NAME_WIDTH) - 19)}'
@@ -907,11 +909,11 @@ def stats_printer(stats: RequestStats) -> Callable[[], None]:
     return stats_printer_func
 
 
-def sort_stats(stats: Dict[Any, S]) -> List[S]:
+def sort_stats(stats: dict[Any, S]) -> list[S]:
     return [stats[key] for key in sorted(stats.keys())]
 
 
-def stats_history(runner: "Runner") -> None:
+def stats_history(runner: Runner) -> None:
     """Save current stats info to history for charts of report."""
     while True:
         stats = runner.stats
@@ -925,6 +927,7 @@ def stats_history(runner: "Runner") -> None:
             }
 
             r = {
+                **current_response_time_percentiles,
                 "time": datetime.datetime.now(tz=datetime.timezone.utc).strftime("%H:%M:%S"),
                 "current_rps": stats.total.current_rps or 0,
                 "current_fail_per_sec": stats.total.current_fail_per_sec or 0,
@@ -933,7 +936,6 @@ def stats_history(runner: "Runner") -> None:
                 "response_time_percentile_2": stats.total.get_current_response_time_percentile(PERCENTILES_TO_CHART[1])
                 or 0,
                 "total_avg_response_time": stats.total.avg_response_time,
-                "current_response_time_percentiles": current_response_time_percentiles,
                 "user_count": runner.user_count or 0,
             }
             stats.history.append(r)
@@ -943,7 +945,7 @@ def stats_history(runner: "Runner") -> None:
 class StatsCSV:
     """Write statistics to csv_writer stream."""
 
-    def __init__(self, environment: "Environment", percentiles_to_report: List[float]) -> None:
+    def __init__(self, environment: Environment, percentiles_to_report: list[float]) -> None:
         self.environment = environment
         self.percentiles_to_report = percentiles_to_report
 
@@ -977,7 +979,7 @@ class StatsCSV:
             "Nodes",
         ]
 
-    def _percentile_fields(self, stats_entry: StatsEntry, use_current: bool = False) -> List[str] | List[int]:
+    def _percentile_fields(self, stats_entry: StatsEntry, use_current: bool = False) -> list[str] | list[int]:
         if not stats_entry.num_requests:
             return self.percentiles_na
         elif use_current:
@@ -1045,8 +1047,8 @@ class StatsCSVFileWriter(StatsCSV):
 
     def __init__(
         self,
-        environment: "Environment",
-        percentiles_to_report: List[float],
+        environment: Environment,
+        percentiles_to_report: list[float],
         base_filepath: str,
         full_history: bool = False,
     ):
@@ -1142,7 +1144,7 @@ class StatsCSVFileWriter(StatsCSV):
 
         stats = self.environment.stats
         timestamp = int(now)
-        stats_entries: List[StatsEntry] = []
+        stats_entries: list[StatsEntry] = []
         if self.full_history:
             stats_entries = sort_stats(stats.entries)
 

locust/templates/index.html

@@ -273,30 +273,15 @@
         </div>
         <div class="padder">
             <h1>About</h1>
-            <p>
-                The original idea for Locust was Carl Byström's who made a first proof of concept in June 2010.
-                Jonatan Heyman picked up Locust in January 2011, implemented the current concept of Locust classes
-                and made it work distributed across multiple machines.
-            </p>
-            <p>
-                Jonatan, Carl and Joakim Hamrén has continued the development of Locust at their job,
-                ESN Social Software, who have adopted Locust as an inhouse Open Source project.
-            </p>
-
-            <h1>Authors and Copyright</h1>
-            <a href="http://cgbystrom.com/">Carl Byström</a> (<a href="https://twitter.com/cgbystrom/">@cgbystrom</a>)<br>
-            <a href="http://heyman.info/">Jonatan Heyman</a> (<a href="https://twitter.com/jonatanheyman/">@jonatanheyman</a>)<br>
-            Joakim Hamrén (<a href="https://twitter.com/Jahaaja/">@jahaaja</a>)<br>
-            <a href="http://esn.me/">ESN Social Software</a> (<a href="https://twitter.com/uprise_ea/">@uprise_ea</a>)<br>
-            Hugo Heyman (<a href="https://twitter.com/hugoheyman/">@hugoheyman</a>)
-
-
-            <h1>License</h1>
-            Open source licensed under the MIT license.
-
+            <h2>Authors and Copyright</h2>
+            <a href="https://github.com/heyman">Jonatan Heyman</a><br>
+            <a href="https://github.com/cyberw">Lars Holmberg</a><br>
+            <a href="https://github.com/andrewbaldwin44">Andrew Baldwin</a><br>
+            Carl Byström, Joakim Hamrén & Hugo Heyman<br>
+            Many thanks to our other great <a href="https://github.com/locustio/locust/graphs/contributors">contributors</a>!
             <h2>Version <a href="https://github.com/locustio/locust/releases/tag/{{version}}">{{version}}</a></h2>
-            <br>
-            <a href="https://locust.io/">https://locust.io</a>
+            <h1>License</h1>
+            <a href="https://github.com/locustio/locust/blob/master/LICENSE">MIT license</a>
         </div>
     </div>
     <nav class="footer">

locust/test/mock_logging.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 
 from typing import List, Union, Dict
@@ -7,11 +9,11 @@ LogMessage = List[Union[str, Dict[str, TracebackType]]]
 
 
 class MockedLoggingHandler(logging.Handler):
-    debug: List[LogMessage] = []
-    warning: List[LogMessage] = []
-    info: List[LogMessage] = []
-    error: List[LogMessage] = []
-    critical: List[LogMessage] = []
+    debug: list[LogMessage] = []
+    warning: list[LogMessage] = []
+    info: list[LogMessage] = []
+    error: list[LogMessage] = []
+    critical: list[LogMessage] = []
 
     def emit(self, record):
         if record.exc_info:

locust/test/test_debugging.py

@@ -1,12 +1,12 @@
-import os
-from threading import Timer
-from unittest import mock
-
 from locust import debug, task
 from locust.test.testcases import LocustTestCase
 from locust.user.task import LOCUST_STATE_STOPPING
 from locust.user.users import HttpUser
 
+import os
+from threading import Timer
+from unittest import mock
+
 
 class DebugTestCase(LocustTestCase):
     def setUp(self):

locust/test/test_dispatch.py

@@ -1,13 +1,14 @@
-import time
-import unittest
-from operator import attrgetter
-from typing import Dict, List, Tuple, Type
+from __future__ import annotations
 
 from locust import User
 from locust.dispatch import UsersDispatcher
 from locust.runners import WorkerNode
 from locust.test.util import clear_all_functools_lru_cache
 
+import time
+import unittest
+from operator import attrgetter
+
 _TOLERANCE = 0.025
 
 
@@ -3372,7 +3373,7 @@ class TestAddWorker(unittest.TestCase):
 
 class TestRampUpUsersFromZeroWithFixed(unittest.TestCase):
     class RampUpCase:
-        def __init__(self, fixed_counts: Tuple[int], weights: Tuple[int], target_user_count: int):
+        def __init__(self, fixed_counts: tuple[int], weights: tuple[int], target_user_count: int):
             self.fixed_counts = fixed_counts
             self.weights = weights
             self.target_user_count = target_user_count
@@ -3382,7 +3383,7 @@ class TestRampUpUsersFromZeroWithFixed(unittest.TestCase):
                 self.fixed_counts, self.weights, self.target_user_count
             )
 
-    def case_handler(self, cases: List[RampUpCase], expected: List[Dict[str, int]], user_classes: List[Type[User]]):
+    def case_handler(self, cases: list[RampUpCase], expected: list[dict[str, int]], user_classes: list[type[User]]):
         self.assertEqual(len(cases), len(expected))
 
         for case_num in range(len(cases)):
@@ -4092,14 +4093,14 @@ class TestRampUpDifferentUsers(unittest.TestCase):
         self.assertEqual(_user_count_on_worker(dispatched_users, worker_nodes[2].id), 6)
 
 
-def _aggregate_dispatched_users(d: Dict[str, Dict[str, int]]) -> Dict[str, int]:
+def _aggregate_dispatched_users(d: dict[str, dict[str, int]]) -> dict[str, int]:
     user_classes = list(next(iter(d.values())).keys())
     return {u: sum(d[u] for d in d.values()) for u in user_classes}
 
 
-def _user_count(d: Dict[str, Dict[str, int]]) -> int:
+def _user_count(d: dict[str, dict[str, int]]) -> int:
     return sum(map(sum, map(dict.values, d.values())))  # type: ignore
 
 
-def _user_count_on_worker(d: Dict[str, Dict[str, int]], worker_node_id: str) -> int:
+def _user_count_on_worker(d: dict[str, dict[str, int]], worker_node_id: str) -> int:
     return sum(d[worker_node_id].values())

locust/test/test_env.py

@@ -7,9 +7,10 @@ from locust.user import (
     task,
 )
 from locust.user.task import TaskSet
-from .testcases import LocustTestCase
+
 from .fake_module1_for_env_test import MyUserWithSameName as MyUserWithSameName1
 from .fake_module2_for_env_test import MyUserWithSameName as MyUserWithSameName2
+from .testcases import LocustTestCase
 
 
 class TestEnvironment(LocustTestCase):
@@ -199,3 +200,31 @@ class TestEnvironment(LocustTestCase):
             ValueError, r"instance of LoadTestShape or subclass LoadTestShape", msg="exception message is mismatching"
         ):
             Environment(user_classes=[MyUserWithSameName1], shape_class=SubLoadTestShape)
+
+    def test_update_user_class(self):
+        class MyUser1(User):
+            @task
+            def my_task(self):
+                pass
+
+            @task
+            def my_task_2(self):
+                pass
+
+        class MyUser2(User):
+            @task
+            def my_task(self):
+                pass
+
+        environment = Environment(
+            user_classes=[MyUser1, MyUser2],
+            available_user_classes={"User1": MyUser1, "User2": MyUser2},
+            available_user_tasks={"User1": MyUser1.tasks, "User2": MyUser2.tasks},
+        )
+
+        environment.update_user_class({"user_class_name": "User1", "host": "http://localhost", "tasks": ["my_task_2"]})
+
+        self.assertEqual(
+            environment.available_user_classes["User1"].json(),
+            {"host": "http://localhost", "tasks": ["my_task_2"], "fixed_count": 0, "weight": 1},
+        )

locust/test/test_fasthttp.py

@@ -1,17 +1,18 @@
+from locust import FastHttpUser
+from locust.argument_parser import parse_options
+from locust.contrib.fasthttp import FastHttpSession
+from locust.exception import CatchResponseError, InterruptTaskSet, LocustError, ResponseError
+from locust.user import TaskSet, task
+from locust.util.load_locustfile import is_user_class
+
 import socket
-import gevent
 import time
 from tempfile import NamedTemporaryFile
 
+import gevent
 from geventhttpclient.client import HTTPClientPool
 
-from locust.argument_parser import parse_options
-from locust.user import task, TaskSet
-from locust.contrib.fasthttp import FastHttpSession
-from locust import FastHttpUser
-from locust.exception import CatchResponseError, InterruptTaskSet, LocustError, ResponseError
-from locust.util.load_locustfile import is_user_class
-from .testcases import WebserverTestCase, LocustTestCase
+from .testcases import LocustTestCase, WebserverTestCase
 from .util import create_tls_cert
 
 

locust/test/test_http.py

@@ -1,10 +1,11 @@
+from locust.clients import HttpSession
+from locust.exception import LocustError, ResponseError
+from locust.user.users import HttpUser
+
 import time
 
-from locust.user.users import HttpUser
 from requests.exceptions import InvalidSchema, InvalidURL, MissingSchema, RequestException
 
-from locust.clients import HttpSession
-from locust.exception import LocustError, ResponseError
 from .testcases import WebserverTestCase