#include <cstdint>
#include <filesystem>  //NOLINT
#include <memory>
#include <string>
#include <system_error>  // NOLINT
#include <utility>
#include <vector>

#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "absl/functional/any_invocable.h"
#include "http_request.hpp"
#include "http_response.hpp"
#include "async_resp.hpp"
#include "dbus_utility.hpp"
#include "managers.hpp"
#include "snapshot_fixture.hpp"
#include <nlohmann/json.hpp>
#include "managed_store.hpp"
#include "managed_store_types.hpp"
#include "test/g3/mock_managed_store.hpp"
#include "test/g3/mock_managed_store_test.hpp"

namespace redfish
{
namespace
{

using ::dbus::utility::DBusPropertiesMap;
using ::dbus::utility::DbusVariantType;
using ::dbus::utility::MapperGetSubTreeResponse;
using ::dbus::utility::MapperServiceMap;
using ::managedStore::KeyType;
using ::managedStore::ManagedType;
using ::managedStore::ValueType;

constexpr char kClassType[] = "Temperature";
constexpr char kSensor[] = "sensor0";
constexpr double kInput = 43.0;
constexpr double kOutput = 4000.0;
constexpr double kSetpoint = 65.0;
constexpr uint8_t kTestData = 15;

// std::shared_ptr<ValueType> CreateMockSubtreeResponse()
// {
//     MapperGetSubTreeResponse mockSubtreeResponse{{std::make_pair(
//         "/xyz/openbmc_project/inventory/system/component/BMC_flash",
//         MapperServiceMap{{std::make_pair(
//             "xyz.openbmc_project.EntityManager",
//             std::vector<std::string>{
//                 "xyz.openbmc_project.Inventory.Decorator.LocationCode"})}})}};
//     return managedStore::MockManagedStoreTest::CreateValueType(
//         std::move(mockSubtreeResponse));
// }

// TODO(edwarddl): Uncomment after handleManagerGet is updated
// TEST_F(SnapshotFixture, handleManagerGetTest)
// {
//     KeyType key(ManagedType::kManagedSubtree,
//                 "/xyz/openbmc_project/inventory", 0,
//                 {"xyz.openbmc_project.Inventory.Item.Bmc"});
//     ASSERT_TRUE(
//         dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
//             managedStore::GetManagedObjectStore())
//             ->upsertMockObjectIntoManagedStore(
//                 key, CreateMockSubtreeResponse())
//             .ok());
//     handleManagerGet(app_, CreateRequest(), share_async_resp_);
//
//     RunIoUntilDone();
//
//     nlohmann::json& json = share_async_resp_->res.jsonValue;
//
//     LOG(INFO) << json.dump(2);
//     EXPECT_EQ(json["@odata.id"], "/redfish/v1/Managers/bmc");
//     EXPECT_EQ(json["Location"]["PartLocation"]["ServiceLabel"], "BMC");
//     EXPECT_EQ(json["Location"]["PartLocation"]["LocationType"], "Embedded");
//     EXPECT_EQ(json["Location"]["PartLocationContext"], "DC_SCM");
//     EXPECT_EQ(json["Location"]["Oem"]["Google"]["EmbeddedLocationContext"],
//               "openbmc_manager");
//     EXPECT_EQ(json["Links"]["ManagerForServers@odata.count"], 1);
//     EXPECT_EQ(json["Links"]["ManagerForServers"][0]["@odata.id"],
//               "/redfish/v1/Systems/system");
//     EXPECT_EQ(share_async_resp_->res.result(),
//               boost::beast::http::status::ok);
// }

std::shared_ptr<ValueType> CreatePidDebugInfoProperty()
{
    DBusPropertiesMap pidDebugInfoProperty{
        {std::make_pair("ClassType", DbusVariantType(kClassType))},
        {std::make_pair("Input", DbusVariantType(kInput))},
        {std::make_pair("Leader", DbusVariantType(kSensor))},
        {std::make_pair("Output", DbusVariantType(kOutput))},
        {std::make_pair("Setpoint", DbusVariantType(kSetpoint))},
        {std::make_pair("TestData", DbusVariantType(kTestData))}};
    return managedStore::MockManagedStoreTest::CreateValueType(
        std::move(pidDebugInfoProperty));
}

TEST_F(SnapshotFixture, updateZoneLeaderInfoGetNull)
{
    const std::string zoneIndex = "0";
    const std::string name = "Zone_0";
    const std::string leader = "sensor_PID";
    const std::string pidDebugInfoPath =
        "/xyz/openbmc_project/settings/fanctrl/zone" + zoneIndex + "/" + leader;

    auto response = std::make_shared<bmcweb::AsyncResp>();
    nlohmann::json& json = response->res.jsonValue;
    managedStore::ManagedObjectStoreContext context(response);

    // Test for null dbus response
    updateZoneLeaderInfo(response, zoneIndex, name, leader, context);

    RunIoUntilDone();

    EXPECT_TRUE(
        json["Oem"]["OpenBmc"]["Fan"]["FanZones"][name]["Leader"]["ClassType"]
            .is_null());
    EXPECT_TRUE(
        json["Oem"]["OpenBmc"]["Fan"]["FanZones"][name]["Leader"]["Input"]
            .is_null());
    EXPECT_TRUE(
        json["Oem"]["OpenBmc"]["Fan"]["FanZones"][name]["Leader"]["Output"]
            .is_null());
    EXPECT_TRUE(
        json["Oem"]["OpenBmc"]["Fan"]["FanZones"][name]["Leader"]["Sensor"]
            .is_null());
    EXPECT_TRUE(
        json["Oem"]["OpenBmc"]["Fan"]["FanZones"][name]["Leader"]["Setpoint"]
            .is_null());
}

TEST_F(SnapshotFixture, updateZoneLeaderInfoSuccess)
{
    const std::string zoneIndex = "0";
    const std::string name = "Zone_0";
    const std::string leader = "sensor_PID";
    const std::string pidDebugInfoPath =
        "/xyz/openbmc_project/settings/fanctrl/zone" + zoneIndex + "/" + leader;

    auto response = std::make_shared<bmcweb::AsyncResp>();
    nlohmann::json& json = response->res.jsonValue;
    managedStore::ManagedObjectStoreContext context(response);

    // kManagedPropertyMap
    KeyType key(ManagedType::kManagedPropertyMap,
                "xyz.openbmc_project.State.FanCtrl", pidDebugInfoPath,
                "xyz.openbmc_project.Debug.Pid.ThermalPower");

    ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
                    managedStore::GetManagedObjectStore())
                    ->upsertMockObjectIntoManagedStore(
                        key, CreatePidDebugInfoProperty())
                    .ok());

