def test_gen_volumes_usage_lt_capacity(self):
"""Test that gen_volumes generates requests and usage values which don't exceed capacity."""
for attributes in [self.attributes, {}]:
with self.subTest(attributes=attributes):
generator = OCPGenerator(self.two_hours_ago, self.now,
attributes)
# gen_volumes depends on the output formatting of gen_namespaces and gen_pods.
out_volumes = generator._gen_volumes(generator.namespaces,
generator.namespace2pods)
for volume in out_volumes.values():
with self.subTest(volume=volume):
total_capacity = 0
for claim in volume.get("volume_claims").values():
with self.subTest(claim=claim):
capacity = claim.get("capacity")
total_capacity += capacity
if attributes:
for value in claim.get(
"volume_claim_usage_gig").values():
self.assertLessEqual(
value * GIGABYTE, capacity)
self.assertLessEqual(
total_capacity,
volume.get("volume_request_gig", 80.0 * GIGABYTE))
def test_gen_volumes_with_namespaces(self):
"""Test that gen_volumes arranges the output dict in the expected way.
If namespaces with volumes are specified, defined volumes are used.
"""
generator = OCPGenerator(self.two_hours_ago, self.now, self.attributes)
# gen_volumes depends on the output formatting of gen_namespaces and gen_pods.
out_volumes = generator._gen_volumes(generator.namespaces,
generator.namespace2pods)
namespaces = self.attributes.get("nodes")[0].get("namespaces")
volume_names = [
vol.get("volume_name") for ns in namespaces
for vol in namespaces.get(ns).get("volumes")
]
self.assertEqual(list(out_volumes.keys()), volume_names)
expected = [
"namespace", "volume", "storage_class", "volume_request", "labels",
"volume_claims"
]
for vol in out_volumes.values():
with self.subTest(volume=vol):
self.assertEqual(list(vol.keys()), expected)
def test_update_data(self):
"""Test that update_data calls the expected update method."""
generator = OCPGenerator(self.two_hours_ago, self.now, self.attributes)
test_method1 = Mock(return_value=True)
test_method2 = Mock(return_value=True)
with patch.dict(
generator.ocp_report_generation,
{
"test_report": {
"_generate_hourly_data": test_method1,
"_update_data": test_method2
}
},
):
kwargs = {"report_type": "test_report"}
generator._update_data({}, self.two_hours_ago, self.now, **kwargs)
test_method2.assert_called_with(
{
"interval_start":
self.two_hours_ago.strftime("%Y-%m-%d %H:%M:%S +0000 UTC"),
"interval_end":
self.now.strftime("%Y-%m-%d %H:%M:%S +0000 UTC"),
},
self.two_hours_ago,
self.now,
**kwargs,
)
test_method1.assert_not_called()
def test_update_pod_data_usage_lt_request(self):
"""Test that _update_pod_data keeps usage <= limit <= request."""
pods = self.attributes.get("nodes")[0].get("namespaces")[0].get("pods")
kwargs = {
"report_type": "test_report",
"cpu_usage": self._usage_dict(),
"mem_usage_gig": self._usage_dict(),
"pod_seconds": 86400,
"pod": pods[0],
}
generator = OCPGenerator(self.two_hours_ago, self.now)
in_row = generator._init_data_row(self.two_hours_ago,
self.now,
report_type=OCP_POD_USAGE)
out_row = generator._update_pod_data(copy(in_row), self.two_hours_ago,
self.now, **kwargs)
for x in ["cpu_core", "memory_byte"]:
with self.subTest(row=out_row):
with self.subTest(x=x):
self.assertLessEqual(
out_row.get(f"pod_usage_{x}_seconds"),
out_row.get(f"pod_request_{x}_seconds"))
self.assertLessEqual(out_row.get(f"pod_usage_{x}_seconds"),
out_row.get(f"pod_limit_{x}_seconds"))
self.assertLessEqual(
out_row.get(f"pod_limit_{x}_seconds"),
out_row.get(f"pod_request_{x}_seconds"))
def test_gen_pods_usage_lt_capacity(self):
"""Test that gen_pods generates requests and usage values which don't exceed limit."""
for attributes in [self.attributes, {}]:
with self.subTest(attributes=attributes):
generator = OCPGenerator(self.two_hours_ago, self.now,
attributes)
# gen_pods depends on the output of gen_namespaces.
out_pods, _ = generator._gen_pods(generator.namespaces)
for pod in out_pods.values():
with self.subTest(pod=pod):
self.assertLessEqual(
pod.get("cpu_limit"),
pod.get("node_capacity_cpu_cores"))
self.assertLessEqual(
pod.get("cpu_request"),
pod.get("node_capacity_cpu_cores"))
self.assertLessEqual(
pod.get("mem_limit_gig"),
pod.get("node_capacity_memory_bytes"))
self.assertLessEqual(
pod.get("mem_request_gig"),
pod.get("node_capacity_memory_bytes"))
if attributes:
for value in pod.get("cpu_usage").values():
self.assertLessEqual(
value, pod.get("node_capacity_cpu_cores"))
for value in pod.get("mem_usage_gig").values():
self.assertLessEqual(
value,
pod.get("node_capacity_memory_bytes"))
def test_generate_data(self):
"""Test that generate_data calls the test method."""
generator = OCPGenerator(self.two_hours_ago, self.now)
with patch.object(generator, "_generate_hourly_data") as mock_method:
kwargs = {"report_type": "test_report"}
generator.generate_data(**kwargs)
mock_method.assert_called_with(**kwargs)
def test_update_storage_data(self):
"""Test that _update_storage_data updates storage data."""
kwargs = {
"volume_claim_usage_gig":
self._usage_dict(),
"vc_capacity":
self.fake.pyint(1, 100),
"namespace":
self.fake.word(),
"pod":
self.fake.word(),
"volume_claim":
self.fake.uuid4(),
"volume_name":
self.fake.word(),
"storage_class":
self.fake.word(),
"volume_request":
self.fake.pyint(1, 100),
"volume_labels": (
f"label_{self.fake.word()}:{self.fake.word()}",
f"|label_{self.fake.word()}:{self.fake.word()}",
),
"volume_claim_labels": (
f"label_{self.fake.word()}:{self.fake.word()}",
f"|label_{self.fake.word()}:{self.fake.word()}",
),
}
changed = {
"namespace",
"pod",
"persistentvolumeclaim",
"persistentvolume",
"storageclass",
"persistentvolumeclaim_capacity_bytes",
"persistentvolumeclaim_capacity_byte_seconds",
"volume_request_storage_byte_seconds",
"persistentvolume_labels",
"persistentvolumeclaim_labels",
"persistentvolumeclaim_usage_byte_seconds",
}
generator = OCPGenerator(self.two_hours_ago, self.now)
in_row = generator._init_data_row(self.two_hours_ago,
self.now,
report_type=OCP_STORAGE_USAGE)
out_row = generator._update_storage_data(copy(in_row),
self.two_hours_ago, self.now,
**kwargs)
for key in changed:
with self.subTest(key=key):
if key in kwargs:
self.assertEqual(out_row.get(key), kwargs.get(key))
self.assertNotEqual(out_row.get(key), in_row.get(key))
for key in list(set(out_row.keys()) - changed):
with self.subTest(key=key):
self.assertIsNotNone(out_row.get(key))
def test_add_common_usage_info(self):
"""Test that add_common_usage_info updates usage timestamps."""
generator = OCPGenerator(self.two_hours_ago, self.now, {})
test_row = {}
output_row = generator._add_common_usage_info(test_row,
self.two_hours_ago,
self.now)
self.assertIn("interval_start", output_row)
self.assertIn("interval_end", output_row)
def test_gen_namespaces_without_namespace(self):
"""Test that gen_namespaces arranges the output dict in the expected way.
If no namespaces are specified, namespaces are generated.
"""
in_nodes = self.attributes.get("nodes")
generator = OCPGenerator(self.two_hours_ago, self.now)
out_namespaces = generator._gen_namespaces(in_nodes[0])
# auto-generating namespaces should create at least 2 namespaces
self.assertGreaterEqual(len(out_namespaces), 1)
def test_gen_nodes_without_nodes(self):
"""Test that gen_nodes arranges the output dict in the expected way.
If nodes are not specified, nodes are generated.
"""
generator = OCPGenerator(self.two_hours_ago, self.now, {})
out_nodes = generator._gen_nodes()
self.assertGreaterEqual(len(list(out_nodes)), 2)
self.assertLessEqual(len(list(out_nodes)), 6)
expected_keys = [
"name", "cpu_cores", "memory_bytes", "resource_id", "node_labels"
]
self.assertEqual(list(out_nodes[0].keys()), expected_keys)
def test_gen_nodes_with_nodes(self):
"""Test that gen_nodes arranges the output dict in the expected way.
If nodes are specified, nodes are not generated.
"""
in_nodes = self.attributes.get("nodes")
generator = OCPGenerator(self.two_hours_ago, self.now, self.attributes)
out_nodes = generator._gen_nodes()
self.assertEqual(len(list(out_nodes)), len(list(in_nodes)))
expected_keys = [
"name", "cpu_cores", "memory_bytes", "resource_id", "namespaces",
"node_labels"
]
self.assertEqual(list(out_nodes[0].keys()), expected_keys)
def test_gen_namespaces_with_namespace(self):
"""Test that gen_namespaces arranges the output dict in the expected way.
If namespaces are specified, namespaces are not generated.
"""
in_nodes = self.attributes.get("nodes")
generator = OCPGenerator(self.two_hours_ago, self.now, self.attributes)
out_namespaces = generator._gen_namespaces(in_nodes)
self.assertEqual(list(out_namespaces.keys()),
list(in_nodes[0].get("namespaces").keys()))
for value in out_namespaces.values():
with self.subTest(node=value):
self.assertEqual(list(value.get("namespaces").keys()),
list(in_nodes[0].get("namespaces").keys()))
def test_init_data_row(self):
"""Test that init_data_row initializes a row of data."""
generator = OCPGenerator(self.two_hours_ago, self.now, self.attributes)
for report_type, columns in [
(OCP_POD_USAGE, OCP_POD_USAGE_COLUMNS),
(OCP_NODE_LABEL, OCP_NODE_LABEL_COLUMNS),
(OCP_STORAGE_USAGE, OCP_STORAGE_COLUMNS),
]:
with self.subTest(report_type=report_type):
row = generator._init_data_row(self.two_hours_ago,
self.now,
report_type=report_type)
self.assertIsInstance(row, dict)
self.assertEqual(list(row.keys()), list(columns))
def test_gen_pods_without_namespaces(self):
"""Test that gen_pods arranges the output dict in the expected way.
If no namespaces are specified, pods are generated.
"""
generator = OCPGenerator(self.two_hours_ago, self.now, {})
out_pods, _ = generator._gen_pods(generator.namespaces)
# these magic numbers are the random ranges defined in the OCP generator.
self.assertGreaterEqual(len(out_pods), 2 * 2 * 2)
self.assertLessEqual(len(out_pods), 6 * 12 * 20)
# This list isn't quite the same as (OCP_POD_USAGE_COLUMNS + OCP_NODE_LABEL_COLUMNS + OCP_STORAGE_COLUMNS)
# This might be a bug.
expected = (
"cpu_limit",
"cpu_request",
"cpu_usage",
"interval_start",
"interval_end",
"mem_limit_gig",
"mem_request_gig",
"mem_usage_gig",
"namespace",
"node",
"node_capacity_cpu_cores",
"node_capacity_cpu_core_seconds",
"node_capacity_memory_bytes",
"node_capacity_memory_byte_seconds",
"node_labels",
"pod",
"pod_labels",
"pod_limit_cpu_core_seconds",
"pod_limit_memory_byte_seconds",
"pod_request_cpu_core_seconds",
"pod_request_memory_byte_seconds",
"pod_seconds",
"pod_usage_cpu_core_seconds",
"pod_usage_memory_byte_seconds",
"report_period_start",
"report_period_end",
"resource_id",
)
for pod in out_pods.values():
with self.subTest(podkeys=pod.keys()):
for key in pod.keys():
with self.subTest(key=key):
self.assertIn(key, expected)
def test_init_with_attributes(self):
"""Test the init with attributes generates a node with the provided name."""
in_yaml = """
---
generators:
- OCPGenerator:
start_date: 1970-01-01
end_date: 1970-02-01
nodes:
- node_name: test_node
namespaces:
- namespace_name: test_namespace
pods:
- pod_name: test_pod
volumes:
- volume_name: test_volume
volume_claims:
- volume_claim_name: test_claim
"""
_, tmp_filename = tempfile.mkstemp()
with open(tmp_filename, "w+") as tmp_handle:
tmp_handle.write(in_yaml)
generator = OCPGenerator(self.two_hours_ago,
self.now,
user_config=tmp_filename)
self.assertIsNotNone(generator.nodes)
self.assertIsInstance(generator.nodes, list)
self.assertGreaterEqual(len(generator.nodes), 1)
self.assertEqual(generator.nodes[0].get("node_name"), "test_node")
os.remove(tmp_filename)
def test_gen_pods_usage_lt_capacity(self):
"""Test that gen_pods generates requests and usage values which don't exceed capacity."""
generator = OCPGenerator(self.two_hours_ago, self.now)
for node in generator.nodes:
with self.subTest(node=node):
for namespace in node.get("namespaces"):
with self.subTest(
namespace=namespace.get("namespace_name")):
for pod in namespace.get("pods"):
with self.subTest(pod=pod.get("pod_name")):
self.assertLessEqual(
pod.get("cpu_limit"),
pod.get("node_capacity_cpu_cores"))
self.assertLessEqual(
pod.get("cpu_request"),
pod.get("node_capacity_cpu_cores"))
self.assertLessEqual(
pod.get("mem_limit_gig"),
pod.get("node_capacity_memory_bytes"))
self.assertLessEqual(
pod.get("mem_request_gig"),
pod.get("node_capacity_memory_bytes"))
for value in pod.get("cpu_usage").values():
self.assertLessEqual(
value,
pod.get("node_capacity_cpu_cores"))
for value in pod.get("mem_usage_gig").values():
self.assertLessEqual(
value,
pod.get("node_capacity_memory_bytes"))
def test_gen_namespaces_without_namespace(self):
"""Test that gen_namespaces arranges the output dict in the expected way.
If no namespaces are specified, namespaces are generated.
"""
in_nodes = self.attributes.get("nodes")
del in_nodes[0]["namespaces"]
generator = OCPGenerator(self.two_hours_ago, self.now, self.attributes)
out_namespaces = generator._gen_namespaces(in_nodes)
# auto-generating namespaces should create at least 2 namespaces
self.assertGreater(len(list(out_namespaces.keys())), 1)
for value in out_namespaces.values():
with self.subTest(namespace=value):
self.assertEqual(list(value.keys()), list(in_nodes[0].keys()))
def test_get_usage_for_date(self):
"""Test that get_usage_for_date returns selected data."""
test_usage = self._usage_dict()
start_date = random.choice(list(test_usage.keys()))
output = OCPGenerator._get_usage_for_date(
test_usage, datetime.strptime(start_date, "%m-%d-%Y"))
self.assertEqual(output, test_usage.get(start_date))
def test_gen_volumes_usage_lt_capacity(self):
"""Test that gen_volumes generates requests and usage values which don't exceed capacity."""
generator = OCPGenerator(self.two_hours_ago, self.now)
for node in generator.nodes:
with self.subTest(node=node):
for namespace in node.get("namespaces"):
with self.subTest(
namespace=namespace.get("namespace_name")):
for volume in namespace.get("volumes"):
with self.subTest(
volume=volume.get("volume_name")):
total_capacity = 0
for claim in volume.get("volume_claims"):
with self.subTest(claim=claim):
capacity = claim.get("capacity_gig")
total_capacity += capacity
for value in claim.get(
"volume_claim_usage_gig"
).values():
self.assertLessEqual(
value, capacity)
self.assertLessEqual(
total_capacity,
volume.get("volume_request_gig"))
def test_gen_hourly_storage_usage(self):
"""Test that gen_hourly_storage_usage generates rows."""
generator = OCPGenerator(self.two_hours_ago, self.now, self.attributes)
namespaces = self.attributes.get("nodes")[0].get("namespaces")
for dikt in namespaces.values():
pods = dikt.get("pods")
for pod in pods:
with self.subTest(pod=pod):
for row in generator._gen_hourly_storage_usage(
report_type=OCP_STORAGE_USAGE):
self.assertIsInstance(row, dict)
for col in OCP_STORAGE_COLUMNS:
with self.subTest(row=row):
with self.subTest(col=col):
self.assertIn(col, row)
self.assertIsNotNone(row[col])
break # only test one row
def test_update_storage_data_usage_lt_request(self):
"""Test that _update_storge_data keeps usage <= capacity <= request."""
kwargs = {
"volume_claim_usage_gig":
self._usage_dict(),
"vc_capacity":
self.fake.pyint(1, 100),
"namespace":
self.fake.word(),
"pod":
self.fake.word(),
"volume_claim":
self.fake.uuid4(),
"volume_name":
self.fake.word(),
"storage_class":
self.fake.word(),
"volume_request":
self.fake.pyint(1, 100),
"volume_labels": (
f"label_{self.fake.word()}:{self.fake.word()}",
f"|label_{self.fake.word()}:{self.fake.word()}",
),
"volume_claim_labels": (
f"label_{self.fake.word()}:{self.fake.word()}",
f"|label_{self.fake.word()}:{self.fake.word()}",
),
}
generator = OCPGenerator(self.two_hours_ago, self.now)
in_row = generator._init_data_row(self.two_hours_ago,
self.now,
report_type=OCP_STORAGE_USAGE)
out_row = generator._update_storage_data(copy(in_row),
self.two_hours_ago, self.now,
**kwargs)
self.assertLessEqual(
out_row.get("persistentvolumeclaim_usage_byte_seconds"),
out_row.get("persistentvolumeclaim_capacity_byte_seconds") *
GIGABYTE,
)
self.assertLessEqual(
out_row.get("persistentvolumeclaim_capacity_byte_seconds"),
out_row.get("volume_request_storage_byte_seconds"),
)
def test_gen_pods_with_namespaces(self):
"""Test that gen_pods arranges the output dict in the expected way.
If namespaces with pods are specified, defined pods are used.
"""
generator = OCPGenerator(self.two_hours_ago, self.now, self.attributes)
out_pods, _ = generator._gen_pods(
generator.namespaces
) # gen_pods depends on the output of gen_namespaces.
self.assertEqual(len(out_pods), 2)
expected = (
"cpu_limit",
"cpu_request",
"cpu_usage",
"interval_start",
"interval_end",
"mem_limit_gig",
"mem_request_gig",
"mem_usage_gig",
"namespace",
"node",
"node_capacity_cpu_cores",
"node_capacity_cpu_core_seconds",
"node_capacity_memory_bytes",
"node_capacity_memory_byte_seconds",
"node_labels",
"pod",
"pod_labels",
"pod_limit_cpu_core_seconds",
"pod_limit_memory_byte_seconds",
"pod_request_cpu_core_seconds",
"pod_request_memory_byte_seconds",
"pod_seconds",
"pod_usage_cpu_core_seconds",
"pod_usage_memory_byte_seconds",
"report_period_start",
"report_period_end",
"resource_id",
)
for pod in out_pods.values():
with self.subTest(podkeys=pod.keys()):
for key in pod.keys():
with self.subTest(key=key):
self.assertIn(key, expected)
def test_generate_hourly_data(self):
"""Test that generate_hourly_data calls the test method."""
generator = OCPGenerator(self.two_hours_ago, self.now)
test_method1 = Mock(return_value=True)
test_method2 = Mock(return_value=True)
with patch.dict(
generator.ocp_report_generation,
{
"test_report": {
"_generate_hourly_data": test_method1,
"_update_data": test_method2
}
},
):
kwargs = {"report_type": "test_report"}
generator._generate_hourly_data(**kwargs)
test_method1.assert_called_with(**kwargs)
test_method2.assert_not_called()
def test_update_node_label_data(self):
"""Test that _update_node_label_data updates label data"""
node = self.attributes.get("nodes")[0]
kwargs = {
"node": node.get("node"),
"node_labels": node.get("node_labels")
}
generator = OCPGenerator(self.two_hours_ago, self.now)
in_row = generator._init_data_row(self.two_hours_ago,
self.now,
report_type=OCP_NODE_LABEL)
out_row = generator._update_node_label_data(copy(in_row),
self.two_hours_ago,
self.now, **kwargs)
self.assertEqual(out_row.get("node"), node.get("node"))
self.assertNotEqual(out_row.get("node"), in_row.get("node"))
self.assertEqual(out_row.get("node_labels"), node.get("node_labels"))
self.assertNotEqual(out_row.get("node_labels"),
in_row.get("node_labels"))
def test_gen_volumes_with_namespaces(self):
"""Test that gen_volumes arranges the output dict in the expected way.
If namespaces with volumes are specified, defined volumes are used.
"""
generator = OCPGenerator(self.two_hours_ago, self.now)
namespaces = self.attributes.get("nodes")[0].get("namespaces")
in_pods = namespaces[0].get("pods")
out_volumes = generator._gen_volumes(in_pods)
expected = [
"namespace", "volume_name", "storage_class", "volume_request_gig",
"labels", "volume_claims"
]
for vol in out_volumes:
with self.subTest(volume=vol):
self.assertEqual(list(vol.keys()), expected)
self.assertEqual(vol.get("namespace"),
namespaces[0].get("namespace_name"))
def test_gen_nodes_with_nodes(self):
"""Test that gen_nodes arranges the output dict in the expected way.
If nodes are specified, the specified data is overlayed onto the generated data.
"""
in_yaml = """
---
generators:
- OCPGenerator:
start_date: 1970-01-01
end_date: 1970-02-01
nodes:
- node_name: test_node
namespaces:
- namespace_name: test_namespace
pods:
- pod_name: test_pod
volumes:
- volume_name: test_volume
volume_claims:
- volume_claim_name: test_claim
"""
_, tmp_filename = tempfile.mkstemp()
with open(tmp_filename, "w+") as tmp_handle:
tmp_handle.write(in_yaml)
generator = OCPGenerator(self.two_hours_ago,
self.now,
user_config=tmp_filename)
self.assertGreaterEqual(len(generator.nodes), 2)
self.assertEqual(generator.nodes[0].get("node_name"), "test_node")
self.assertEqual(
generator.nodes[0].get("namespaces")[0].get("namespace_name"),
"test_namespace")
self.assertEqual(
generator.nodes[0].get("namespaces")[0].get("pods")[0].get(
"pod_name"), "test_pod")
self.assertEqual(
generator.nodes[0].get("namespaces")[0].get("volumes")[0].get(
"volume_name"), "test_volume")
self.assertEqual(
generator.nodes[0].get("namespaces")[0].get("volumes")[0].get(
"volume_claims")[0].get("volume_claim_name"),
"test_claim",
)
expected_keys = [
"node_name", "cpu_cores", "memory_gig", "resource_id", "labels",
"namespaces"
]
self.assertEqual(list(generator.nodes[0].keys()), expected_keys)
os.remove(tmp_filename)
def test_gen_volumes_without_namespaces(self):
"""Test that gen_volumes arranges the output dict in the expected way.
If no namespaces are specified, volumes are generated.
"""
generator = OCPGenerator(self.two_hours_ago, self.now, {})
# gen_volumes depends on the output formatting of gen_namespaces and gen_pods.
out_volumes = generator._gen_volumes(generator.namespaces,
generator.namespace2pods)
# these magic numbers are the random ranges defined in the OCP generator.
self.assertGreaterEqual(len(out_volumes), 2 * 2 * 1)
self.assertLessEqual(len(out_volumes), 6 * 12 * 3)
expected = [
"namespace", "volume", "storage_class", "volume_request", "labels",
"volume_claims"
]
for vol in out_volumes.values():
with self.subTest(volume=vol):
self.assertEqual(list(vol.keys()), expected)
def test_update_pod_data(self):
"""Test that _update_pod_data updates pod data"""
pods = self.attributes.get("nodes")[0].get("namespaces")[0].get("pods")
usage_dict = self._usage_dict()
kwargs = {
"report_type": "test_report",
"cpu_usage": usage_dict,
"mem_usage_gig": usage_dict,
"pod_seconds": 86400,
"pod": pods[0],
}
changed = {
"pod_usage_cpu_core_seconds",
"pod_request_cpu_core_seconds",
"pod_limit_cpu_core_seconds",
"pod_usage_memory_byte_seconds",
"pod_request_memory_byte_seconds",
"pod_limit_memory_byte_seconds",
}
generator = OCPGenerator(self.two_hours_ago, self.now)
generator.nodes = self.attributes
in_row = generator._init_data_row(self.two_hours_ago,
self.now,
report_type=OCP_POD_USAGE)
out_row = generator._update_pod_data(
copy(in_row),
datetime.strptime(random.choice(list(usage_dict.keys())),
"%m-%d-%Y"), self.now, **kwargs)
for key in changed:
with self.subTest(key=key):
self.assertIsNotNone(out_row.get(key))
self.assertNotEqual(out_row.get(key), in_row.get(key))
for key in list(set(out_row.keys()) - changed):
with self.subTest(key=key):
self.assertIsNotNone(out_row.get(key))
def test_gen_pods_with_namespaces(self):
"""Test that gen_pods arranges the output dict in the expected way.
If namespaces with pods are specified, defined pods are used.
"""
generator = OCPGenerator(self.two_hours_ago, self.now)
in_node = self.attributes.get("nodes")[0]
in_namespace = self.attributes.get("nodes")[0].get(
"namespaces")[0].get("namespace_name")
out_pods = generator._gen_pods(in_node, in_namespace)
self.assertGreaterEqual(len(out_pods), 1)
expected = (
"namespace",
"node",
"resource_id",
"pod_name",
"node_capacity_cpu_cores",
"node_capacity_cpu_core_seconds",
"node_capacity_memory_bytes",
"node_capacity_memory_byte_seconds",
"cpu_request",
"cpu_limit",
"mem_request_gig",
"mem_limit_gig",
"labels",
"cpu_usage",
"mem_usage_gig",
"pod_seconds",
)
for pod in out_pods:
with self.subTest(podkeys=pod.keys()):
for key in pod.keys():
with self.subTest(key=key):
self.assertIn(key, expected)
self.assertEqual(pod.get("node"), in_node.get("node_name"))
self.assertEqual(pod.get("namespace"), in_namespace)
def test_update_pod_data(self):
"""Test that _update_pod_data updates pod data"""
pods = next(
iter(self.attributes.get("nodes")[0].get(
"namespaces").values())).get("pods")
kwargs = {
"cpu_usage": self._usage_dict(),
"mem_usage_gig": self._usage_dict(),
"pod_seconds": 86400,
"pod": pods[0],
}
changed = {
"pod_usage_cpu_core_seconds",
"pod_request_cpu_core_seconds",
"pod_limit_cpu_core_seconds",
"pod_usage_memory_byte_seconds",
"pod_request_memory_byte_seconds",
"pod_limit_memory_byte_seconds",
}
generator = OCPGenerator(self.two_hours_ago, self.now, {})
in_row = generator._init_data_row(self.two_hours_ago,
self.now,
report_type=OCP_POD_USAGE)
out_row = generator._update_pod_data(copy(in_row), self.two_hours_ago,
self.now, **kwargs)
for key in changed:
with self.subTest(key=key):
self.assertEqual(out_row.get(key), pods[0].get(key))
self.assertNotEqual(out_row.get(key), in_row.get(key))
for key in list(set(out_row.keys()) - changed):
with self.subTest(key=key):
self.assertIn(
out_row.get(key),
[pods[0].get(key), in_row.get(key)])
