locust 2.29.2.dev10__tar.gz → 2.29.2.dev26__tar.gz

{locust-2.29.2.dev10 → locust-2.29.2.dev26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: locust
-Version: 2.29.2.dev10
+Version: 2.29.2.dev26
 Summary: Developer-friendly load testing framework
 License: MIT
 Project-URL: Homepage, https://github.com/locustio/locust

{locust-2.29.2.dev10 → locust-2.29.2.dev26}/benchmarks/dispatch.py

@@ -1,7 +1,7 @@
 """
 This file contains a benchmark to validate the performance of Locust itself.
 More precisely, the performance of the `UsersDispatcher` class which is responsible
-for calculating the distribution of users on each workers. This benchmark is to be used
+for calculating the distribution of users on each worker. This benchmark is to be used
 by people working on Locust's development.
 """
 
@@ -9,105 +9,146 @@ from locust import User
 from locust.dispatch import UsersDispatcher
 from locust.runners import WorkerNode
 
+import argparse
+import gc
 import itertools
 import statistics
 import time
 
 from prettytable import PrettyTable
 
-# fmt: off
-WEIGHTS = [
-     5, 55, 37,  2, 97, 41, 33, 19, 19, 34,
-    78, 76, 28, 62, 69,  5, 55, 37,  2, 97,
-    41, 33, 19, 19, 34, 78, 76, 28, 62, 69,
-    41, 33, 19, 19, 34, 78, 76, 28, 62, 69,
-    41, 33, 19, 19, 34, 78, 76, 28, 62, 69,
-     5, 55, 37,  2, 97, 41, 33, 19, 19, 34,
-    78, 76, 28, 62, 69,  5, 55, 37,  2, 97,
-    41, 33, 19, 19, 34, 78, 76, 28, 62, 69,
-    41, 33, 19, 19, 34, 78, 76, 28, 62, 69,
-    41, 33, 19, 19, 34, 78, 76, 28, 62, 69,
-]
-# fmt: on
+NUMBER_OF_USER_CLASSES: int = 1000
+USER_CLASSES: list[type[User]] = []
+WEIGHTS = list(range(1, NUMBER_OF_USER_CLASSES + 1))
 
 for i, x in enumerate(WEIGHTS):
-    exec(f"class User{i+1}(User): weight = {x}")
+    exec(f"class User{i}(User): weight = {x}")
 
 # Equivalent to:
 #
-# class User1(User):
+# class User0(User):
 #     weight = 5
 #
-# class User2(User):
+# class User1(User):
 #     weight = 55
 # .
 # .
 # .
-# class User100(User):
-#     weight = 69
 
-exec("USER_CLASSES = [" + ",".join(f"User{i+1}" for i in range(len(WEIGHTS))) + "]")
+exec("USER_CLASSES = [" + ",".join(f"User{i}" for i in range(len(WEIGHTS))) + "]")
 # Equivalent to:
 #
 # USER_CLASSES = [
+#     User0,
 #     User1,
-#     User2,
 #     .
 #     .
 #     .
-#     User100,
 # ]
 
 
 if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-f", "--full-benchmark", action="store_true", help="run benchmark on full test matrix")
+    parser.add_argument(
+        "-i",
+        "--include-fixed-users",
+        action="store_true",
+        help="add test cases when 50 percent of users use User.fixed_count instead of User.weight",
+    )
+    parser.add_argument("-r", "--repeat", default=1, type=int, help="number of test cases with the same parameters")
+    parser.add_argument("-s", "--save-output", action="store_true", help="save test results to files")
+    args = parser.parse_args()
+
     now = time.time()
 
-    worker_count_cases = [10, 100, 500, 1000, 5000, 10_000, 15_000, 20_000]
-    user_count_cases = [10, 100, 1000, 10_000, 50_000, 100_000, 500_000]
-    number_of_user_classes_cases = [1, 10, 40, 60, 80, 100]
-    spawn_rate_cases = [1, 10, 100, 500, 1000, 2500, 5000, 10_000, 20_000, 25_000]
+    worker_count_cases = [10, 100, 1000]
+    user_count_cases = [10_000, 100_000, 1_000_000]
+    number_of_user_classes_cases = [1, 30, 1000]
+    spawn_rate_cases = [100, 10_000]
+    fixed_count_cases = [False, True] if args.include_fixed_users else [False]
+    # [0% fixed_count users, 50% fixed_count users] if args.mixed_user_types else [0% fixed_count users]
+    repeat_cases = list(range(1, args.repeat + 1))
+
+    if not args.full_benchmark:
+        worker_count_cases = [max(worker_count_cases)]
+        user_count_cases = [max(user_count_cases)]
+        number_of_user_classes_cases = [max(number_of_user_classes_cases)]
+        spawn_rate_cases = [max(spawn_rate_cases)]
 
     case_count = (
-        len(worker_count_cases) * len(user_count_cases) * len(number_of_user_classes_cases) * len(spawn_rate_cases)
+        len(worker_count_cases)
+        * len(user_count_cases)
+        * len(number_of_user_classes_cases)
+        * len(spawn_rate_cases)
+        * len(fixed_count_cases)
+        * len(repeat_cases)
     )
 
     results = {}
 
     try:
-        for case_index, (worker_count, user_count, number_of_user_classes, spawn_rate) in enumerate(
-            itertools.product(worker_count_cases, user_count_cases, number_of_user_classes_cases, spawn_rate_cases)
+        for case_index, (
+            worker_count,
+            user_count,
+            number_of_user_classes,
+            spawn_rate,
+            fixed_users,
+            iteration,
+        ) in enumerate(
+            itertools.product(
+                worker_count_cases,
+                user_count_cases,
+                number_of_user_classes_cases,
+                spawn_rate_cases,
+                fixed_count_cases,
+                repeat_cases,
+            )
         ):
-            if user_count / spawn_rate > 1000:
-                print(f"Skipping user_count = {user_count:,} - spawn_rate = {spawn_rate:,}")
-                continue
+            workers = [WorkerNode(str(i)) for i in range(worker_count)]
+            if fixed_users:
+                sum_fixed_weight = 0
+                for j in range(0, number_of_user_classes, 2):
+                    sum_fixed_weight += USER_CLASSES[j].weight
 
-            workers = [WorkerNode(str(i + 1)) for i in range(worker_count)]
+                for j in range(0, number_of_user_classes, 2):  # set fixed_weights for 50% of users
+                    USER_CLASSES[j].fixed_count = max(1, USER_CLASSES[j].weight // sum_fixed_weight)  # type: ignore # assigned .weight is int
 
-            ts = time.perf_counter()
+            ts = time.process_time()
             users_dispatcher = UsersDispatcher(
                 worker_nodes=workers,
-                user_classes=USER_CLASSES[:number_of_user_classes],  # noqa: F821 (Undefined name `USER_CLASSES`) -> It's created inside "exec"
+                user_classes=USER_CLASSES[:number_of_user_classes],
             )
-            instantiate_duration = time.perf_counter() - ts
+            instantiate_duration = time.process_time() - ts
 
             # Ramp-up
-            ts = time.perf_counter()
+            gc.disable()
+            ts = time.process_time()
             users_dispatcher.new_dispatch(target_user_count=user_count, spawn_rate=spawn_rate)
-            new_dispatch_ramp_up_duration = time.perf_counter() - ts
+            new_dispatch_ramp_up_duration = time.process_time() - ts
+            gc.enable()
+
             assert len(users_dispatcher.dispatch_iteration_durations) == 0
             users_dispatcher._wait_between_dispatch = 0
             all_dispatched_users_ramp_up = list(users_dispatcher)
             dispatch_iteration_durations_ramp_up = users_dispatcher.dispatch_iteration_durations[:]
 
             # Ramp-down
-            ts = time.perf_counter()
+            gc.disable()
+            ts = time.process_time()
             users_dispatcher.new_dispatch(target_user_count=0, spawn_rate=spawn_rate)
-            new_dispatch_ramp_down_duration = time.perf_counter() - ts
+            new_dispatch_ramp_down_duration = time.process_time() - ts
+            gc.enable()
+
             assert len(users_dispatcher.dispatch_iteration_durations) == 0
             users_dispatcher._wait_between_dispatch = 0
             all_dispatched_users_ramp_down = list(users_dispatcher)
             dispatch_iteration_durations_ramp_down = users_dispatcher.dispatch_iteration_durations[:]
 
+            if fixed_users:
+                for j in range(0, number_of_user_classes, 2):
+                    USER_CLASSES[j].fixed_count = None
+
             cpu_ramp_up = "{:3.3f}/{:3.3f}/{:3.3f}".format(  # noqa: UP032
                 1000 * statistics.mean(dispatch_iteration_durations_ramp_up),
                 1000 * min(dispatch_iteration_durations_ramp_up),
@@ -135,7 +176,10 @@ if __name__ == "__main__":
                 )
             )
 
-            results[(worker_count, user_count, number_of_user_classes, spawn_rate)] = (cpu_ramp_up, cpu_ramp_down)
+            results[(worker_count, user_count, number_of_user_classes, spawn_rate, fixed_users, iteration)] = (
+                cpu_ramp_up,
+                cpu_ramp_down,
+            )
 
     finally:
         table = PrettyTable()
@@ -144,6 +188,8 @@ if __name__ == "__main__":
             "Users",
             "User Classes",
             "Spawn Rate",
+            "Fixed Users",
+            "Iteration",
             "Ramp-Up (avg/min/max) (ms)",
             "Ramp-Down (avg/min/max) (ms)",
         ]
@@ -151,6 +197,8 @@ if __name__ == "__main__":
         table.align["Users"] = "l"
         table.align["User Classes"] = "l"
         table.align["Spawn Rate"] = "l"
+        table.align["Fixed Users"] = "l"
+        table.align["Iteration"] = "c"
         table.align["Ramp-Up (avg/min/max) (ms)"] = "c"
         table.align["Ramp-Down (avg/min/max) (ms)"] = "c"
         table.add_rows(
@@ -160,22 +208,23 @@ if __name__ == "__main__":
                     f"{user_count:,}",
                     number_of_user_classes,
                     f"{spawn_rate:,}",
+                    "50%" if fixed_users else "0%",
+                    iteration,
                     cpu_ramp_up,
                     cpu_ramp_down,
                 ]
-                for (worker_count, user_count, number_of_user_classes, spawn_rate), (
+                for (worker_count, user_count, number_of_user_classes, spawn_rate, fixed_users, iteration), (
                     cpu_ramp_up,
                     cpu_ramp_down,
                 ) in results.items()
             ]
         )
         print()