    updateZoneLeaderInfo(response, zoneIndex, name, leader, context);

    RunIoUntilDone();

    EXPECT_EQ(
        json["Oem"]["OpenBmc"]["Fan"]["FanZones"][name]["Leader"]["ClassType"],
        kClassType);
    EXPECT_EQ(
        json["Oem"]["OpenBmc"]["Fan"]["FanZones"][name]["Leader"]["Input"],
        kInput);
    EXPECT_EQ(
        json["Oem"]["OpenBmc"]["Fan"]["FanZones"][name]["Leader"]["Sensor"],
        kSensor);
    EXPECT_EQ(
        json["Oem"]["OpenBmc"]["Fan"]["FanZones"][name]["Leader"]["Output"],
        kOutput);
    EXPECT_EQ(
        json["Oem"]["OpenBmc"]["Fan"]["FanZones"][name]["Leader"]["Setpoint"],
        kSetpoint);
    EXPECT_EQ(
        json["Oem"]["OpenBmc"]["Fan"]["FanZones"][name]["Leader"]["TestData"],
        "n/a");
}

TEST_F(SnapshotFixture, PostManagerResetActionGood)
{
    // using expected call to mitigate the memory issue in valgrind
    // https://b.corp.google.com/issues/416295689
    // https://b.corp.google.com/issues/416608762
    EXPECT_CALL(
        *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
            managedStore::GetManagedObjectStore()),
        PostDbusCallToIoContextThreadSafe(
            testing::_,
            testing::An<
                absl::AnyInvocable<void(const boost::system::error_code&)>&&>(),
            "xyz.openbmc_project.State.Chassis",
            testing::An<const std::string&>(),
            "org.freedesktop.DBus.Properties", "Set",
            "xyz.openbmc_project.State.Chassis", "RequestedPowerTransition",
            dbus::utility::DbusVariantType(
                "xyz.openbmc_project.State.Chassis.Transition.PowerCycle")))
        .WillOnce(
            managedStore::SimulateSuccessfulAsyncPostDbusCallThreadSafeAction::
                SimulateSuccessfulAsyncPostDbusCall());

    handlePostManagerResetAction(
        app_, CreateRequest("{\"ResetType\":\"TrayPowerCycle\"} "),
        share_async_resp_);

    RunIoUntilDone();

    EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);
}

