* Copyright (c) 2024 Huawei Technologies Co., Ltd.
* openUBMC is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <algorithm>
#include <array>
#include <atomic>
#include <cstdio>
#include <cstdlib>
#include <devmon/driver_abi.h>
#include <dlfcn.h>
#include <fstream>
#include <mc/engine/property/ref_object.h>
#include <mc/log.h>
#include <memory>
#include <openssl/evp.h>
#include <sys/stat.h>
#include <test_utilities/test_base.h>
#include <thread>
#include <unistd.h>
#include <unordered_map>
#include <vector>
#include <gtest/gtest.h>
#define private public
#include "../../../drivers/connector/connector/connector.h"
#undef private
#include "../../../drivers/connector/connector/sr_overlay.h"
#include "../test_utils/root_object.h"
using namespace dev;
using namespace devmon;
namespace drivers {
namespace connector {
namespace test {
class mock_self_description_record : public mc::engine::interface<mock_self_description_record> {
public:
MC_INTERFACE("bmc.dev.Chip.SelfDescriptionRecord")
mc::engine::property<std::string> FormatVersion;
mc::engine::property<std::string> DataVersion;
mc::engine::property<std::string> BoardId;
std::tuple<uint8_t, std::string> GetSRData()
{
csr2_call_count++;
if (throw_on_call) {
MC_THROW(mc::not_implemented_exception, "CSR2 GetSRData disabled");
}
return std::make_tuple(status, payload);
}
uint8_t status = load_status::SUCCESS;
std::string payload = R"({"Name":"CSR2_EEPROM"})";
bool throw_on_call = false;
int csr2_call_count = 0;
};
class mock_eeprom_data : public mc::engine::interface<mock_eeprom_data> {
public:
MC_INTERFACE("bmc.kepler.EepromData")
mc::engine::property<std::string> DataVersion;
std::tuple<uint8_t, std::string, std::string> GetSRData()
{
csr1_call_count++;
DataVersion = data_version;
if (throw_on_call) {
MC_THROW(mc::not_implemented_exception, "CSR1 GetSRData disabled");
}
if (hardware_access_failures_remaining > 0) {
hardware_access_failures_remaining--;
return std::make_tuple(load_status::HARDWARE_ACCESS_FAIL, std::string{}, std::string{});
}
return std::make_tuple(status, payload, uid);
}
std::tuple<uint8_t, std::string, std::string> GetEepromHeader()
{
header_call_count++;
if (throw_on_call) {
MC_THROW(mc::not_implemented_exception, "CSR1 GetEepromHeader disabled");
}
return std::make_tuple(status, uid, data_version);
}
uint8_t status = load_status::SUCCESS;
std::string payload = R"({"Name":"CSR1_EEPROM"})";
std::string uid = "EEPROMUID";
std::string data_version = "3.10";
bool throw_on_call = false;
int hardware_access_failures_remaining = 0;
int csr1_call_count = 0;
int header_call_count = 0;
};
class mock_eeprom_chip : public mc::engine::object<mock_eeprom_chip> {
public:
MC_OBJECT(mock_eeprom_chip, "MockEepromChip", "/bmc/test/MockEepromChip/${object_name}",
(mock_self_description_record)(mock_eeprom_data))
mock_self_description_record csr2;
mock_eeprom_data csr1;
};
class mock_devmon_interface : public mc::engine::interface<mock_devmon_interface> {
public:
MC_INTERFACE("bmc.dev")
mc::result<void> AddDeviceWithData(const mc::variant& sr_data, const mc::dict& connector)
{
add_device_call_count++;
last_sr_data = sr_data;
add_device_connectors.push_back(connector);
if (fail_add) {
return mc::make_shared<mc::error>("InvalidCsr", "CSR Unit Type is empty");
}
if (delay_add) {
return mc::delay(mc::milliseconds(50));
}
return mc::resolve();
}
void RemoveDevice(const mc::dict& connector)
{
remove_device_call_count++;
remove_device_connectors.push_back(connector);
}
int add_device_call_count = 0;
int remove_device_call_count = 0;
bool delay_add = false;
bool fail_add = false;
std::optional<mc::variant> last_sr_data;
std::vector<mc::dict> add_device_connectors;
std::vector<mc::dict> remove_device_connectors;
};
class mock_devmon_object : public mc::engine::object<mock_devmon_object> {
public:
MC_OBJECT(mock_devmon_object, "Devmon", "/bmc/test/Devmon/${object_name}", (mock_devmon_interface))
mock_devmon_interface devmon;
};
class connector_test_service : public mc::engine::service {
public:
connector_test_service(const std::string& name) : mc::engine::service(name)
{}
};
class ConnectorTest : public mc::test::TestWithEngine {
protected:
static void SetUpTestSuite()
{
TestWithEngine::SetUpTestSuite();
m_test_service = mc::make_shared<connector_test_service>("bmc.kepler.test_connector");
m_test_service->init();
m_test_service->start();
m_root_object = root_object::create_root_object(m_test_service.get());
}
static void TearDownTestSuite()
{
m_test_service->stop();
m_root_object.reset();
m_test_service.reset();
TestWithEngine::TearDownTestSuite();
}
void SetUp() override
{
original_csr_path = std::getenv("PROG_CSR_PATH");
mkdir("/tmp/connector_ut_empty_gold", 0755);
mkdir("/tmp/connector_ut_empty_temp", 0755);
setenv("CONNECTOR_SR_GOLD_DIR", "/tmp/connector_ut_empty_gold", 1);
setenv("CONNECTOR_SR_TEMP_DIR", "/tmp/connector_ut_empty_temp", 1);
m_connector = mc::make_shared<Connector>();
m_connector->set_position("97");
m_connector->set_object_name("Connector");
m_test_service->register_object(m_connector);
m_connector->i_connector.begin_start();
}
void TearDown() override
{
cleanup_test_sr_dir();
unsetenv("CONNECTOR_SR_DIR");
unsetenv("CONNECTOR_SR_GOLD_DIR");
unsetenv("CONNECTOR_SR_TEMP_DIR");
if (original_csr_path) {
setenv("PROG_CSR_PATH", original_csr_path, 1);
} else {
unsetenv("PROG_CSR_PATH");
}
if (m_mock_chip) {
m_test_service->unregister_object(std::string(m_mock_chip->get_object_path()));
m_mock_chip.reset();
}
if (m_mock_devmon) {
m_test_service->unregister_object(std::string(m_mock_devmon->get_object_path()));
m_mock_devmon.reset();
}
restore_root_devmon();
if (m_connector) {
m_test_service->unregister_object(std::string(m_connector->get_object_path()));
m_connector.reset();
}
}
mc::dict create_test_connector()
{
mc::dict connector{{"Bom", "BOM123"}, {"Id", "BOARD456"}, {"AuxId", "AUX789"}, {"GroupPosition", "POS1"}};
return connector;
}
mc::mutable_dict create_test_csr(uint8_t presence, uint8_t identify_mode = 0)
{
return mc::mutable_dict{{"Bom", std::string("BOM12345")},
{"Slot", static_cast<uint8_t>(1)},
{"GroupId", static_cast<uint32_t>(10)},
{"GroupPosition", std::string("A1")},
{"Presence", presence},
{"Id", std::string("BOARD456")},
{"AuxId", std::string("AUX789")},
{"Buses", std::vector<std::string>{"I2c_1"}},
{"SystemId", static_cast<uint8_t>(1)},
{"ManagerId", std::string("Manager1")},
{"SilkText", std::string("Silk1")},
{"Type", std::string("Card")},
{"IdentifyMode", identify_mode},
{"ChassisId", std::string("Chassis1")},
{"LoadStatus", static_cast<uint8_t>(load_status::DEFAULT)},
{"Chip", std::string()}};
}
std::string test_sr_dir;
std::string test_gold_dir;
std::string test_temp_dir;
void set_test_sr_dir(const std::string& dir)
{
test_sr_dir = dir;
test_gold_dir = dir + "_gold";
test_temp_dir = dir + "_temp";
mkdir(test_sr_dir.c_str(), 0755);
mkdir(test_gold_dir.c_str(), 0755);
mkdir(test_temp_dir.c_str(), 0755);
setenv("CONNECTOR_SR_DIR", test_sr_dir.c_str(), 1);
setenv("CONNECTOR_SR_GOLD_DIR", test_gold_dir.c_str(), 1);
setenv("CONNECTOR_SR_TEMP_DIR", test_temp_dir.c_str(), 1);
}
void write_file(const std::string& path, const std::string& content)
{
std::ofstream ofs(path);
ofs << content;
ofs.close();
}
static std::string md5_hex_of(const std::string& content)
{
auto context = std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)>(EVP_MD_CTX_new(), EVP_MD_CTX_free);
EXPECT_TRUE(context);
EXPECT_EQ(EVP_DigestInit_ex(context.get(), EVP_md5(), nullptr), 1);
EXPECT_EQ(EVP_DigestUpdate(context.get(), content.data(), content.size()), 1);
unsigned char digest[EVP_MAX_MD_SIZE];
unsigned int digest_size = 0;
EXPECT_EQ(EVP_DigestFinal_ex(context.get(), digest, &digest_size), 1);
static constexpr char hex[] = "0123456789abcdef";
std::string result;
result.reserve(digest_size * 2);
for (unsigned int i = 0; i < digest_size; ++i) {
result.push_back(hex[digest[i] >> 4]);
result.push_back(hex[digest[i] & 0x0f]);
}
return result;
}
void write_sr_with_md5(const std::string& path, const std::string& content)
{
write_file(path, content);
write_file(path + ".md5", md5_hex_of(content));
}
void write_csr_version(const std::string& file_key, const std::string& version)
{
write_file(test_sr_dir + "/csr_version.json",
std::string("{\"") + file_key + "\":{\"DataVersion\":\"" + version + "\"}}");
}
static void remove_sr_pair(const std::string& dir, const std::string& name)
{
if (dir.empty()) {
return;
}
std::remove((dir + "/" + name).c_str());
std::remove((dir + "/" + name + ".md5").c_str());
}
void cleanup_overlay_dir(const std::string& dir)
{
remove_sr_pair(dir, "BOM12345_EEPROMUID_AUX789.sr");
remove_sr_pair(dir, "BOM12345_EEPROMUID_AUX789_soft.sr");
remove_sr_pair(dir, "BOM12345_.sr");
remove_sr_pair(dir, "BOM12345_BOARD456_AUX789.sr");
remove_sr_pair(dir, "BOM12345_BOARD456_AUX789_soft.sr");
remove_sr_pair(dir, "NEWBOM_NEWID_NEWAUX.sr");
if (!dir.empty()) {
rmdir(dir.c_str());
}
}
void cleanup_test_sr_dir()
{
if (test_sr_dir.empty()) {
return;
}
std::remove((test_sr_dir + "/csr_version.json").c_str());
cleanup_overlay_dir(test_sr_dir);
cleanup_overlay_dir(test_gold_dir);
cleanup_overlay_dir(test_temp_dir);
test_sr_dir.clear();
test_gold_dir.clear();
test_temp_dir.clear();
}
template <typename T>
mc::shared_ptr<mc::engine::ref_object> make_ref_object(const mc::shared_ptr<T>& object)
{
std::string object_name = std::string(object->get_object_name());
auto object_finder = [object](mc::string_view name) -> mc::engine::abstract_object* {
if (name == object->get_object_name()) {
return object.get();
}
return nullptr;
};
return mc::make_shared<mc::engine::ref_object>(object_name, object_finder);
}
template <typename Property, typename T>
void install_ref_object(Property& property, const mc::shared_ptr<T>& object)
{
auto ref_object = make_ref_object(object);
auto cache = std::make_unique<mc::variant>(ref_object);
property.set_property_type(mc::engine::p_type::ref_object);
property.set_ref_object_cache(std::move(cache));
property.set_internal_value(mc::variant(std::string(ref_object->get_object_name())));
}
void install_mock_chip()
{
m_mock_chip = mc::make_shared<mock_eeprom_chip>();
m_mock_chip->set_object_name("MockEepromChip");
m_test_service->register_object(m_mock_chip);
install_ref_object(m_connector->Chip, m_mock_chip);
}
void install_mock_devmon()
{
if (m_root_object && !m_root_devmon_replaced) {
m_test_service->unregister_object(std::string(m_root_object->get_object_path()));
m_root_devmon_replaced = true;
}
m_mock_devmon = mc::make_shared<mock_devmon_object>();
m_mock_devmon->set_object_name("Devmon");
m_test_service->register_object(m_mock_devmon);
}
void restore_root_devmon()
{
if (!m_root_devmon_replaced || !m_root_object) {
return;
}
m_test_service->register_object(m_root_object);
m_root_devmon_replaced = false;
}
bool wait_for_load_status(uint8_t expected, int timeout_ms = 2000)
{
auto deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms);
while (std::chrono::steady_clock::now() < deadline) {
if (m_connector->i_connector.LoadStatus.get_value().as<uint8_t>() == expected) {
return true;
}
std::this_thread::sleep_for(std::chrono::milliseconds(5));
}
return false;
}
protected:
static mc::shared_ptr<connector_test_service> m_test_service;
static root_object_ptr m_root_object;
mc::shared_ptr<Connector> m_connector;
mc::shared_ptr<mock_eeprom_chip> m_mock_chip;
mc::shared_ptr<mock_devmon_object> m_mock_devmon;
const char* original_csr_path = nullptr;
bool m_root_devmon_replaced = false;
};
mc::shared_ptr<connector_test_service> ConnectorTest::m_test_service;
root_object_ptr ConnectorTest::m_root_object;
TEST_F(ConnectorTest, test_basic_init)
{
auto csr = create_test_csr(1);
auto connector = create_test_connector();
bool result = m_connector->init(csr, connector);
EXPECT_TRUE(result);
EXPECT_EQ(m_connector->i_connector.Presence.get_value(), 1);
}
TEST_F(ConnectorTest, test_basic_init2)
{
auto csr = create_test_csr(0);
auto connector = create_test_connector();
bool result = m_connector->init(csr, connector);
EXPECT_TRUE(result);
EXPECT_EQ(m_connector->i_connector.Presence.get_value(), 0);
}
TEST_F(ConnectorTest, ConnectorInterfaceExcludesChipObjectOwnsChip)
{
auto csr = create_test_csr(1);
auto connector = create_test_connector();
csr["Chip"] = std::string("ConfiguredEepromChip");
ASSERT_TRUE(m_connector->init(csr, connector));
EXPECT_TRUE(m_connector->get_property("Chip", "bmc.kepler.Connector", 0).is_null());
EXPECT_EQ(m_connector->get_property("Chip", {}, 0).as<std::string>(), "ConfiguredEepromChip");
EXPECT_EQ(m_connector->i_connector.build_connector_dict().at("Chip").as<std::string>(), "ConfiguredEepromChip");
EXPECT_EQ(m_connector->i_connector.build_connector_dict().at("ObjectName").as<std::string>(), "Connector");
}
TEST_F(ConnectorTest, test_init_missing_fields)
{
auto csr = mc::mutable_dict{{"InvalidField", "InvalidValue"}};
auto connector = create_test_connector();
bool result = m_connector->init(csr, connector);
EXPECT_TRUE(result);
}
TEST_F(ConnectorTest, build_connector_dict_uses_defaults_when_properties_missing)
{
auto csr = mc::mutable_dict{{"InvalidField", "InvalidValue"}};
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
mc::dict dict;
EXPECT_NO_THROW(dict = m_connector->i_connector.build_connector_dict());
EXPECT_EQ(dict.at("SystemId").as<uint8_t>(), 1);
EXPECT_EQ(dict.at("ManagerId").as<std::string>(), "1");
EXPECT_EQ(dict.at("ChassisId").as<std::string>(), "1");
EXPECT_EQ(dict.at("SilkText").as<std::string>(), "");
EXPECT_EQ(dict.at("Slot").as<uint8_t>(), 0);
EXPECT_EQ(dict.at("LoadStatus").as<uint8_t>(), load_status::DEFAULT);
EXPECT_EQ(dict.at("Buses").as<std::vector<std::string>>().size(), 0u);
}
TEST_F(ConnectorTest, build_connector_dict_respects_configured_chassis_id)
{
auto connector = create_test_connector();
auto csr_configured = create_test_csr(1);
csr_configured["ChassisId"] = std::string("Chassis1");
ASSERT_TRUE(m_connector->init(csr_configured, connector));
EXPECT_EQ(m_connector->i_connector.build_connector_dict().at("ChassisId").as<std::string>(), "Chassis1");
auto csr_empty = mc::mutable_dict{{"ChassisId", std::string("")}};
ASSERT_TRUE(m_connector->init(csr_empty, connector));
EXPECT_EQ(m_connector->i_connector.build_connector_dict().at("ChassisId").as<std::string>(), "");
}
TEST_F(ConnectorTest, GetFilePath_WithBomAndAuxId)
{
Context ctx{"BOM123", "BOARD456", "AUX789", "POS1"};
std::string path = m_connector->i_connector.get_file_path(ctx, "/config/csr");
EXPECT_EQ(path, "/config/csr/BOM123_BOARD456_AUX789.sr");
}
TEST_F(ConnectorTest, GetFilePath_WithBomNoAuxId)
{
Context ctx{"BOM123", "BOARD456", "", "POS1"};
std::string path = m_connector->i_connector.get_file_path(ctx, "/config/csr");
EXPECT_EQ(path, "/config/csr/BOM123_BOARD456.sr");
}
TEST_F(ConnectorTest, GetFilePath_NoBomWithAuxId)
{
Context ctx{"", "BOARD456", "AUX789", "POS1"};
std::string path = m_connector->i_connector.get_file_path(ctx, "/config/csr");
EXPECT_EQ(path, "/config/csr/BOARD456_AUX789.sr");
}
TEST_F(ConnectorTest, GetFilePath_NoBomNoAuxId)
{
Context ctx{"", "BOARD456", "", "POS1"};
std::string path = m_connector->i_connector.get_file_path(ctx, "/config/csr");
EXPECT_EQ(path, "/config/csr/BOARD456.sr");
}
TEST_F(ConnectorTest, GetCsrFile_Success)
{
auto connector = create_test_connector();
std::string path = m_connector->i_connector.get_csr_file(connector);
EXPECT_EQ(path, "/opt/bmc/sr/BOM123_BOARD456_AUX789.sr");
}
TEST_F(ConnectorTest, GetCsrFile_MissingEnvVar_DoesNotAffectDefaultPath)
{
unsetenv("PROG_CSR_PATH");
auto connector = create_test_connector();
std::string path = m_connector->i_connector.get_csr_file(connector);
EXPECT_EQ(path, "/opt/bmc/sr/BOM123_BOARD456_AUX789.sr");
}
TEST_F(ConnectorTest, GetCsrFile_UsesUnitTestSrDirOverride)
{
set_test_sr_dir("/tmp/connector_sr_dir_override");
auto connector = create_test_connector();
std::string path = m_connector->i_connector.get_csr_file(connector);
EXPECT_EQ(path, "/tmp/connector_sr_dir_override/BOM123_BOARD456_AUX789.sr");
}
TEST_F(ConnectorTest, GetCsrFile_MissingFieldInDict)
{
setenv("PROG_CSR_PATH", "/firmware/csr", 1);
mc::dict bad_connector;
std::string path = m_connector->i_connector.get_csr_file(bad_connector);
EXPECT_TRUE(path.empty());
}
TEST_F(ConnectorTest, GetCsrData_ValidFile_ReturnsJsonString)
{
const std::string temp_file = "/tmp/test_csr.json";
const std::string json_content = R"({"chip_id": 123, "status": "ok"})";
std::ofstream ofs(temp_file);
ofs << json_content;
ofs.close();
std::string result = m_connector->i_connector.get_csr_data(temp_file);
EXPECT_EQ(result, json_content);
std::remove(temp_file.c_str());
}
TEST_F(ConnectorTest, GetCsrData_NonExistentFile_ReturnsEmptyString)
{
std::string result = m_connector->i_connector.get_csr_data("/non/existent/file.json");
EXPECT_EQ(result, "");
}
TEST_F(ConnectorTest, GetCsrData_InvalidJson_ReturnsEmptyString)
{
const std::string temp_file = "/tmp/invalid_csr.json";
std::ofstream ofs(temp_file);
ofs << "{ invalid json }";
ofs.close();
std::string result = m_connector->i_connector.get_csr_data(temp_file);
EXPECT_EQ(result, "");
std::remove(temp_file.c_str());
}
TEST_F(ConnectorTest, GetLocalCsrDataVersion_ReturnsVersionForMatchingFile)
{
set_test_sr_dir("/tmp/connector_sr_local_version_match");
mc::mutable_dict versions;
versions["BOM123_BOARD456_AUX789"] = mc::dict{{"DataVersion", std::string("3.10")}};
const std::string sr_file = test_sr_dir + "/BOM123_BOARD456_AUX789.sr";
write_file(sr_file, R"({"Name":"LOCAL"})");
std::string version = m_connector->i_connector.get_local_csr_data_version(versions, sr_file);
EXPECT_EQ(version, "3.10");
}
TEST_F(ConnectorTest, GetLocalCsrDataVersion_ReturnsEmptyWhenFileAbsent)
{
set_test_sr_dir("/tmp/connector_sr_local_version_absent");
mc::mutable_dict versions;
versions["BOM123_BOARD456_AUX789"] = mc::dict{{"DataVersion", std::string("3.10")}};
const std::string sr_file = test_sr_dir + "/BOM123_BOARD456_AUX789.sr";
std::remove(sr_file.c_str());
std::string version = m_connector->i_connector.get_local_csr_data_version(versions, sr_file);
EXPECT_EQ(version, "");
}
TEST_F(ConnectorTest, GetLocalCsrDataVersion_ReturnsEmptyForMissingEntry)
{
set_test_sr_dir("/tmp/connector_sr_local_version_missing_entry");
mc::mutable_dict versions;
versions["OTHER"] = mc::dict{{"DataVersion", std::string("1.00")}};
const std::string sr_file = test_sr_dir + "/BOM123_BOARD456_AUX789.sr";
write_file(sr_file, R"({"Name":"LOCAL"})");
std::string version = m_connector->i_connector.get_local_csr_data_version(versions, sr_file);
EXPECT_EQ(version, "");
}
TEST_F(ConnectorTest, GetLocalCsrDataVersion_ReturnsEmptyForInvalidShape)
{
set_test_sr_dir("/tmp/connector_sr_local_version_invalid_shape");
mc::mutable_dict versions;
versions["BOM123_BOARD456_AUX789"] = std::string("invalid");
const std::string sr_file = test_sr_dir + "/BOM123_BOARD456_AUX789.sr";
write_file(sr_file, R"({"Name":"LOCAL"})");
std::string version = m_connector->i_connector.get_local_csr_data_version(versions, sr_file);
EXPECT_EQ(version, "");
}
TEST_F(ConnectorTest, ConnectorPayloadCache_HitsWhenSourceAndKeyMatch)
{
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
mc::variant payload = mc::dict{{"Name", std::string("CachedSr")}};
m_connector->i_connector.update_cached_sr_data(connector_sr_source::local, payload, "BOARD456", "", "3.10",
"/opt/bmc/sr/BOM123_BOARD456_AUX789.sr");
mc::variant cached;
bool hit = m_connector->i_connector.try_get_cached_sr_data(connector_sr_source::local, "BOARD456", "", "3.10",
"/opt/bmc/sr/BOM123_BOARD456_AUX789.sr", cached);
ASSERT_TRUE(hit);
EXPECT_EQ(cached.as<mc::dict>()["Name"].as<std::string>(), "CachedSr");
}
TEST_F(ConnectorTest, ConnectorPayloadCache_MissesWhenSourceDiffers)
{
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
mc::variant payload = mc::dict{{"Name", std::string("CachedSr")}};
m_connector->i_connector.update_cached_sr_data(connector_sr_source::local, payload, "BOARD456", "", "3.10",
"/opt/bmc/sr/BOM123_BOARD456_AUX789.sr");
mc::variant cached;
bool hit = m_connector->i_connector.try_get_cached_sr_data(connector_sr_source::eeprom, "BOARD456", "", "3.10",
"/opt/bmc/sr/BOM123_BOARD456_AUX789.sr", cached);
EXPECT_FALSE(hit);
}
TEST_F(ConnectorTest, ConnectorPayloadCache_MissesWhenVersionDiffers)
{
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
mc::variant payload = mc::dict{{"Name", std::string("CachedSr")}};
m_connector->i_connector.update_cached_sr_data(connector_sr_source::local, payload, "BOARD456", "", "3.10",
"/opt/bmc/sr/BOM123_BOARD456_AUX789.sr");
mc::variant cached;
bool hit = m_connector->i_connector.try_get_cached_sr_data(connector_sr_source::local, "BOARD456", "", "3.11",
"/opt/bmc/sr/BOM123_BOARD456_AUX789.sr", cached);
EXPECT_FALSE(hit);
}
TEST_F(ConnectorTest, ConnectorPayloadCache_MissesWhenMergedFlagDiffers)
{
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
mc::variant payload = mc::dict{{"Name", std::string("CachedSr")}};
m_connector->i_connector.update_cached_sr_data(connector_sr_source::local, payload, "BOARD456", "", "3.10",
"/opt/bmc/sr/BOM123_BOARD456_AUX789.sr", "", false);
mc::variant cached;
bool hit = m_connector->i_connector.try_get_cached_sr_data(connector_sr_source::local, "BOARD456", "", "3.10",
"/opt/bmc/sr/BOM123_BOARD456_AUX789.sr", cached, true);
EXPECT_FALSE(hit);
}
TEST_F(ConnectorTest, ConnectorPayloadCache_MissesWhenIdentityKeyDiffers)
{
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
mc::variant payload = mc::dict{{"Name", std::string("CachedSr")}};
m_connector->i_connector.update_cached_sr_data(connector_sr_source::local, payload, "EEPROMUID-A", "", "3.10",
"/opt/bmc/sr/BOM123_EEPROMUID-A_AUX789.sr");
mc::variant cached;
bool hit = m_connector->i_connector.try_get_cached_sr_data(connector_sr_source::local, "EEPROMUID-B", "", "3.10",
"/opt/bmc/sr/BOM123_EEPROMUID-A_AUX789.sr", cached);
EXPECT_FALSE(hit);
}
TEST_F(ConnectorTest, ResolveSrData_RefreshFlagSkipsMatchingCacheAndReReadsEeprom)
{
set_test_sr_dir("/tmp/connector_sr_refresh_flag");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_FIRST"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto first = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(first.has_value());
auto first_data = first->as<mc::dict>();
EXPECT_EQ(first_data["Name"].as<std::string>(), "EEPROM_FIRST");
EXPECT_EQ(first_data["DataVersion"].as<std::string>(), "3.10");
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_SECOND"})";
auto second = m_connector->i_connector.resolve_sr_data(true, true, false, err);
ASSERT_TRUE(second.has_value());
auto second_data = second->as<mc::dict>();
EXPECT_EQ(second_data["Name"].as<std::string>(), "EEPROM_SECOND");
EXPECT_EQ(second_data["DataVersion"].as<std::string>(), "3.10");
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 2);
}
TEST_F(ConnectorTest, GetLocalCsrData_InvalidJsonSetsDataFormatError)
{
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
const std::string temp_file = "/tmp/connector_invalid_sr.json";
std::ofstream ofs(temp_file);
ofs << "{ invalid json }";
ofs.close();
uint8_t error = 0;
auto payload = m_connector->i_connector.get_local_csr_data(temp_file, &error);
EXPECT_FALSE(payload.has_value());
EXPECT_EQ(error, load_status::DATA_FORMAT_ERROR);
std::remove(temp_file.c_str());
}
TEST_F(ConnectorTest, GetLocalCsrData_MissingFileSetsLocalFileError)
{
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
uint8_t error = 0;
auto payload = m_connector->i_connector.get_local_csr_data("/tmp/connector_missing_sr.json", &error);
EXPECT_FALSE(payload.has_value());
EXPECT_EQ(error, load_status::LOCAL_FILE_ERROR);
}
TEST_F(ConnectorTest, GetE2pCsrData_UsesCsr1First)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"CSR1"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
auto result = m_connector->i_connector.get_e2p_csr_data();
ASSERT_TRUE(result.has_value());
EXPECT_EQ(result->identity_key, "EEPROMUID");
EXPECT_EQ(result->data_version, "3.10");
EXPECT_EQ(result->payload.as<std::string>(), R"({"Name":"CSR1"})");
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);
EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 0);
}
TEST_F(ConnectorTest, GetE2pCsrData_FallsBackToCsr2AndReturnsBoardId)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr1.throw_on_call = true;
m_mock_chip->csr2.BoardId = std::string("CSR2BOARD");
m_mock_chip->csr2.DataVersion = std::string("3.12");
m_mock_chip->csr2.payload = R"({"Name":"CSR2"})";
auto result = m_connector->i_connector.get_e2p_csr_data();
ASSERT_TRUE(result.has_value());
EXPECT_EQ(result->identity_key, "CSR2BOARD");
EXPECT_EQ(result->data_version, "3.12");
EXPECT_EQ(result->payload.as<std::string>(), R"({"Name":"CSR2"})");
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);
EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 1);
}
TEST_F(ConnectorTest, GetE2pCsrData_RetriesCsr1HardwareAccessFailure)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr1.status = load_status::HARDWARE_ACCESS_FAIL;
uint8_t error_status = load_status::DEFAULT;
auto result = m_connector->i_connector.get_e2p_csr_data(&error_status);
EXPECT_FALSE(result.has_value());
EXPECT_EQ(error_status, load_status::HARDWARE_ACCESS_FAIL);
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 5);
EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 0);
}
TEST_F(ConnectorTest, GetE2pCsrData_RecoversAfterHardwareAccessFailures)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr1.hardware_access_failures_remaining = 3;
auto result = m_connector->i_connector.get_e2p_csr_data();
ASSERT_TRUE(result.has_value());
EXPECT_EQ(result->payload.as<std::string>(), R"({"Name":"CSR1_EEPROM"})");
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 4);
EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 0);
}
TEST_F(ConnectorTest, GetE2pCsrData_RetriesCsr2HardwareAccessFailure)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr1.throw_on_call = true;
m_mock_chip->csr2.status = load_status::HARDWARE_ACCESS_FAIL;
uint8_t error_status = load_status::DEFAULT;
auto result = m_connector->i_connector.get_e2p_csr_data(&error_status);
EXPECT_FALSE(result.has_value());
EXPECT_EQ(error_status, load_status::HARDWARE_ACCESS_FAIL);
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);
EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 5);
}
TEST_F(ConnectorTest, GetE2pCsrData_DoesNotRetryNonHardwareFailure)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr1.status = load_status::DATA_FORMAT_ERROR;
uint8_t error_status = load_status::DEFAULT;
auto result = m_connector->i_connector.get_e2p_csr_data(&error_status);
EXPECT_FALSE(result.has_value());
EXPECT_EQ(error_status, load_status::DATA_FORMAT_ERROR);
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);
EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 0);
}
TEST_F(ConnectorTest, TryLoadDevice_KeepsEepromIntegrityVerifyError)
{
set_test_sr_dir("/tmp/connector_integrity_verify_error");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
install_mock_devmon();
m_mock_chip->csr1.status = load_status::INTEGRITY_VERIFY_ERROR;
EXPECT_NO_THROW(m_connector->i_connector.try_load_device().get());
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::INTEGRITY_VERIFY_ERROR);
EXPECT_EQ(m_mock_chip->csr1.header_call_count, 1);
EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 0);
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 0);
}
TEST_F(ConnectorTest, GetE2pCsrData_RejectsCsr1EmptyUid)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.status = load_status::SUCCESS;
m_mock_chip->csr1.payload = R"({"Name":"CSR1"})";
m_mock_chip->csr1.uid = "";
m_mock_chip->csr1.data_version = "3.11";
auto result = m_connector->i_connector.get_e2p_csr_data();
EXPECT_FALSE(result.has_value());
EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 1);
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);
}
TEST_F(ConnectorTest, GetCsr1EepromHeader_RetriesHardwareAccessFailure)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr1.status = load_status::HARDWARE_ACCESS_FAIL;
auto* ref_obj = m_connector->i_connector.get_chip_ref_object();
ASSERT_NE(ref_obj, nullptr);
uint8_t error_status = load_status::DEFAULT;
bool unsupported = false;
auto result = m_connector->i_connector.get_csr1_eeprom_header(*ref_obj, &error_status, unsupported);
EXPECT_FALSE(result.has_value());
EXPECT_FALSE(unsupported);
EXPECT_EQ(error_status, load_status::HARDWARE_ACCESS_FAIL);
EXPECT_EQ(m_mock_chip->csr1.header_call_count, 5);
}
TEST_F(ConnectorTest, ResolveSrData_Csr1UsesUidPathAndLocalWhenLocalVersionNewer)
{
set_test_sr_dir("/tmp/connector_sr_csr1_local_newer");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_OLDER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.09";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "LOCAL_NEWER");
EXPECT_EQ(m_connector->i_connector.Id.get_value().as<std::string>(), "EEPROMUID");
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.valid);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.board_id, "EEPROMUID");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.file_path, test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr");
}
TEST_F(ConnectorTest, ResolveSrData_ProbeUsesHeaderOnlyAndSkipsFullReadWhenLocalNewer)
{
set_test_sr_dir("/tmp/connector_sr_probe_header_only");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_OLDER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.09";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "LOCAL_NEWER");
EXPECT_EQ(m_mock_chip->csr1.header_call_count, 1);
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 0);
}
TEST_F(ConnectorTest, ResolveSrData_Csr1UsesEepromWhenEepromVersionEqualOrNewer)
{
set_test_sr_dir("/tmp/connector_sr_csr1_eeprom_newer");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_NEWER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto data = payload->as<mc::dict>();
EXPECT_EQ(data["Name"].as<std::string>(), "EEPROM_NEWER");
EXPECT_EQ(data["DataVersion"].as<std::string>(), "3.10");
EXPECT_EQ(m_connector->i_connector.Id.get_value().as<std::string>(), "EEPROMUID");
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.valid);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.board_id, "EEPROMUID");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.file_path, test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr");
}
TEST_F(ConnectorTest, ResolveSrData_Csr1EmptyUidFallsBackToConfiguredLocalPath)
{
set_test_sr_dir("/tmp/connector_sr_csr1_empty_uid");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"LOCAL_CONFIGURED"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_NO_UID"})";
m_mock_chip->csr1.uid = "";
m_mock_chip->csr1.data_version = "3.11";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "LOCAL_CONFIGURED");
EXPECT_EQ(m_connector->i_connector.Id.get_value().as<std::string>(), "BOARD456");
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.valid);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.board_id, "BOARD456");
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.eeprom_data_version.empty());
}
TEST_F(ConnectorTest, ResolveSrData_Csr1UsesEepromWhenLocalFileAbsent)
{
set_test_sr_dir("/tmp/connector_sr_csr1_local_absent");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_ONLY"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = load_status::DEFAULT;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto data = payload->as<mc::dict>();
EXPECT_EQ(data["Name"].as<std::string>(), "EEPROM_ONLY");
EXPECT_EQ(data["DataVersion"].as<std::string>(), "3.10");
EXPECT_EQ(m_connector->i_connector.Id.get_value().as<std::string>(), "EEPROMUID");
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.valid);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.board_id, "EEPROMUID");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.eeprom_data_version, "3.10");
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.local_data_version.empty());
EXPECT_EQ(err, load_status::DEFAULT);
}
TEST_F(ConnectorTest, ResolveSrData_EepromFallbackWhenCsrVersionExistsButFileAbsent)
{
set_test_sr_dir("/tmp/connector_sr_json_ver_no_file");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_FALLBACK"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.09";
uint8_t err = load_status::DEFAULT;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "EEPROM_FALLBACK");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
EXPECT_EQ(err, load_status::DEFAULT);
}
TEST_F(ConnectorTest, ResolveSrData_CacheHitWhenLocalFileAbsent)
{
set_test_sr_dir("/tmp/connector_sr_csr1_local_absent_cache");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_ONLY"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = load_status::DEFAULT;
auto first = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(first.has_value());
auto first_data = first->as<mc::dict>();
EXPECT_EQ(first_data["Name"].as<std::string>(), "EEPROM_ONLY");
EXPECT_EQ(first_data["DataVersion"].as<std::string>(), "3.10");
int csr1_calls_before = m_mock_chip->csr1.csr1_call_count;
uint8_t err2 = load_status::DEFAULT;
auto second = m_connector->i_connector.resolve_sr_data(false, true, false, err2);
ASSERT_TRUE(second.has_value());
auto second_data = second->as<mc::dict>();
EXPECT_EQ(second_data["Name"].as<std::string>(), "EEPROM_ONLY");
EXPECT_EQ(second_data["DataVersion"].as<std::string>(), "3.10");
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, csr1_calls_before);
EXPECT_EQ(err2, load_status::DEFAULT);
}
TEST_F(ConnectorTest, ResolveSrData_LocalVersionFallbackFromSrFileSelectsLocalWhenEqual)
{
set_test_sr_dir("/tmp/connector_sr_fallback_equal");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_FROM_SR","DataVersion":"3.99"})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_SAME_VER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.99";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto d = payload->as<mc::dict>();
EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_FROM_SR");
EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.99");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.local_data_version, "3.99");
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.local_version_from_sr_file);
EXPECT_EQ(m_mock_chip->csr1.header_call_count, 1);
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 0);
std::remove((test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr").c_str());
int header_calls_before = m_mock_chip->csr1.header_call_count;
int csr1_calls_before = m_mock_chip->csr1.csr1_call_count;
uint8_t err2 = 0;
auto second = m_connector->i_connector.resolve_sr_data(false, true, false, err2);
ASSERT_TRUE(second.has_value());
auto d2 = second->as<mc::dict>();
EXPECT_EQ(d2["Name"].as<std::string>(), "LOCAL_FROM_SR");
EXPECT_EQ(d2["DataVersion"].as<std::string>(), "3.99");
EXPECT_EQ(m_mock_chip->csr1.header_call_count, header_calls_before);
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, csr1_calls_before);
}
TEST_F(ConnectorTest, ResolveSrData_LocalVersionFallbackFromSrFileSelectsEepromWhenOlder)
{
set_test_sr_dir("/tmp/connector_sr_fallback_older");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_FROM_SR","DataVersion":"3.09"})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_NEWER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "EEPROM_NEWER");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.local_data_version, "3.09");
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.local_version_from_sr_file);
}
TEST_F(ConnectorTest, ResolveSrData_LocalVersionFallbackWithoutDataVersionStillUsesEeprom)
{
set_test_sr_dir("/tmp/connector_sr_fallback_no_ver");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NO_VER"})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_ONLY"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "EEPROM_ONLY");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.local_data_version.empty());
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.local_version_from_sr_file);
}
TEST_F(ConnectorTest, ResolveSrData_LocalSelectedStampsEepromDataVersionOntoPayload)
{
set_test_sr_dir("/tmp/connector_sr_local_stamp_eeprom_ver");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_OLDER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.09";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto d = payload->as<mc::dict>();
EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_NEWER");
EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.09");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.eeprom_data_version, "3.09");
}
TEST_F(ConnectorTest, ResolveSrData_LocalSelectedOverwritesExistingDataVersionWithEepromVersion)
{
set_test_sr_dir("/tmp/connector_sr_local_stamp_overwrite");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER","DataVersion":"9.9"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_OLDER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.09";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto d = payload->as<mc::dict>();
EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_NEWER");
EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.09");
}
TEST_F(ConnectorTest, ResolveSrData_LocalSelectedWithoutEepromVersionDoesNotStamp)
{
set_test_sr_dir("/tmp/connector_sr_local_no_eeprom_ver");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"LOCAL_CONFIGURED","DataVersion":"2.0"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_NO_UID"})";
m_mock_chip->csr1.uid = "";
m_mock_chip->csr1.data_version = "3.11";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto d = payload->as<mc::dict>();
EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_CONFIGURED");
ASSERT_TRUE(d.contains("DataVersion"));
EXPECT_EQ(d["DataVersion"].as<std::string>(), "2.0");
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.eeprom_data_version.empty());
}
TEST_F(ConnectorTest, ResolveSrData_EepromSelectedStampsDataVersion)
{
set_test_sr_dir("/tmp/connector_sr_eeprom_selected_no_stamp");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_NEWER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto data = payload->as<mc::dict>();
EXPECT_EQ(data["Name"].as<std::string>(), "EEPROM_NEWER");
EXPECT_EQ(data["DataVersion"].as<std::string>(), "3.10");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
}
TEST_F(ConnectorTest, ResolveSrData_LocalFallbackStampsEepromHeaderDataVersion)
{
set_test_sr_dir("/tmp/connector_sr_eeprom_fallback_stamp");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_FALLBACK","DataVersion":"1.00"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.BoardId = std::string("EEPROMUID");
m_mock_chip->csr2.DataVersion = std::string("3.10");
m_mock_chip->csr2.status = load_status::HARDWARE_ACCESS_FAIL;
m_mock_chip->csr1.throw_on_call = true;
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto data = payload->as<mc::dict>();
EXPECT_EQ(data["Name"].as<std::string>(), "LOCAL_FALLBACK");
EXPECT_EQ(data["DataVersion"].as<std::string>(), "3.10");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
}
TEST_F(ConnectorTest, ResolveSrData_CacheHitReturnsStampedDataVersion)
{
set_test_sr_dir("/tmp/connector_sr_local_stamp_cache");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER","DataVersion":"3.10"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_OLDER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.09";
uint8_t err = 0;
auto first = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(first.has_value());
EXPECT_EQ(first->as<mc::dict>()["Name"].as<std::string>(), "LOCAL_NEWER");
EXPECT_EQ(first->as<mc::dict>()["DataVersion"].as<std::string>(), "3.09");
int csr1_calls_before = m_mock_chip->csr1.csr1_call_count;
uint8_t err2 = 0;
auto second = m_connector->i_connector.resolve_sr_data(false, true, false, err2);
ASSERT_TRUE(second.has_value());
EXPECT_EQ(second->as<mc::dict>()["DataVersion"].as<std::string>(), "3.09");
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, csr1_calls_before);
}
TEST(NormalizeVersionTest, FormatsVersionToTwoDecimalPlaces)
{
EXPECT_EQ(normalize_version(std::string("3.1")), "3.10");
EXPECT_EQ(normalize_version(std::string("3.10")), "3.10");
EXPECT_EQ(normalize_version(std::string("3")), "3.00");
EXPECT_EQ(normalize_version(std::string("5.0")), "5.00");
EXPECT_EQ(normalize_version(std::string("3.09")), "3.09");
EXPECT_EQ(normalize_version(3.1), "3.10");
EXPECT_EQ(normalize_version(5.0), "5.00");
}
TEST(NormalizeVersionTest, PreservesEmptyAndNonNumeric)
{
EXPECT_EQ(normalize_version(std::string("")), "");
EXPECT_EQ(normalize_version(std::string("abc")), "abc");
}
TEST_F(ConnectorTest, ResolveSrData_NormalizesEepromDataVersionToTwoDecimals)
{
set_test_sr_dir("/tmp/connector_sr_normalize_eeprom_ver");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_OLDER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.1";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto d = payload->as<mc::dict>();
EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_NEWER");
EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.10");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.eeprom_data_version, "3.10");
}
TEST_F(ConnectorTest, ResolveSrData_NumericDataVersionAlwaysStampedToString)
{
set_test_sr_dir("/tmp/connector_sr_numeric_data_ver");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER","DataVersion":3.1})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_OLDER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto d = payload->as<mc::dict>();
EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_NEWER");
EXPECT_TRUE(d["DataVersion"].is_string());
EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.10");
}
TEST_F(ConnectorTest, ResolveSrData_NormalizesLocalCsrVersionForSourceSelection)
{
set_test_sr_dir("/tmp/connector_sr_normalize_local_ver");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.1");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_OLDER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.09";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(m_connector->i_connector.m_sr_cache.local_data_version, "3.10");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
auto d = payload->as<mc::dict>();
EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_NEWER");
EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.09");
}
TEST_F(ConnectorTest, test_iconnector_dump)
{
auto csr = create_test_csr(0);
auto connector = create_test_connector();
bool result = m_connector->init(csr, connector);
ASSERT_TRUE(result);
uint8_t presence = m_connector->i_connector.Presence.get_value().as<uint8_t>();
m_connector->i_connector.Presence.set_value(1);
auto dump_info = m_connector->i_connector.dump();
EXPECT_EQ(dump_info.presence, 1);
}
TEST_F(ConnectorTest, test_connector_dump)
{
auto csr = create_test_csr(0);
auto connector = create_test_connector();
bool result = m_connector->init(csr, connector);
ASSERT_TRUE(result);
m_connector->i_connector.Presence.set_value(1);
ASSERT_TRUE(wait_for_load_status(load_status::LOCAL_FILE_ERROR));
std::string dump_output = m_connector->dump();
auto verify_line = [&](const std::string& prefix, const std::string& label, const std::string& value_str) {
auto pos = dump_output.find(prefix + label);
EXPECT_NE(pos, std::string::npos) << "Missing line for: " << prefix << label;
if (pos == std::string::npos) {
return;
}
auto nl = dump_output.find('\n', pos);
ASSERT_NE(nl, std::string::npos);
std::string line = dump_output.substr(pos, nl - pos);
EXPECT_NE(line.find(value_str), std::string::npos) << "Expected value '" << value_str << "' in line: " << line;
};
EXPECT_FALSE(dump_output.empty());
verify_line(".", "AuxId", "AUX789");
verify_line(".", "Bom", "BOM12345");
verify_line(".", "Buses", R"(["I2c_1"])");
verify_line(".", "ChassisId", "Chassis1");
verify_line(".", "GroupId", "10");
verify_line(".", "GroupPosition", "A1");
verify_line(".", "Id", "BOARD456");
verify_line(".", "IdentifyMode", "0");
verify_line(".", "LoadStatus", "4");
verify_line(".", "ManagerId", "Manager1");
verify_line(".", "Presence", "1");
verify_line(".", "SilkText", "Silk1");
verify_line(".", "Slot", "1");
verify_line(".", "SystemId", "1");
verify_line(".", "Type", "Card");
EXPECT_EQ(dump_output.find("-SoftSourcePath"), std::string::npos);
EXPECT_EQ(dump_output.find("-DataSource"), std::string::npos);
EXPECT_EQ(dump_output.find("-EffectiveFormatVersion"), std::string::npos);
EXPECT_EQ(dump_output.find("-EffectiveDataVersion"), std::string::npos);
EXPECT_EQ(dump_output.find("-EepromFormatVersion"), std::string::npos);
EXPECT_EQ(dump_output.find("-EepromDataVersion"), std::string::npos);
EXPECT_EQ(dump_output.find("-LocalFormatVersion"), std::string::npos);
EXPECT_EQ(dump_output.find("-LocalDataVersion"), std::string::npos);
}
TEST_F(ConnectorTest, test_connector_dump_success)
{
set_test_sr_dir("/tmp/connector_dump_success");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr",
R"({"Name":"DUMP_LOCAL","FormatVersion":"1.0","DataVersion":"2.0"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"DUMP_EEPROM","FormatVersion":"3.0","DataVersion":"4.0"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
std::string dump_output = m_connector->dump();
auto verify_line = [&](const std::string& prefix, const std::string& label, const std::string& value_str) {
auto pos = dump_output.find(prefix + label);
EXPECT_NE(pos, std::string::npos) << "Missing line for: " << prefix << label;
if (pos == std::string::npos) {
return;
}
auto nl = dump_output.find('\n', pos);
ASSERT_NE(nl, std::string::npos);
std::string line = dump_output.substr(pos, nl - pos);
EXPECT_NE(line.find(value_str), std::string::npos) << "Expected value '" << value_str << "' in line: " << line;
};
EXPECT_FALSE(dump_output.empty());
verify_line(".", "AuxId", "AUX789");
verify_line(".", "Bom", "BOM12345");
verify_line(".", "Buses", R"(["I2c_1"])");
verify_line(".", "ChassisId", "Chassis1");
verify_line(".", "GroupId", "10");
verify_line(".", "GroupPosition", "A1");
verify_line(".", "Id", "EEPROMUID");
verify_line(".", "IdentifyMode", "3");
verify_line(".", "LoadStatus", "255");
verify_line(".", "ManagerId", "Manager1");
verify_line(".", "Presence", "1");
verify_line(".", "SilkText", "Silk1");
verify_line(".", "Slot", "1");
verify_line(".", "SystemId", "1");
verify_line(".", "Type", "Card");
EXPECT_EQ(dump_output.find("-SourcePath"), std::string::npos);
EXPECT_EQ(dump_output.find("-LocalDataVersion"), std::string::npos);
}
TEST_F(ConnectorTest, test_connector_dump_success_includes_source_path)
{
auto csr = create_test_csr(0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
m_connector->i_connector.m_sr_cache.valid = true;
m_connector->i_connector.m_sr_cache.source = connector_sr_source::local;
m_connector->i_connector.m_sr_cache.file_path = "/opt/bmc/sr/test_connector.sr";
EXPECT_TRUE(m_connector->get_managed_objects().empty());
EXPECT_NE(m_connector->dump().find("/opt/bmc/sr/test_connector.sr"), std::string::npos);
}
TEST_F(ConnectorTest, test_connector_dump_eeprom_source_path)
{
auto csr = create_test_csr(0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
m_connector->i_connector.m_sr_cache.valid = true;
m_connector->i_connector.m_sr_cache.source = connector_sr_source::eeprom;
m_connector->i_connector.m_sr_cache.board_id = "EEPROMUID";
EXPECT_NE(m_connector->dump().find("/data/opt/bmc/sr/backup/EEPROMUID.bin"), std::string::npos);
}
TEST_F(ConnectorTest, test_connector_dump_gold_source_path)
{
auto csr = create_test_csr(0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
m_connector->i_connector.m_sr_cache.valid = true;
m_connector->i_connector.m_sr_cache.source = connector_sr_source::gold;
m_connector->i_connector.m_sr_cache.selected_path = "/data/opt/bmc/sr/gold/test_connector.sr";
std::string dump_output = m_connector->dump();
EXPECT_NE(dump_output.find("GOLD"), std::string::npos);
EXPECT_NE(dump_output.find("/data/opt/bmc/sr/gold/test_connector.sr"), std::string::npos);
}
TEST_F(ConnectorTest, test_connector_dump_temp_source_path)
{
auto csr = create_test_csr(0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
m_connector->i_connector.m_sr_cache.valid = true;
m_connector->i_connector.m_sr_cache.source = connector_sr_source::temp;
m_connector->i_connector.m_sr_cache.selected_path = "/data/opt/bmc/sr/temp/test_connector.sr";
std::string dump_output = m_connector->dump();
EXPECT_NE(dump_output.find("TEMP"), std::string::npos);
EXPECT_NE(dump_output.find("/data/opt/bmc/sr/temp/test_connector.sr"), std::string::npos);
}
TEST_F(ConnectorTest, test_connector_dump_buses_string_output)
{
auto check_buses_line = [](const std::string& output, const std::string& expected_buses) {
auto pos = output.find(".Buses");
EXPECT_NE(pos, std::string::npos);
if (pos == std::string::npos) {
return;
}
auto nl = output.find('\n', pos);
ASSERT_NE(nl, std::string::npos);
std::string line = output.substr(pos, nl - pos);
EXPECT_NE(line.find(expected_buses), std::string::npos);
};
{
auto csr = create_test_csr(0);
csr["Buses"] = std::vector<std::string>{"I2c_1", "I2c_2"};
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
std::string output = m_connector->dump();
check_buses_line(output, R"(["I2c_1","I2c_2"])");
}
{
auto csr = create_test_csr(0);
csr["Buses"] = std::vector<std::string>{"bus\"with\"quotes", "bus\\backslash", "bus\nnewline"};
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
std::string output = m_connector->dump();
check_buses_line(output, R"(["bus\"with\"quotes","bus\\backslash","bus\nnewline"])");
}
{
auto csr = create_test_csr(0);
csr["Buses"] = std::vector<std::string>{};
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
std::string output = m_connector->dump();
check_buses_line(output, "[]");
}
}
TEST_F(ConnectorTest, test_connector_dump_buses_json_escape)
{
auto csr = create_test_csr(0);
csr["Buses"] = std::vector<std::string>{"bus\"with\"quotes", "bus\\backslash", "bus\nnewline"};
auto connector = create_test_connector();
bool result = m_connector->init(csr, connector);
ASSERT_TRUE(result);
auto dump_info = m_connector->i_connector.dump();
EXPECT_EQ(dump_info.buses, R"(["bus\"with\"quotes","bus\\backslash","bus\nnewline"])");
}
TEST_F(ConnectorTest, test_connector_dump_buses_simple)
{
auto csr = create_test_csr(0);
csr["Buses"] = std::vector<std::string>{"I2c_1", "I2c_2"};
auto connector = create_test_connector();
bool result = m_connector->init(csr, connector);
ASSERT_TRUE(result);
auto dump_info = m_connector->i_connector.dump();
EXPECT_EQ(dump_info.buses, R"(["I2c_1","I2c_2"])");
}
TEST_F(ConnectorTest, test_connector_dump_buses_empty)
{
auto csr = create_test_csr(0);
csr["Buses"] = std::vector<std::string>{};
auto connector = create_test_connector();
bool result = m_connector->init(csr, connector);
ASSERT_TRUE(result);
auto dump_info = m_connector->i_connector.dump();
EXPECT_EQ(dump_info.buses, "[]");
}
TEST_F(ConnectorTest, Reload_RemovesOldIdentityThenLoadsReplacementIdentity)
{
set_test_sr_dir("/tmp/connector_reload_local");
write_file(test_sr_dir + "/NEWBOM_NEWID_NEWAUX.sr", R"({"Name":"RELOADED"})");
write_csr_version("NEWBOM_NEWID_NEWAUX", "3.10");
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
m_connector->i_connector.Reload("NEWBOM", "NEWID", "NEWAUX", 0);
ASSERT_EQ(m_mock_devmon->devmon.remove_device_call_count, 1);
ASSERT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
ASSERT_EQ(m_mock_devmon->devmon.remove_device_connectors.size(), 1u);
ASSERT_EQ(m_mock_devmon->devmon.add_device_connectors.size(), 1u);
const auto& removed = m_mock_devmon->devmon.remove_device_connectors.front();
EXPECT_EQ(removed.at("Bom").as<std::string>(), "BOM12345");
EXPECT_EQ(removed.at("Id").as<std::string>(), "BOARD456");
EXPECT_EQ(removed.at("AuxId").as<std::string>(), "AUX789");
const auto& added = m_mock_devmon->devmon.add_device_connectors.front();
EXPECT_EQ(added.at("Bom").as<std::string>(), "NEWBOM");
EXPECT_EQ(added.at("Id").as<std::string>(), "NEWID");
EXPECT_EQ(added.at("AuxId").as<std::string>(), "NEWAUX");
EXPECT_EQ(added.at("IdentifyMode").as<uint8_t>(), 0);
EXPECT_EQ(m_connector->i_connector.Bom.get_value().as<std::string>(), "NEWBOM");
EXPECT_EQ(m_connector->i_connector.Id.get_value().as<std::string>(), "NEWID");
EXPECT_EQ(m_connector->i_connector.AuxId.get_value().as<std::string>(), "NEWAUX");
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::SUCCESS);
}
TEST_F(ConnectorTest, TryLoadDeviceWaitsForAsyncDevmonWithoutBlockingCaller)
{
set_test_sr_dir("/tmp/connector_async_load");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"ASYNC_LOAD"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(0, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
m_mock_devmon->devmon.delay_add = true;
auto completion = m_connector->i_connector.try_load_device();
EXPECT_FALSE(completion.is_ready());
EXPECT_NO_THROW(completion.get());
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::SUCCESS);
}
TEST_F(ConnectorTest, TryLoadDeviceSetsObjectParseErrorWhenDevmonRejectsCsr)
{
set_test_sr_dir("/tmp/connector_devmon_reject");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"INVALID_CSR"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(0, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
m_mock_devmon->devmon.fail_add = true;
auto completion = m_connector->i_connector.try_load_device();
EXPECT_THROW(completion.get(), mc::exception);
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::OBJECT_PARSE_ERROR);
}
TEST_F(ConnectorTest, TryLoadDeviceSingleFlightGuardDedupsDuplicateTriggerThenReleases)
{
set_test_sr_dir("/tmp/connector_singleflight_guard");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"SINGLEFLIGHT"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(0, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
m_mock_devmon->devmon.delay_add = true;
auto epoch = m_connector->i_connector.begin_start();
auto f1 = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
auto f2 = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
EXPECT_TRUE(f1.get());
EXPECT_FALSE(f2.get());
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::SUCCESS);
auto f3 = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
EXPECT_TRUE(f3.get());
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 2);
}
TEST_F(ConnectorTest, OldInflightChainTerminalReleaseDoesNotClobberReinsertedChainGuard)
{
set_test_sr_dir("/tmp/connector_singleflight_clobber");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"CLOBBER"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(0, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
m_mock_devmon->devmon.delay_add = true;
auto epoch = m_connector->i_connector.begin_start();
auto chainA = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
m_connector->i_connector.force_release_load_guard();
auto tokenB = m_connector->i_connector.next_load_chain_id();
ASSERT_TRUE(m_connector->i_connector.acquire_load_guard(tokenB));
EXPECT_TRUE(chainA.get());
auto chainC = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
EXPECT_FALSE(chainC.get());
m_connector->i_connector.release_load_guard(tokenB);
auto chainD = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
EXPECT_TRUE(chainD.get());
}
TEST_F(ConnectorTest, RetryChainAbortsWhenGuardOwnershipLost)
{
set_test_sr_dir("/tmp/connector_retry_abort");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"RETRYABORT"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(0, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
auto epoch = m_connector->i_connector.begin_start();
auto foreign_token = m_connector->i_connector.next_load_chain_id();
auto f_abort = m_connector->i_connector.try_load_device_with_sr_retry(epoch, foreign_token, 2);
EXPECT_FALSE(f_abort.get());
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 0);
m_mock_devmon->devmon.delay_add = true;
auto held_token = m_connector->i_connector.next_load_chain_id();
ASSERT_TRUE(m_connector->i_connector.acquire_load_guard(held_token));
auto f_ok = m_connector->i_connector.try_load_device_with_sr_retry(epoch, held_token, 2);
EXPECT_TRUE(f_ok.get());
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
}
TEST_F(ConnectorTest, PresenceChangeLoadsDeviceAfterPropertyCallbackReturns)
{
set_test_sr_dir("/tmp/connector_presence_load");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"PRESENCE_LOAD"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(0, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
ASSERT_TRUE(wait_for_load_status(load_status::SUCCESS));
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::SUCCESS);
}
TEST_F(ConnectorTest, PresenceChangeRetriesWholeEepromLoad)
{
set_test_sr_dir("/tmp/connector_presence_load_retry");
auto csr = create_test_csr(0, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
install_mock_devmon();
m_mock_chip->csr1.hardware_access_failures_remaining = 5;
EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
ASSERT_TRUE(wait_for_load_status(load_status::SUCCESS));
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 6);
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
}
TEST_F(ConnectorTest, TryLoadDeviceWithRetryStopsAfterTwoFailedEepromLoads)
{
set_test_sr_dir("/tmp/connector_presence_load_retry_exhausted");
auto csr = create_test_csr(0, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
install_mock_devmon();
m_mock_chip->csr1.hardware_access_failures_remaining = 10;
auto epoch = m_connector->i_connector.begin_start();
auto completion = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
EXPECT_NO_THROW(completion.get());
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 10);
EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 0);
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 0);
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::HARDWARE_ACCESS_FAIL);
}
TEST_F(ConnectorTest, PresenceChangeDoesNotRetryDevmonFailure)
{
set_test_sr_dir("/tmp/connector_presence_devmon_failure");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"INVALID_CSR"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(0, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
m_mock_devmon->devmon.fail_add = true;
EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
ASSERT_TRUE(wait_for_load_status(load_status::OBJECT_PARSE_ERROR));
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
}
TEST_F(ConnectorTest, MissingHotPluggableDefaultsToSupported)
{
set_test_sr_dir("/tmp/connector_hotplug_default");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"DEFAULT_HOTPLUG"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
EXPECT_NO_THROW(m_connector->i_connector.try_load_device().get());
EXPECT_TRUE(m_connector->i_connector.HotPluggable.get_value().as<bool>());
EXPECT_TRUE(m_mock_devmon->devmon.add_device_connectors.front().at("HotPluggable").as<bool>());
}
TEST_F(ConnectorTest, NonHotPluggableDeviceStaysLoadedAcrossPresenceChanges)
{
set_test_sr_dir("/tmp/connector_non_hotplug");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"NON_HOTPLUG"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(0, 0);
csr["HotPluggable"] = false;
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
ASSERT_TRUE(wait_for_load_status(load_status::SUCCESS));
EXPECT_FALSE(m_connector->i_connector.HotPluggable.get_value().as<bool>());
EXPECT_FALSE(m_mock_devmon->devmon.add_device_connectors.front().at("HotPluggable").as<bool>());
EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(static_cast<uint8_t>(0)));
std::this_thread::sleep_for(std::chrono::milliseconds(50));
EXPECT_EQ(m_mock_devmon->devmon.remove_device_call_count, 0);
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::SUCCESS);
EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
std::this_thread::sleep_for(std::chrono::milliseconds(50));
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
}
TEST_F(ConnectorTest, NonHotPluggableDeviceRetriesSrLoadFiveTimes)
{
set_test_sr_dir("/tmp/connector_non_hotplug_sr_retry");
auto csr = create_test_csr(1, identify_mode::EEPROM);
csr["HotPluggable"] = false;
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
install_mock_devmon();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.hardware_access_failures_remaining = 25;
auto epoch = m_connector->i_connector.begin_start();
auto start = std::chrono::steady_clock::now();
EXPECT_NO_THROW(m_connector->i_connector.try_load_device_with_sr_retry(epoch).get());
const auto elapsed =
std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start);
EXPECT_GE(elapsed.count(), 1900);
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 25);
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 0);
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::HARDWARE_ACCESS_FAIL);
}
TEST_F(ConnectorTest, NonHotPluggableDeviceDoesNotRetryAddDeviceFailure)
{
set_test_sr_dir("/tmp/connector_non_hotplug_add_failure");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"NON_HOTPLUG"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(1, 0);
csr["HotPluggable"] = false;
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
m_mock_devmon->devmon.fail_add = true;
EXPECT_THROW(m_connector->i_connector.try_load_device().get(), mc::exception);
EXPECT_FALSE(m_connector->i_connector.HotPluggable.get_value().as<bool>());
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::OBJECT_PARSE_ERROR);
}
TEST_F(ConnectorTest, HotPluggableDeviceUnloadsOnPresenceDeassertion)
{
set_test_sr_dir("/tmp/connector_hotplug_unload");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"HOTPLUG"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(0, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
ASSERT_TRUE(wait_for_load_status(load_status::SUCCESS));
EXPECT_TRUE(m_connector->i_connector.HotPluggable.get_value().as<bool>());
EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(static_cast<uint8_t>(0)));
ASSERT_TRUE(wait_for_load_status(load_status::DEFAULT));
EXPECT_EQ(m_mock_devmon->devmon.remove_device_call_count, 1);
}
TEST_F(ConnectorTest, TryLoadDeviceWithRetrySkipsStoppedAndStaleStart)
{
set_test_sr_dir("/tmp/connector_retry_stale_start");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"STALE_START"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(0, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
auto old_epoch = m_connector->i_connector.begin_start();
m_connector->stop();
EXPECT_NO_THROW(m_connector->i_connector.try_load_device_with_sr_retry(old_epoch).get());
m_connector->i_connector.begin_start();
EXPECT_NO_THROW(m_connector->i_connector.try_load_device_with_sr_retry(old_epoch).get());
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 0);
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::DEFAULT);
}
TEST_F(ConnectorTest, Reload_EepromModeRefreshesCachedEepromData)
{
set_test_sr_dir("/tmp/connector_reload_eeprom_refresh");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
install_mock_devmon();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_FIRST"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto first = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(first.has_value());
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_SECOND"})";
m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
m_connector->i_connector.Reload("BOM12345", "EEPROMUID", "AUX789", identify_mode::EEPROM);
EXPECT_GE(m_mock_chip->csr1.csr1_call_count, 2);
ASSERT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
ASSERT_TRUE(m_mock_devmon->devmon.last_sr_data.has_value());
auto data = m_mock_devmon->devmon.last_sr_data->as<mc::dict>();
EXPECT_EQ(data["Name"].as<std::string>(), "EEPROM_SECOND");
EXPECT_EQ(data["DataVersion"].as<std::string>(), "3.10");
}
TEST_F(ConnectorTest, PreloadEepromFailureDoesNotChangeLoadStatus)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.status = load_status::HARDWARE_ACCESS_FAIL;
m_mock_chip->csr1.throw_on_call = true;
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, false, true, err);
EXPECT_FALSE(payload.has_value());
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::DEFAULT);
}
TEST_F(ConnectorTest, PreloadLocalFileFailureDoesNotChangeLoadStatus)
{
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
setenv("CONNECTOR_SR_DIR", "/tmp/connector_nonexistent_dir", 1);
unsetenv("PROG_CSR_PATH");
m_connector->i_connector.Bom.set_value(std::string("BOM12345"));
m_connector->i_connector.Id.set_value(std::string("NONEXISTENT"));
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, false, true, err);
EXPECT_FALSE(payload.has_value());
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::DEFAULT);
}
TEST_F(ConnectorTest, PreloadWithoutIdentitySkipsMalformedLocalPath)
{
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
set_test_sr_dir("/tmp/connector_preload_without_identity");
write_file(test_sr_dir + "/csr_version.json", "{}");
write_file(test_sr_dir + "/BOM12345_.sr", R"({"Name":"SHOULD_NOT_LOAD"})");
unsetenv("PROG_CSR_PATH");
m_connector->i_connector.Bom.set_value(std::string("BOM12345"));
m_connector->i_connector.Id.set_value(std::string());
m_connector->i_connector.AuxId.set_value(std::string());
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, false, true, err);
EXPECT_FALSE(payload.has_value());
EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::DEFAULT);
}
TEST_F(ConnectorTest, LoadPathEepromFailureSetsErrorStatus)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.status = load_status::HARDWARE_ACCESS_FAIL;
m_mock_chip->csr1.throw_on_call = true;
uint8_t err = load_status::DEFAULT;
auto payload = m_connector->i_connector.resolve_sr_data(true, true, false, err);
EXPECT_FALSE(payload.has_value());
EXPECT_EQ(err, load_status::HARDWARE_ACCESS_FAIL);
}
TEST_F(ConnectorTest, LoadPathLocalFileFailureSetsErrorStatus)
{
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
setenv("CONNECTOR_SR_DIR", "/tmp/connector_nonexistent_dir", 1);
unsetenv("PROG_CSR_PATH");
m_connector->i_connector.Bom.set_value(std::string("BOM12345"));
m_connector->i_connector.Id.set_value(std::string("NONEXISTENT"));
uint8_t err = load_status::DEFAULT;
auto payload = m_connector->i_connector.resolve_sr_data(true, true, false, err);
EXPECT_FALSE(payload.has_value());
EXPECT_EQ(err, load_status::LOCAL_FILE_ERROR);
}
TEST_F(ConnectorTest, LoadPathSuccessDoesNotChangeErrorStatus)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr1.payload = R"({"Name":"TEST"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
m_mock_chip->csr2.throw_on_call = true;
set_test_sr_dir("/tmp/connector_sr_success_test");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "0.1");
unsetenv("PROG_CSR_PATH");
uint8_t err = load_status::DEFAULT;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
EXPECT_TRUE(payload.has_value());
EXPECT_EQ(err, load_status::DEFAULT);
}
TEST_F(ConnectorTest, LoadPathCacheHitSkipsChipAccess)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"CSR1"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
set_test_sr_dir("/tmp/connector_sr_fast_cache_hit");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "0.1");
unsetenv("PROG_CSR_PATH");
uint8_t dummy = 0;
auto preload_result = m_connector->i_connector.resolve_sr_data(false, false, true, dummy);
ASSERT_TRUE(preload_result.has_value());
int csr2_calls_before = m_mock_chip->csr2.csr2_call_count;
int csr1_calls_before = m_mock_chip->csr1.csr1_call_count;
uint8_t err = load_status::DEFAULT;
auto load_result = m_connector->i_connector.resolve_sr_data(false, true, false, err);
EXPECT_TRUE(load_result.has_value());
EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, csr2_calls_before);
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, csr1_calls_before);
}
TEST_F(ConnectorTest, LoadPathCacheMissFallsBackToChipAccess)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"CSR1"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
set_test_sr_dir("/tmp/connector_sr_fast_cache_miss");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "0.1");
unsetenv("PROG_CSR_PATH");
uint8_t dummy = 0;
auto preload_result = m_connector->i_connector.resolve_sr_data(false, false, true, dummy);
ASSERT_TRUE(preload_result.has_value());
write_csr_version("BOM12345_EEPROMUID_AUX789", "5.0");
m_connector->i_connector.m_local_csr_version_cache.reset();
int header_calls_before = m_mock_chip->csr1.header_call_count;
int csr1_calls_before = m_mock_chip->csr1.csr1_call_count;
uint8_t err = load_status::DEFAULT;
auto load_result = m_connector->i_connector.resolve_sr_data(false, true, false, err);
EXPECT_TRUE(load_result.has_value());
EXPECT_GT(m_mock_chip->csr1.header_call_count, header_calls_before);
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, csr1_calls_before);
}
TEST_F(ConnectorTest, GetSoftFilePath_NormalPath)
{
EXPECT_EQ(m_connector->i_connector.get_soft_file_path("/opt/bmc/sr/BOM_BOARD.sr"), "/opt/bmc/sr/BOM_BOARD_soft.sr");
}
TEST_F(ConnectorTest, GetSoftFilePath_WithoutExtension)
{
EXPECT_EQ(m_connector->i_connector.get_soft_file_path("/opt/bmc/sr/noext"), "/opt/bmc/sr/noext_soft.sr");
}
TEST_F(ConnectorTest, GetSoftFilePath_EmptyPath)
{
EXPECT_EQ(m_connector->i_connector.get_soft_file_path(""), "_soft.sr");
}
TEST_F(ConnectorTest, MergeSoftData_MergesObjectsCorrectly)
{
set_test_sr_dir("/tmp/connector_merge_basic");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"soft","type":"chip"},"chip3":{"addr":3}}})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
mc::variant eeprom_payload(std::string(
R"({"FormatVersion":"3.0","DataVersion":"1.0","Objects":{"chip1":{"addr":1},"chip2":{"addr":2}}})"));
auto merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);
ASSERT_TRUE(merged.has_value());
auto d = merged->as<mc::dict>();
auto objects = d["Objects"].as<mc::dict>();
ASSERT_TRUE(objects.contains("chip1"));
auto chip1 = objects["chip1"].as<mc::dict>();
EXPECT_EQ(chip1["name"].as<std::string>(), "soft");
EXPECT_EQ(chip1["type"].as<std::string>(), "chip");
EXPECT_EQ(chip1["addr"].as<int>(), 1);
ASSERT_TRUE(objects.contains("chip2"));
auto chip2 = objects["chip2"].as<mc::dict>();
EXPECT_EQ(chip2["addr"].as<int>(), 2);
ASSERT_TRUE(objects.contains("chip3"));
auto chip3 = objects["chip3"].as<mc::dict>();
EXPECT_EQ(chip3["addr"].as<int>(), 3);
}
TEST_F(ConnectorTest, MergeSoftData_PreservesBaseSectionsAndMergesTopology)
{
set_test_sr_dir("/tmp/connector_merge_topology");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr", R"({
"FormatVersion":"3.0",
"Unit":{"Name":"SOFT_UNIT"},
"SoftOnly":{"value":1},
"Objects":{"shared":{"soft":1},"soft_object":{"value":1}},
"ManagementTopology":{
"Anchor":{"Buses":["B","A"]},
"Bus":{"Chips":["soft_chip"],"Connectors":["connector"],"SoftField":2},
"SoftBus":{"Buses":["soft_bus"]}
}
})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
mc::variant eeprom_payload(std::string(R"({
"FormatVersion":"3.0",
"DataVersion":"3.10",
"Unit":{"Name":"EEPROM_UNIT"},
"BaseOnly":{"value":1},
"Objects":{"shared":{"eeprom":1},"eeprom_object":{"value":1}},
"ManagementTopology":{
"Anchor":{"Buses":["A"]},
"Bus":{"Chips":["eeprom_chip"],"Buses":["base_bus"],"BaseField":1},
"EepromBus":{"Buses":["eeprom_bus"]}
}
})"));
auto merged =
m_connector->i_connector.merge_soft_data(eeprom_payload, test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr");
ASSERT_TRUE(merged.has_value());
auto data = merged->as<mc::dict>();
EXPECT_EQ(data["Unit"].as<mc::dict>()["Name"].as<std::string>(), "EEPROM_UNIT");
EXPECT_TRUE(data.contains("BaseOnly"));
EXPECT_FALSE(data.contains("SoftOnly"));
auto objects = data["Objects"].as<mc::dict>();
EXPECT_TRUE(objects.contains("eeprom_object"));
EXPECT_TRUE(objects.contains("soft_object"));
auto shared = objects["shared"].as<mc::dict>();
EXPECT_EQ(shared["eeprom"].as<int>(), 1);
EXPECT_EQ(shared["soft"].as<int>(), 1);
auto topology = data["ManagementTopology"].as<mc::dict>();
EXPECT_TRUE(topology.contains("EepromBus"));
EXPECT_TRUE(topology.contains("SoftBus"));
EXPECT_EQ(topology["Anchor"].as<mc::dict>()["Buses"].as<std::vector<std::string>>(),
(std::vector<std::string>{"A", "B"}));
auto bus = topology["Bus"].as<mc::dict>();
EXPECT_EQ(bus["Chips"].as<std::vector<std::string>>(), (std::vector<std::string>{"eeprom_chip", "soft_chip"}));
EXPECT_EQ(bus["Buses"].as<std::vector<std::string>>(), (std::vector<std::string>{"base_bus"}));
EXPECT_EQ(bus["Connectors"].as<std::vector<std::string>>(), (std::vector<std::string>{"connector"}));
EXPECT_EQ(bus["BaseField"].as<int>(), 1);
EXPECT_EQ(bus["SoftField"].as<int>(), 2);
}
TEST_F(ConnectorTest, MergeSoftData_KeepsBaseTopologyNodeWhenSoftNodeIsInvalid)
{
set_test_sr_dir("/tmp/connector_merge_invalid_topology");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr", R"({
"FormatVersion":"3.0",
"Objects":{"soft_object":{"value":1}},
"ManagementTopology":{"Bus":"invalid"}
})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
mc::variant base_payload(std::string(R"({
"FormatVersion":"3.0",
"Objects":{"base_object":{"value":1}},
"ManagementTopology":{"Bus":{"Buses":["base_bus"]}}
})"));
auto merged =
m_connector->i_connector.merge_soft_data(base_payload, test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr");
ASSERT_TRUE(merged.has_value());
auto data = merged->as<mc::dict>();
auto objects = data["Objects"].as<mc::dict>();
EXPECT_TRUE(objects.contains("base_object"));
EXPECT_TRUE(objects.contains("soft_object"));
EXPECT_EQ(data["ManagementTopology"].as<mc::dict>()["Bus"].as<mc::dict>()["Buses"].as<std::vector<std::string>>(),
(std::vector<std::string>{"base_bus"}));
}
TEST_F(ConnectorTest, MergeSoftData_SoftFileNotFoundReturnsNullopt)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
mc::variant eeprom_payload(std::string(R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})"));
auto merged = m_connector->i_connector.merge_soft_data(eeprom_payload, "/nonexistent/soft.sr");
EXPECT_FALSE(merged.has_value());
}
TEST_F(ConnectorTest, MergeSoftData_FormatVersionBelowRangeSkipsMerge)
{
set_test_sr_dir("/tmp/connector_merge_low_version");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
R"({"FormatVersion":"2.0","Objects":{"chip1":{"name":"soft"}}})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
mc::variant eeprom_payload(std::string(R"({"FormatVersion":"2.0","Objects":{"chip1":{"addr":1}}})"));
auto merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);
EXPECT_FALSE(merged.has_value());
}
TEST_F(ConnectorTest, MergeSoftData_FormatVersionAboveRangeSkipsMerge)
{
set_test_sr_dir("/tmp/connector_merge_high_version");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
R"({"FormatVersion":"5.0","Objects":{"chip1":{"name":"soft"}}})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
mc::variant eeprom_payload(std::string(R"({"FormatVersion":"5.0","Objects":{"chip1":{"addr":1}}})"));
auto merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);
EXPECT_FALSE(merged.has_value());
}
TEST_F(ConnectorTest, MergeSoftData_NoFormatVersionSkipsMerge)
{
set_test_sr_dir("/tmp/connector_merge_no_fmt_ver");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr", R"({"Objects":{"chip1":{"name":"soft"}}})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
mc::variant eeprom_payload(std::string(R"({"Objects":{"chip1":{"addr":1}}})"));
auto merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);
EXPECT_FALSE(merged.has_value());
}
TEST_F(ConnectorTest, MergeSoftData_SoftFileNoObjectsSkipsMerge)
{
set_test_sr_dir("/tmp/connector_merge_no_objects");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr", R"({"FormatVersion":"3.0"})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
mc::variant eeprom_payload(std::string(R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})"));
auto merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);
EXPECT_FALSE(merged.has_value());
}
TEST_F(ConnectorTest, MergeSoftData_InvalidSoftJsonReturnsNullopt)
{
set_test_sr_dir("/tmp/connector_merge_invalid_json");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr", "{ invalid json }");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
mc::variant eeprom_payload(std::string(R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})"));
auto merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);
EXPECT_FALSE(merged.has_value());
}
TEST_F(ConnectorTest, MergeSoftData_EepromNoObjectsSkipsMerge)
{
set_test_sr_dir("/tmp/connector_merge_eeprom_no_obj");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"soft"}}})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
mc::variant eeprom_payload(std::string(R"({"FormatVersion":"3.0"})"));
auto merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);
EXPECT_FALSE(merged.has_value());
}
TEST_F(ConnectorTest, ResolveSrData_EepromSourceMergesSoftDataAndCachesResult)
{
set_test_sr_dir("/tmp/connector_resolve_merge");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"soft","type":"chip"},"chip3":{"addr":3}}})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload =
std::string(R"({"FormatVersion":"3.0","DataVersion":"1.0","Objects":{"chip1":{"addr":1},"chip2":{"addr":2}}})");
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto d = payload->as<mc::dict>();
auto objects = d["Objects"].as<mc::dict>();
EXPECT_EQ(objects["chip1"].as<mc::dict>()["name"].as<std::string>(), "soft");
EXPECT_EQ(objects["chip1"].as<mc::dict>()["addr"].as<int>(), 1);
EXPECT_TRUE(objects.contains("chip2"));
EXPECT_TRUE(objects.contains("chip3"));
EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.10");
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.valid);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
EXPECT_FALSE(m_connector->i_connector.m_sr_cache.soft_source_path.empty());
}
TEST_F(ConnectorTest, ResolveSrData_LocalSourceMergesWhenCsrVersionIsNotMerged)
{
set_test_sr_dir("/tmp/connector_resolve_local_no_merge");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr",
R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"soft"}}})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = std::string(R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})");
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.09";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto objects = payload->as<mc::dict>()["Objects"].as<mc::dict>();
EXPECT_EQ(objects["chip1"].as<mc::dict>()["addr"].as<int>(), 1);
EXPECT_EQ(objects["chip1"].as<mc::dict>()["name"].as<std::string>(), "soft");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
EXPECT_FALSE(m_connector->i_connector.m_sr_cache.local_sr_merged);
EXPECT_FALSE(m_connector->i_connector.m_sr_cache.soft_source_path.empty());
}
TEST_F(ConnectorTest, ResolveSrData_LocalSourceSkipsMergeWhenCsrVersionIsMerged)
{
set_test_sr_dir("/tmp/connector_resolve_local_merged");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr",
R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})");
write_file(test_sr_dir + "/csr_version.json",
R"({"BOM12345_EEPROMUID_AUX789":{"DataVersion":"3.10","Merged":true}})");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"soft"}}})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = std::string(R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})");
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.09";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto objects = payload->as<mc::dict>()["Objects"].as<mc::dict>();
EXPECT_EQ(objects["chip1"].as<mc::dict>()["addr"].as<int>(), 1);
EXPECT_FALSE(objects["chip1"].as<mc::dict>().contains("name"));
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.local_sr_merged);
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.soft_source_path.empty());
}
TEST_F(ConnectorTest, ResolveSrData_MergeFailureStillReturnsEepromData)
{
set_test_sr_dir("/tmp/connector_resolve_merge_fail");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = std::string(R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})");
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.soft_source_path.empty());
}
TEST_F(ConnectorTest, DumpShowsSoftSourcePathAfterMerge)
{
set_test_sr_dir("/tmp/connector_dump_merge");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"soft"}}})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload =
std::string(R"({"FormatVersion":"3.0","DataVersion":"1.0","Objects":{"chip1":{"addr":1}}})");
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto dump_info = m_connector->i_connector.dump();
EXPECT_NE(dump_info.soft_source_path, "NA");
EXPECT_NE(dump_info.soft_source_path.find("_soft.sr"), std::string::npos);
}
TEST_F(ConnectorTest, DumpShowsNASoftSourcePathWithoutMerge)
{
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
m_connector->i_connector.m_sr_cache.valid = true;
m_connector->i_connector.m_sr_cache.source = connector_sr_source::local;
m_connector->i_connector.m_sr_cache.payload =
mc::dict{{"FormatVersion", std::string("1.0")}, {"DataVersion", std::string("2.0")}};
m_connector->i_connector.m_sr_cache.board_id = "BOARD456";
m_connector->i_connector.m_sr_cache.file_path = "/opt/bmc/sr/test.sr";
m_connector->i_connector.m_sr_cache.soft_source_path = "";
m_connector->i_connector.m_sr_cache.local_data_version = "2.0";
auto dump_info = m_connector->i_connector.dump();
EXPECT_EQ(dump_info.soft_source_path, "NA");
}
TEST_F(ConnectorTest, CleanupClearsSoftSourcePath)
{
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_connector->i_connector.m_sr_cache.valid = true;
m_connector->i_connector.m_sr_cache.source = connector_sr_source::eeprom;
m_connector->i_connector.m_sr_cache.payload = mc::dict{{"Name", std::string("test")}};
m_connector->i_connector.m_sr_cache.soft_source_path = "/opt/bmc/sr/BOM_BOARD_soft.sr";
m_connector->i_connector.m_sr_cache.selected_path = "/data/opt/bmc/sr/gold/BOM_BOARD.sr";
m_connector->i_connector.m_sr_cache.flash_data_version = "2.0";
ASSERT_FALSE(m_connector->i_connector.m_sr_cache.soft_source_path.empty());
m_connector->i_connector.cleanup();
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.soft_source_path.empty());
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.selected_path.empty());
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.flash_data_version.empty());
EXPECT_FALSE(m_connector->i_connector.m_sr_cache.valid);
}
namespace {
constexpr const char* k_sr_v10 = R"({"Name":"LOCAL","DataVersion":"1.0"})";
constexpr const char* k_sr_v11 = R"({"Name":"LOCAL","DataVersion":"1.1"})";
constexpr const char* k_sr_v20_gold = R"({"Name":"GOLD","DataVersion":"2.0"})";
constexpr const char* k_sr_v20_temp = R"({"Name":"TEMP","DataVersion":"2.0"})";
constexpr const char* k_sr_v90_temp = R"({"Name":"TEMP","DataVersion":"9.0"})";
}
TEST_F(ConnectorTest, ResolveSrData_GoldSkipsTempWhenMd5Ok)
{
set_test_sr_dir("/tmp/connector_sr_gold_skips_temp");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v10);
write_csr_version("BOM12345_BOARD456_AUX789", "1.0");
write_sr_with_md5(test_gold_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v20_gold);
write_sr_with_md5(test_temp_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v90_temp);
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "GOLD");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::gold);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.selected_path, test_gold_dir + "/BOM12345_BOARD456_AUX789.sr");
}
TEST_F(ConnectorTest, ResolveSrData_GoldMd5FailUsesTemp)
{
set_test_sr_dir("/tmp/connector_sr_gold_md5_fail");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v11);
write_csr_version("BOM12345_BOARD456_AUX789", "1.1");
write_file(test_gold_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v10);
write_file(test_gold_dir + "/BOM12345_BOARD456_AUX789.sr.md5", "ffffffffffffffffffffffffffffffff");
write_sr_with_md5(test_temp_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v20_temp);
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "TEMP");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::temp);
}
TEST_F(ConnectorTest, ResolveSrData_EqualVersionPrefersGoldOverEeprom)
{
set_test_sr_dir("/tmp/connector_sr_gold_tie_eeprom");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", k_sr_v10);
write_csr_version("BOM12345_EEPROMUID_AUX789", "2.0");
write_sr_with_md5(test_gold_dir + "/BOM12345_EEPROMUID_AUX789.sr", k_sr_v20_gold);
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_SAME"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "2.0";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "GOLD");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::gold);
EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 0);
}
TEST_F(ConnectorTest, ResolveSrData_EepromWinsWhenNewerThanGold)
{
set_test_sr_dir("/tmp/connector_sr_eeprom_newer_than_gold");
write_sr_with_md5(test_gold_dir + "/BOM12345_EEPROMUID_AUX789.sr", k_sr_v20_gold);
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", k_sr_v10);
write_csr_version("BOM12345_EEPROMUID_AUX789", "1.0");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_NEWER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "EEPROM_NEWER");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
}
TEST_F(ConnectorTest, ResolveSrData_UidRenameLooksUpGoldUnderNewBasename)
{
set_test_sr_dir("/tmp/connector_sr_gold_uid_rename");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v10);
write_csr_version("BOM12345_BOARD456_AUX789", "1.0");
write_sr_with_md5(test_gold_dir + "/BOM12345_EEPROMUID_AUX789.sr", k_sr_v20_gold);
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_OLDER"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "1.0";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "GOLD");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::gold);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.selected_path, test_gold_dir + "/BOM12345_EEPROMUID_AUX789.sr");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.file_path, test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr");
}
TEST_F(ConnectorTest, ResolveSrData_EepromOnlyWhenGoldTempLocalAbsent)
{
set_test_sr_dir("/tmp/connector_sr_eeprom_only_overlay");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload = R"({"Name":"EEPROM_ONLY"})";
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = load_status::DEFAULT;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "EEPROM_ONLY");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
EXPECT_TRUE(m_connector->i_connector.m_sr_cache.selected_path.empty());
EXPECT_EQ(err, load_status::DEFAULT);
}
TEST_F(ConnectorTest, ResolveSrData_GoldCacheHitAndDumpSourcePath)
{
set_test_sr_dir("/tmp/connector_sr_gold_cache_dump");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v10);
write_csr_version("BOM12345_BOARD456_AUX789", "1.0");
write_sr_with_md5(test_gold_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v20_gold);
auto csr = create_test_csr(1, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
uint8_t err = 0;
auto first = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(first.has_value());
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::gold);
auto second = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(second.has_value());
EXPECT_EQ(second->as<mc::dict>()["Name"].as<std::string>(), "GOLD");
m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
auto dump_info = m_connector->i_connector.dump();
EXPECT_EQ(dump_info.data_source, "GOLD");
EXPECT_EQ(dump_info.source_path, test_gold_dir + "/BOM12345_BOARD456_AUX789.sr");
}
TEST_F(ConnectorTest, ResolveSrData_SoftOverlayFromGoldAndDumpSoftPath)
{
set_test_sr_dir("/tmp/connector_sr_gold_soft");
write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
write_sr_with_md5(test_gold_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"gold_soft"}}})");
auto csr = create_test_csr(1, identify_mode::EEPROM);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_chip();
m_mock_chip->csr2.throw_on_call = true;
m_mock_chip->csr1.payload =
std::string(R"({"FormatVersion":"3.0","DataVersion":"1.0","Objects":{"chip1":{"addr":1}}})");
m_mock_chip->csr1.uid = "EEPROMUID";
m_mock_chip->csr1.data_version = "3.10";
uint8_t err = 0;
auto payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
ASSERT_TRUE(payload.has_value());
auto objects = payload->as<mc::dict>()["Objects"].as<mc::dict>();
EXPECT_EQ(objects["chip1"].as<mc::dict>()["name"].as<std::string>(), "gold_soft");
EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
EXPECT_EQ(m_connector->i_connector.m_sr_cache.soft_source_path,
test_gold_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr");
m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
auto dump_info = m_connector->i_connector.dump();
EXPECT_EQ(dump_info.soft_source_path, test_gold_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr");
}
TEST_F(ConnectorTest, claim_edge_starts_from_baseline_absent)
{
auto& conn = m_connector->i_connector;
EXPECT_EQ(conn.m_prev_presence.load(), 0);
EXPECT_FALSE(conn.claim_edge(0)) << "0 on baseline 0 is not an edge";
EXPECT_TRUE(conn.claim_edge(1)) << "0->1 is a load edge";
EXPECT_EQ(conn.m_prev_presence.load(), 1);
}
TEST_F(ConnectorTest, prev_edge_dedups_startup_double)
{
auto& conn = m_connector->i_connector;
EXPECT_TRUE(conn.claim_edge(1)) << "first 0->1 wins the edge";
EXPECT_FALSE(conn.claim_edge(1)) << "duplicate same-value trigger must be deduped";
EXPECT_FALSE(conn.claim_edge(1)) << "repeated same value stays no-op";
}
TEST_F(ConnectorTest, fast_1_0_1_emits_three_edges_not_coalesced)
{
auto& conn = m_connector->i_connector;
EXPECT_TRUE(conn.claim_edge(1)) << "insert edge (LOAD)";
EXPECT_FALSE(conn.claim_edge(1)) << "redundant same-value write between real edges";
EXPECT_TRUE(conn.claim_edge(0)) << "pull edge (UNLOAD)";
EXPECT_TRUE(conn.claim_edge(1)) << "re-insert edge (LOAD), not coalesced with the first";
EXPECT_EQ(conn.m_prev_presence.load(), 1);
}
TEST_F(ConnectorTest, restart_resets_prev_and_reloads_present)
{
auto& conn = m_connector->i_connector;
EXPECT_TRUE(conn.claim_edge(1));
EXPECT_FALSE(conn.claim_edge(1));
conn.force_release_load_guard();
EXPECT_EQ(conn.m_prev_presence.load(), 0);
EXPECT_TRUE(conn.claim_edge(1)) << "present device re-claims a 0->1 load edge after restart";
}
TEST_F(ConnectorTest, claim_edge_concurrent_same_value_yields_exactly_one_winner)
{
auto& conn = m_connector->i_connector;
constexpr int kThreads = 16;
std::atomic<int> winners{0};
std::atomic<bool> go{false};
std::vector<std::thread> ts;
ts.reserve(kThreads);
for (int i = 0; i < kThreads; ++i) {
ts.emplace_back([&conn, &winners, &go] {
while (!go.load(std::memory_order_relaxed)) {
}
if (conn.claim_edge(1)) {
winners.fetch_add(1);
}
});
}
go.store(true, std::memory_order_release);
for (auto& t : ts) {
t.join();
}
EXPECT_EQ(winners.load(), 1) << "CAS must admit exactly one 0->1 winner under contention";
EXPECT_EQ(conn.m_prev_presence.load(), 1);
}
TEST_F(ConnectorTest, claim_edge_emits_every_real_flip_over_long_sequence)
{
auto& conn = m_connector->i_connector;
for (int k = 0; k < 8; ++k) {
EXPECT_TRUE(conn.claim_edge(1)) << "insert flip #" << k;
EXPECT_FALSE(conn.claim_edge(1)) << "duplicate insert #" << k;
EXPECT_TRUE(conn.claim_edge(0)) << "pull flip #" << k;
EXPECT_FALSE(conn.claim_edge(0)) << "duplicate pull #" << k;
}
EXPECT_EQ(conn.m_prev_presence.load(), 0);
}
TEST_F(ConnectorTest, PresenceSignalAndInitialCheckDedupToSingleLoad)
{
set_test_sr_dir("/tmp/connector_wiring_dedup");
write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"WIRING_DEDUP"})");
write_csr_version("BOM12345_BOARD456_AUX789", "3.10");
auto csr = create_test_csr(0, 0);
auto connector = create_test_connector();
ASSERT_TRUE(m_connector->init(csr, connector));
install_mock_devmon();
EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
ASSERT_TRUE(wait_for_load_status(load_status::SUCCESS));
ASSERT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
EXPECT_EQ(m_connector->i_connector.m_prev_presence.load(), 1);
EXPECT_NO_THROW(m_connector->i_connector.check_initial_presence());
std::this_thread::sleep_for(std::chrono::milliseconds(50));
EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1)
<< "initial check must not start a second load chain for an already-claimed 0->1 edge";
EXPECT_EQ(m_connector->i_connector.m_prev_presence.load(), 1);
}
}
}
}
MC_REFLECT(drivers::connector::test::mock_self_description_record,
(FormatVersion)(DataVersion)(BoardId)((GetSRData, "GetSRData")))
MC_REFLECT(drivers::connector::test::mock_eeprom_data,
(DataVersion)((GetSRData, "GetSRData"))((GetEepromHeader, "GetEepromHeader")))
MC_REFLECT(drivers::connector::test::mock_eeprom_chip,
((csr2, "bmc.dev.Chip.SelfDescriptionRecord"))((csr1, "bmc.kepler.EepromData")))
MC_REFLECT(drivers::connector::test::mock_devmon_interface,
((AddDeviceWithData, "AddDeviceWithData"))((RemoveDevice, "RemoveDevice")))
MC_REFLECT(drivers::connector::test::mock_devmon_object, ((devmon, "bmc.dev")))