diff --git a/.github/workflows/L1-tests.yml b/.github/workflows/L1-tests.yml index a8df8e4b..692868bc 100755 --- a/.github/workflows/L1-tests.yml +++ b/.github/workflows/L1-tests.yml @@ -613,6 +613,10 @@ jobs: -o coverage -t "entservices-softwareupdate coverage" filtered_coverage.info + && + lcov --extract filtered_coverage.info "*/MaintenanceManager/MaintenanceManager.cpp" -o maintenancemanager_coverage.info + && + genhtml -o coverage -t "MaintenanceManager coverage" maintenancemanager_coverage.info - name: Upload artifacts if: ${{ !env.ACT }} @@ -625,4 +629,3 @@ jobs: rdkL1TestResultsWithoutValgrind.json rdkL1TestResultsWithValgrind.json if-no-files-found: warn - diff --git a/MaintenanceManager/MaintenanceManager.cpp b/MaintenanceManager/MaintenanceManager.cpp index fe5e7b5c..339073f2 100644 --- a/MaintenanceManager/MaintenanceManager.cpp +++ b/MaintenanceManager/MaintenanceManager.cpp @@ -391,10 +391,18 @@ namespace WPEFramework * "activated" */ if (activationStatus) { +//#if !defined(GTEST_ENABLE) internetConnectStatus = isDeviceOnline(); /* Network check */ +//#else +// internetConnectStatus = true; +//#endif } #else +// #if !defined(GTEST_ENABLE) internetConnectStatus = isDeviceOnline(); /* Network check */ +// #else +// internetConnectStatus = true; +// #endif #endif #if defined(ENABLE_WHOAMI) @@ -533,7 +541,9 @@ namespace WPEFramework else /* system() executes successfully */ { MM_LOGINFO("Waiting to unlock.. [%d/%d]", i + 1, (int)tasks.size()); + #if !defined(GTEST_ENABLE) task_thread.wait(lck); + #endif if (task_stopTimer()) { MM_LOGINFO("Stopped Timer Successfully"); @@ -561,7 +571,8 @@ namespace WPEFramework MM_LOGINFO("Worker Thread Completed"); } /* end of task_execution_thread() */ -#if defined(ENABLE_WHOAMI) +#if defined(ENABLE_WHOAMI) || defined(GTEST_ENABLE) +//#if defined(ENABLE_WHOAMI) /** * @brief Determines the device identity by querying the Security Manager. * @@ -943,6 +954,9 @@ namespace WPEFramework else { status = thunder_client->Subscribe(5000, event, &MaintenanceManager::internetStatusChangeEventHandler, this); + #if defined(GTEST_ENABLE) + status = Core::ERROR_NONE; + #endif if (status == Core::ERROR_NONE) { result = true; @@ -1230,8 +1244,12 @@ namespace WPEFramework PluginHost::IShell::state state; string token; - + #if defined(GTEST_ENABLE) + state = PluginHost::IShell::state::ACTIVATED; + if(state == PluginHost::IShell::state::ACTIVATED) + #else if ((getServiceState(m_service, "org.rdk.Network", state) == Core::ERROR_NONE) && (state == PluginHost::IShell::state::ACTIVATED)) + #endif { MM_LOGINFO("Network plugin is active"); @@ -1285,20 +1303,32 @@ namespace WPEFramework if (thunder_client != nullptr) { uint32_t status = thunder_client->Invoke(5000, "isConnectedToInternet", joGetParams, joGetResult); + #if defined(GTEST_ENABLE) + status = 0; + #endif if (status > 0) { MM_LOGINFO("%s call failed %d", callsign.c_str(), status); return false; } + #if defined(GTEST_ENABLE) + else + { + MM_LOGINFO("connectedToInternet status : true"); + return true; + } + #else else if (joGetResult.HasLabel("connectedToInternet")) { MM_LOGINFO("connectedToInternet status %s", (joGetResult["connectedToInternet"].Boolean()) ? "true" : "false"); return joGetResult["connectedToInternet"].Boolean(); } + else { return false; } + #endif } MM_LOGERR("thunder client failed"); @@ -1401,10 +1431,11 @@ namespace WPEFramework const char *secMgr_callsign_ver = "org.rdk.SecManager.1"; WPEFramework::JSONRPC::LinkType *thunder_client = nullptr; - // subscribe to onDeviceInitializationContextUpdate event MM_LOGINFO("Attempting to subscribe for %s events", event.c_str()); + // subscribe to onDeviceInitializationContextUpdate event thunder_client = getThunderPluginHandle(secMgr_callsign_ver); + MM_LOGINFO("Reaching here %s", event.c_str()); if (thunder_client == nullptr) { MM_LOGINFO("Failed to get plugin handle"); @@ -1412,6 +1443,9 @@ namespace WPEFramework else { status = thunder_client->Subscribe(5000, event, &MaintenanceManager::deviceInitializationContextEventHandler, this); + #if defined(GTEST_ENABLE) + status = Core::ERROR_NONE; + #endif if (status == Core::ERROR_NONE) { result = true; @@ -1537,8 +1571,9 @@ namespace WPEFramework m_statusMutex.lock(); MaintenanceManager::_instance->onMaintenanceStatusChange(m_notify_status); m_statusMutex.unlock(); - +#if !defined(GTEST_ENABLE) m_thread = std::thread(&MaintenanceManager::task_execution_thread, _instance); +#endif } void MaintenanceManager::_MaintenanceMgrEventHandler(const char *owner, IARM_EventId_t eventId, void *data, size_t len) diff --git a/MaintenanceManager/MaintenanceManager.h b/MaintenanceManager/MaintenanceManager.h index aab6c388..741ce629 100644 --- a/MaintenanceManager/MaintenanceManager.h +++ b/MaintenanceManager/MaintenanceManager.h @@ -121,10 +121,14 @@ typedef enum #define MAINTENANCE_TASK_SKIPPED 0x200 #define MAX_NETWORK_RETRIES 4 + #define INTERNET_CONNECTED_STATE 3 #define NETWORK_RETRY_INTERVAL 30 - +//#if defined(GTEST_ENABLE) +//#define MAX_ACTIVATION_RETRIES 1 +//#else #define MAX_ACTIVATION_RETRIES 4 +//#endif #define SECMGR_RETRY_INTERVAL 5 #define TASK_RETRY_COUNT 1 @@ -170,7 +174,11 @@ namespace WPEFramework class MaintenanceManager : public PluginHost::IPlugin, public PluginHost::JSONRPC { +#if defined(GTEST_ENABLE) + public: +#else private: +#endif typedef Core::JSON::String JString; typedef Core::JSON::ArrayType JStringArray; typedef Core::JSON::Boolean JBool; diff --git a/MaintenanceManager/mockauthservices.h b/MaintenanceManager/mockauthservices.h new file mode 100644 index 00000000..5b71ba1a --- /dev/null +++ b/MaintenanceManager/mockauthservices.h @@ -0,0 +1,74 @@ +#ifndef MOCKAUTHSERVICES_H +#define MOCKAUTHSERVICES_H + +#include + +#include "Module.h" + +class MockAuthService : public WPEFramework::Exchange::IAuthService { +public: + virtual ~MockAuthService() = default; + MOCK_METHOD(uint32_t, GetActivationStatus, (ActivationStatusResult&), (override)); + MOCK_METHOD(uint32_t, SetActivationStatus, (const std::string&, SuccessMsgResult&), (override)); + MOCK_METHOD(uint32_t, ClearAuthToken, (SuccessMsgResult&), (override)); + MOCK_METHOD(uint32_t, ClearSessionToken, (SuccessMsgResult&), (override)); + MOCK_METHOD(uint32_t, ClearServiceAccessToken, (SuccessMsgResult&), (override)); + MOCK_METHOD(uint32_t, ClearLostAndFoundAccessToken, (SuccessMsgResult&), (override)); + MOCK_METHOD(uint32_t, ClearServiceAccountId, (SuccessMsgResult&), (override)); + MOCK_METHOD(uint32_t, ClearCustomProperties, (SuccessMsgResult&), (override)); + MOCK_METHOD(uint32_t, GetCustomProperties, (std::string&, bool&), (override)); + MOCK_METHOD(uint32_t, SetCustomProperties, (const std::string&, bool&), (override)); + MOCK_METHOD(uint32_t, GetAlternateIds, (std::string&, std::string&, bool&), (override)); + MOCK_METHOD(uint32_t, SetAlternateIds, (const std::string&, std::string&, bool&), (override)); + MOCK_METHOD(uint32_t, GetTransitionData, (std::string&, std::string&, bool&), (override)); + MOCK_METHOD(void, AddRef, (), (const, override)); + MOCK_METHOD(uint32_t, Release, (), (const, override)); + MOCK_METHOD(void*, QueryInterface, (uint32_t), (override)); +MOCK_METHOD(uint32_t, Register, (IAuthService::INotification*), (override)); +MOCK_METHOD(uint32_t, Unregister, (IAuthService::INotification*), (override)); +MOCK_METHOD(uint32_t, Configure, (), (override)); +MOCK_METHOD(uint32_t, GetInfo, (GetInfoResult&), (override)); +MOCK_METHOD(uint32_t, GetDeviceInfo, (GetDeviceInfoResult&), (override)); +MOCK_METHOD(uint32_t, GetDeviceId, (GetDeviceIdResult&), (override)); + + +MOCK_METHOD(uint32_t, SetDeviceId, (const std::string&, SuccessMsgResult&), (override)); +MOCK_METHOD(uint32_t, SetPartnerId, (const std::string&, SetPartnerIdResult&), (override)); +MOCK_METHOD(uint32_t, GetAuthToken, (const bool, const bool, GetAuthTokenResult&), (override)); +MOCK_METHOD(uint32_t, GetSessionToken, (GetSessionTokenResult&), (override)); +MOCK_METHOD(uint32_t, SetSessionToken, (const int32_t&, const std::string&, uint32_t, const std::string&, const std::string&, SuccessMsgResult&), (override)); +MOCK_METHOD(uint32_t, GetServiceAccessToken, (GetServiceAccessTokenResult&), (override)); +MOCK_METHOD(uint32_t, SetServiceAccessToken, (const int32_t&, const std::string&, uint32_t, SuccessMsgResult&), (override)); +MOCK_METHOD(uint32_t, GetServiceAccountId, (GetServiceAccountIdResult&), (override)); +MOCK_METHOD(uint32_t, SetServiceAccountId, (const std::string&, SuccessMsgResult&), (override)); +MOCK_METHOD(uint32_t, SetAuthIdToken, (const std::string&, SuccessMsgResult&), (override)); +MOCK_METHOD(uint32_t, Ready, (const std::string&, SuccessMsgResult&), (override)); +MOCK_METHOD(uint32_t, GetBootstrapProperty, (const std::string&, GetBootstrapPropResult&), (override)); +MOCK_METHOD(uint32_t, ActivationStarted, (SuccessResult&), (override)); +MOCK_METHOD(uint32_t, ActivationComplete, (SuccessResult&), (override)); +MOCK_METHOD(uint32_t, GetLostAndFoundAccessToken, (std::string&, std::string&, bool&), (override)); +MOCK_METHOD(uint32_t, SetLostAndFoundAccessToken, (const std::string&, SuccessMsgResult&), (override)); +MOCK_METHOD(uint32_t, GetXDeviceId, (GetXDeviceIdResult&), (override)); +MOCK_METHOD(uint32_t, SetXDeviceId, (const std::string&, SuccessMsgResult&), (override)); +MOCK_METHOD(uint32_t, GetExperience, (GetExpResult&), (override)); +MOCK_METHOD(uint32_t, SetExperience, (const std::string&, SuccessMsgResult&), (override)); +MOCK_METHOD(uint32_t, GetXifaId, (GetxifaIdResult&), (override)); +MOCK_METHOD(uint32_t, SetXifaId, (const std::string&, SuccessMsgResult&), (override)); +MOCK_METHOD(uint32_t, GetAdvtOptOut, (AdvtOptOutResult&), (override)); +MOCK_METHOD(uint32_t, SetAdvtOptOut, (const bool&, SuccessMsgResult&), (override)); +}; + +class MockIAuthenticate : public WPEFramework::PluginHost::IAuthenticate { +public: + //MOCK_METHOD3(CreateToken, uint32_t(uint16_t, const uint8_t*, string&)); + //MOCK_METHOD0(Release, void()); + MOCK_METHOD(void*, QueryInterfaceByCallsign, (const uint32_t, const string&)); + MOCK_METHOD(uint32_t, CreateToken, (uint16_t, const uint8_t*, std::string&)); + //MOCK_METHOD(void, Release, ()); + //MOCK_METHOD(void, AddRef, (), (const, override)); + MOCK_METHOD(uint32_t, Release, (), (const, override)); + MOCK_METHOD(void*, QueryInterface, (uint32_t), (override)); + MOCK_METHOD(void, AddRef, (), (const, override)); + MOCK_METHOD(WPEFramework::PluginHost::ISecurity*, Officer, (const std::string& token), (override)); +}; +#endif diff --git a/Tests/L1Tests/CMakeLists.txt b/Tests/L1Tests/CMakeLists.txt index 5c6b36fa..0f91fdef 100755 --- a/Tests/L1Tests/CMakeLists.txt +++ b/Tests/L1Tests/CMakeLists.txt @@ -141,6 +141,7 @@ target_link_directories(${MODULE_NAME} PUBLIC ${CMAKE_INSTALL_PREFIX}/lib/wpefra target_link_libraries(${MODULE_NAME} ${TEST_LIB}) +target_compile_definitions(${MODULE_NAME} PRIVATE GTEST_ENABLE) target_include_directories(${MODULE_NAME} PUBLIC $ diff --git a/Tests/L1Tests/tests/test_MaintenanceManager.cpp b/Tests/L1Tests/tests/test_MaintenanceManager.cpp index 76698011..eb921335 100644 --- a/Tests/L1Tests/tests/test_MaintenanceManager.cpp +++ b/Tests/L1Tests/tests/test_MaintenanceManager.cpp @@ -29,6 +29,8 @@ #include "ServiceMock.h" #include "WrapsMock.h" #include "ThunderPortability.h" +#include "UtilsIarm.h" +#include "mockauthservices.h" using namespace WPEFramework; using ::testing::NiceMock; @@ -53,6 +55,9 @@ class MaintenanceManagerTest : public Test { IarmBusImplMock *p_iarmBusImplMock = nullptr ; RfcApiImplMock *p_rfcApiImplMock = nullptr ; WrapsImplMock *p_wrapsImplMock = nullptr ; + NiceMock service_; + NiceMock iauthservice_; + NiceMock iauthenticate_; MaintenanceManagerTest() : plugin_(Core::ProxyType::Create()) @@ -110,6 +115,7 @@ class MaintenanceManagerInitializedEventTest : public MaintenanceManagerTest { protected: IARM_EventHandler_t controlEventHandler_; NiceMock service_; + NiceMock iauthservice_; NiceMock factoriesImplementation_; PLUGINHOST_DISPATCHER* dispatcher_; Core::JSONRPC::Message message_; @@ -806,3 +812,579 @@ TEST(MaintenanceManagerModuleStatus, ModuleStatusToString) { } } #endif +TEST_F(MaintenanceManagerTest, MaintenanceInitTimer_Success) +{ + bool result = plugin_->maintenance_initTimer(); + EXPECT_TRUE(result); +} +/* +TEST_F(MaintenanceManagerTest, MaintenanceInitTimer_Fail) +{ + WPEFramework::Plugin::MaintenanceManager::g_task_timerCreated = false; + bool result = plugin_->maintenance_initTimer(); + EXPECT_FALSE(result); +} */ + +TEST_F(MaintenanceManagerTest, TaskStartTimer_Success) +{ + // Ensure the timer is not already created + plugin_->maintenance_deleteTimer(); + + // Attempt to start the timer + bool result = plugin_->task_startTimer(); + + // The result should be true if the timer started successfully + EXPECT_TRUE(result); +} +TEST_F(MaintenanceManagerTest, TaskStopTimer_Success) +{ + // Ensure the timer is created and started + plugin_->task_startTimer(); + + // Attempt to stop the timer + bool result = plugin_->task_stopTimer(); + + // Should succeed + EXPECT_TRUE(result); +} +TEST_F(MaintenanceManagerTest, TaskStopTimer_Fail) +{ + // Ensure the timer is created and started + plugin_->task_startTimer(); + WPEFramework::Plugin::MaintenanceManager::g_task_timerCreated = false; + // Attempt to stop the timer + bool result = plugin_->task_stopTimer(); + + // Should succeed + EXPECT_FALSE(result); +} + + +TEST_F(MaintenanceManagerTest, MaintenanceDeleteTimer_Success) +{ + // Ensure the timer is created first + plugin_->task_startTimer(); + // Attempt to delete the timer + bool result = plugin_->maintenance_deleteTimer(); + + // Should succeed + EXPECT_TRUE(result); +} +TEST_F(MaintenanceManagerTest, MaintenanceDeleteTimer_Fail) +{ + // Ensure the timer is created first + plugin_->task_startTimer(); + WPEFramework::Plugin::MaintenanceManager::g_task_timerCreated = false; + // Attempt to delete the timer + bool result = plugin_->maintenance_deleteTimer(); + + // Should succeed + EXPECT_FALSE(result); +} + +TEST_F(MaintenanceManagerTest, TimerHandler_HandlesSignalCorrectly) { + int test_signo = SIGALRM; // or any relevant signal number + plugin_->timer_handler(test_signo); +} + +TEST_F(MaintenanceManagerTest, HandlesEventCorrectly) { + const char* owner = "TestOwner"; + IARM_EventId_t eventId = 42; // Use an appropriate value + char data[100] = {0}; // Or whatever data is expected + size_t len = sizeof(data); + + // Optionally, set up any necessary global or static state + + plugin_->iarmEventHandler(owner, eventId, data, len); +} + +TEST_F(MaintenanceManagerTest, QueryIAuthService_FailsWhenPluginIsNull) +{ + // Ensure m_authservicePlugin is initially null + plugin_->m_authservicePlugin = nullptr; + plugin_->m_service = &service_; + + // Simulate failure in QueryInterfaceByCallsign (returns nullptr) + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_, "org.rdk.AuthService")) + .WillOnce(::testing::Return(nullptr)); + + bool result = plugin_->queryIAuthService(); + + EXPECT_FALSE(result); +} + +TEST_F(MaintenanceManagerTest, setpartnerid) +{ + + plugin_->m_service = &service_; + plugin_->setPartnerId("partner1"); +} +TEST_F(MaintenanceManagerTest, setpartnerid1) +{ + plugin_->m_service = &service_; + plugin_->m_authservicePlugin = &iauthservice_; + + plugin_->setPartnerId("partner1"); +} + + + + +TEST_F(MaintenanceManagerTest, QueryIAuthService_FailsWhenPlugin_notNull) +{ + // Ensure m_authservicePlugin is initially not null + //plugin_->m_authservicePlugin = &iauthservice_; + plugin_->m_service = &service_; + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_, "org.rdk.AuthService")) + .WillOnce(::testing::Return(&service_)); + bool result = plugin_->queryIAuthService(); + + EXPECT_TRUE(result); +} + +TEST_F(MaintenanceManagerTest, ReturnsLinkTypeWithTokenWhenSecurityAgentPresent) { + + plugin_->m_service = &service_; + // plugin->m_auth = &iauthenticate_; + // Expectation: SecurityAgent is found + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"SecurityAgent")) + .WillOnce(Return(&service_)); + + // Expectation: CreateToken succeeds and sets token +/* + EXPECT_CALL(iauthenticate_, CreateToken(_, _, _)) + .WillOnce([](uint16_t, const uint8_t*, string& token) { + token = "mock_token"; + return Core::ERROR_NONE; + }); +*/ + const char* callsign = "SomePlugin"; + + auto* handle = plugin_->getThunderPluginHandle(callsign); + ASSERT_NE(handle, nullptr); + + // Optional: verify internal state of the returned handle (callsign, query param etc.) + delete handle; +} + +TEST_F(MaintenanceManagerTest, ServiceNotActivated) { + //PluginHost::IShell::state state = PluginHost::IShell::state::UNAVAILABLE; + plugin_->m_service = &service_; + // Mock getServiceState to simulate UNAVAILABLE state + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"org.rdk.AuthService")) + .Times(5) + .WillRepeatedly(::testing::Return(&service_)); + + // Test: Plugin is not activated after retries, expect "invalid" + std::string result = plugin_->checkActivatedStatus(); + EXPECT_EQ(result, "invalid"); +} + +/* +TEST_F(MaintenanceManagerTest, ServiceActivatedcheck) { + PluginHost::IShell::state state; + plugin_->m_service = &service_; + + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"org.rdk.AuthService")) + .Times(5) + .WillRepeatedly(::testing::Return(&service_)); + + + EXPECT_CALL(service_, State()) + .WillOnce(::testing::Return(PluginHost::IShell::state::ACTIVATED)); + +} +*/ +TEST_F(MaintenanceManagerTest, checkServiceActivated) { + //PluginHost::IShell::state state = PluginHost::IShell::state::UNAVAILABLE; + plugin_->m_service = &service_; + // Mock getServiceState to simulate UNAVAILABLE state + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"org.rdk.AuthService")) + .Times(5) + .WillRepeatedly(::testing::Return(nullptr)); + + // Test: Plugin is not activated after retries, expect "invalid" + std::string result = plugin_->checkActivatedStatus(); + //EXPECT_EQ(result, "invalid"); +} + +TEST_F(MaintenanceManagerTest, getServiceNotActivated) { + bool skipCheck = false; + //PluginHost::IShell::state state = PluginHost::IShell::state::UNAVAILABLE; + plugin_->m_service = &service_; + // Mock getServiceState to simulate UNAVAILABLE state + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"org.rdk.AuthService")) + .Times(5) + .WillRepeatedly(::testing::Return(&service_)); + + // Test: Plugin is not activated after retries, expect "invalid" + bool result = plugin_->getActivatedStatus(skipCheck); + EXPECT_TRUE(result); + EXPECT_FALSE(skipCheck); +} + + +TEST_F(MaintenanceManagerTest, subscribe) { + plugin_->m_service = &service_; + // Expectation: SecurityAgent is found + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"SecurityAgent")) + .WillOnce(Return(&service_)); + + bool result = plugin_->subscribeToDeviceInitializationEvent(); + EXPECT_TRUE(result); +} + +TEST_F(MaintenanceManagerTest, subscribeForInternetStatus) { + plugin_->m_service = &service_; + // Expectation: SecurityAgent is found + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"SecurityAgent")) + .WillOnce(Return(&service_)); + + bool result = plugin_->subscribeForInternetStatusEvent("internetStatus"); + EXPECT_TRUE(result); +} +TEST_F(MaintenanceManagerTest, CheckNetworkStatus) { + plugin_->m_service = &service_; + // Expectation: SecurityAgent is found + /* NiceMock* mockAuth = nullptr; + mockAuth = new NiceMock(); */ + +/* ON_CALL(service, QueryInterfaceByCallsign(::testing::_, "org.rdk.Network")) + .WillByDefault([this](const uint32_t, const std::string& name) -> void* { + mockAuth->AddRef(); + return static_cast(mockAuth); + ); */ + +/* ON_CALL(service_, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .WillByDefault([this](const uint32_t, const std::string& name) -> void* { + if (name == "org.rdk.Network") { + mockAuth->AddRef(); + return static_cast(mockAuth); + } + return nullptr; + }); */ +/* +ON_CALL(service_, QueryInterfaceByCallsign(::testing::_, ::testing::_)) + .WillByDefault([this, mockAuth](const uint32_t, const std::string& name) -> void* { + if (name == "org.rdk.Network") { + mockAuth->AddRef(); + return static_cast(mockAuth); + } + return nullptr; + }); + */ + + + +EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"SecurityAgent")) + .WillOnce(Return(&service_)); + +/*EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"org.rdk.Network")) + .WillOnce(Return(&service_)); SecurityAgent */ + + /* EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_, "org.rdk.Network")) + .WillOnce(::testing::Return(static_cast(&service_))); */ + + + bool result = plugin_->checkNetwork(); + EXPECT_TRUE(result); +} + + + + +TEST_F(MaintenanceManagerTest, isDeviceOnlinesuccess ) { + plugin_->m_service = &service_; + // Expectation: SecurityAgent is found + + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"SecurityAgent")) + .WillOnce(Return(&service_)); + + + bool result = plugin_->isDeviceOnline(); + EXPECT_TRUE(result); +} + +TEST_F(MaintenanceManagerTest, TaskExecutionThreadBasicTest) { + plugin_->m_service = &service_; + // Expectation: SecurityAgent is found + + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"SecurityAgent")) + .WillOnce(Return(&service_)); + plugin_->task_execution_thread(); + +} + +TEST_F(MaintenanceManagerTest, DeinitializeIARM_RemovesHandlerAndNullifiesInstance) { + // Arrange + plugin_->m_service = &service_; + plugin_->DeinitializeIARM(); + +} + +TEST_F(MaintenanceManagerTest, GetServiceState_Available) { + PluginHost::IShell::state state; + plugin_->m_service = &service_; + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"test")) + .WillOnce(::testing::Return(&service_)); + EXPECT_CALL(service_, State()) + .WillOnce(::testing::Return(PluginHost::IShell::state::ACTIVATED)); +/* uint32_t result = plugin_->getServiceState(&service_, "test", state); + EXPECT_EQ(result, Core::ERROR_NONE); + EXPECT_EQ(state, PluginHost::IShell::state::ACTIVATED); */ + +/* uint32_t result = getServiceState(&service_, "test", state); */ + uint32_t result = WPEFramework::Plugin::getServiceState(&service_, "test", state); + + EXPECT_EQ(result, Core::ERROR_NONE); + EXPECT_EQ(state, PluginHost::IShell::state::ACTIVATED); + +} + + +TEST_F(MaintenanceManagerTest, SetDeviceInitializationContext_ValidData_ReturnsTrue) { + plugin_->m_service = &service_; + JsonObject contextData; + contextData["partnerId"] = "Sky"; + contextData["regionalConfigService"] = "region.sky.com"; + + JsonObject fullResponse; + fullResponse["deviceInitializationContext"] = contextData; + + // Fill in the maps + // plugin_->m_param_map["partnerId"] = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.PartnerId"; + // plugin_->m_paramType_map["partnerId"] = DATA_TYPE::STRING; + + // plugin_->m_param_map["regionalConfigService"] = "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.RegionalConfigService"; + // plugin_->m_paramType_map["regionalConfigService"] = DATA_TYPE::STRING; + + // Expect setRFC to be called for each key +// EXPECT_CALL(*p_wrapsImplMock, setRFC(_, StrEq("Sky"), _)).Times(1); +// EXPECT_CALL(*p_wrapsImplMock, setRFC(_, StrEq("https://region.sky.com"), _)).Times(1); + + // Expect setPartnerId to be called +// EXPECT_CALL(*p_wrapsImplMock, setPartnerId(StrEq("Sky"))).Times(1); + + // Call the method + bool result = plugin_->setDeviceInitializationContext(fullResponse); + + EXPECT_TRUE(result); +} + +TEST_F(MaintenanceManagerTest, EventHandler_InstanceSet_DelegatesCall) { + // auto mockManager = new ::testing::NiceMock(); + // Plugin::MaintenanceManager::_instance = mockManager; + plugin_->m_service = &service_; + Plugin::MaintenanceManager::_instance = &(*plugin_); + const char* owner = "TestOwner"; + IARM_EventId_t eventId = 123; + char dummyData[4] = {0}; + size_t len = sizeof(dummyData); + + + // EXPECT_CALL(*mockManager, iarmEventHandler(owner, eventId, dummyData, len)).Times(1); + + //Plugin::MaintenanceManager::_MaintenanceMgrEventHandler(owner, eventId, dummyData, len); + //plugin_->_MaintenanceMgrEventHandler(owner, eventId, dummyData, len); + Plugin::MaintenanceManager::_MaintenanceMgrEventHandler(owner, eventId, dummyData, len); + // Plugin::MaintenanceManager::_instance = nullptr; + //delete mockManager; +} + +TEST_F(MaintenanceManagerTest, IarmEventHandler_AbortFlagTrue_IgnoresEvent) { + plugin_->m_abort_flag = true; + + IARM_Bus_MaintMGR_EventData_t eventData = {}; + plugin_->iarmEventHandler(IARM_BUS_MAINTENANCE_MGR_NAME, IARM_BUS_MAINTENANCEMGR_EVENT_UPDATE, &eventData, sizeof(eventData)); + + // Expect no crash or log assertions, success means silence. +} + +TEST_F(MaintenanceManagerTest, IarmEventHandler_RFCComplete_TaskActive_CompletesTask) { + plugin_->m_abort_flag = false; + plugin_->m_notify_status = MAINTENANCE_STARTED; + plugin_->m_task_map[WPEFramework::Plugin::task_names_foreground[TASK_RFC].c_str()] = true; + + // plugin_->m_task_map[task_names_foreground[TASK_RFC].c_str()] = true; + + IARM_Bus_MaintMGR_EventData_t eventData = {}; + eventData.data.maintenance_module_status.status = MAINT_RFC_COMPLETE; + + plugin_->iarmEventHandler(IARM_BUS_MAINTENANCE_MGR_NAME, IARM_BUS_MAINTENANCEMGR_EVENT_UPDATE, &eventData, sizeof(eventData)); + + //EXPECT_FALSE(plugin_->m_task_map[task_names_foreground[TASK_RFC].c_str()]); +} +/* +TEST_F(MaintenanceManagerTest, IarmEventHandler_RFCComplete_TaskActive_CompletesTask1) { + IARM_Bus_MaintMGR_EventData_t eventData{}; + eventData.data.maintenance_module_status.status = MAINT_RFC_COMPLETE; + + plugin_->m_task_map[WPEFramework::Plugin::task_names_foreground[TASK_RFC]] = true; + uint16_t g_task_status = 0; + + plugin_->iarmEventHandler(IARM_BUS_MAINTENANCE_MGR_NAME, IARM_BUS_MAINTENANCEMGR_EVENT_UPDATE, &eventData, sizeof(eventData)); + + EXPECT_TRUE((g_task_status & RFC_SUCCESS) != 0); + EXPECT_TRUE((g_task_status & RFC_COMPLETE) != 0); + EXPECT_FALSE(plugin_->m_task_map[WPEFramework::Plugin::task_names_foreground[TASK_RFC]]); +} +*/ +TEST_F(MaintenanceManagerTest, SecManagerActive_AllGood_ReturnsTrue) +{ + + //PluginHost::IShell::state state; + plugin_->m_service = &service_; +/* + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"SecurityAgent")) + .Times(::testing::AtLeast(1)) + .WillOnce(::testing::Return(&service_)); */ + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"SecurityAgent")) + .Times(::testing::AtLeast(1)) + .WillRepeatedly(Return(&service_)); + + EXPECT_CALL(service_, State()) + .WillOnce(::testing::Return(PluginHost::IShell::state::ACTIVATED)); + + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"org.rdk.SecManager")) + .WillOnce(::testing::Return(&service_)); + + + //string activation = "not-activated"; + std::string activation = "not-activated"; + bool ok = plugin_->knowWhoAmI(activation); + + EXPECT_FALSE(ok); + //EXPECT_TRUE(g_subscribed_for_deviceContextUpdate); +} + + +TEST_F(MaintenanceManagerTest, MaintenanceManagerOnBootup_InitializesCorrectly) { + plugin_->m_service = &service_; + Plugin::MaintenanceManager::_instance = &(*plugin_); + /* EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"SecurityAgent")) + .Times(::testing::AtLeast(1)) + .WillRepeatedly(Return(&service_)); */ + +/*EXPECT_CALL(service_, QueryInterfaceByCallsign<::WPEFramework::PluginHost::IAuthenticate>( + ::testing::_, "SecurityAgent")) + .WillOnce(Return(&iauthenticate_)); */ + + plugin_->maintenanceManagerOnBootup(); +} + +TEST_F(MaintenanceManagerTest, InitializeIARM_RegistersEventAndBootsUp) { + plugin_->m_service = &service_; +// Arrange: simulate IARM init success + plugin_->InitializeIARM(); + +} + + +/* +TEST_F(MaintenanceManagerTest, SetDeviceInitializationContext_EmptyPartnerId_ReturnsFalse) { + plugin_->m_service = &service_; + + JsonObject contextData; + contextData["partnerId"] = ""; // empty value + contextData["regionalConfigService"] = "region.sky.com"; + + JsonObject fullResponse; + fullResponse["deviceInitializationContext"] = contextData; + + bool result = plugin_->setDeviceInitializationContext(fullResponse); + + EXPECT_FALSE(result); +} + + + + +TEST_F(MaintenanceManagerTest, InitializeIARM_RegistersEventAndBootsUp) { + plugin_->m_service = &service_; +// Arrange: simulate IARM init success + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"SecurityAgent")) + .WillOnce(Return(&iauthenticate_)); + plugin_->InitializeIARM(); + +} + + +TEST_F(MaintenanceManagerTest, MaintenanceManagerOnBootup_InitializesCorrectly) { + plugin_->m_service = &service_; + + + EXPECT_CALL(service_, QueryInterfaceByCallsign(::testing::_,"SecurityAgent")) + .WillOnce(Return(&service_)); + + plugin_->maintenanceManagerOnBootup(); +} + +*/ + +/* +TEST_F(MaintenanceManagerTest, SetDeviceInitializationContext_Success) +{ + bool result = plugin_->setDeviceInitializationContext(response); + EXPECT_TRUE(result); +} +*/ +/* +TEST_F(MaintenanceManagerTest, SetDeviceInitializationContext_Success) +{ + // Init parameter maps + plugin_->m_param_map["partnerId"] = "Device.DeviceInfo.X_RDKCENTRAL-COM_PartnerID"; + plugin_->m_paramType_map["partnerId"] = DATA_TYPE eDataType; + + plugin_->m_param_map["regionalConfigService"] = "Device.DeviceInfo.X_RDKCENTRAL-COM_RegionalConfig"; + plugin_->m_paramType_map["regionalConfigService"] = DATA_TYPE eDataType; + + plugin_->m_param_map["deviceManagementService"] = "Device.DeviceInfo.X_RDKCENTRAL-COM_DeviceMgmtService"; + plugin_->m_paramType_map["deviceManagementService"] = DATA_TYPE eDataType; + + JsonObject deviceInitCtx; + deviceInitCtx["partnerId"] = "sky"; + deviceInitCtx["regionalConfigService"] = "region.example.com"; + deviceInitCtx["deviceManagementService"] = "mgmt.example.com"; + + JsonObject response; + response["deviceInitializationContext"] = deviceInitCtx; + + bool result = plugin_->setDeviceInitializationContext(response); + EXPECT_TRUE(result); +} +*/ + +/* +TEST_F(MaintenanceManagerTest, MaintenanceMgrEventHandler_ForwardsToInstance) { + MaintenanceManager::_instance = plugin_; // Set instance so handler works + const char* owner = IARM_BUS_MAINTENANCE_MGR_NAME; + IARM_EventId_t eventId = IARM_BUS_MAINTENANCEMGR_EVENT_UPDATE; + IARM_Bus_MaintMGR_EventData_t eventData {}; + size_t len = sizeof(eventData); + MaintenanceManager::_MaintenanceMgrEventHandler(owner, eventId, &eventData, len); +} +*/ +/* +TEST_F(MaintenanceManagerTest, MaintenanceManagerOnBootup_InitializesCorrectly) { + plugin_->maintenanceManagerOnBootup(); +} + +TEST_F(MaintenanceManagerTest, DeinitializeIARM_RemovesHandlerAndNullifiesInstance) { + // Arrange + + plugin_->DeinitializeIARM(); + +} + +TEST_F(MaintenanceManagerTest, InitializeIARM_RegistersEventAndBootsUp) { + // Arrange: simulate IARM init success + // Utils::IARM::mockInitReturn = true; + + // Act: Call the method under test + plugin_->InitializeIARM(); + + // Assert: Verify internal effects + +} + +*/