TEST_F(SnapshotFixture, PostManagerResetActionBadResetType)
{
    handlePostManagerResetAction(
        app_, CreateRequest("{\"ResetType\":\"Typo\"} "), share_async_resp_);

    RunIoUntilDone();

    EXPECT_EQ(share_async_resp_->res.result(),
              boost::beast::http::status::bad_request);
}

TEST_F(SnapshotFixture, handleManagerResetActionInfoAllowableValues)
{
    handleManagerResetActionInfo(app_, CreateRequest(""), share_async_resp_);

    RunIoUntilDone();

    EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);

    auto allowable_values =
        share_async_resp_->res.jsonValue["Parameters"][0]["AllowableValues"];
    EXPECT_THAT(allowable_values,
                testing::ElementsAre("GracefulRestart", "ForceRestart",
                                     "TrayPowerCycle"));
}

// TODO(edwarddl): Uncomment after handleManagerGet is updated
// TEST_F(SnapshotFixture, handleManagerGetMultiSystem)
// {
//     KeyType key(ManagedType::kManagedSubtreePaths, "/", 0,
//                 {"xyz.openbmc_project.Inventory.Item.System"});
//
//     std::vector<std::string> path = {
//         "/xyz/system1",
//         "/xyz/system2",
//     };
//     std::shared_ptr<ValueType> test_value = CreateValueType(path);
//     ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
//                     managedStore::GetManagedObjectStore())
//                     ->upsertMockObjectIntoManagedStore(key, test_value)
//                     .ok());
//
//     handleManagerGet(app_, CreateRequest(), share_async_resp_);
//
//     RunIoUntilDone();
//
//     nlohmann::json& json = share_async_resp_->res.jsonValue;
//
//     EXPECT_EQ(json["Links"]["ManagerForServers@odata.count"], 2);
//     EXPECT_EQ(json["Links"]["ManagerForServers"][0]["@odata.id"],
//               "/redfish/v1/Systems/system1");
//     EXPECT_EQ(json["Links"]["ManagerForServers"][1]["@odata.id"],
//               "/redfish/v1/Systems/system2");
//     EXPECT_EQ(share_async_resp_->res.result(),
//               boost::beast::http::status::ok);
// }

TEST_F(SnapshotFixture, handleManagerGetFruDeviceOemLink) {
  std::error_code ec;
  auto origPath = std::filesystem::current_path(ec);
  std::filesystem::current_path(std::filesystem::temp_directory_path(ec), ec);

  handleManagerGet(app_, CreateRequest(), share_async_resp_, "bmc");

  RunIoUntilDone();

  std::filesystem::current_path(origPath, ec);

  nlohmann::json& json = share_async_resp_->res.jsonValue;
  EXPECT_EQ(json["Oem"]["Google"]["FruDevice"]["@odata.id"],
            "/redfish/v1/Managers/bmc/Oem/Google/FruDevice");
}

