| #include "sse_plugin/event.h" |
| |
| #include <string> |
| |
| #include "quality/actions/offline/android/portable_protos/portable_message.h" |
| #include "gmock.h" |
| #include "gunit.h" |
| #include "absl/container/flat_hash_map.h" |
| #include "absl/status/status.h" |
| #include "absl/strings/string_view.h" |
| #include "redfish_query_engine/protobuf/parse.h" |
| #include "proxy_config.pb.h" |
| #include "events.pb.h" |
| #include "vendor_events.pb.h" |
| #include "google/protobuf/repeated_ptr_field.h" |
| |
| namespace milotic { |
| namespace { |
| |
| using testing::AllOf; |
| using testing::Property; |
| using testing::SizeIs; |
| using testing::status::IsOkAndHolds; |
| using testing::status::StatusIs; |
| |
| TEST(ParseRedfishEventTest, InvalidJson) { |
| constexpr absl::string_view kEventJson = R"json(invalid-json)json"; |
| EventParseConfig parse_config; |
| |
| EXPECT_THAT( |
| Event::ParseRedfishEvent(parse_config, kEventJson), |
| StatusIs(absl::StatusCode::kInvalidArgument, "Failed to parse json")); |
| } |
| |
| TEST(ParseRedfishEventTest, InvalidEventJsonNotArray) { |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": {"MessageSeverity": "OK", "EventId": |
| "1"}})json"; |
| EventParseConfig parse_config; |
| |
| EXPECT_THAT( |
| Event::ParseRedfishEvent(parse_config, kEventJson), |
| StatusIs( |
| absl::StatusCode::kInvalidArgument, |
| "Invalid event json, Events should be an array with single element")); |
| } |
| |
| TEST(ParseRedfishEventTest, InvalidEventJsonArraySizeZero) { |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": []})json"; |
| EventParseConfig parse_config; |
| |
| EXPECT_THAT( |
| Event::ParseRedfishEvent(parse_config, kEventJson), |
| StatusIs( |
| absl::StatusCode::kInvalidArgument, |
| "Invalid event json, Events should be an array with single element")); |
| } |
| |
| TEST(ParseRedfishEventTest, InvalidEventJsonArraySizeGTOne) { |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "OK", "EventId": |
| "1"}, {"MessageSeverity": "OK", "EventId": "2"}]})json"; |
| EventParseConfig parse_config; |
| |
| EXPECT_THAT( |
| Event::ParseRedfishEvent(parse_config, kEventJson), |
| StatusIs( |
| absl::StatusCode::kInvalidArgument, |
| "Invalid event json, Events should be an array with single element")); |
| } |
| |
| TEST(ParseRedfishEventTest, SSEIdEventIdMismatch) { |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "OK", "EventId": |
| "2"}]})json"; |
| EventParseConfig parse_config; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| "EventId mismatch, Id: 1, Events[0][EventId]: 2")); |
| } |
| |
| TEST(ParseRedfishEventTest, EventIdNotNumber) { |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "a","Events": [{"MessageSeverity": "OK", "EventId": |
| "a"}]})json"; |
| EventParseConfig parse_config; |
| |
| EXPECT_THAT( |
| Event::ParseRedfishEvent(parse_config, kEventJson), |
| StatusIs(absl::StatusCode::kInvalidArgument, "EventId is not a number")); |
| } |
| |
| TEST(ParseRedfishEventTest, InvalidMessageSev) { |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Invalid", "EventId": |
| "1"}]})json"; |
| EventParseConfig parse_config; |
| |
| EXPECT_THAT( |
| Event::ParseRedfishEvent(parse_config, kEventJson), |
| StatusIs(absl::StatusCode::kInvalidArgument, "Invalid message severity")); |
| } |
| |
| TEST(ParseRedfishEventTest, OkEvent) { |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "OK", "EventId": |
| "1"}]})json"; |
| EventParseConfig parse_config; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds( |
| Contains(AllOf(Property(&Event::severity, EventSeverity::kOk), |
| Property(&Event::event_id, 1))))); |
| } |
| |
| TEST(ParseRedfishEventTest, WarningEvent) { |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1"}]})json"; |
| EventParseConfig parse_config; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1))))); |
| } |
| |
| TEST(ParseRedfishEventTest, CriticalEvent) { |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Critical", |
| "EventId": "1"}]})json"; |
| EventParseConfig parse_config; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kCritical), |
| Property(&Event::event_id, 1))))); |
| } |
| |
| milotic_grpc_proxy::EventParse GetEventParseProtoWithOemPathReasonId() { |
| return ecclesia::ParseTextAsProtoOrDie<milotic_grpc_proxy::EventParse>(R"pb( |
| reason_id_parse: { oem_field_path: "/OriginOfCondition/Oem/Hpe/Faults" } |
| )pb"); |
| } |
| |
| // Test various failure conditions on FindReasonId, such that event severity |
| // falls to MessageSeverity |
| TEST(FindReasonIdOemPathTest, EventWithInvalidReasonID) { |
| // ReasonID should be int |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": {"Hpe": {"Faults": [{"Reasons": |
| [{"ReasonId": "302", "DateTime": "2023-05-12T01:51:50Z"}]}]}}} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event.set_reason_id(302); |
| registry.emplace(302, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithInvalidDateTime1) { |
| // DateTime should be string |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": {"Hpe": {"Faults": [{"Reasons": |
| [{"ReasonId": 302, "DateTime": 123}]}]}}} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event.set_reason_id(302); |
| registry.emplace(302, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithInvalidDateTime2) { |
| // DateTime should be valid |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": {"Hpe": {"Faults": [{"Reasons": |
| [{"ReasonId": "302", "DateTime": "2023-05-12T01:51:90Z"}]}]}}} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event.set_reason_id(302); |
| registry.emplace(302, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithNoReasonId) { |
| // No Reason ID in event |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": {"Hpe": {"Faults": [{"Reasons": |
| []}]}}} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event.set_reason_id(302); |
| registry.emplace(302, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithReasonsNotArray) { |
| // Reasons is not array |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": {"Hpe": {"Faults": [{"Reasons": |
| {}}]}}} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event.set_reason_id(302); |
| registry.emplace(302, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithNoReasonsInFaults) { |
| // No Reasons in Faults |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": {"Hpe": {"Faults": []}}} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event.set_reason_id(302); |
| registry.emplace(302, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithFaultsNotArray) { |
| // Faults is not array |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": {"Hpe": {"Faults": {}}}} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event.set_reason_id(302); |
| registry.emplace(302, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithFaultPathNotPresent1) { |
| // Faults path not present |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": {"Hpe": {"Faults1": {}}}} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event.set_reason_id(302); |
| registry.emplace(302, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithFaultPathNotPresent2) { |
| // Faults path not present |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": {"Hpe": {}}} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event.set_reason_id(302); |
| registry.emplace(302, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithFaultPathNotPresent3) { |
| // Faults path not present |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": {"Hpe": []}} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event.set_reason_id(302); |
| registry.emplace(302, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithFaultPathNotPresent4) { |
| // Faults path not present |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": []} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event.set_reason_id(302); |
| registry.emplace(302, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithValidReasonID) { |
| // Registry severity should be used instead of MessageSeverity |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": {"Hpe": {"Faults": [{"Reasons": |
| [{"ReasonId": 302, "DateTime": "2023-05-12T01:51:50Z"}]}]}}} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event.set_reason_id(302); |
| registry.emplace(302, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT( |
| Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains(AllOf( |
| Property(&Event::severity, EventSeverity::kCritical), |
| Property(&Event::event_id, 1), Property(&Event::reason_id, 302))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithMultipleReasonID) { |
| // Registry severity should be used of reason ID with max DateTime |
| // even if severity of other reason is higher |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Ok", "EventId": "1", |
| "OriginOfCondition": {"Oem": {"Hpe": {"Faults": [{"Reasons": [ |
| {"ReasonId": 302, "DateTime": "2023-05-12T01:51:50Z"}, |
| {"ReasonId": 303, "DateTime": "2023-05-13T01:51:50Z"} |
| ]}]}}} |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event1 = platforms_vbmc::VendorEvent(); |
| vendor_event1.set_severity(platforms_vbmc::OtsEvent::SEVERITY_CRITICAL); |
| vendor_event1.set_reason_id(302); |
| registry.emplace(302, vendor_event1); |
| auto vendor_event2 = platforms_vbmc::VendorEvent(); |
| vendor_event2.set_severity(platforms_vbmc::OtsEvent::SEVERITY_WARNING); |
| vendor_event2.set_reason_id(303); |
| registry.emplace(303, vendor_event2); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT( |
| Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains(AllOf( |
| Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), Property(&Event::reason_id, 303))))); |
| } |
| |
| TEST(FindReasonIdOemPathTest, EventWithReasonIdNotInRegistry) { |
| // If reason ID is not found in registry fall back to MessageSeverity |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": |
| "1", "OriginOfCondition": {"Oem": {"Hpe": {"Faults": [{"Reasons": |
| [{"ReasonId": 302, "DateTime": "2023-05-12T01:51:50Z"}]}]}}} |
| }]})json"; |
| EventParseConfig parse_config = {.event_parse = |
| GetEventParseProtoWithOemPathReasonId()}; |
| |
| EXPECT_THAT( |
| Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains(AllOf( |
| Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), Property(&Event::reason_id, 302))))); |
| } |
| |
| milotic_grpc_proxy::EventParse GetEventParseProtoWithMsgArgsReasonId() { |
| return ecclesia::ParseTextAsProtoOrDie<milotic_grpc_proxy::EventParse>(R"pb( |
| reason_id_parse: { |
| message_args_index: { |
| message_key: "ServiceEventGeneratedNoIndictment" |
| message_arg_index: 1 |
| } |
| } |
| )pb"); |
| } |
| |
| TEST(FindReasonIdMessageArgsTest, EventWithInvalidMessageId) { |
| // If MessageId is invalid and reason id parsing with message arg is set, |
| // InvalidArgument error is returned |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{ |
| "MessageSeverity": "Critical", "EventId": "1", |
| "Message": "A service event has been generated against npar 0 for reason ID 1349.", |
| "MessageArgs":["0","1349"], |
| "MessageId":"ServiceEventGeneratedNoIndictment" |
| }]})json"; |
| EventParseConfig parse_config = {.event_parse = |
| GetEventParseProtoWithMsgArgsReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| "MessageId not in correct format")); |
| } |
| |
| TEST(FindReasonIdMessageArgsTest, MessageArgIndexNotPresent) { |
| // MessageSeverity will be used, since we're not able to find the reason ID |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{ |
| "MessageSeverity": "Critical", "EventId": "1", |
| "Message": "A service event has been generated against npar 0 for reason ID 1349.", |
| "MessageArgs":["1349"], |
| "MessageId":"H3Alert.1.1.ServiceEventGeneratedNoIndictment" |
| }]})json"; |
| EventParseConfig parse_config = {.event_parse = |
| GetEventParseProtoWithMsgArgsReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kCritical), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdMessageArgsTest, MessageArgIndexNotInt) { |
| // MessageSeverity will be used, since we're not able to find the reason ID |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{ |
| "MessageSeverity": "Critical", "EventId": "1", |
| "Message": "A service event has been generated against npar 0 for reason ID 1349.", |
| "MessageArgs":["0", "invalid"], |
| "MessageId":"H3Alert.1.1.ServiceEventGeneratedNoIndictment" |
| }]})json"; |
| EventParseConfig parse_config = {.event_parse = |
| GetEventParseProtoWithMsgArgsReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kCritical), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(FindReasonIdMessageArgsTest, EventWithValidReasonID) { |
| // Registry severity should be used instead of MessageSeverity |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{ |
| "MessageSeverity": "Critical", "EventId": "1", |
| "Message": "A service event has been generated against npar 0 for reason ID 1349.", |
| "MessageArgs":["0","1349"], |
| "MessageId":"H3Alert.1.1.ServiceEventGeneratedNoIndictment" |
| }]})json"; |
| absl::flat_hash_map<int, platforms_vbmc::VendorEvent> registry; |
| auto vendor_event = platforms_vbmc::VendorEvent(); |
| vendor_event.set_severity(platforms_vbmc::OtsEvent::SEVERITY_WARNING); |
| vendor_event.set_reason_id(1349); |
| registry.emplace(1349, vendor_event); |
| EventParseConfig parse_config = { |
| .registry = registry, |
| .event_parse = GetEventParseProtoWithMsgArgsReasonId()}; |
| |
| EXPECT_THAT( |
| Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains(AllOf( |
| Property(&Event::severity, EventSeverity::kWarning), |
| Property(&Event::event_id, 1), Property(&Event::reason_id, 1349))))); |
| } |
| |
| TEST(FindReasonIdMessageArgsTest, EventWithMissingMessageArgs) { |
| // Registry severity should be used instead of MessageSeverity |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{ |
| "MessageSeverity": "Critical", "EventId": "1", |
| "Message": "A service event has been generated against npar 0 for reason ID 1349.", |
| "MessageId":"H3Alert.1.1.ServiceEventGeneratedNoIndictment" |
| }]})json"; |
| EventParseConfig parse_config = {.event_parse = |
| GetEventParseProtoWithMsgArgsReasonId()}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains( |
| AllOf(Property(&Event::severity, EventSeverity::kCritical), |
| Property(&Event::event_id, 1), |
| Property(&Event::reason_id, kInvalidReasonId))))); |
| } |
| |
| TEST(IgnoreEventsWOReasonIdTest, UseOkSeverity) { |
| // If ignore w/o reasonId is set, use Ok severity if we cannot find reasonId |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{ |
| "MessageSeverity": "Critical", "EventId": "1", |
| "MessageId":"H3Alert.1.1.ServiceEventGeneratedNoIndictment" |
| }]})json"; |
| milotic_grpc_proxy::EventParse proto_config; |
| proto_config.set_ignore_event_sev_wo_reason_id(true); |
| EventParseConfig parse_config = {.event_parse = proto_config}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds( |
| Contains(AllOf(Property(&Event::severity, EventSeverity::kOk), |
| Property(&Event::event_id, 1))))); |
| } |
| |
| TEST(IgnoreEventsWOReasonIdTest, ReasonIdPresentRegistryEmpty) { |
| // If we find reasonId but registry is empty/doesn't contain the reasonId we |
| // use MessageSeverity |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{ |
| "MessageSeverity": "Critical", "EventId": "1", |
| "Message": "A service event has been generated against npar 0 for reason ID 1349.", |
| "MessageArgs":["0","1349"], |
| "MessageId":"H3Alert.1.1.ServiceEventGeneratedNoIndictment" |
| }]})json"; |
| milotic_grpc_proxy::EventParse proto_config = |
| GetEventParseProtoWithMsgArgsReasonId(); |
| proto_config.set_ignore_event_sev_wo_reason_id(true); |
| EventParseConfig parse_config = {.event_parse = proto_config}; |
| |
| EXPECT_THAT( |
| Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds(Contains(AllOf( |
| Property(&Event::severity, EventSeverity::kCritical), |
| Property(&Event::event_id, 1), Property(&Event::reason_id, 1349))))); |
| } |
| |
| TEST(FindMessageKeyTest, EventWithInvalidMessageId) { |
| // If MessageId is invalid and ignore_message_keys is set, |
| // InvalidArgument error is returned |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": "1", |
| "MessageId": "LastEventIdTooOld" |
| }]})json"; |
| RepeatedPtrField<std::string> ignore_list; |
| ignore_list.Add("LastEventIdTooOld"); |
| milotic_grpc_proxy::EventParse proto_config; |
| *proto_config.mutable_ignore_event_sev_message_keys() = ignore_list; |
| EventParseConfig parse_config = {.event_parse = proto_config}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| "MessageId not in correct format")); |
| } |
| |
| TEST(FindMessageKeyTest, EventWithMessageKeyInIgnoreList) { |
| // OK severity should be used instead of MessageSeverity |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": "1", |
| "MessageId": "H3Alert.1.1.LastEventIdTooOld" |
| }]})json"; |
| RepeatedPtrField<std::string> ignore_list; |
| ignore_list.Add("LastEventIdTooOld"); |
| milotic_grpc_proxy::EventParse proto_config; |
| *proto_config.mutable_ignore_event_sev_message_keys() = ignore_list; |
| EventParseConfig parse_config = {.event_parse = proto_config}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds( |
| Contains(AllOf(Property(&Event::severity, EventSeverity::kOk), |
| Property(&Event::event_id, 1))))); |
| } |
| |
| TEST(FindMessagePrefixTest, EventWithInvalidMessageId) { |
| // If MessageId is invalid and ignore_message_prefix is set, |
| // InvalidArgument error is returned |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": "1", |
| "MessageId": "ResourceStatusChangedWarning" |
| }]})json"; |
| RepeatedPtrField<std::string> ignore_list; |
| ignore_list.Add("ResourceEvent"); |
| milotic_grpc_proxy::EventParse proto_config; |
| *proto_config.mutable_ignore_event_sev_message_prefix() = ignore_list; |
| EventParseConfig parse_config = {.event_parse = proto_config}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| "MessageId not in correct format")); |
| } |
| |
| TEST(FindMessagePrefixTest, EventWithMessagePrefixInIgnoreList) { |
| // OK severity should be used instead of MessageSeverity |
| constexpr absl::string_view kEventJson = |
| R"json({"Id" : "1","Events": [{"MessageSeverity": "Warning", "EventId": "1", |
| "MessageId": "ResourceEvent.1.3.ResourceStatusChangedWarning" |
| }]})json"; |
| RepeatedPtrField<std::string> ignore_list; |
| ignore_list.Add("ResourceEvent"); |
| milotic_grpc_proxy::EventParse proto_config; |
| *proto_config.mutable_ignore_event_sev_message_prefix() = ignore_list; |
| EventParseConfig parse_config = {.event_parse = proto_config}; |
| |
| EXPECT_THAT(Event::ParseRedfishEvent(parse_config, kEventJson), |
| IsOkAndHolds( |
| Contains(AllOf(Property(&Event::severity, EventSeverity::kOk), |
| Property(&Event::event_id, 1))))); |
| } |
| |
| TEST(ParseReplayEventTest, EmptyResponse) { |
| constexpr absl::string_view kEventJson; |
| EventParseConfig parse_config; |
| EXPECT_THAT(Event::ParseReplayEvents(parse_config, kEventJson), |
| IsOkAndHolds(SizeIs(0))); |
| } |
| |
| TEST(ParseReplayEventTest, InvalidJson) { |
| constexpr absl::string_view kEventJson = R"json(invalid-json)json"; |
| EventParseConfig parse_config; |
| EXPECT_THAT( |
| Event::ParseReplayEvents(parse_config, kEventJson), |
| StatusIs(absl::StatusCode::kInvalidArgument, "Failed to parse json")); |
| } |
| |
| TEST(ParseReplayEventTest, NotArray) { |
| constexpr absl::string_view kEventJson = |
| R"json({"MessageSeverity": "Critical", "EventId": "1"})json"; |
| EventParseConfig parse_config; |
| EXPECT_THAT(Event::ParseReplayEvents(parse_config, kEventJson), |
| StatusIs(absl::StatusCode::kInvalidArgument, "Invalid json")); |
| } |
| |
| TEST(ParseReplayEventTest, MultipleEvents) { |
| constexpr absl::string_view kEventJson = |
| R"json([{"MessageSeverity": "Critical", "EventId": "1"}, |
| {"MessageSeverity": "Critical", "EventId": "2"}])json"; |
| EventParseConfig parse_config; |
| EXPECT_THAT(Event::ParseReplayEvents(parse_config, kEventJson), |
| IsOkAndHolds(SizeIs(2))); |
| } |
| |
| TEST(ParseReplayEventTest, OneInvalidEvent) { |
| constexpr absl::string_view kEventJson = |
| R"json([{"MessageSeverity": "Critical", "EventId": "1"}, |
| {"MessageSeverity": "Critical", "EventId": "a"}])json"; |
| EventParseConfig parse_config; |
| EXPECT_THAT( |
| Event::ParseReplayEvents(parse_config, kEventJson), |
| StatusIs(absl::StatusCode::kInvalidArgument, "EventId is not a number")); |
| } |
| |
| } // namespace |
| } // namespace milotic |