-        print()
-        print()
         print(table)
 
-        with open(f"results-dispatch-benchmarks-{int(now)}.txt", "w") as file:
-            file.write(table.get_string())
+        if args.save_output:
+            with open(f"results-dispatch-benchmarks-{int(now)}.txt", "w") as file:
+                file.write(table.get_string())
 
-        with open(f"results-dispatch-benchmarks-{int(now)}.json", "w") as file:
-            file.write(table.get_json_string())
+            with open(f"results-dispatch-benchmarks-{int(now)}.json", "w") as file:
+                file.write(table.get_json_string())

{locust-2.29.2.dev10 → locust-2.29.2.dev26}/examples/test_data_management.py

@@ -6,6 +6,10 @@
 # 3. Test start
 # 4. User start
 # 5. Inside a task
+# M1. CPU & memory usage
+# M2. master sent heartbeat to worker 1-N
+# M3. worker 1-N received heartbeat from master
+# (M* are repeated as long as locust is running)
 # ...
 # 6. Test run stopping
 # 7. User stop
@@ -15,17 +19,21 @@
 # 10. Locust quit
 #
 # try it out by running:
-#  locust -f test_data_management.py --headless -u 2 -t 5
+#  locust -f test_data_management.py --headless -u 2 -t 5 --processes 2
+from __future__ import annotations
+
 from locust import HttpUser, events, task