TEST_F(SnapshotFixture, handleFruDeviceGet) {
  handleFruDeviceGet(app_, CreateRequest(), share_async_resp_);

  RunIoUntilDone();

  nlohmann::json& json = share_async_resp_->res.jsonValue;
  EXPECT_EQ(json, nlohmann::json::parse(R"({
    "@odata.id": "/redfish/v1/Managers/bmc/Oem/Google/FruDevice",
    "@odata.type": "#GoogleFruDevice.v1_0_0.GoogleFruDeviceService",
    "Id": "FruDevice",
    "IpmiFrus": {
      "@odata.id": "/redfish/v1/Managers/bmc/Oem/Google/FruDevice/IpmiFrus"
    },
    "Name": "Google FRU Device Service",
    "RawEeproms": {
      "@odata.id": "/redfish/v1/Managers/bmc/Oem/Google/FruDevice/RawEeproms"
    }
  })"));
  EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);
}

TEST_F(SnapshotFixture, handleIpmiFruCollectionGet) {
  KeyType key(ManagedType::kManagedSubtreePaths,
              "/xyz/openbmc_project/FruDevice", 0,
              {"xyz.openbmc_project.FruDevice"});

  std::vector<std::string> paths = {
      "/xyz/openbmc_project/FruDevice/TestFru1",
      "/xyz/openbmc_project/FruDevice/TestFru2",
  };
  ASSERT_TRUE(
      dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore())
          ->upsertMockObjectIntoManagedStore(
              key, managedStore::MockManagedStoreTest::CreateValueType(paths))
          .ok());

  handleIpmiFruCollectionGet(app_, CreateRequest(), share_async_resp_);

  RunIoUntilDone();

  nlohmann::json& json = share_async_resp_->res.jsonValue;
  EXPECT_EQ(json, nlohmann::json::parse(R"({
    "@odata.id": "/redfish/v1/Managers/bmc/Oem/Google/FruDevice/IpmiFrus",
    "@odata.type": "#GoogleFruDevice.v1_0_0.GoogleIpmiFruCollection",
    "Id": "IpmiFrus",
    "Members": [
      {
        "@odata.id": "/redfish/v1/Managers/bmc/Oem/Google/FruDevice/IpmiFrus/TestFru1"
      },
      {
        "@odata.id": "/redfish/v1/Managers/bmc/Oem/Google/FruDevice/IpmiFrus/TestFru2"
      }
    ],
    "Members@odata.count": 2,
    "Name": "Google IPMI FRU Collection"
  })"));
  EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);
}

TEST_F(SnapshotFixture, handleRawEepromCollectionGet) {
  KeyType key(ManagedType::kManagedSubtreePaths,
              "/xyz/openbmc_project/FruDevice", 0,
              {"xyz.openbmc_project.Inventory.Item.I2CDevice"});

  std::vector<std::string> paths = {
      "/xyz/openbmc_project/FruDevice/Eeprom1",
  };
  ASSERT_TRUE(
      dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore())
          ->upsertMockObjectIntoManagedStore(
              key, managedStore::MockManagedStoreTest::CreateValueType(paths))
          .ok());

  handleRawEepromCollectionGet(app_, CreateRequest(), share_async_resp_);

  RunIoUntilDone();

  nlohmann::json& json = share_async_resp_->res.jsonValue;
  EXPECT_EQ(json, nlohmann::json::parse(R"({
    "@odata.id": "/redfish/v1/Managers/bmc/Oem/Google/FruDevice/RawEeproms",
    "@odata.type": "#GoogleFruDevice.v1_0_0.GoogleRawEepromCollection",
    "Id": "RawEeproms",
    "Members": [
      {
        "@odata.id": "/redfish/v1/Managers/bmc/Oem/Google/FruDevice/RawEeproms/Eeprom1"
      }
    ],
    "Members@odata.count": 1,
    "Name": "Google Raw EEPROM Collection"
  })"));
  EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);
}

