def test_aggregation(self):
s1 = RequestStats("GET", "aggregate me!")
s1.log(12, 0)
s1.log(12, 0)
s1.log(38, 0)
s1.log_error("Dummy exzeption")
s2 = RequestStats("GET", "aggregate me!")
s2.log_error("Dummy exzeption")
s2.log_error("Dummy exzeption")
s2.log(12, 0)
s2.log(99, 0)
s2.log(14, 0)
s2.log(55, 0)
s2.log(38, 0)
s2.log(55, 0)
s2.log(97, 0)
s = RequestStats("GET", "")
s.iadd_stats(s1, full_request_history=True)
s.iadd_stats(s2, full_request_history=True)
self.assertEqual(s.num_reqs, 10)
self.assertEqual(s.num_failures, 3)
self.assertEqual(s.median_response_time, 38)
self.assertEqual(s.avg_response_time, 43.2)
def test_master_total_stats_with_none_response_times(self):
class MyTestLocust(Locust):
pass
with mock.patch("locust.rpc.rpc.Server", mocked_rpc()) as server:
master = MasterLocustRunner(MyTestLocust, self.options)
server.mocked_send(Message("client_ready", None, "fake_client"))
stats = RequestStats()
stats.log_request("GET", "/1", 100, 3546)
stats.log_request("GET", "/1", 800, 56743)
stats.log_request("GET", "/1", None, 56743)
stats2 = RequestStats()
stats2.log_request("GET", "/2", 700, 2201)
stats2.log_request("GET", "/2", None, 2201)
stats3 = RequestStats()
stats3.log_request("GET", "/3", None, 2201)
server.mocked_send(Message("stats", {
"stats":stats.serialize_stats(),
"stats_total": stats.total.serialize(),
"errors":stats.serialize_errors(),
"user_count": 1,
}, "fake_client"))
server.mocked_send(Message("stats", {
"stats":stats2.serialize_stats(),
"stats_total": stats2.total.serialize(),
"errors":stats2.serialize_errors(),
"user_count": 2,
}, "fake_client"))
server.mocked_send(Message("stats", {
"stats":stats3.serialize_stats(),
"stats_total": stats3.total.serialize(),
"errors":stats3.serialize_errors(),
"user_count": 2,
}, "fake_client"))
self.assertEqual(700, master.stats.total.median_response_time)
def test_master_current_response_times(self):
class MyTestLocust(Locust):
pass
start_time = 1
with mock.patch("time.time") as mocked_time:
mocked_time.return_value = start_time
global_stats.reset_all()
with mock.patch("locust.rpc.rpc.Server", mocked_rpc()) as server:
master = MasterLocustRunner(MyTestLocust, self.options)
mocked_time.return_value += 1.0234
server.mocked_send(Message("client_ready", None, "fake_client"))
stats = RequestStats()
stats.log_request("GET", "/1", 100, 3546)
stats.log_request("GET", "/1", 800, 56743)
server.mocked_send(Message("stats", {
"stats":stats.serialize_stats(),
"stats_total": stats.total.get_stripped_report(),
"errors":stats.serialize_errors(),
"user_count": 1,
}, "fake_client"))
mocked_time.return_value += 1
stats2 = RequestStats()
stats2.log_request("GET", "/2", 400, 2201)
server.mocked_send(Message("stats", {
"stats":stats2.serialize_stats(),
"stats_total": stats2.total.get_stripped_report(),
"errors":stats2.serialize_errors(),
"user_count": 2,
}, "fake_client"))
mocked_time.return_value += 4
self.assertEqual(400, master.stats.total.get_current_response_time_percentile(0.5))
self.assertEqual(800, master.stats.total.get_current_response_time_percentile(0.95))
# let 10 second pass, do some more requests, send it to the master and make
# sure the current response time percentiles only accounts for these new requests
mocked_time.return_value += 10.10023
stats.log_request("GET", "/1", 20, 1)
stats.log_request("GET", "/1", 30, 1)
stats.log_request("GET", "/1", 3000, 1)
server.mocked_send(Message("stats", {
"stats":stats.serialize_stats(),
"stats_total": stats.total.get_stripped_report(),
"errors":stats.serialize_errors(),
"user_count": 2,
}, "fake_client"))
self.assertEqual(30, master.stats.total.get_current_response_time_percentile(0.5))
self.assertEqual(3000, master.stats.total.get_current_response_time_percentile(0.95))
def __init__(
self, *,
user_classes=[],
shape_class=None,
tags=None,
exclude_tags=None,
events=None,
host=None,
reset_stats=False,
step_load=False,
stop_timeout=None,
catch_exceptions=True,
parsed_options=None,
):
if events:
self.events = events
else:
self.events = Events()
self.user_classes = user_classes
self.shape_class = shape_class
self.tags = tags
self.exclude_tags = exclude_tags
self.stats = RequestStats()
self.host = host
self.reset_stats = reset_stats
self.step_load = step_load
self.stop_timeout = stop_timeout
self.catch_exceptions = catch_exceptions
self.parsed_options = parsed_options
self._filter_tasks_by_tags()
def test_error_grouping_errors_with_memory_addresses(self):
# reset stats
self.stats = RequestStats()
class Dummy(object):
pass
self.stats.log_error("GET", "/", Exception("Error caused by %r" % Dummy()))
self.assertEqual(1, len(self.stats.errors))
def test_percentile(self):
s = RequestStats("GET", "percentile_test")
for x in xrange(100):
s.log(x, 0)
self.assertEqual(s.get_response_time_percentile(0.5), 50)
self.assertEqual(s.get_response_time_percentile(0.6), 60)
self.assertEqual(s.get_response_time_percentile(0.95), 95)
def test_print_percentile_stats(self):
stats = RequestStats()
for i in range(100):
stats.log_request("GET", "test_entry", i, 2000+i)
locust.stats.print_percentile_stats(stats)
info = self.mocked_log.info
self.assertEqual(7, len(info))
# check that headline contains same number of column as the value rows
headlines = info[1].replace("# reqs", "#reqs").split()
self.assertEqual(len(headlines), len(info[3].split()))
self.assertEqual(len(headlines), len(info[5].split()))
def setUp(self):
RequestStats.global_start_time = time.time()
self.s = RequestStats("GET", "test_entry")
self.s.log(45, 0)
self.s.log(135, 0)
self.s.log(44, 0)
self.s.log_error(Exception("dummy fail"))
self.s.log_error(Exception("dummy fail"))
self.s.log(375, 0)
self.s.log(601, 0)
self.s.log(35, 0)
self.s.log(79, 0)
self.s.log_error(Exception("dummy fail"))
def test_error_grouping(self):
# reset stats
self.stats = RequestStats()
self.stats.log_error("GET", "/some-path", Exception("Exception!"))
self.stats.log_error("GET", "/some-path", Exception("Exception!"))
self.assertEqual(1, len(self.stats.errors))
self.assertEqual(2, list(self.stats.errors.values())[0].occurrences)
self.stats.log_error("GET", "/some-path", Exception("Another exception!"))
self.stats.log_error("GET", "/some-path", Exception("Another exception!"))
self.stats.log_error("GET", "/some-path", Exception("Third exception!"))
self.assertEqual(3, len(self.stats.errors))
def setUp(self):
self.stats = RequestStats()
self.stats.start_time = time.time()
self.s = StatsEntry(self.stats, "test_entry", "GET")
self.s.log(45, 0)
self.s.log(135, 0)
self.s.log(44, 0)
self.s.log_error(Exception("dummy fail"))
self.s.log_error(Exception("dummy fail"))
self.s.log(375, 0)
self.s.log(601, 0)
self.s.log(35, 0)
self.s.log(79, 0)
self.s.log_error(Exception("dummy fail"))
def create_worker_runner(self, master_host, master_port):
"""
Create a :class:`WorkerRunner <locust.runners.WorkerRunner>` instance for this Environment
:param master_host: Host/IP of a running master node
:param master_port: Port on master node to connect to
"""
# Create a new RequestStats with use_response_times_cache set to False to save some memory
# and CPU cycles, since the response_times_cache is not needed for Worker nodes
self.stats = RequestStats(use_response_times_cache=False)
return self._create_runner(
WorkerRunner,
master_host=master_host,
master_port=master_port,
)
def setUp(self):
self.stats = RequestStats()
def log(response_time, size):
self.stats.log_request("GET", "test_entry", response_time, size)
def log_error(exc):
self.stats.log_error("GET", "test_entry", exc)
log(45, 1)
log(135, 1)
log(44, 1)
log(None, 1)
log_error(Exception("dummy fail"))
log_error(Exception("dummy fail"))
log(375, 1)
log(601, 1)
log(35, 1)
log(79, 1)
log(None, 1)
log_error(Exception("dummy fail"))
self.s = self.stats.get("test_entry", "GET")
def setUp(self):
super().setUp()
self.stats = RequestStats()
for i in range(100):
for method, name, freq in [
(
"GET",
"test_entry",
5,
),
(
"DELETE",
"test" * int((STATS_NAME_WIDTH - STATS_TYPE_WIDTH + 4) / len("test")),
3,
),
]:
self.stats.log_request(method, name, i, 2000 + i)
if i % freq == 0:
self.stats.log_error(method, name, RuntimeError(f"{method} error"))
def setUp(self, *args, **kwargs):
super(TestStatsEntry, self).setUp(*args, **kwargs)
self.stats = RequestStats()
def setUp(self, *args, **kwargs):
super(TestStatsEntryResponseTimesCache, self).setUp(*args, **kwargs)
self.stats = RequestStats()
def setUp(self, *args, **kwargs):
super().setUp(*args, **kwargs)
self.stats = RequestStats()
