blob: 921737b71d99ea5de94436b17d8b615aa1116b3a [file] [log] [blame]
import time
import pytest
from redfish_requests import Duration, RedfishHttpStatus
def test_get_telemetry_service(redfish):
r = redfish.get(redfish.telemetry_service_path)
assert r["Status"]["State"] == "Enabled", "Invalid status of service"
assert (
Duration.to_seconds(r["MinCollectionInterval"]) > 0
), "Invalid duration format"
assert r["MaxReports"] > 0, "Invalid count of max reports"
def test_get_metric_definition_collection(redfish):
r = redfish.get(redfish.metric_definition_path)
assert "Members" in r, "Missing members property"
assert "Members@odata.count" in r, "Missing members count property"
def test_verify_metric_definition_members_if_contains_metrics(redfish):
r = redfish.get(redfish.metric_definition_path)
for m in r["Members"]:
path = m["@odata.id"]
metricDefinition = redfish.get(path)
assert "MetricProperties" in metricDefinition, "Missing metrics"
assert len(metricDefinition["MetricProperties"]) > 0, "Missing metrics"
def test_get_metric_definition_that_not_exist_expect_not_found(redfish):
redfish.get(
f"{redfish.metric_definition_path}/NotExisting",
code=RedfishHttpStatus.not_found,
)
def test_get_metric_report_definition_collection(redfish):
r = redfish.get(redfish.metric_report_definition_path)
assert "Members" in r, "Missing members property"
assert "Members@odata.count" in r, "Missing members count property"
def test_get_metric_report_definition_that_not_exist_expect_not_found(redfish):
redfish.get(
f"{redfish.metric_report_definition_path}/NotExisting",
code=RedfishHttpStatus.not_found,
)
def test_get_metric_report_collection(redfish):
r = redfish.get(redfish.metric_report_path)
assert "Members" in r, "Missing members property"
assert "Members@odata.count" in r, "Missing members count property"
def test_get_metric_report_that_not_exist_expect_not_found(redfish):
redfish.get(
f"{redfish.metric_report_path}/NotExisting",
code=RedfishHttpStatus.not_found,
)
def test_post_report_definition_with_empty_body_expect_bad_request(redfish):
redfish.post(
redfish.metric_report_definition_path,
body={},
code=RedfishHttpStatus.bad_request,
)
def test_post_report_definition_with_some_body_expect_bad_request(redfish):
redfish.post(
redfish.metric_report_definition_path,
body={"key": "value"},
code=RedfishHttpStatus.bad_request,
)
def test_delete_non_exisiting_metric_report_definition(redfish):
redfish.delete(
f"{redfish.metric_report_definition_path}/NonExisitingReport",
code=RedfishHttpStatus.not_found,
)
def test_add_report(redfish, report_definitions):
id = "Test"
report_definitions.add_report(id)
assert 1 == len(report_definitions.get_collection())
r = redfish.get(f"{redfish.metric_report_definition_path}/{id}")
assert r["Id"] == id, "Invalid Id, different then requested"
r = redfish.get(f"{redfish.metric_report_path}/{id}")
assert r["Id"] == id, "Invalid Id, different then requested"
def test_add_report_above_max_report_expect_bad_request(
telemetry, report_definitions
):
id = "Test"
for i in range(telemetry.max_reports):
report_definitions.add_report(id + str(i))
assert telemetry.max_reports == len(report_definitions.get_collection())
report_definitions.add_report(
id + str(telemetry.max_reports),
metrics=[],
interval=telemetry.min_interval,
code=RedfishHttpStatus.bad_request,
)
def test_add_report_long_name(report_definitions):
report_definitions.add_report("Test" * 65)
def test_add_report_twice_expect_bad_request(report_definitions):
report_definitions.add_report("Test")
report_definitions.add_report("Test", code=RedfishHttpStatus.bad_request)
@pytest.mark.parametrize(
"actions",
[
[],
["RedfishEvent"],
["LogToMetricReportsCollection"],
["RedfishEvent", "LogToMetricReportsCollection"],
],
)
def test_add_report_with_actions(actions, redfish, report_definitions):
report_definitions.add_report("Test", actions=actions)
r = redfish.get(f"{redfish.metric_report_definition_path}/Test")
assert (
r["ReportActions"] == actions
), "Invalid actions, different then requested"
@pytest.mark.parametrize(
"invalid_actions",
[
["NonExisting"],
["RedfishEvent", "Partially"],
["LogToMetricNotThisOne"],
],
)
def test_add_report_with_invalid_actions_expect_bad_request(
invalid_actions, report_definitions
):
report_definitions.add_report(
"Test", actions=invalid_actions, code=RedfishHttpStatus.bad_request
)
@pytest.mark.parametrize("invalid_id", ["test_-", "t t", "T.T", "T,t", "T:t"])
def test_add_report_with_invalid_id_expect_bad_request(
invalid_id, report_definitions
):
report_definitions.add_report(
invalid_id, code=RedfishHttpStatus.bad_request
)
def test_add_report_with_metric(redfish, telemetry, report_definitions):
if len(telemetry.metrics) <= 0:
pytest.skip("Redfish has no sensor available")
metric = {"MetricId": "Id1", "MetricProperties": [telemetry.metrics[0]]}
report_definitions.add_report("Test", metrics=[metric])
r = redfish.get(redfish.metric_report_definition_path + "/Test")
assert len(r["Metrics"]) == 1, "Invalid Metrics, different then requested"
assert (
r["Metrics"][0]["MetricId"] == metric["MetricId"]
), "Invalid MetricId, different then requested"
assert (
r["Metrics"][0]["MetricProperties"] == metric["MetricProperties"]
), "Invalid MetricProperties, different then requested"
def test_add_report_with_invalid_metric_expect_bad_request(report_definitions):
metric = {
"MetricId": "Id1",
"MetricProperties": [
"/redfish/v1/Chassis/chassis/Sensors/NonExisting/Reading"
],
}
report_definitions.add_report(
"Test", metrics=[metric], code=RedfishHttpStatus.bad_request
)
def test_add_report_with_many_metrics(redfish, telemetry, report_definitions):
if len(telemetry.metrics) <= 0:
pytest.skip("Redfish has no sensor available")
metrics = []
for i, prop in enumerate(telemetry.metrics):
metrics.append({"MetricId": f"Id{str(i)}", "MetricProperties": [prop]})
report_definitions.add_report("Test", metrics=metrics)
r = redfish.get(redfish.metric_report_definition_path + "/Test")
assert len(r["Metrics"]) == len(
telemetry.metrics
), "Invalid Metrics, different then requested"
def test_add_report_on_request_with_metric_expect_updated_metric_report(
redfish, telemetry, report_definitions
):
if len(telemetry.metrics) <= 0:
pytest.skip("Redfish has no sensor available")
metric = {"MetricId": "Id1", "MetricProperties": [telemetry.metrics[0]]}
report_definitions.add_report("Test", metrics=[metric], type="OnRequest")
r = redfish.get(redfish.metric_report_path + "/Test")
assert len(r["MetricValues"]) > 0, "Missing MetricValues"
metric_value = r["MetricValues"][0]
assert metric_value["MetricValue"], "Missing MetricValues"
assert (
metric_value["MetricId"] == metric["MetricId"]
), "Different Id then set in request"
assert (
metric_value["MetricProperty"] == metric["MetricProperties"][0]
), "Different MetricProperty then set in request"
def test_add_report_periodic_with_metric_expect_updated_metric_report(
redfish, telemetry, report_definitions
):
if len(telemetry.metrics) <= 0:
pytest.skip("Redfish has no sensor available")
metric = {"MetricId": "Id1", "MetricProperties": [telemetry.metrics[0]]}
report_definitions.add_report(
"Test",
metrics=[metric],
type="Periodic",
interval=Duration.to_iso8061(telemetry.min_interval),
)
time.sleep(telemetry.min_interval + 1)
r = redfish.get(redfish.metric_report_path + "/Test")
assert len(r["MetricValues"]) > 0, "Missing MetricValues"
metric_value = r["MetricValues"][0]
assert metric_value["MetricValue"], "Missing MetricValues"
assert (
metric_value["MetricId"] == metric["MetricId"]
), "Different Id then set in request"
assert (
metric_value["MetricProperty"] == metric["MetricProperties"][0]
), "Different MetricProperty then set in request"
@pytest.mark.parametrize("interval", [10, 60, 2400, 90000])
def test_add_report_check_if_duration_is_set(
interval, redfish, telemetry, report_definitions
):
if interval < telemetry.min_interval:
pytest.skip("Interval is below minimal acceptable value, skipping")
id = f"Test{str(interval)}"
report_definitions.add_report(
id, type="Periodic", interval=Duration.to_iso8061(interval)
)
r = redfish.get(f"{redfish.metric_report_definition_path}/{id}")
assert r["Schedule"]["RecurrenceInterval"], "Missing RecurrenceInterval"
r_interval = Duration.to_seconds(r["Schedule"]["RecurrenceInterval"])
assert interval == r_interval, "Invalid interval, different then requested"
@pytest.mark.parametrize(
"invalid", ["50000", "P12ST", "PT12S12", "PPPPD222T222H222M222.222S"]
)
def test_add_report_with_invalid_duration_response_bad_request(
invalid, report_definitions
):
r = report_definitions.add_report(
"Test",
type="Periodic",
interval=invalid,
code=RedfishHttpStatus.bad_request,
)
assert r["error"]["@Message.ExtendedInfo"][
0
], "Wrong response, not an error"
info = r["error"]["@Message.ExtendedInfo"][0]
assert (
"RecurrenceInterval" in info["MessageArgs"]
), 'Wrong response, should contain "RecurrenceInterval"'
def test_stress_add_reports_with_many_metrics_check_metric_reports(
redfish, telemetry, report_definitions
):
if len(telemetry.metrics) <= 0:
pytest.skip("Redfish has no sensor available")
metrics = []
for i, prop in enumerate(telemetry.metrics):
metrics.append({"MetricId": f"Id{str(i)}", "MetricProperties": [prop]})
for i in range(telemetry.max_reports):
report_definitions.add_report(f"Test{str(i)}", metrics=metrics)
for i in range(telemetry.max_reports):
r = redfish.get(
f"{redfish.metric_report_definition_path}/Test{str(i)}"
)
assert len(r["Metrics"]) == len(
telemetry.metrics
), "Invalid Metrics, different then requested"
for i in range(telemetry.max_reports):
r = redfish.get(f"{redfish.metric_report_path}/Test{str(i)}")
assert len(r["MetricValues"]) > 0, "Missing MetricValues"