+from locust.env import Environment
 from locust.runners import MasterRunner
 from locust.user.wait_time import constant
 
 import datetime
+from typing import Any
 
 import requests
 
 
-def timestring():
+def timestring() -> str:
     now = datetime.datetime.now()
     return datetime.datetime.strftime(now, "%m:%S.%f")[:-5]
 
@@ -42,17 +50,17 @@ test_run_specific_data = None
 
 
 @events.init.add_listener
-def init(environment, **_kwargs):
+def init(environment: Environment, **_kwargs: Any) -> None:
     print("2. Initializing locust, happens after parsing the locustfile but before test start")
 
 
 @events.quitting.add_listener
-def quitting(environment, **_kwargs):
+def quitting(environment: Environment, **_kwargs: Any) -> None:
     print("9. locust is about to shut down")
 
 
 @events.test_start.add_listener
-def test_start(environment, **_kwargs):
+def test_start(environment: Environment, **_kwargs) -> None:
     # happens only once in headless runs, but can happen multiple times in web ui-runs
     global test_run_specific_data
     print("3. Starting test run")
@@ -64,18 +72,35 @@ def test_start(environment, **_kwargs):
         ).json()["data"]
 
 
+@events.heartbeat_sent.add_listener
+def heartbeat_sent(client_id: str, timestamp: float) -> None:
+    print(f"M2. master sent heartbeat to worker {client_id} at {datetime.datetime.fromtimestamp(timestamp)}")
+
+
+@events.heartbeat_received.add_listener
+def heartbeat_received(client_id: str, timestamp: float) -> None:
+    print(f"M3. worker {client_id} received heartbeat from master at {datetime.datetime.fromtimestamp(timestamp)}")
+
+
+@events.usage_monitor.add_listener
+def usage_monitor(environment: Environment, cpu_usage: float, memory_usage: int) -> None:
+    # convert from bytes to Mebibytes
+    memory_usage = memory_usage / 1024 / 1024
+    print(f"M1. {environment.runner.__class__.__name__}: cpu={cpu_usage}%, memory={memory_usage}M")
+
+
 @events.quit.add_listener