TEST(ToTitleCaseTest, ConvertsPropertyNamesToTitleCase) {
  EXPECT_EQ(toTitleCase("BOARD_PRODUCT_NAME"), "BoardProductName");
  EXPECT_EQ(toTitleCase("BUS"), "Bus");
  EXPECT_EQ(toTitleCase("ADDRESS"), "Address");
  EXPECT_EQ(toTitleCase("PRODUCT_MANUFACTURER"), "ProductManufacturer");
  EXPECT_EQ(toTitleCase("PRODUCT_SERIAL_NUMBER"), "ProductSerialNumber");
  EXPECT_EQ(toTitleCase("foo_bar_baz"), "FooBarBaz");
  EXPECT_EQ(toTitleCase(""), "");
}

TEST_F(SnapshotFixture, handleIpmiFruMemberGet) {
  std::string fruId = "TestFru1";
  KeyType key(ManagedType::kManagedPropertyMap, "xyz.openbmc_project.FruDevice",
              "/xyz/openbmc_project/FruDevice/" + fruId,
              "xyz.openbmc_project.FruDevice");

  DBusPropertiesMap props = {
      {std::make_pair("BUS", DbusVariantType(static_cast<uint32_t>(1)))},
      {std::make_pair("ADDRESS", DbusVariantType(static_cast<uint32_t>(80)))},
      {std::make_pair("BOARD_PRODUCT_NAME", DbusVariantType("BoardName"))}};

  ASSERT_TRUE(
      dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore())
          ->upsertMockObjectIntoManagedStore(
              key, managedStore::MockManagedStoreTest::CreateValueType(props))
          .ok());

  handleIpmiFruMemberGet(app_, CreateRequest(), share_async_resp_, fruId);

  RunIoUntilDone();

  nlohmann::json& json = share_async_resp_->res.jsonValue;
  EXPECT_EQ(json, nlohmann::json::parse(R"({
    "@odata.id": "/redfish/v1/Managers/bmc/Oem/Google/FruDevice/IpmiFrus/TestFru1",
    "@odata.type": "#GoogleFruDevice.v1_0_0.IpmiFru",
    "Id": "TestFru1",
    "Name": "Google IPMI FRU",
    "Bus": 1,
    "Address": 80,
    "BoardProductName": "BoardName"
  })"));
  EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);
}

TEST_F(SnapshotFixture, handleIpmiFruMemberGetNotFound) {
  handleIpmiFruMemberGet(app_, CreateRequest(), share_async_resp_,
                         "NonExistentFru");

  RunIoUntilDone();

  EXPECT_EQ(share_async_resp_->res.result(),
            boost::beast::http::status::not_found);
}

TEST_F(SnapshotFixture, handleRawEepromMemberGet) {
  std::string rawId = "Eeprom1";
  KeyType key(ManagedType::kManagedPropertyMap, "xyz.openbmc_project.FruDevice",
              "/xyz/openbmc_project/FruDevice/" + rawId,
              "xyz.openbmc_project.Inventory.Item.I2CDevice");

  DBusPropertiesMap props = {
      {std::make_pair("Bus", DbusVariantType(static_cast<uint32_t>(2)))},
      {std::make_pair("Address", DbusVariantType(static_cast<uint32_t>(81)))},
  };

  ASSERT_TRUE(
      dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore())
          ->upsertMockObjectIntoManagedStore(
              key, managedStore::MockManagedStoreTest::CreateValueType(props))
          .ok());

  EXPECT_CALL(
      *dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
          managedStore::GetManagedObjectStore()),
      PostDbusCallToIoContextThreadSafe(
          testing::_,
          testing::An<
              absl::AnyInvocable<void(const boost::system::error_code&,
                                      const std::vector<uint8_t>&)>&&>(),
          "xyz.openbmc_project.FruDevice", "/xyz/openbmc_project/FruDevice",
          "xyz.openbmc_project.FruDeviceManager", "GetRawFru",
          testing::Eq(static_cast<uint16_t>(2)),
          testing::Eq(static_cast<uint8_t>(81))))
      .WillOnce(
          managedStore::
              SimulateSuccessfulAsyncPostDbusCallThreadSafeWithValueAction<
                  std::vector<uint8_t>>::
                  SimulateSuccessfulAsyncPostDbusCallWithValue(
                      std::make_shared<std::vector<uint8_t>>(
                          std::vector<uint8_t>{1, 2, 3})));

  handleRawEepromMemberGet(app_, CreateRequest(), share_async_resp_, rawId);

  RunIoUntilDone();

  nlohmann::json& json = share_async_resp_->res.jsonValue;
  EXPECT_EQ(json, nlohmann::json::parse(R"({
    "@odata.id": "/redfish/v1/Managers/bmc/Oem/Google/FruDevice/RawEeproms/Eeprom1",
    "@odata.type": "#GoogleFruDevice.v1_0_0.RawEeprom",
    "Id": "Eeprom1",
    "Name": "Google Raw EEPROM",
    "Bus": 2,
    "Address": 81,
    "RawData": [1, 2, 3]
  })"));
  EXPECT_EQ(share_async_resp_->res.result(), boost::beast::http::status::ok);
}

