| #include <array> |
| #include <cstdint> |
| #include <cstdio> |
| #include <fstream> |
| #include <ios> |
| #include <memory> |
| #include <optional> |
| #include <string> |
| #include <string_view> |
| #include <tuple> |
| #include <utility> |
| #include <vector> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| #include "absl/cleanup/cleanup.h" |
| #include "absl/functional/any_invocable.h" |
| #include "absl/status/status.h" |
| #include "absl/status/statusor.h" |
| #include "boost/system/detail/error_code.hpp" // NOLINT |
| #include "http_request.hpp" |
| #include "logging.hpp" |
| #include "async_resp.hpp" |
| #include "dbus_utility.hpp" |
| #include "subprocess_utils.hpp" |
| #include "subprocess_utils_fake.hpp" |
| #include "systems.hpp" |
| #include "test/redfish-core/lib/snapshot_fixture.hpp" |
| #include <nlohmann/json.hpp> |
| #include "tlbmc/hal/system_registry_mock.h" |
| #include "managed_store.hpp" |
| #include "managed_store_types.hpp" |
| #include "test/g3/mock_managed_store.hpp" |
| #include "test/g3/mock_managed_store_test.hpp" |
| #include "sdbusplus/message/native_types.hpp" |
| |
| namespace redfish { |
| namespace { |
| |
| using ::dbus::utility::DbusVariantType; |
| using ::managedStore::KeyType; |
| using ::managedStore::ManagedType; |
| using ::managedStore::SimulateFailedAsyncPostDbusCallThreadSafeAction; |
| using ::managedStore::SimulateSuccessfulAsyncPostDbusCallThreadSafeAction; |
| using ::managedStore::ValueType; |
| using ::milotic_tlbmc::MockSystemRegistry; |
| using ::testing::_; |
| using ::testing::An; |
| |
| TEST(HandlerSystemTest, VerifyCreateResetActionInfoResponse) { |
| auto shareAsyncResp = std::make_shared<bmcweb::AsyncResp>(); |
| createResetActionInfoResponse(shareAsyncResp, "test"); |
| nlohmann::json& json = shareAsyncResp->res.jsonValue; |
| EXPECT_EQ(json["@odata.id"], "/redfish/v1/Systems/test/ResetActionInfo"); |
| EXPECT_EQ(json["@odata.type"], "#ActionInfo.v1_1_2.ActionInfo"); |
| EXPECT_EQ(json["Name"], "Reset Action Info"); |
| EXPECT_EQ(json["Id"], "ResetActionInfo"); |
| nlohmann::json::array_t parameters; |
| nlohmann::json::object_t parameter; |
| parameter["Name"] = "ResetType"; |
| parameter["Required"] = true; |
| parameter["DataType"] = "String"; |
| parameter["Delay"] = "Number"; |
| nlohmann::json::array_t allowableValues; |
| allowableValues.emplace_back("On"); |
| allowableValues.emplace_back("ForceOff"); |
| allowableValues.emplace_back("ForceOn"); |
| allowableValues.emplace_back("ForceRestart"); |
| allowableValues.emplace_back("GracefulRestart"); |
| allowableValues.emplace_back("GracefulShutdown"); |
| allowableValues.emplace_back("PowerCycle"); |
| allowableValues.emplace_back("Nmi"); |
| #ifdef BMCWEB_ENABLE_REALLY_GRACEFUL_SHUTDOWN |
| allowableValues.emplace_back("ReallyGracefulShutDownTechDebt"); |
| #endif |
| parameter["AllowableValues"] = std::move(allowableValues); |
| parameters.emplace_back(std::move(parameter)); |
| nlohmann::json::object_t delayParameter; |
| delayParameter["Name"] = "Delay"; |
| delayParameter["Required"] = false; |
| delayParameter["DataType"] = "Number"; |
| parameters.emplace_back(std::move(delayParameter)); |
| EXPECT_EQ(json["Parameters"], parameters); |
| } |
| |
| TEST(GetSystemResetCommandFromInputTest, TestOnAndForceOnReturnCorrectly) { |
| SystemResetCommand systemResetCommandOn = |
| GetSystemResetCommandFromInput("On"); |
| EXPECT_EQ(systemResetCommandOn.command, |
| "xyz.openbmc_project.State.Host.Transition.On"); |
| EXPECT_TRUE(systemResetCommandOn.hostCommand); |
| EXPECT_TRUE(systemResetCommandOn.validCommand); |
| SystemResetCommand systemResetCommandForceOn = |
| GetSystemResetCommandFromInput("ForceOn"); |
| EXPECT_EQ(systemResetCommandForceOn.command, |
| "xyz.openbmc_project.State.Host.Transition.On"); |
| EXPECT_TRUE(systemResetCommandForceOn.hostCommand); |
| EXPECT_TRUE(systemResetCommandForceOn.validCommand); |
| } |
| |
| TEST(GetSystemResetCommandFromInputTest, TestForceOffReturnCorrectly) { |
| SystemResetCommand systemResetCommandOn = |
| GetSystemResetCommandFromInput("ForceOff"); |
| EXPECT_EQ(systemResetCommandOn.command, |
| "xyz.openbmc_project.State.Chassis.Transition.Off"); |
| EXPECT_FALSE(systemResetCommandOn.hostCommand); |
| EXPECT_TRUE(systemResetCommandOn.validCommand); |
| } |
| |
| TEST(GetSystemResetCommandFromInputTest, TestForceRestartReturnCorrectly) { |
| SystemResetCommand systemResetCommandOn = |
| GetSystemResetCommandFromInput("ForceRestart"); |
| EXPECT_EQ(systemResetCommandOn.command, |
| "xyz.openbmc_project.State.Host.Transition.ForceWarmReboot"); |
| EXPECT_TRUE(systemResetCommandOn.hostCommand); |
| EXPECT_TRUE(systemResetCommandOn.validCommand); |
| } |
| |
| TEST(GetSystemResetCommandFromInputTest, TestGracefulShutdownReturnCorrectly) { |
| SystemResetCommand systemResetCommandOn = |
| GetSystemResetCommandFromInput("GracefulShutdown"); |
| EXPECT_EQ(systemResetCommandOn.command, |
| "xyz.openbmc_project.State.Host.Transition.Off"); |
| EXPECT_TRUE(systemResetCommandOn.hostCommand); |
| EXPECT_TRUE(systemResetCommandOn.validCommand); |
| } |
| |
| TEST(GetSystemResetCommandFromInputTest, TestGracefulRestartReturnCorrectly) { |
| SystemResetCommand systemResetCommandOn = |
| GetSystemResetCommandFromInput("GracefulRestart"); |
| EXPECT_EQ(systemResetCommandOn.command, |
| "xyz.openbmc_project.State.Host.Transition.GracefulWarmReboot"); |
| EXPECT_TRUE(systemResetCommandOn.hostCommand); |
| EXPECT_TRUE(systemResetCommandOn.validCommand); |
| } |
| |
| TEST(GetSystemResetCommandFromInputTest, TestPowerCycleReturnCorrectly) { |
| SystemResetCommand systemResetCommandOn = |
| GetSystemResetCommandFromInput("PowerCycle"); |
| EXPECT_EQ(systemResetCommandOn.command, |
| "xyz.openbmc_project.State.Host.Transition.Reboot"); |
| EXPECT_TRUE(systemResetCommandOn.hostCommand); |
| EXPECT_TRUE(systemResetCommandOn.validCommand); |
| } |
| |
| #ifdef BMCWEB_ENABLE_REALLY_GRACEFUL_SHUTDOWN |
| TEST(GetSystemResetCommandFromInputTest, |
| TestReallyGracefulShutDownTechDebtReturnCorrectly) { |
| SystemResetCommand systemResetCommandOn = |
| GetSystemResetCommandFromInput("ReallyGracefulShutDownTechDebt"); |
| EXPECT_EQ(systemResetCommandOn.command, |
| "xyz.openbmc_project.State.Host.Transition.ReallyGracefulShutDown"); |
| EXPECT_TRUE(systemResetCommandOn.hostCommand); |
| EXPECT_TRUE(systemResetCommandOn.validCommand); |
| } |
| #endif |
| |
| TEST(GetSystemResetCommandFromInputTest, TestInvalidInput) { |
| SystemResetCommand systemResetCommandOn = |
| GetSystemResetCommandFromInput("SomeInvalidInput"); |
| EXPECT_FALSE(systemResetCommandOn.validCommand); |
| } |
| |
| TEST(GetSystemSuffixHelperTest, TestAllInputs) { |
| // Empty, invalid strings |
| EXPECT_EQ("", getSystemSuffix("")); |
| EXPECT_EQ("", getSystemSuffix("asdf")); |
| EXPECT_EQ("", getSystemSuffix("syste")); |
| // Valid Systems/ |
| EXPECT_EQ("", getSystemSuffix("system")); |
| EXPECT_EQ("1", getSystemSuffix("system1")); |
| EXPECT_EQ("13", getSystemSuffix("system13")); |
| EXPECT_EQ("FUTURE", getSystemSuffix("systemFUTURE")); |
| } |
| |
| TEST(HandlerSystemTest, HelpersValuesEnable) { |
| auto shareAsyncResp = std::make_shared<bmcweb::AsyncResp>(); |
| nlohmann::json& json = shareAsyncResp->res.jsonValue; |
| json["MemorySummary"]["Status"]["State"] = "Disabled"; |
| json["ProcessorSummary"]["Count"] = 1; |
| json["ProcessorSummary"]["Status"]["State"] = "Disabled"; |
| updateDimmProperties(shareAsyncResp, true); |
| modifyCpuPresenceState(shareAsyncResp, true); |
| modifyCpuFunctionalState(shareAsyncResp, true); |
| EXPECT_EQ(json["MemorySummary"]["Status"]["State"], "Enabled"); |
| EXPECT_EQ(json["ProcessorSummary"]["Count"], 2); |
| EXPECT_EQ(json["ProcessorSummary"]["Status"]["State"], "Enabled"); |
| } |
| |
| class SystemResetSnapshotFixture : public SnapshotFixture { |
| protected: |
| static void SetupDbusMockIfNeeded() { |
| #ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM |
| managedStore::KeyType systemKey( |
| managedStore::ManagedType::kManagedSubtreePaths, "/", 0, |
| {"xyz.openbmc_project.Inventory.Item.System"}); |
| std::vector<std::string> mockSystems = { |
| "/xyz/openbmc_project/inventory/system1"}; |
| ASSERT_TRUE( |
| dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore( |
| systemKey, managedStore::MockManagedStoreTest::CreateValueType( |
| mockSystems)) |
| .ok()); |
| |
| managedStore::KeyType hostAssocKey( |
| managedStore::ManagedType::kManagedAssociatedSubtree, |
| "/xyz/openbmc_project/inventory/system1/host_power", |
| "/xyz/openbmc_project/state", 0, {"xyz.openbmc_project.State.Host"}); |
| dbus::utility::MapperGetSubTreeResponse mockHostAssoc = { |
| { "/xyz/openbmc_project/state/host0", |
| { |
| { "xyz.openbmc_project.State.Host", |
| {"xyz.openbmc_project.State.Host"} } |
| } }}; |
| ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore( |
| hostAssocKey, |
| managedStore::MockManagedStoreTest::CreateValueType( |
| mockHostAssoc)) |
| .ok()); |
| |
| managedStore::KeyType chassisAssocKey( |
| managedStore::ManagedType::kManagedAssociatedSubtree, |
| "/xyz/openbmc_project/inventory/system1/chassis_power", |
| "/xyz/openbmc_project/state", 0, {"xyz.openbmc_project.State.Chassis"}); |
| dbus::utility::MapperGetSubTreeResponse mockChassisAssoc = { |
| { "/xyz/openbmc_project/state/chassis0", |
| { |
| { "xyz.openbmc_project.State.Chassis", |
| {"xyz.openbmc_project.State.Chassis"} } |
| } }}; |
| ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore( |
| chassisAssocKey, |
| managedStore::MockManagedStoreTest::CreateValueType( |
| mockChassisAssoc)) |
| .ok()); |
| #endif |
| } |
| |
| static std::string GetTestSystemName() { |
| #ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM |
| return "system1"; |
| #else |
| return "system"; |
| #endif |
| } |
| }; |
| |
| TEST_F(SystemResetSnapshotFixture, PostSystemResetAsNMIOnDBusCallFailed) { |
| SetupDbusMockIfNeeded(); |
| EXPECT_CALL( |
| *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()), |
| PostDbusCallToIoContextThreadSafe( |
| _, An<absl::AnyInvocable<void(const boost::system::error_code&)>&&>(), |
| "xyz.openbmc_project.Control.Host.NMI", |
| "/xyz/openbmc_project/control/host0/nmi", |
| "xyz.openbmc_project.Control.Host.NMI", "NMI")) |
| .Times(1) |
| .WillOnce(SimulateFailedAsyncPostDbusCallThreadSafeAction:: |
| SimulateFailedAsyncPostDbusCall()); |
| handlePostComputerSystemReset(app_, CreateRequest("{\"ResetType\":\"Nmi\"}"), |
| share_async_resp_, GetTestSystemName()); |
| RunIoUntilDone(); |
| EXPECT_EQ(share_async_resp_->res.result(), |
| boost::beast::http::status::internal_server_error); |
| } |
| |
| TEST_F(SystemResetSnapshotFixture, PostSystemResetAsNMIOnDBusCallSuccess) { |
| SetupDbusMockIfNeeded(); |
| EXPECT_CALL( |
| *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()), |
| PostDbusCallToIoContextThreadSafe( |
| _, An<absl::AnyInvocable<void(const boost::system::error_code&)>&&>(), |
| "xyz.openbmc_project.Control.Host.NMI", |
| "/xyz/openbmc_project/control/host0/nmi", |
| "xyz.openbmc_project.Control.Host.NMI", "NMI")) |
| .Times(1) |
| .WillOnce(SimulateSuccessfulAsyncPostDbusCallThreadSafeAction:: |
| SimulateSuccessfulAsyncPostDbusCall()); |
| handlePostComputerSystemReset(app_, CreateRequest("{\"ResetType\":\"Nmi\"}"), |
| share_async_resp_, GetTestSystemName()); |
| RunIoUntilDone(); |
| EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok); |
| } |
| |
| TEST_F(SystemResetSnapshotFixture, PostSystemResetSingleSystemHostResetOnFail) { |
| SetupDbusMockIfNeeded(); |
| EXPECT_CALL( |
| *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()), |
| PostDbusCallToIoContextThreadSafe( |
| _, An<absl::AnyInvocable<void(const boost::system::error_code&)>&&>(), |
| "xyz.openbmc_project.State.Host", "/xyz/openbmc_project/state/host0", |
| "org.freedesktop.DBus.Properties", "Set", |
| "xyz.openbmc_project.State.Host", "RequestedHostTransition", |
| dbus::utility::DbusVariantType( |
| "xyz.openbmc_project.State.Host.Transition.On"))) |
| .Times(1) |
| .WillOnce(SimulateFailedAsyncPostDbusCallThreadSafeAction:: |
| SimulateFailedAsyncPostDbusCall()); |
| handlePostComputerSystemReset(app_, |
| CreateRequest("{\"ResetType\":\"ForceOn\"}"), |
| share_async_resp_, GetTestSystemName()); |
| RunIoUntilDone(); |
| EXPECT_EQ(share_async_resp_->res.result(), |
| boost::beast::http::status::internal_server_error); |
| } |
| |
| TEST_F(SystemResetSnapshotFixture, |
| PostSystemResetSingleSystemHostResetOnSuccess) { |
| SetupDbusMockIfNeeded(); |
| EXPECT_CALL( |
| *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()), |
| PostDbusCallToIoContextThreadSafe( |
| _, An<absl::AnyInvocable<void(const boost::system::error_code&)>&&>(), |
| "xyz.openbmc_project.State.Host", "/xyz/openbmc_project/state/host0", |
| "org.freedesktop.DBus.Properties", "Set", |
| "xyz.openbmc_project.State.Host", "RequestedHostTransition", |
| dbus::utility::DbusVariantType( |
| "xyz.openbmc_project.State.Host.Transition.On"))) |
| .Times(1) |
| .WillOnce(SimulateSuccessfulAsyncPostDbusCallThreadSafeAction:: |
| SimulateSuccessfulAsyncPostDbusCall()); |
| handlePostComputerSystemReset(app_, |
| CreateRequest("{\"ResetType\":\"ForceOn\"}"), |
| share_async_resp_, GetTestSystemName()); |
| RunIoUntilDone(); |
| EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok); |
| } |
| |
| TEST_F(SystemResetSnapshotFixture, |
| PostSystemResetSingleSystemChassisResetOnFail) { |
| SetupDbusMockIfNeeded(); |
| EXPECT_CALL( |
| *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()), |
| PostDbusCallToIoContextThreadSafe( |
| _, An<absl::AnyInvocable<void(const boost::system::error_code&)>&&>(), |
| "xyz.openbmc_project.State.Chassis", |
| "/xyz/openbmc_project/state/chassis0", |
| "org.freedesktop.DBus.Properties", "Set", |
| "xyz.openbmc_project.State.Chassis", "RequestedPowerTransition", |
| dbus::utility::DbusVariantType( |
| "xyz.openbmc_project.State.Chassis.Transition.Off"))) |
| .Times(1) |
| .WillOnce(SimulateFailedAsyncPostDbusCallThreadSafeAction:: |
| SimulateFailedAsyncPostDbusCall()); |
| handlePostComputerSystemReset(app_, |
| CreateRequest("{\"ResetType\":\"ForceOff\"}"), |
| share_async_resp_, GetTestSystemName()); |
| RunIoUntilDone(); |
| EXPECT_EQ(share_async_resp_->res.result(), |
| boost::beast::http::status::internal_server_error); |
| } |
| |
| TEST_F(SystemResetSnapshotFixture, |
| PostSystemResetSingleSystemChassisResetOnSuccess) { |
| SetupDbusMockIfNeeded(); |
| EXPECT_CALL( |
| *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()), |
| PostDbusCallToIoContextThreadSafe( |
| _, An<absl::AnyInvocable<void(const boost::system::error_code&)>&&>(), |
| "xyz.openbmc_project.State.Chassis", |
| "/xyz/openbmc_project/state/chassis0", |
| "org.freedesktop.DBus.Properties", "Set", |
| "xyz.openbmc_project.State.Chassis", "RequestedPowerTransition", |
| dbus::utility::DbusVariantType( |
| "xyz.openbmc_project.State.Chassis.Transition.Off"))) |
| .Times(1) |
| .WillOnce(SimulateSuccessfulAsyncPostDbusCallThreadSafeAction:: |
| SimulateSuccessfulAsyncPostDbusCall()); |
| handlePostComputerSystemReset(app_, |
| CreateRequest("{\"ResetType\":\"ForceOff\"}"), |
| share_async_resp_, GetTestSystemName()); |
| RunIoUntilDone(); |
| EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok); |
| } |
| |
| TEST_F(SnapshotFixture, CheckComputerSystemHostStateSingleHost) { |
| KeyType key( |
| ManagedType::kManagedProperty, "xyz.openbmc_project.State.Host", |
| sdbusplus::message::object_path("/xyz/openbmc_project/state/host0"), |
| "xyz.openbmc_project.State.Host", "CurrentHostState"); |
| const std::array<std::tuple<std::string, std::string, std::string>, 6> |
| testCases{ |
| {{"xyz.openbmc_project.State.Host.HostState.Running", "On", |
| "Enabled"}, |
| {"xyz.openbmc_project.State.Host.HostState.Quiesced", "On", |
| "Quiesced"}, |
| {"xyz.openbmc_project.State.Host.HostState.DiagnosticMode", "On", |
| "InTest"}, |
| {"xyz.openbmc_project.State.Host.HostState.TransitioningToRunning", |
| "PoweringOn", "Starting"}, |
| {"xyz.openbmc_project.State.Host.HostState.TransitioningToOff", |
| "PoweringOff", "Disabled"}, |
| {"xyz.openbmc_project.State.Host.HostState.OtherDummy", "Off", |
| "Disabled"}}}; |
| for (auto testCase : testCases) { |
| const auto [currentHostState, powerState, status] = testCase; |
| DbusVariantType targetState = currentHostState; |
| std::shared_ptr<ValueType> mockHostStateValue = |
| managedStore::MockManagedStoreTest::CreateValueType( |
| std::move(targetState)); |
| ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore(key, mockHostStateValue) |
| .ok()); |
| handleComputerSystem(share_async_resp_, "", "system", false); |
| RunIoUntilDone(); |
| nlohmann::json& json = share_async_resp_->res.jsonValue; |
| EXPECT_TRUE(json.contains("PowerState")); |
| EXPECT_TRUE(json.contains("Status")); |
| EXPECT_EQ(json["PowerState"], powerState); |
| EXPECT_TRUE(json["Status"].contains("State")); |
| EXPECT_EQ(json["Status"]["State"], status); |
| } |
| } |
| |
| TEST_F(SnapshotFixture, GetSystemHostPowerAssociatedSubTreeFailed) { |
| // Looking for |
| // kManagedAssociatedSubtree|/xyz/openbmc_project/state|0|xyz.openbmc_project.State.Host|/host_power |
| KeyType key(ManagedType::kManagedAssociatedSubtree, "/host_power", |
| "/xyz/openbmc_project/state", 0, |
| {"xyz.openbmc_project.State.Host"}); |
| absl::StatusOr<std::shared_ptr<ValueType>> associatedSubtreeObjectsStatusOr = |
| dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->getMockObjectFromManagedStore(key); |
| ASSERT_TRUE(associatedSubtreeObjectsStatusOr.ok()); |
| // TODO(b/416746677): Uncomment after the bug is fixed |
| // ASSERT_EQ(associatedSubtreeObjectsStatusOr.value()->managedType, |
| // ManagedType::kManagedSubtreePaths); |
| std::optional<dbus::utility::MapperGetSubTreeResponse> |
| originalAssociatedSubtree = |
| associatedSubtreeObjectsStatusOr.value()->managedSubtree; |
| ASSERT_TRUE(originalAssociatedSubtree.has_value()); |
| ASSERT_TRUE( |
| dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore( |
| key, managedStore::MockManagedStoreTest::CreateErrorValueType( |
| originalAssociatedSubtree.value(), |
| boost::system::errc::make_error_code( |
| boost::system::errc::io_error))) |
| .ok()); |
| absl::Cleanup mockManagedStoreResetter = [key, originalAssociatedSubtree]() { |
| ASSERT_TRUE( |
| dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore( |
| key, managedStore::MockManagedStoreTest::CreateValueType( |
| originalAssociatedSubtree.value())) |
| .ok()); |
| }; |
| handleComputerSystem(share_async_resp_, "", "system", false); |
| RunIoUntilDone(); |
| EXPECT_EQ(share_async_resp_->res.result(), |
| boost::beast::http::status::internal_server_error); |
| } |
| |
| std::shared_ptr<ValueType> CreateMockAssociatedSubtree() { |
| dbus::utility::MapperGetSubTreeResponse mockAssociatedSubtree = { |
| std::make_pair( |
| "/xyz/openbmc_project/state/host1", |
| dbus::utility::MapperServiceMap{ |
| {std::make_pair("xyz.openbmc_project.Chassis.Buttons1", |
| std::vector<std::string>{ |
| "org.freedesktop.DBus.Introspectable", |
| "org.freedesktop.DBus.Peer", |
| "org.freedesktop.DBus.Properties", |
| "xyz.openbmc_project.State.Host", |
| }), |
| std::make_pair("xyz.openbmc_project.Control.Host.RestartCause1", |
| std::vector<std::string>{ |
| "org.freedesktop.DBus.Introspectable", |
| "org.freedesktop.DBus.Peer", |
| "org.freedesktop.DBus.Properties", |
| "xyz.openbmc_project.State.Host", |
| })}}), |
| std::make_pair( |
| "/xyz/openbmc_project/state/host2", |
| dbus::utility::MapperServiceMap{ |
| {std::make_pair("xyz.openbmc_project.Chassis.Buttons1", |
| std::vector<std::string>{ |
| "org.freedesktop.DBus.Introspectable", |
| "org.freedesktop.DBus.Peer", |
| "org.freedesktop.DBus.Properties", |
| "xyz.openbmc_project.State.Host", |
| }), |
| std::make_pair("xyz.openbmc_project.Control.Host.RestartCause1", |
| std::vector<std::string>{ |
| "org.freedesktop.DBus.Introspectable", |
| "org.freedesktop.DBus.Peer", |
| "org.freedesktop.DBus.Properties", |
| "xyz.openbmc_project.State.Host", |
| })}}), |
| }; |
| return managedStore::MockManagedStoreTest::CreateValueType( |
| std::move(mockAssociatedSubtree)); |
| } |
| |
| TEST_F(SnapshotFixture, |
| GetSystemHostPowerAssociatedSubTreeHasMoreThanOneObjects) { |
| crow::Logger::setLogLevel(crow::LogLevel::Error); |
| // Looking for |
| // kManagedAssociatedSubtree|/xyz/openbmc_project/state|0|xyz.openbmc_project.State.Host|/host_power |
| KeyType key(ManagedType::kManagedAssociatedSubtree, "/host_power", |
| "/xyz/openbmc_project/state", 0, |
| {"xyz.openbmc_project.State.Host"}); |
| absl::StatusOr<std::shared_ptr<ValueType>> associatedSubtreeObjectsStatusOr = |
| dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->getMockObjectFromManagedStore(key); |
| ASSERT_TRUE(associatedSubtreeObjectsStatusOr.ok()); |
| // TODO(b/416746677): Uncomment after the bug is fixed |
| // ASSERT_EQ(associatedSubtreeObjectsStatusOr.value()->managedType, |
| // ManagedType::kManagedSubtreePaths); |
| std::optional<dbus::utility::MapperGetSubTreeResponse> |
| originalAssociatedSubtree = |
| associatedSubtreeObjectsStatusOr.value()->managedSubtree; |
| ASSERT_TRUE(originalAssociatedSubtree.has_value()); |
| ASSERT_TRUE( |
| dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore(key, CreateMockAssociatedSubtree()) |
| .ok()); |
| absl::Cleanup mockManagedStoreResetter = [key, originalAssociatedSubtree]() { |
| ASSERT_TRUE( |
| dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore( |
| key, managedStore::MockManagedStoreTest::CreateValueType( |
| originalAssociatedSubtree.value())) |
| .ok()); |
| }; |
| handleComputerSystem(share_async_resp_, "", "system", false); |
| RunIoUntilDone(); |
| EXPECT_EQ(share_async_resp_->res.result(), |
| boost::beast::http::status::internal_server_error); |
| } |
| |
| TEST_F(SnapshotFixture, GetSystemHostPowerAssociatedSubTreeHasEmptyObjects) { |
| KeyType key(ManagedType::kManagedAssociatedSubtree, "system1/host_power", |
| "/xyz/openbmc_project/state", 0, |
| {"xyz.openbmc_project.State.Host"}); |
| dbus::utility::MapperGetSubTreeResponse mockAssociatedSubtree; |
| ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore( |
| key, managedStore::MockManagedStoreTest::CreateValueType( |
| std::move(mockAssociatedSubtree))) |
| .ok()); |
| |
| KeyType chassis_key(ManagedType::kManagedAssociatedSubtree, |
| "system1/chassis_power", "/xyz/openbmc_project/state", 0, |
| {"xyz.openbmc_project.State.Chassis"}); |
| dbus::utility::MapperGetSubTreeResponse mockChassisSubtree; |
| ASSERT_TRUE( |
| dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore( |
| chassis_key, managedStore::MockManagedStoreTest::CreateValueType( |
| std::move(mockChassisSubtree))) |
| .ok()); |
| |
| handleComputerSystem(share_async_resp_, "system1", "system1", true); |
| RunIoUntilDone(); |
| |
| EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok); |
| nlohmann::json& json = share_async_resp_->res.jsonValue; |
| EXPECT_EQ(json["PowerState"], "Unknown"); |
| EXPECT_EQ(json["Status"]["State"], "Unknown"); |
| EXPECT_EQ(json["LastResetTime"], "Unknown"); |
| } |
| |
| TEST_F(SystemResetSnapshotFixture, |
| PostSystemResetSingleSystemChassisResetOnSuccessDelay) { |
| SetupDbusMockIfNeeded(); |
| SubprocessUtilsFake subprocessUtilsFake; |
| SubprocessUtilsBase::setInstance( |
| std::make_unique<SubprocessUtilsFake>(subprocessUtilsFake)); |
| handlePostComputerSystemReset( |
| app_, CreateRequest("{\"ResetType\":\"ForceOff\", \"Delay\":1} "), |
| share_async_resp_, GetTestSystemName()); |
| RunIoUntilDone(); |
| EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok); |
| EXPECT_EQ(share_async_resp_->res.jsonValue["ResetString"], |
| "systemd-run --on-active=1 --timer-property=AccuracySec=100ms -- " |
| "curl -d {\"ResetType\":\"ForceOff\"} -H Content-Type: " |
| "application/json -X POST " |
| "localhost:80/redfish/v1/Systems/" + |
| GetTestSystemName() + "/Actions/ComputerSystem.Reset"); |
| } |
| |
| TEST_F(SystemResetSnapshotFixture, |
| PostSystemResetSingleSystemChassisResetOnFailTimeDelay) { |
| SetupDbusMockIfNeeded(); |
| handlePostComputerSystemReset( |
| app_, CreateRequest("{\"ResetType\":\"ForceOff\", \"Delay\":901} "), |
| share_async_resp_, GetTestSystemName()); |
| RunIoUntilDone(); |
| EXPECT_EQ(share_async_resp_->res.result(), |
| boost::beast::http::status::bad_request); |
| } |
| |
| TEST_F(SystemResetSnapshotFixture, |
| PostSystemResetSingleSystemChassisResetOnFailTypeDelay) { |
| SetupDbusMockIfNeeded(); |
| handlePostComputerSystemReset( |
| app_, CreateRequest("{\"ResetType\":\"PleaseReset\", \"Delay\":1} "), |
| share_async_resp_, GetTestSystemName()); |
| RunIoUntilDone(); |
| EXPECT_EQ(share_async_resp_->res.result(), |
| boost::beast::http::status::bad_request); |
| } |
| |
| TEST_F(SnapshotFixture, HandleGetSystemBootGuestOSInfo) { |
| handleGetSystemBootGuestOSInfo(app_, CreateRequest(""), share_async_resp_, |
| "system2"); |
| RunIoUntilDone(); |
| nlohmann::json& json = share_async_resp_->res.jsonValue; |
| EXPECT_EQ(json["@odata.id"], |
| "/redfish/v1/System/system2/Oem/Google/BootGuestOSActionInfo"); |
| } |
| |
| TEST_F(SnapshotFixture, handleGetBareMetalInstanceBase) { |
| handleGetBareMetalInstance(app_, CreateRequest(""), share_async_resp_, |
| "system1"); |
| RunIoUntilDone(); |
| nlohmann::json& json = share_async_resp_->res.jsonValue; |
| EXPECT_EQ(json["@odata.id"], |
| "/redfish/v1/Systems/system1/Oem/Google/BareMetalInstance"); |
| EXPECT_EQ(json["@odata.type"], |
| "#GoogleBareMetalInstance.v1_0_0.GoogleBareMetalInstance"); |
| } |
| |
| TEST_F(SystemResetSnapshotFixture, HandleGetBootNumber) { |
| SetupDbusMockIfNeeded(); |
| std::string biosPath = |
| #ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM |
| "/xyz/openbmc_project/inventory/system1/chassis/motherboard/bios"; |
| #else |
| "/xyz/openbmc_project/inventory/system/chassis/motherboard/bios"; |
| #endif |
| KeyType key(ManagedType::kManagedProperty, |
| "xyz.openbmc_project.Smbios.MDR_V2", |
| sdbusplus::message::object_path(biosPath), |
| "xyz.openbmc_project.State.Host", "BootCount"); |
| uint32_t num = 1000; |
| std::shared_ptr<ValueType> bootCountValue = |
| managedStore::MockManagedStoreTest::CreateValueType(std::move(num)); |
| ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore(key, bootCountValue) |
| .ok()); |
| handleGetBootNumber(app_, CreateRequest(""), share_async_resp_, |
| GetTestSystemName()); |
| RunIoUntilDone(); |
| nlohmann::json& json = share_async_resp_->res.jsonValue; |
| EXPECT_EQ(json["@odata.id"], "/redfish/v1/Systems/" + GetTestSystemName() + |
| "/Oem/Google/BootNumber"); |
| EXPECT_EQ(json["@odata.type"], "#GoogleBootNumber.v1_0_0.GoogleBootNumber"); |
| EXPECT_TRUE(json.contains("BootNumber")); |
| EXPECT_EQ(json["BootNumber"], 1000); |
| } |
| |
| TEST_F(SnapshotFixture, SingleHostPlatformIncludesBios) { |
| handleComputerSystem(share_async_resp_, "", "system", false); |
| RunIoUntilDone(); |
| nlohmann::json& json = share_async_resp_->res.jsonValue; |
| EXPECT_TRUE(json.contains("Bios")); |
| EXPECT_EQ(json["Bios"]["@odata.id"], "/redfish/v1/Systems/system/Bios"); |
| } |
| |
| TEST(SystemsTest, SetAndGetBootOrder) { |
| const std::string biosSettingFile = "/tmp/oem_bios_setting.test"; |
| // Ensure file is removed before and after test |
| std::remove(biosSettingFile.c_str()); |
| auto cleanup = |
| absl::MakeCleanup([&]() { std::remove(biosSettingFile.c_str()); }); |
| auto asyncResp = std::make_shared<bmcweb::AsyncResp>(); |
| // Test setting the boot order |
| std::vector<std::string> bootOrderToWrite = {"Boot0001", "Boot0000", |
| "Boot0028"}; |
| setBootOrder(asyncResp, bootOrderToWrite, biosSettingFile); |
| // Verify the file content |
| std::ifstream fileIn(biosSettingFile, std::ios::binary); |
| ASSERT_TRUE(fileIn.is_open()); |
| std::vector<uint16_t> bootIndices; |
| uint16_t index; |
| while (fileIn.read(reinterpret_cast<char*>(&index), sizeof(index))) { |
| bootIndices.push_back(index); |
| } |
| fileIn.close(); |
| ASSERT_EQ(bootIndices.size(), 3); |
| EXPECT_EQ(bootIndices[0], 1); |
| EXPECT_EQ(bootIndices[1], 0); |
| EXPECT_EQ(bootIndices[2], 0x28); |
| // Test getting the boot order |
| asyncResp->res.clear(); |
| getBootOrder(asyncResp, biosSettingFile); |
| EXPECT_EQ(asyncResp->res.jsonValue["Boot"]["BootOrder"], bootOrderToWrite); |
| } |
| |
| TEST(SystemsTest, SetAndGetBootOrderHex) { |
| const std::string biosSettingFile = "/tmp/oem_bios_setting.test"; |
| // Ensure file is removed before and after test |
| std::remove(biosSettingFile.c_str()); |
| auto cleanup = |
| absl::MakeCleanup([&]() { std::remove(biosSettingFile.c_str()); }); |
| auto asyncResp = std::make_shared<bmcweb::AsyncResp>(); |
| // Test setting the boot order |
| std::vector<std::string> bootOrderToWrite = {"Boot0001", "Boot0000", |
| "BootFFFE"}; |
| setBootOrder(asyncResp, bootOrderToWrite, biosSettingFile); |
| // Verify the file content |
| std::ifstream fileIn(biosSettingFile, std::ios::binary); |
| ASSERT_TRUE(fileIn.is_open()); |
| std::vector<uint16_t> bootIndices; |
| uint16_t index; |
| while (fileIn.read(reinterpret_cast<char*>(&index), sizeof(index))) { |
| bootIndices.push_back(index); |
| } |
| fileIn.close(); |
| ASSERT_EQ(bootIndices.size(), 3); |
| EXPECT_EQ(bootIndices[0], 1); |
| EXPECT_EQ(bootIndices[1], 0); |
| EXPECT_EQ(bootIndices[2], 0xFFFE); |
| // Test getting the boot order |
| asyncResp->res.clear(); |
| getBootOrder(asyncResp, biosSettingFile); |
| EXPECT_EQ(asyncResp->res.jsonValue["Boot"]["BootOrder"], bootOrderToWrite); |
| } |
| |
| TEST(SystemsTest, SetBootOrderInvalidFormat) { |
| const std::string biosSettingFile = "/tmp/oem_bios_setting.test"; |
| std::remove(biosSettingFile.c_str()); |
| auto cleanup = |
| absl::MakeCleanup([&]() { std::remove(biosSettingFile.c_str()); }); |
| auto asyncResp = std::make_shared<bmcweb::AsyncResp>(); |
| std::vector<std::string> bootOrderToWrite = {"InvalidBoot0001"}; |
| setBootOrder(asyncResp, bootOrderToWrite, biosSettingFile); |
| // Expect an error message |
| EXPECT_EQ(asyncResp->res.result(), boost::beast::http::status::bad_request); |
| // File should not have been created or should be empty |
| std::ifstream fileIn(biosSettingFile, std::ios::binary | std::ios::ate); |
| EXPECT_TRUE(!fileIn.is_open() || fileIn.tellg() == 0); |
| } |
| |
| TEST(SystemsTest, SetBootOrderIndexOutOfRange) { |
| const std::string biosSettingFile = "/tmp/oem_bios_setting.test"; |
| std::remove(biosSettingFile.c_str()); |
| auto cleanup = |
| absl::MakeCleanup([&]() { std::remove(biosSettingFile.c_str()); }); |
| auto asyncResp = std::make_shared<bmcweb::AsyncResp>(); |
| std::vector<std::string> bootOrderToWrite = {"Boot99999"}; |
| setBootOrder(asyncResp, bootOrderToWrite, biosSettingFile); |
| // Expect an error message |
| EXPECT_EQ(asyncResp->res.result(), boost::beast::http::status::bad_request); |
| // File should not have been created or should be empty |
| std::ifstream fileIn(biosSettingFile, std::ios::binary | std::ios::ate); |
| EXPECT_TRUE(!fileIn.is_open() || fileIn.tellg() == 0); |
| } |
| |
| TEST(SystemsTest, SetBootOrderMixedCaseHex) { |
| const std::string biosSettingFile = "/tmp/oem_bios_setting.test"; |
| // Ensure file is removed before and after test |
| std::remove(biosSettingFile.c_str()); |
| auto cleanup = |
| absl::MakeCleanup([&]() { std::remove(biosSettingFile.c_str()); }); |
| auto asyncResp = std::make_shared<bmcweb::AsyncResp>(); |
| // Test setting the boot order with mixed-case hex values |
| std::vector<std::string> bootOrderToWrite = {"Boot000f", "Boot0E40"}; |
| setBootOrder(asyncResp, bootOrderToWrite, biosSettingFile); |
| // Verify the file content |
| std::ifstream fileIn(biosSettingFile, std::ios::binary); |
| ASSERT_TRUE(fileIn.is_open()); |
| std::vector<uint16_t> bootIndices; |
| uint16_t index; |
| while (fileIn.read(reinterpret_cast<char*>(&index), sizeof(index))) { |
| bootIndices.push_back(index); |
| } |
| fileIn.close(); |
| ASSERT_EQ(bootIndices.size(), 2); |
| EXPECT_EQ(bootIndices[0], 0x000f); |
| EXPECT_EQ(bootIndices[1], 0x0e40); |
| // Test getting the boot order |
| asyncResp->res.clear(); |
| getBootOrder(asyncResp, biosSettingFile); |
| // getBootOrder normalizes to uppercase hex |
| std::vector<std::string> expectedBootOrder = {"Boot000F", "Boot0E40"}; |
| EXPECT_EQ(asyncResp->res.jsonValue["Boot"]["BootOrder"], expectedBootOrder); |
| } |
| |
| TEST(SystemsTest, GetBiosSettingPath) { |
| absl::StatusOr<std::string> path1 = getBiosSettingPath("system"); |
| ASSERT_TRUE(path1.ok()); |
| EXPECT_EQ(*path1, "/var/google/oem_bios_setting"); |
| |
| absl::StatusOr<std::string> path2 = getBiosSettingPath("system1"); |
| ASSERT_TRUE(path2.ok()); |
| EXPECT_EQ(*path2, "/var/google/system1/oem_bios_setting"); |
| |
| absl::StatusOr<std::string> path3 = getBiosSettingPath("system2"); |
| ASSERT_TRUE(path3.ok()); |
| EXPECT_EQ(*path3, "/var/google/system2/oem_bios_setting"); |
| |
| absl::StatusOr<std::string> path4 = getBiosSettingPath("unknown_system"); |
| ASSERT_FALSE(path4.ok()); |
| EXPECT_EQ(path4.status().code(), absl::StatusCode::kInvalidArgument); |
| } |
| |
| #ifdef ENABLE_REDFISH_CONFIGURE_IFS |
| TEST_F(SnapshotFixture, GetIfsPropertiesPresent) { |
| auto mock_registry = std::make_shared<MockSystemRegistry>(); |
| EXPECT_CALL(*mock_registry, GetBase64EncodedIfsPattern("system1")) |
| .WillOnce(::testing::Return("SGVsbG8h")); |
| |
| managedStore::GetManagedObjectStore()->SetSystemRegistry(mock_registry); |
| |
| handleComputerSystem(share_async_resp_, "system1", "system1", true); |
| RunIoUntilDone(); |
| |
| nlohmann::json& json = share_async_resp_->res.jsonValue; |
| EXPECT_EQ(json["Actions"]["Oem"]["Google"] |
| ["#GoogleComputerSystem.ResetCpuIfsPattern"]["target"], |
| "/redfish/v1/Systems/system1/Actions/Oem/" |
| "GoogleComputerSystem.ResetCpuIfsPattern"); |
| EXPECT_EQ(json["Oem"]["Google"]["CpuIfsPatternBase64"], "SGVsbG8h"); |
| } |
| |
| TEST_F(SnapshotFixture, GetIfsPropertiesEmptyPattern) { |
| auto mock_registry = std::make_shared<MockSystemRegistry>(); |
| EXPECT_CALL(*mock_registry, GetBase64EncodedIfsPattern("system1")) |
| .WillOnce(::testing::Return("")); |
| |
| managedStore::GetManagedObjectStore()->SetSystemRegistry(mock_registry); |
| |
| handleComputerSystem(share_async_resp_, "system1", "system1", true); |
| RunIoUntilDone(); |
| |
| nlohmann::json& json = share_async_resp_->res.jsonValue; |
| EXPECT_EQ(json["Oem"]["Google"]["CpuIfsPatternBase64"], ""); |
| } |
| |
| TEST_F(SnapshotFixture, GetIfsPropertiesErrorFallback) { |
| auto mock_registry = std::make_shared<MockSystemRegistry>(); |
| EXPECT_CALL(*mock_registry, GetBase64EncodedIfsPattern("system1")) |
| .WillOnce( |
| ::testing::Return(absl::InternalError("Simulated internal error"))); |
| |
| managedStore::GetManagedObjectStore()->SetSystemRegistry(mock_registry); |
| |
| handleComputerSystem(share_async_resp_, "system1", "system1", true); |
| RunIoUntilDone(); |
| |
| EXPECT_EQ(share_async_resp_->res.result(), |
| boost::beast::http::status::internal_server_error); |
| } |
| #else |
| TEST_F(SnapshotFixture, GetIfsPropertiesFlagOff) { |
| handleComputerSystem(share_async_resp_, "system1", "system1", true); |
| RunIoUntilDone(); |
| |
| nlohmann::json& json = share_async_resp_->res.jsonValue; |
| EXPECT_FALSE(json.contains("Actions") && json["Actions"].contains("Oem") && |
| json["Actions"]["Oem"].contains("Google") && |
| json["Actions"]["Oem"]["Google"].contains( |
| "#GoogleComputerSystem.ResetCpuIfsPattern")); |
| EXPECT_FALSE(json.contains("Oem") && json["Oem"].contains("Google") && |
| json["Oem"]["Google"].contains("CpuIfsPatternBase64")); |
| } |
| #endif |
| |
| #ifdef BMCWEB_ALLOW_NON_HARDCODED_SINGLEHOST_SYSTEM |
| TEST_F(SnapshotFixture, HandleGetSystemsCollectionSingleHostFallbackDisabled) { |
| managedStore::KeyType key(managedStore::ManagedType::kManagedSubtreePaths, |
| "/", 0, |
| {"xyz.openbmc_project.Inventory.Item.System"}); |
| std::vector<std::string> mockSystems = { |
| "/xyz/openbmc_project/inventory/system1"}; |
| ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore( |
| key, managedStore::MockManagedStoreTest::CreateValueType( |
| mockSystems)) |
| .ok()); |
| |
| handleGetSystemsCollection(app_, CreateRequest(""), share_async_resp_); |
| RunIoUntilDone(); |
| EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok); |
| nlohmann::json& json = share_async_resp_->res.jsonValue; |
| EXPECT_EQ(json["Members"].size(), 1); |
| EXPECT_EQ(json["Members"][0]["@odata.id"], "/redfish/v1/Systems/system1"); |
| } |
| #endif |
| |
| TEST_F(SnapshotFixture, GetBootNextPresent) { |
| auto mock_registry = std::make_shared<MockSystemRegistry>(); |
| EXPECT_CALL(*mock_registry, GetBootNext("system")) |
| .WillOnce(::testing::Return("Boot0001")); |
| managedStore::GetManagedObjectStore()->SetSystemRegistry(mock_registry); |
| |
| handleComputerSystem(share_async_resp_, "", "system", false); |
| RunIoUntilDone(); |
| |
| nlohmann::json& json = share_async_resp_->res.jsonValue; |
| EXPECT_EQ(json["Boot"]["BootNext"], "Boot0001"); |
| } |
| |
| TEST_F(SnapshotFixture, GetBootNextNotFound) { |
| auto mock_registry = std::make_shared<MockSystemRegistry>(); |
| EXPECT_CALL(*mock_registry, GetBootNext("system")) |
| .WillOnce(::testing::Return(absl::NotFoundError(""))); |
| managedStore::GetManagedObjectStore()->SetSystemRegistry(mock_registry); |
| |
| handleComputerSystem(share_async_resp_, "", "system", false); |
| RunIoUntilDone(); |
| |
| nlohmann::json& json = share_async_resp_->res.jsonValue; |
| EXPECT_FALSE(json["Boot"].contains("BootNext")); |
| } |
| |
| TEST_F(SnapshotFixture, PatchBootNext) { |
| managedStore::KeyType key(managedStore::ManagedType::kManagedSubtreePaths, |
| "/", 0, |
| {"xyz.openbmc_project.Inventory.Item.System"}); |
| std::vector<std::string> mockSystems = { |
| "/xyz/openbmc_project/inventory/system"}; |
| ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore( |
| key, managedStore::MockManagedStoreTest::CreateValueType( |
| mockSystems)) |
| .ok()); |
| |
| auto mock_registry = std::make_shared<MockSystemRegistry>(); |
| EXPECT_CALL(*mock_registry, SetBootNext("system", "Boot0002")) |
| .WillOnce(::testing::Return(absl::OkStatus())); |
| managedStore::GetManagedObjectStore()->SetSystemRegistry(mock_registry); |
| |
| crow::Request req = CreateRequest("{\"Boot\": {\"BootNext\": \"Boot0002\"}}"); |
| req.req.method(boost::beast::http::verb::patch); |
| |
| handlePatchComputerSystemCollection(app_, req, share_async_resp_, "system"); |
| RunIoUntilDone(); |
| |
| EXPECT_EQ(share_async_resp_->res.result(), |
| boost::beast::http::status::no_content); |
| } |
| |
| TEST_F(SnapshotFixture, PatchBootNextRegistryNull) { |
| managedStore::KeyType key(managedStore::ManagedType::kManagedSubtreePaths, |
| "/", 0, |
| {"xyz.openbmc_project.Inventory.Item.System"}); |
| std::vector<std::string> mockSystems = { |
| "/xyz/openbmc_project/inventory/system"}; |
| ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore( |
| key, managedStore::MockManagedStoreTest::CreateValueType( |
| mockSystems)) |
| .ok()); |
| |
| managedStore::GetManagedObjectStore()->SetSystemRegistry(nullptr); |
| |
| crow::Request req = CreateRequest("{\"Boot\": {\"BootNext\": \"Boot0002\"}}"); |
| req.req.method(boost::beast::http::verb::patch); |
| |
| handlePatchComputerSystemCollection(app_, req, share_async_resp_, "system"); |
| RunIoUntilDone(); |
| |
| EXPECT_EQ(share_async_resp_->res.result(), |
| boost::beast::http::status::internal_server_error); |
| } |
| |
| TEST_F(SnapshotFixture, PatchBootNextSetFailed) { |
| managedStore::KeyType key(managedStore::ManagedType::kManagedSubtreePaths, |
| "/", 0, |
| {"xyz.openbmc_project.Inventory.Item.System"}); |
| std::vector<std::string> mockSystems = { |
| "/xyz/openbmc_project/inventory/system"}; |
| ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>( |
| managedStore::GetManagedObjectStore()) |
| ->upsertMockObjectIntoManagedStore( |
| key, managedStore::MockManagedStoreTest::CreateValueType( |
| mockSystems)) |
| .ok()); |
| |
| auto mock_registry = std::make_shared<MockSystemRegistry>(); |
| EXPECT_CALL(*mock_registry, SetBootNext("system", "Boot0002")) |
| .WillOnce(::testing::Return( |
| absl::InternalError("Simulated write failure"))); |
| managedStore::GetManagedObjectStore()->SetSystemRegistry(mock_registry); |
| |
| crow::Request req = CreateRequest("{\"Boot\": {\"BootNext\": \"Boot0002\"}}"); |
| req.req.method(boost::beast::http::verb::patch); |
| |
| handlePatchComputerSystemCollection(app_, req, share_async_resp_, "system"); |
| RunIoUntilDone(); |
| |
| EXPECT_EQ(share_async_resp_->res.result(), |
| boost::beast::http::status::internal_server_error); |
| } |
| |
| } // namespace |
| } // namespace redfish |