-def quit(exit_code, **kwargs):
+def quit(exit_code: int, **kwargs: Any) -> None:
     print(f"10. Locust has shut down with code {exit_code}")
 
 
 @events.test_stopping.add_listener
-def test_stopping(environment, **_kwargs):
+def test_stopping(environment: Environment, **_kwargs: Any) -> None:
     print("6. stopping test run")
 
 
 @events.test_stop.add_listener
-def test_stop(environment, **_kwargs):
+def test_stop(environment: Environment, **_kwargs: Any) -> None:
     print("8. test run stopped")
 
 
@@ -84,7 +109,7 @@ class MyUser(HttpUser):
     wait_time = constant(180)  # be nice to postman-echo
     first_start = True
 
-    def on_start(self):
+    def on_start(self) -> None:
         if MyUser.first_start:
             MyUser.first_start = False
             # This is useful for similar things as to test_start, but happens in the context of a User
@@ -101,7 +126,7 @@ class MyUser(HttpUser):
         ).json()["data"]
 
     @task
-    def t(self):
+    def t(self) -> None:
         self.client.get(f"/get?{global_test_data}")
         self.client.get(f"/get?{test_run_specific_data}")
         self.client.get(f"/get?{self.user_specific_testdata}")
@@ -114,6 +139,6 @@ class MyUser(HttpUser):
         ).json()["data"]
         self.client.get(f"/get?{task_run_specific_testdata}")
 
-    def on_stop(self):
+    def on_stop(self) -> None:
         # this is a good place to clean up/release any user-specific test data
         print("7. a user was stopped")

