def test_compute_statuses(patch_path, expected_status):
client_name = "client"
user_journey_name = "uj"
node_name = "node"
orphan_name = "orphan"
client_name_message_map = {
client_name:
Client(
name=client_name,
user_journeys=[
UserJourney(
name=user_journey_name,
client_name=client_name,
dependencies=[
Dependency(
source_name=f"{client_name}.{user_journey_name}",
target_name=node_name,
)
],
),
],
),
}
node_name_message_map = {
node_name: Node(name=node_name),
orphan_name: Node(name=orphan_name),
}
def side_effect_update_node_name_message_map(_, node_name):
node_name_message_map[node_name].status = expected_status
return expected_status
with patch(
f"{patch_path}.compute_single_node_status",
Mock(side_effect=side_effect_update_node_name_message_map),
) as mock_compute_single_node_status, patch(
f"{patch_path}.compute_status_from_count_map",
Mock(return_value=expected_status),
) as mock_compute_status_from_count_map:
ujt.compute_status.compute_statuses(node_name_message_map,
client_name_message_map)
assert (client_name_message_map[client_name].user_journeys[0].status ==
expected_status)
assert node_name_message_map[node_name].status == expected_status
assert node_name_message_map[orphan_name].status == expected_status
assert mock_compute_single_node_status.mock_calls == [
call(ANY, node_name),
call(ANY, orphan_name),
]
assert mock_compute_status_from_count_map.mock_calls == [
call({expected_status: 1})
]
def generate_nodes():
"""Generates mock service data used to test the UJT.
Returns: a list of Service protobufs.
"""
services = []
endpoints = []
for service_name, relative_endpoint_names in SERVICE_ENDPOINT_NAME_MAP.items(
):
service = Node(node_type=NodeType.NODETYPE_SERVICE, name=service_name)
fully_qualified_endpoint_names = [
f"{service.name}.{relative_endpoint_name}"
for relative_endpoint_name in relative_endpoint_names
]
service.child_names.extend(fully_qualified_endpoint_names)
service.slis.extend([
SLI(
node_name=service_name,
sli_value=random.random(),
slo_target=SLO_TARGET,
sli_type=SLIType.SLITYPE_AVAILABILITY,
intra_status_change_threshold=INTRA_STATUS_CHANGE_THRESHOLD,
**SLO_BOUNDS,
)
])
services.append(service)
for endpoint_name in fully_qualified_endpoint_names:
endpoint = Node(
node_type=NodeType.NODETYPE_ENDPOINT,
name=endpoint_name,
parent_name=service.name,
)
endpoint.dependencies.extend([
Dependency(target_name=target_name, source_name=endpoint_name)
for target_name in NODE_DEPENDENCY_MAP[endpoint_name]
])
endpoint.slis.extend([
SLI(
node_name=endpoint_name,
sli_value=random.random(),
slo_target=SLO_TARGET,
sli_type=SLIType.SLITYPE_LATENCY,
intra_status_change_threshold=INTRA_STATUS_CHANGE_THRESHOLD,
**SLO_BOUNDS,
)
])
endpoints.append(endpoint)
return services + endpoints
def test_read_write_functional(patch_path, tmp_path):
node = Node()
node.name = "name"
node.comment = "comment"
ujt.server.server_utils.write_proto_to_file(
tmp_path / ujt.server.server_utils.named_proto_file_name(node.name, Node),
node,
)
service_from_file = ujt.server.server_utils.read_proto_from_file(
tmp_path / ujt.server.server_utils.named_proto_file_name(node.name, Node),
Node,
)
assert service_from_file == node
def test_datatable_from_nodes():
node = Node(name="node", status=Status.STATUS_HEALTHY)
table_id = "test-table"
expected_columns = [
{
"name": "Node",
"id": "Node"
},
{
"name": "Status",
"id": "Status"
},
]
expected_data = [{
"Node": node.name,
"Status": "HEALTHY",
}]
table = ujt.converters.datatable_from_nodes(
[node],
use_relative_names=False,
table_id=table_id,
)
assert table.id == table_id # pylint: disable=no-member
assert table.columns == expected_columns # pylint: disable=no-member
assert table.data == expected_data # pylint: disable=no-member
assert (table.style_data_conditional # pylint: disable=no-member
== ujt.constants.DATATABLE_CONDITIONAL_STYLE)
def test_reset_node_statuses():
node_name = "node"
node_name_message_map = {
node_name: Node(name=node_name, status=Status.STATUS_ERROR),
}
ujt.compute_status.reset_node_statuses(node_name_message_map)
assert node_name_message_map[node_name].status == Status.STATUS_UNSPECIFIED
def test_compute_single_node_status_already_set():
node_name = "node"
node_name_message_map = {
node_name: Node(name=node_name, status=Status.STATUS_HEALTHY)
}
assert (ujt.compute_status.compute_single_node_status(
node_name_message_map, node_name) == Status.STATUS_HEALTHY)
assert node_name_message_map[node_name].status == Status.STATUS_HEALTHY
def test_compute_single_node_status_with_child(expected_status):
parent_name = "parent"
child_name = "child"
node_name_message_map = {
parent_name:
Node(
name=parent_name,
status=Status.STATUS_UNSPECIFIED,
child_names=[child_name],
),
child_name:
Node(
name=child_name,
status=expected_status,
parent_name=parent_name,
),
}
assert (ujt.compute_status.compute_single_node_status(
node_name_message_map, parent_name) == expected_status)
assert node_name_message_map[parent_name].status == expected_status
def test_compute_single_node_status_with_dependency(expected_status):
source_name = "source"
target_name = "target"
node_name_message_map = {
source_name:
Node(
name=source_name,
status=Status.STATUS_UNSPECIFIED,
dependencies=[
Dependency(target_name=target_name, source_name=source_name),
],
),
target_name:
Node(
name=target_name,
status=expected_status,
),
}
assert (ujt.compute_status.compute_single_node_status(
node_name_message_map, source_name) == expected_status)
assert node_name_message_map[source_name].status == expected_status
def test_compute_single_node_status_with_sli(sli_value, expected_status,
slo_bounds):
node_name = "node"
node_name_message_map = {
node_name:
Node(
name=node_name,
slis=[SLI(node_name=node_name, sli_value=sli_value, **slo_bounds)],
)
}
assert (ujt.compute_status.compute_single_node_status(
node_name_message_map, node_name) == expected_status)
assert node_name_message_map[node_name].status == expected_status
def test_apply_node_property_classes(assert_same_elements):
node_name = "node"
node_name_message_map = {
node_name: Node(
name=node_name,
status=Status.STATUS_HEALTHY,
node_type=NodeType.NODETYPE_SERVICE,
),
}
client_name = "client"
client_name_message_map = {
client_name: Client(
name=client_name,
),
}
virtual_node_name = "virtual_node"
virtual_node_name_message_map = {
virtual_node_name: VirtualNode(
name=virtual_node_name,
status=Status.STATUS_HEALTHY,
node_type=NodeType.NODETYPE_VIRTUAL,
)
}
elements = [
{
"data": {
"ujt_id": node_name,
},
"classes": "",
},
{
"data": {
"ujt_id": client_name,
},
"classes": "",
},
{
"data": {
"ujt_id": virtual_node_name,
},
"classes": "",
},
]
expected_elements = [
{
"data": {
"ujt_id": node_name,
},
"classes": " NODETYPE_SERVICE STATUS_HEALTHY",
},
{
"data": {
"ujt_id": client_name,
},
"classes": f" {ujt.constants.CLIENT_CLASS}",
},
{
"data": {
"ujt_id": virtual_node_name,
},
"classes": " NODETYPE_VIRTUAL STATUS_HEALTHY",
},
]
returned_elements = ujt.transformers.apply_node_property_classes(
elements,
node_name_message_map,
client_name_message_map,
virtual_node_name_message_map,
)
assert_same_elements(returned_elements, expected_elements)
def test_generate_nodes_functional(patch_path, assert_same_elements):
service_relative_names = ["Service0", "Service1"]
endpoint_relative_names = ["Endpoint0", "Endpoint1", "Endpoint2"]
test_service_endpoint_name_map = {
service_relative_names[0]: [
endpoint_relative_names[0],
endpoint_relative_names[1],
],
service_relative_names[1]: [endpoint_relative_names[2]],
}
test_node_dependency_map = {
f"{service_relative_names[0]}.{endpoint_relative_names[0]}": [
f"{service_relative_names[0]}.{endpoint_relative_names[1]}",
f"{service_relative_names[1]}.{endpoint_relative_names[2]}",
],
f"{service_relative_names[0]}.{endpoint_relative_names[1]}":
[f"{service_relative_names[1]}.{endpoint_relative_names[2]}"],
f"{service_relative_names[1]}.{endpoint_relative_names[2]}": [],
}
expected_nodes = [
Node(
node_type=NodeType.NODETYPE_SERVICE,
name=service_relative_names[0],
child_names=[
f"{service_relative_names[0]}.{endpoint_relative_names[0]}",
f"{service_relative_names[0]}.{endpoint_relative_names[1]}",
],
slis=[
SLI(
node_name=service_relative_names[0],
sli_value=0.5,
slo_target=ujt.server.generate_data.SLO_TARGET,
sli_type=SLIType.SLITYPE_AVAILABILITY,
intra_status_change_threshold=ujt.server.generate_data.
INTRA_STATUS_CHANGE_THRESHOLD,
**ujt.server.generate_data.SLO_BOUNDS,
),
],
),
Node(
node_type=NodeType.NODETYPE_SERVICE,
name=service_relative_names[1],
child_names=[
f"{service_relative_names[1]}.{endpoint_relative_names[2]}"
],
slis=[
SLI(
node_name=service_relative_names[1],
sli_value=0.5,
slo_target=ujt.server.generate_data.SLO_TARGET,
sli_type=SLIType.SLITYPE_AVAILABILITY,
intra_status_change_threshold=ujt.server.generate_data.
INTRA_STATUS_CHANGE_THRESHOLD,
**ujt.server.generate_data.SLO_BOUNDS,
),
],
),
Node(
node_type=NodeType.NODETYPE_ENDPOINT,
name=f"{service_relative_names[0]}.{endpoint_relative_names[0]}",
parent_name=service_relative_names[0],
dependencies=[
Dependency(
target_name=
f"{service_relative_names[0]}.{endpoint_relative_names[1]}",
source_name=
f"{service_relative_names[0]}.{endpoint_relative_names[0]}",
),
Dependency(
target_name=
f"{service_relative_names[1]}.{endpoint_relative_names[2]}",
source_name=
f"{service_relative_names[0]}.{endpoint_relative_names[0]}",
),
],
slis=[
SLI(
node_name=
f"{service_relative_names[0]}.{endpoint_relative_names[0]}",
sli_value=0.5,
slo_target=ujt.server.generate_data.SLO_TARGET,
sli_type=SLIType.SLITYPE_LATENCY,
intra_status_change_threshold=ujt.server.generate_data.
INTRA_STATUS_CHANGE_THRESHOLD,
**ujt.server.generate_data.SLO_BOUNDS,
),
],
),
Node(
node_type=NodeType.NODETYPE_ENDPOINT,
name=f"{service_relative_names[0]}.{endpoint_relative_names[1]}",
parent_name=service_relative_names[0],
dependencies=[
Dependency(
target_name=
f"{service_relative_names[1]}.{endpoint_relative_names[2]}",
source_name=
f"{service_relative_names[0]}.{endpoint_relative_names[1]}",
),
],
slis=[
SLI(
node_name=
f"{service_relative_names[0]}.{endpoint_relative_names[1]}",
sli_value=0.5,
slo_target=ujt.server.generate_data.SLO_TARGET,
sli_type=SLIType.SLITYPE_LATENCY,
intra_status_change_threshold=ujt.server.generate_data.
INTRA_STATUS_CHANGE_THRESHOLD,
**ujt.server.generate_data.SLO_BOUNDS,
),
],
),
Node(
node_type=NodeType.NODETYPE_ENDPOINT,
name=f"{service_relative_names[1]}.{endpoint_relative_names[2]}",
parent_name=service_relative_names[1],
slis=[
SLI(
node_name=
f"{service_relative_names[1]}.{endpoint_relative_names[2]}",
sli_value=0.5,
slo_target=ujt.server.generate_data.SLO_TARGET,
sli_type=SLIType.SLITYPE_LATENCY,
intra_status_change_threshold=ujt.server.generate_data.
INTRA_STATUS_CHANGE_THRESHOLD,
**ujt.server.generate_data.SLO_BOUNDS,
),
],
),
]
with patch(f"{patch_path}.SERVICE_ENDPOINT_NAME_MAP",
test_service_endpoint_name_map), patch(
f"{patch_path}.NODE_DEPENDENCY_MAP",
test_node_dependency_map), patch(
f"{patch_path}.random.random", Mock(return_value=0.5)):
nodes = ujt.server.generate_data.generate_nodes()
assert_same_elements(nodes, expected_nodes)
def example_node_name_message_map(
slo_bounds,
example_node_name_message_map_service_relative_names,
example_node_name_message_map_endpoint_relative_names,
):
service_relative_names = example_node_name_message_map_service_relative_names
endpoint_relative_names = example_node_name_message_map_endpoint_relative_names
node_name_message_map = {
service_relative_names[0]: Node(
node_type=NodeType.NODETYPE_SERVICE,
name=service_relative_names[0],
child_names=[
f"{service_relative_names[0]}.{endpoint_relative_names[0]}",
f"{service_relative_names[0]}.{endpoint_relative_names[1]}",
],
slis=[
SLI(
node_name=service_relative_names[0],
sli_value=0.5,
**slo_bounds,
),
],
),
service_relative_names[1]: Node(
node_type=NodeType.NODETYPE_SERVICE,
name=service_relative_names[1],
child_names=[f"{service_relative_names[1]}.{endpoint_relative_names[2]}"],
slis=[
SLI(
node_name=service_relative_names[1],
sli_value=0.5,
**slo_bounds,
),
],
),
f"{service_relative_names[0]}.{endpoint_relative_names[0]}": Node(
node_type=NodeType.NODETYPE_ENDPOINT,
name=f"{service_relative_names[0]}.{endpoint_relative_names[0]}",
parent_name=service_relative_names[0],
dependencies=[
Dependency(
target_name=f"{service_relative_names[0]}.{endpoint_relative_names[1]}",
source_name=f"{service_relative_names[0]}.{endpoint_relative_names[0]}",
),
Dependency(
target_name=f"{service_relative_names[1]}.{endpoint_relative_names[2]}",
source_name=f"{service_relative_names[0]}.{endpoint_relative_names[0]}",
),
],
slis=[
SLI(
node_name=f"{service_relative_names[0]}.{endpoint_relative_names[0]}",
sli_value=0.5,
**slo_bounds,
),
],
),
f"{service_relative_names[0]}.{endpoint_relative_names[1]}": Node(
node_type=NodeType.NODETYPE_ENDPOINT,
name=f"{service_relative_names[0]}.{endpoint_relative_names[1]}",
parent_name=service_relative_names[0],
dependencies=[
Dependency(
target_name=f"{service_relative_names[1]}.{endpoint_relative_names[2]}",
source_name=f"{service_relative_names[0]}.{endpoint_relative_names[1]}",
),
],
slis=[
SLI(
node_name=f"{service_relative_names[0]}.{endpoint_relative_names[1]}",
sli_value=0.5,
**slo_bounds,
),
],
),
f"{service_relative_names[1]}.{endpoint_relative_names[2]}": Node(
node_type=NodeType.NODETYPE_ENDPOINT,
name=f"{service_relative_names[1]}.{endpoint_relative_names[2]}",
parent_name=service_relative_names[1],
slis=[
SLI(
node_name=f"{service_relative_names[1]}.{endpoint_relative_names[2]}",
sli_value=0.5,
**slo_bounds,
),
],
),
}
return node_name_message_map