TEST_F(SnapshotFixture, handleRawEepromMemberGetNotFound) {
  handleRawEepromMemberGet(app_, CreateRequest(), share_async_resp_,
                           "NonExistentEeprom");

  RunIoUntilDone();

  EXPECT_EQ(share_async_resp_->res.result(),
            boost::beast::http::status::not_found);
}

TEST_F(SnapshotFixture, handleIpmiFruCollectionGetInvalidOdataVersion) {
  boost::beast::http::request<boost::beast::http::string_body> reqIn;
  reqIn.set("OData-Version", "3.0");
  std::error_code ec;
  crow::Request req(reqIn, ec);
  handleIpmiFruCollectionGet(app_, req, share_async_resp_);
  RunIoUntilDone();
  EXPECT_EQ(share_async_resp_->res.result(),
            boost::beast::http::status::precondition_failed);
}

TEST_F(SnapshotFixture, handleRawEepromCollectionGetInvalidOdataVersion) {
  boost::beast::http::request<boost::beast::http::string_body> reqIn;
  reqIn.set("OData-Version", "3.0");
  std::error_code ec;
  crow::Request req(reqIn, ec);
  handleRawEepromCollectionGet(app_, req, share_async_resp_);
  RunIoUntilDone();
  EXPECT_EQ(share_async_resp_->res.result(),
            boost::beast::http::status::precondition_failed);
}

TEST_F(SnapshotFixture, handleIpmiFruMemberGetInvalidId) {
  std::string fruId = "Test-Fru";
  handleIpmiFruMemberGet(app_, CreateRequest(), share_async_resp_, fruId);
  RunIoUntilDone();
  EXPECT_EQ(share_async_resp_->res.result(),
            boost::beast::http::status::not_found);
}

TEST_F(SnapshotFixture, handleRawEepromMemberGetInvalidId) {
  std::string rawId = "Eeprom.1";
  handleRawEepromMemberGet(app_, CreateRequest(), share_async_resp_, rawId);
  RunIoUntilDone();
  EXPECT_EQ(share_async_resp_->res.result(),
            boost::beast::http::status::not_found);
}