{locust-2.29.2.dev10 → locust-2.29.2.dev26}/locust/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.29.2.dev10'
-__version_tuple__ = version_tuple = (2, 29, 2, 'dev10')
+__version__ = version = '2.29.2.dev26'
+__version_tuple__ = version_tuple = (2, 29, 2, 'dev26')

{locust-2.29.2.dev10 → locust-2.29.2.dev26}/locust/event.py

@@ -235,6 +235,38 @@ class Events:
     Fired when the CPU usage exceeds runners.CPU_WARNING_THRESHOLD (90% by default)
     """
 
+    heartbeat_sent: EventHook
+    """
+    Fired when a heartbeat is sent by master to a worker.
+
+    Event arguments:
+
+    :param client_id: worker client id
+    :param timestamp: time in seconds since the epoch (float) when the event occured
+    """
+
+    heartbeat_received: EventHook
+    """
+    Fired when a heartbeat is received by a worker from master.
+
+    Event arguments:
+
+    :param client_id: worker client id
+    :param timestamp: time in seconds since the epoch (float) when the event occured
+    """
+
+    usage_monitor: EventHook
+    """
+    Fired every runners.CPU_MONITOR_INTERVAL (5.0 seconds by default) with information about
+    current CPU and memory usage.
+
+    Event arguments:
+
+    :param environment: locust environment
+    :param cpu_usage: current CPU usage in percent
+    :param memory_usage: current memory usage (RSS) in bytes
+    """
+
     def __init__(self):
         # For backward compatibility use also values of class attributes
         for name, value in vars(type(self)).items():

{locust-2.29.2.dev10 → locust-2.29.2.dev26}/locust/runners.py

@@ -15,19 +15,9 @@ import traceback
 from abc import abstractmethod
 from collections import defaultdict
 from collections.abc import Iterator, MutableMapping, ValuesView
-from operator import (
-    itemgetter,
-    methodcaller,
-)
+from operator import itemgetter, methodcaller
 from types import TracebackType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    NoReturn,
-    TypedDict,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, Callable, NoReturn, TypedDict, cast
 from uuid import uuid4
 
 import gevent
@@ -40,15 +30,8 @@ from . import argument_parser
 from .dispatch import UsersDispatcher
 from .exception import RPCError, RPCReceiveError, RPCSendError
 from .log import get_logs, greenlet_exception_logger
-from .rpc import (
-    Message,
-    rpc,
-)
-from .stats import (
-    RequestStats,
-    StatsError,
-    setup_distributed_stats_event_listeners,
-)
+from .rpc import Message, rpc
+from .stats import RequestStats, StatsError, setup_distributed_stats_event_listeners
 
 if TYPE_CHECKING:
     from . import User
@@ -106,7 +89,7 @@ class Runner:
         self.spawning_greenlet: gevent.Greenlet | None = None
         self.shape_greenlet: gevent.Greenlet | None = None
         self.shape_last_tick: tuple[int, float] | tuple[int, float, list[type[User]] | None] | None = None
-        self.current_cpu_usage: int = 0
+        self.current_cpu_usage: float = 0.0
         self.cpu_warning_emitted: bool = False
         self.worker_cpu_warning_emitted: bool = False
         self.current_memory_usage: int = 0
@@ -308,6 +291,10 @@ class Runner:
                         f"CPU usage above {CPU_WARNING_THRESHOLD}%! This may constrain your throughput and may even give inconsistent response time measurements! See https://docs.locust.io/en/stable/running-distributed.html for how to distribute the load over multiple CPU cores or machines"
                     )
                     self.cpu_warning_emitted = True
+
+            self.environment.events.usage_monitor.fire(
+                environment=self.environment, cpu_usage=self.current_cpu_usage, memory_usage=self.current_memory_usage
+            )
             gevent.sleep(CPU_MONITOR_INTERVAL)
 
     @abstractmethod
@@ -1102,6 +1089,7 @@ class MasterRunner(DistributedRunner):
                         )
                     if "current_memory_usage" in msg.data:
                         c.memory_usage = msg.data["current_memory_usage"]
+                    self.environment.events.heartbeat_sent.fire(client_id=msg.node_id, timestamp=time.time())
                     self.server.send_to_client(Message("heartbeat", None, msg.node_id))
                 else:
                     logging.debug(f"Got heartbeat message from unknown worker {msg.node_id}")
@@ -1399,6 +1387,9 @@ class WorkerRunner(DistributedRunner):
                 self.reset_connection()
             elif msg.type == "heartbeat":
                 self.last_heartbeat_timestamp = time.time()
+                self.environment.events.heartbeat_received.fire(
+                    client_id=msg.node_id, timestamp=self.last_heartbeat_timestamp
+                )
             elif msg.type == "update_user_class":
                 self.environment.update_user_class(msg.data)
             elif msg.type == "spawning_complete":

{locust-2.29.2.dev10 → locust-2.29.2.dev26}/locust/test/test_runners.py

@@ -1,12 +1,7 @@
 from __future__ import annotations
 
 import locust
-from locust import (
-    LoadTestShape,
-    __version__,
-    constant,
-    runners,
-)
+from locust import LoadTestShape, __version__, constant, runners
 from locust.argument_parser import parse_options
 from locust.dispatch import UsersDispatcher
 from locust.env import Environment
@@ -26,11 +21,7 @@ from locust.runners import (
     WorkerRunner,
 )
 from locust.stats import RequestStats
-from locust.user import (
-    TaskSet,
-    User,
-    task,
-)
+from locust.user import TaskSet, User, task
 
 import json
 import logging
@@ -2136,6 +2127,149 @@ class TestMasterWorkerRunners(LocustTestCase):
 
             self.assertEqual(test_start_exec_count, 1)
 
+    def test_heartbeat_event(self) -> None:
+        """
+        Tests that heartbeat event is fired during a test
+        """
+
+        class TestUser(User):
+            wait_time = constant(0.1)
+
+            @task
+            def noop(self) -> None:
+                pass
+
+        with mock.patch("locust.runners.HEARTBEAT_INTERVAL", new=1):
+            # start a Master runner
+            master_env = Environment(user_classes=[TestUser])
+            worker_connect_events = []
+            timestamp_start: list[float] = [time.time() + 3600.0]
+
+            def on_connect(client_id: str) -> None:
+                worker_connect_events.append(client_id)
+                timestamp_start[0] = time.time()
+
+            master_env.events.worker_connect.add_listener(on_connect)
+            master = master_env.create_master_runner("*", 0)
+            sleep(0)
+            worker_env = Environment(user_classes=[TestUser])
+            worker: WorkerRunner = worker_env.create_worker_runner("127.0.0.1", master.server.port)
+
+            with (
+                mock.patch.object(
+                    worker.environment.events.heartbeat_received,
+                    "fire",
+                    wraps=worker.environment.events.heartbeat_received.fire,
+                ) as worker_heartbeat_received_mock,
+                mock.patch.object(
+                    master.environment.events.heartbeat_sent,
+                    "fire",
+                    wraps=master.environment.events.heartbeat_sent.fire,
+                ) as master_heartbeat_sent_mock,
+            ):
+                # give workers time to connect
+                sleep(0.1)
+                # issue start command that should trigger TestUsers to be spawned in the Workers
+                master.start(2, spawn_rate=2)
+                sleep(0.1)
+                # check that worker nodes have started locusts
+                self.assertEqual(2, worker.user_count)
+
+                # give time for nodes to send and receive 5 heartbeats, HEARTBEAT_INTERVAL mocked to 1 second, so
+                # sleep 5 seconds - 1 second that represents the overhead from connecting
+                sleep(5 - 1)
+                master.quit()
+
+                # make sure users are killed
+                self.assertEqual(0, worker.user_count)
+                # make sure events happened correctly
+                self.assertIn(worker.client_id, worker_connect_events)
+
+                timestamp_stop = time.time()
+
+                self.assertEqual(worker_heartbeat_received_mock.call_count, 5)
+                self.assertEqual(master_heartbeat_sent_mock.call_count, 5)
+
+                for call_args, call_kwargs in [
+                    *worker_heartbeat_received_mock.call_args_list,
+                    *master_heartbeat_sent_mock.call_args_list,
+                ]:
+                    self.assertEqual(call_args, ())  # args
+                    self.assertEqual(call_kwargs, {"client_id": worker.client_id, "timestamp": mock.ANY})  # kwargs
+                    self.assertGreaterEqual(call_kwargs["timestamp"], timestamp_start[0])
+                    self.assertLessEqual(call_kwargs["timestamp"], timestamp_stop)
+
+    def test_usage_monitor_event(self) -> None:
+        """
+        Tests that usage_monitor event is fired during a test
+        """
+
+        class TestUser(User):
+            wait_time = constant(0.1)
+
+            @task
+            def noop(self) -> None:
+                pass
+
+        with mock.patch("locust.runners.CPU_MONITOR_INTERVAL", new=1):
+            # start a Master runner
+            master_env = Environment(user_classes=[TestUser])
+            worker_connect_events = []
+
+            def on_connect(client_id: str) -> None:
+                worker_connect_events.append(client_id)
+
+            master_env.events.worker_connect.add_listener(on_connect)
+            master = master_env.create_master_runner("*", 0)
+            sleep(0)
+            worker_env = Environment(user_classes=[TestUser])
+            worker: WorkerRunner = worker_env.create_worker_runner("127.0.0.1", master.server.port)
+
+            with (
+                mock.patch.object(
+                    worker.environment.events.usage_monitor, "fire", wraps=worker.environment.events.usage_monitor.fire
+                ) as worker_usage_monitor_mock,
+                mock.patch.object(
+                    master.environment.events.usage_monitor, "fire", wraps=master.environment.events.usage_monitor.fire
+                ) as master_usage_monitor_mock,
+            ):
+                # give workers time to connect
+                sleep(0.1)
+                # issue start command that should trigger TestUsers to be spawned in the Workers
+                master.start(2, spawn_rate=2)
+                sleep(0.1)
+                # check that worker nodes have started locusts
+                self.assertEqual(2, worker.user_count)
+
+                # give time for nodes to send 5 usage_monitor events, CPU_MONITOR_INTERVAL mocked to 1 second, so
+                # sleep 5 seconds
+                sleep(5)
+                master.quit()
+
+                # make sure users are killed
+                self.assertEqual(0, worker.user_count)
+                # make sure events happened correctly
+                self.assertIn(worker.client_id, worker_connect_events)
+
+                self.assertEqual(worker_usage_monitor_mock.call_count, 5)
+                self.assertEqual(master_usage_monitor_mock.call_count, 5)
+
+                for call_args, call_kwargs in master_usage_monitor_mock:
+                    self.assertEqual(call_args, ())  # args
+                    self.assertEqual(
+                        call_kwargs, {"environment": master_env, "cpu_usage": mock.ANY, "memory_usage": mock.ANY}
+                    )  # kwargs
+                    self.assertTrue(isinstance(call_kwargs["cpu_usage"], float))
+                    self.assertTrue(isinstance(call_kwargs["memory_usage"], int))
+
+                for call_args, call_kwargs in worker_usage_monitor_mock:
+                    self.assertEqual(call_args, ())  # args
+                    self.assertEqual(
+                        call_kwargs, {"environment": worker_env, "cpu_usage": mock.ANY, "memory_usage": mock.ANY}
+                    )  # kwargs
+                    self.assertTrue(isinstance(call_kwargs["cpu_usage"], float))
+                    self.assertTrue(isinstance(call_kwargs["memory_usage"], int))
+
 
 class TestMasterRunner(LocustRunnerTestCase):
     def setUp(self):