def test_get_name_and_average(self):
report_manager = ReportManager(None, None, None, "ss", "2017-01-01",
"2017-01-01", None, None, None, None,
None, None, None, None, None, None,
None, None)
key = "ee-dev"
report_row = ReportRow(None)
report_row.duration_avg = (5123.123, 15)
produced_service = True
service_name = "service"
self.assertEqual(
report_manager.get_name_and_average(key, report_row,
produced_service,
service_name),
("ss: ee-dev",
round(report_row.duration_avg[0] / (report_row.duration_avg[1]))))
produced_service = False
self.assertEqual(
report_manager.get_name_and_average(key, report_row,
produced_service,
service_name),
("ee-dev: service",
round(report_row.duration_avg[0] / (report_row.duration_avg[1]))))
report_row.duration_avg = (None, None)
self.assertEqual(
report_manager.get_name_and_average(key, report_row,
produced_service,
service_name),
("ee-dev: service", None))
def test_return_row(self):
report_row_producer = ReportRow(None)
row = [
0, 0, None, (None, None), None, None, (None, None), None, None,
(None, None), None
]
self.assertEqual(report_row_producer.return_row(), row)
report_row_producer = ReportRow(None)
number_of_clients = 300
client_responses = []
client_requests = []
client_durations = []
for i in range(number_of_clients):
response_size = random.randint(0, 1000)
request_size = random.randint(0, 1000)
duration_size = random.randint(0, 1000)
client_responses.append(response_size)
client_requests.append(request_size)
client_durations.append(duration_size)
new_doc = {
'clientResponseSize': response_size,
'producerResponseSize': response_size,
'clientRequestSize': request_size,
'producerRequestSize': request_size,
'succeeded': True,
'producerDurationProducerView': duration_size,
'totalDuration': duration_size
}
new_doc_none = {
'clientResponseSize': None,
'producerResponseSize': None,
'clientRequestSize': None,
'producerRequestSize': None,
'succeeded': None,
'producerDurationProducerView': None,
'totalDuration': None
}
report_row_producer.update_row(new_doc.copy())
report_row_producer.update_row(new_doc_none.copy())
row = [
number_of_clients, number_of_clients,
min(client_durations), (sum(client_durations), number_of_clients),
max(client_durations),
min(client_requests), (sum(client_requests), number_of_clients),
max(client_requests),
min(client_responses), (sum(client_responses), number_of_clients),
max(client_responses)
]
self.assertEqual(report_row_producer.return_row(), row)
def test_get_name_and_count(self):
report_manager = ReportManager(None, None, None, "ss", "2017-01-01",
"2017-01-01", None, None, None, None,
None, None, None, None, None, None,
None, None)
key = "ee-dev"
report_row = ReportRow(None)
suc_queries = 10
report_row.succeeded_queries = suc_queries
produced_service = True
service_name = "service"
self.assertEqual(
report_manager.get_name_and_count(key, report_row,
produced_service, service_name),
("ss: ee-dev", suc_queries))
produced_service = False
self.assertEqual(
report_manager.get_name_and_count(key, report_row,
produced_service, service_name),
("ee-dev: service", suc_queries))
def test_update_row(self):
report_row_producer = ReportRow(None)
number_of_clients = 300
client_responses = []
client_requests = []
client_durations = []
for i in range(number_of_clients):
response_size = random.randint(0, 1000)
request_size = random.randint(0, 1000)
duration_size = random.randint(0, 1000)
client_responses.append(response_size)
client_requests.append(request_size)
client_durations.append(duration_size)
new_doc = {
'clientResponseSize': response_size,
'producerResponseSize': response_size,
'clientRequestSize': request_size,
'producerRequestSize': request_size,
'succeeded': True,
'producerDurationProducerView': duration_size,
'totalDuration': duration_size
}
new_doc_none = {
'clientResponseSize': None,
'producerResponseSize': None,
'clientRequestSize': None,
'producerRequestSize': None,
'succeeded': None,
'producerDurationProducerView': None,
'totalDuration': None
}
report_row_producer.update_row(new_doc.copy())
report_row_producer.update_row(new_doc_none.copy())
self.assertEqual(report_row_producer.response_min,
min(client_responses))
self.assertEqual(report_row_producer.response_max,
max(client_responses))
self.assertEqual(report_row_producer.response_avg,
(sum(client_responses), number_of_clients))
self.assertEqual(report_row_producer.request_min, min(client_requests))
self.assertEqual(report_row_producer.request_max, max(client_requests))
self.assertEqual(report_row_producer.request_avg,
(sum(client_requests), number_of_clients))
self.assertEqual(report_row_producer.duration_min,
min(client_durations))
self.assertEqual(report_row_producer.duration_max,
max(client_durations))
self.assertEqual(report_row_producer.duration_avg,
(sum(client_durations), number_of_clients))
self.assertEqual(report_row_producer.succeeded_queries,
number_of_clients)
# It is equal to number_of_clients because the "succeeded": None means it is False in the new_doc_none.
self.assertEqual(report_row_producer.failed_queries, number_of_clients)
def test_calculate_succeeded_queries(self):
report_row = ReportRow(None)
number_of_succeeded = 300
number_of_failed = 200
for i in range(number_of_succeeded):
report_row.calculate_succeeded_queries(True)
for i in range(number_of_failed):
report_row.calculate_succeeded_queries(False)
self.assertEqual(report_row.succeeded_queries, number_of_succeeded)
def test_calculate_request(self):
report_row_producer = ReportRow(None)
report_row_consumer = ReportRow(None)
number_of_client_requirements = 300
number_of_producer_requirements = 200
client_requirements = []
for i in range(number_of_client_requirements):
request_size = random.randint(0, 1000)
client_requirements.append(request_size)
new_doc = {
'clientRequestSize': request_size,
'producerRequestSize': None
}
new_doc_none = {
'clientRequestSize': None,
'producerRequestSize': None
}
report_row_producer.calculate_request(new_doc)
report_row_producer.calculate_request(new_doc_none)
self.assertEqual(report_row_producer.request_min,
min(client_requirements))
self.assertEqual(report_row_producer.request_max,
max(client_requirements))
self.assertEqual(
report_row_producer.request_avg,
(sum(client_requirements), number_of_client_requirements))
producer_requirements = []
for i in range(number_of_producer_requirements):
request_size = random.randint(0, 1000)
producer_requirements.append(request_size)
new_doc = {
'clientRequestSize': None,
'producerRequestSize': request_size
}
new_doc_none = {
'clientRequestSize': None,
'producerRequestSize': None
}
report_row_consumer.calculate_request(new_doc)
report_row_consumer.calculate_request(new_doc_none)
self.assertEqual(report_row_consumer.request_min,
min(producer_requirements))
self.assertEqual(report_row_consumer.request_max,
max(producer_requirements))
self.assertEqual(
report_row_consumer.request_avg,
(sum(producer_requirements), number_of_producer_requirements))
def test_calculate_duration(self):
report_row_producer = ReportRow(True)
report_row_consumer = ReportRow(False)
number_of_producers = 300
number_of_consumers = 200
producers_duration = []
for i in range(number_of_producers):
duration = random.randint(0, 1000)
producers_duration.append(duration)
new_doc = {
'producerDurationProducerView': duration,
'totalDuration': None
}
new_doc_none = {
'producerDurationProducerView': None,
'totalDuration': None
}
report_row_producer.calculate_duration(new_doc)
report_row_producer.calculate_duration(new_doc_none)
self.assertEqual(report_row_producer.duration_min,
min(producers_duration))
self.assertEqual(report_row_producer.duration_max,
max(producers_duration))
self.assertEqual(report_row_producer.duration_avg,
(sum(producers_duration), number_of_producers))
consumers_duration = []
for i in range(number_of_consumers):
duration = random.randint(0, 1000)
consumers_duration.append(duration)
new_doc = {
'producerDurationProducerView': None,
'totalDuration': duration
}
new_doc_none = {
'producerDurationProducerView': None,
'totalDuration': None
}
report_row_consumer.calculate_duration(new_doc)
report_row_consumer.calculate_duration(new_doc_none)
self.assertEqual(report_row_consumer.duration_min,
min(consumers_duration))
self.assertEqual(report_row_consumer.duration_max,
max(consumers_duration))
self.assertEqual(report_row_consumer.duration_avg,
(sum(consumers_duration), number_of_consumers))
def test_get_duration_top(self):
report_manager = ReportManager(None, None, None, "ss", "2017-01-01",
"2017-01-01", None, None, None, None,
None, None, None, None, None, None,
None, None)
report_row = ReportRow(None)
report_row.duration_avg = (100, 10)
report_row_2 = ReportRow(None)
report_row_2.duration_avg = (1000, 10)
report_row_3 = ReportRow(None)
report_row_3.duration_avg = (200, 10)
report_row_4 = ReportRow(None)
report_row_4.duration_avg = (109, 10)
report_row_5 = ReportRow(None)
report_row_5.duration_avg = (1100, 10)
report_row_6 = ReportRow(None)
report_row_6.duration_avg = (209, 10)
report_row_7 = ReportRow(None)
report_row_7.duration_avg = (90, 10)
report_row_8 = ReportRow(None)
report_row_8.duration_avg = (900, 10)
report_row_9 = ReportRow(None)
report_row_9.duration_avg = (190, 10)
test_data = {
"service_1": {
"ee-dev": report_row,
"ee-dev_2": report_row_2,
"ee-dev_3": report_row_3
},
"service_2": {
"ee-dev_4": report_row_7,
"ee-dev_5": report_row_8,
"ee-dev_6": report_row_9
},
"service_3": {
"ee-dev_7": report_row_4,
"ee-dev_8": report_row_5,
"ee-dev_9": report_row_6
},
}
self.assertEqual(report_manager.get_duration_top(test_data, True),
[("ss: service_2", 90), ("ss: service_1", 100),
("ss: service_3", 110)])
self.assertEqual(report_manager.get_duration_top(test_data, False),
[("service_1: ee-dev_3", 20),
("service_3: ee-dev_9", 21),
("service_2: ee-dev_5", 90),
("service_1: ee-dev_2", 100),
("service_3: ee-dev_8", 110)])
def test_get_succeeded_top(self):
report_manager = ReportManager(None, None, None, "ss", "2017-01-01",
"2017-01-01", None, None, None, None,
None, None, None, None, None, None,
None, None)
report_row = ReportRow(None)
report_row.succeeded_queries = 10
report_row_2 = ReportRow(None)
report_row_2.succeeded_queries = 15
report_row_3 = ReportRow(None)
report_row_3.succeeded_queries = 7
report_row_4 = ReportRow(None)
report_row_4.succeeded_queries = 12
report_row_5 = ReportRow(None)
report_row_5.succeeded_queries = 13
report_row_6 = ReportRow(None)
report_row_6.succeeded_queries = 8
report_row_7 = ReportRow(None)
report_row_7.succeeded_queries = 11
report_row_8 = ReportRow(None)
report_row_8.succeeded_queries = 14
report_row_9 = ReportRow(None)
report_row_9.succeeded_queries = 9
test_data = {
"service_1": {
"ee-dev": report_row,
"ee-dev_2": report_row_2,
"ee-dev_3": report_row_3
},
"service_2": {
"ee-dev_4": report_row_7,
"ee-dev_5": report_row_8,
"ee-dev_6": report_row_9
},
"service_3": {
"ee-dev_7": report_row_4,
"ee-dev_8": report_row_5,
"ee-dev_9": report_row_6
},
}
self.assertEqual(report_manager.get_succeeded_top(test_data, True),
[("ss: service_3", 13), ("ss: service_2", 14),
("ss: service_1", 15)])
self.assertEqual(report_manager.get_succeeded_top(test_data, False),
[("service_2: ee-dev_4", 11),
("service_3: ee-dev_7", 12),
("service_3: ee-dev_8", 13),
("service_2: ee-dev_5", 14),
("service_1: ee-dev_2", 15)])