TEST_F(SnapshotFixture, asyncPopulatePidZoneChassisValid) {
  const std::string connection = "xyz.openbmc_project.EntityManager";
  const std::string path = "/xyz/openbmc_project/inventory";
  const std::string zoneName = "Zone_0";
  const std::string chassisName = "TestChassis";

  // Mock ManagedObjectType for asyncPopulatePid
  dbus::utility::ManagedObjectType managedObj = {
      {sdbusplus::message::object_path(
           "/xyz/openbmc_project/inventory/system/chassis/" + chassisName +
           "/" + zoneName),
       {{"xyz.openbmc_project.Configuration.Pid.Zone",
         {{"Name", DbusVariantType(zoneName)},
          {"Class", DbusVariantType("temp")},
          {"ZoneIndex", DbusVariantType(0.0)},
          {"MinThermalOutput", DbusVariantType(3000.0)}}}}}};

  KeyType objKey(ManagedType::kManagedObject, connection, path);
  ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
                  managedStore::GetManagedObjectStore())
                  ->upsertMockObjectIntoManagedStore(
                      objKey, managedStore::MockManagedStoreTest::CreateValueType(
                                  managedObj))
                  .ok());

  // Mock chassis subtree paths containing the matching chassis
  std::vector<std::string> chassisPaths = {
      "/xyz/openbmc_project/inventory/system/chassis/" + chassisName,
  };
  KeyType chassisSubtreeKey(
      ManagedType::kManagedSubtreePaths, "/xyz/openbmc_project/inventory", 0,
      {"xyz.openbmc_project.Inventory.Item.Board",
       "xyz.openbmc_project.Inventory.Item.Chassis"});
  ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
                  managedStore::GetManagedObjectStore())
                  ->upsertMockObjectIntoManagedStore(
                      chassisSubtreeKey,
                      managedStore::MockManagedStoreTest::CreateValueType(
                          chassisPaths))
                  .ok());

  asyncPopulatePid(connection, path, "", {}, share_async_resp_);
  RunIoUntilDone();

  nlohmann::json& json = share_async_resp_->res.jsonValue;
  EXPECT_EQ(
      json["Oem"]["OpenBmc"]["Fan"]["FanZones"][zoneName]["Chassis"]["@odata.id"],
      "/redfish/v1/Chassis/" + chassisName);
}

TEST_F(SnapshotFixture, asyncPopulatePidZoneChassisInvalid) {
  const std::string connection = "xyz.openbmc_project.EntityManager";
  const std::string path = "/xyz/openbmc_project/inventory";
  const std::string zoneName = "Zone_0";
  const std::string chassisName = "InvalidChassis";

  // Mock ManagedObjectType with an invalid chassis name in the path
  dbus::utility::ManagedObjectType managedObj = {
      {sdbusplus::message::object_path(
           "/xyz/openbmc_project/inventory/system/chassis/" + chassisName +
           "/" + zoneName),
       {{"xyz.openbmc_project.Configuration.Pid.Zone",
         {{"Name", DbusVariantType(zoneName)},
          {"Class", DbusVariantType("temp")},
          {"ZoneIndex", DbusVariantType(0.0)},
          {"MinThermalOutput", DbusVariantType(3000.0)}}}}}};

  KeyType objKey(ManagedType::kManagedObject, connection, path);
  ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
                  managedStore::GetManagedObjectStore())
                  ->upsertMockObjectIntoManagedStore(
                      objKey, managedStore::MockManagedStoreTest::CreateValueType(
                                  managedObj))
                  .ok());

  // Mock chassis subtree paths containing only OtherChassis (not InvalidChassis)
  std::vector<std::string> chassisPaths = {
      "/xyz/openbmc_project/inventory/system/chassis/OtherChassis",
  };
  KeyType chassisSubtreeKey(
      ManagedType::kManagedSubtreePaths, "/xyz/openbmc_project/inventory", 0,
      {"xyz.openbmc_project.Inventory.Item.Board",
       "xyz.openbmc_project.Inventory.Item.Chassis"});
  ASSERT_TRUE(dynamic_cast<managedStore::MockSerializedManagedObjectStore*>(
                  managedStore::GetManagedObjectStore())
                  ->upsertMockObjectIntoManagedStore(
                      chassisSubtreeKey,
                      managedStore::MockManagedStoreTest::CreateValueType(
                          chassisPaths))
                  .ok());

  asyncPopulatePid(connection, path, "", {}, share_async_resp_);
  RunIoUntilDone();

  nlohmann::json& json = share_async_resp_->res.jsonValue;
  // When chassis is invalid, Chassis property should not be reported
  EXPECT_FALSE(
      json["Oem"]["OpenBmc"]["Fan"]["FanZones"][zoneName].contains("Chassis"));
}

}  // namespace
}  // namespace redfish