[ICD]Add unit tests for the ICD Manager operational states (#28729)

* Add unit tests for the ICD Manager

* Address comment, try to fix test for ESP and IOT SDK

* Use GetIOContext().DriveIO() to run event loop. Set the systemLayer for test to be the IOContext one

* Clean up

* Restyled by whitespace

---------

Co-authored-by: Restyled.io <[email protected]>

src/app/icd/ICDManager.cpp

@@ -75,9 +75,12 @@ void ICDManager::Shutdown()
 
 bool ICDManager::SupportsCheckInProtocol()
 {
-    bool success;
-    uint32_t featureMap;
+    bool success        = false;
+    uint32_t featureMap = 0;
+    // Can't use attribute accessors/Attributes::FeatureMap::Get in unit tests
+#ifndef CONFIG_BUILD_FOR_HOST_UNIT_TEST
     success = (Attributes::FeatureMap::Get(kRootEndpointId, &featureMap) == EMBER_ZCL_STATUS_SUCCESS);
+#endif
     return success ? ((featureMap & to_underlying(Feature::kCheckInProtocolSupport)) != 0) : false;
 }
 

src/app/icd/ICDManager.h

@@ -26,6 +26,10 @@
 namespace chip {
 namespace app {
 
+// Forward declaration of TestICDManager to allow it to be friend with ICDManager
+// Used in unit tests
+class TestICDManager;
+
 /**
  * @brief ICD Manager is responsible of processing the events and triggering the correct action for an ICD
  */
@@ -67,6 +71,8 @@ class ICDManager
     static System::Clock::Milliseconds32 GetFastPollingInterval() { return kFastPollingInterval; }
 
 protected:
+    friend class TestICDManager;
+
     static void OnIdleModeDone(System::Layer * aLayer, void * appState);
     static void OnActiveModeDone(System::Layer * aLayer, void * appState);
 

src/app/tests/TestICDManager.cpp

@@ -15,17 +15,199 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
+#include <app/EventManagement.h>
+#include <app/tests/AppTestContext.h>
+#include <lib/support/TestPersistentStorageDelegate.h>
+#include <lib/support/UnitTestContext.h>
 #include <lib/support/UnitTestRegistration.h>
 #include <nlunit-test.h>
+#include <system/SystemLayerImpl.h>
 
-int TestICDManager()
+#include <app/icd/ICDManager.h>
+#include <app/icd/ICDStateObserver.h>
+#include <app/icd/IcdManagementServer.h>
+
+using namespace chip;
+using namespace chip::app;
+using namespace chip::System;
+
+namespace {
+
+class TestICDStateObserver : public app::ICDStateObserver
+{
+public:
+    void OnEnterActiveMode() {}
+};
+
+TestICDStateObserver mICDStateObserver;
+static Clock::Internal::MockClock gMockClock;
+static Clock::ClockBase * gRealClock;
+
+class TestContext : public Test::AppContext
+{
+public:
+    static int Initialize(void * context)
+    {
+        if (AppContext::Initialize(context) != SUCCESS)
+            return FAILURE;
+
+        auto * ctx = static_cast<TestContext *>(context);
+        DeviceLayer::SetSystemLayerForTesting(&ctx->GetSystemLayer());
+
+        gRealClock = &SystemClock();
+        Clock::Internal::SetSystemClockForTesting(&gMockClock);
+
+        if (ctx->mEventCounter.Init(0) != CHIP_NO_ERROR)
+        {
+            return FAILURE;
+        }
+
+        ctx->mICDManager.Init(&ctx->testStorage, &ctx->GetFabricTable(), &mICDStateObserver);
+        return SUCCESS;
+    }
+
+    static int Finalize(void * context)
+    {
+        auto * ctx = static_cast<TestContext *>(context);
+        ctx->mICDManager.Shutdown();
+        app::EventManagement::DestroyEventManagement();
+        System::Clock::Internal::SetSystemClockForTesting(gRealClock);
+        DeviceLayer::SetSystemLayerForTesting(nullptr);
+
+        if (AppContext::Finalize(context) != SUCCESS)
+            return FAILURE;
+
+        return SUCCESS;
+    }
+
+    app::ICDManager mICDManager;
+
+private:
+    TestPersistentStorageDelegate testStorage;
+    MonotonicallyIncreasingCounter<EventNumber> mEventCounter;
+};
+
+} // namespace
+
+namespace chip {
+namespace app {
+class TestICDManager
 {
-    static nlTest sTests[] = { NL_TEST_SENTINEL() };
+public:
+    /*
+     * Advance the test Mock clock time by the amout passed in argument
+     * and then force the SystemLayer Timer event loop. It will check for any expired timer,
+     * and invoke their callbacks if there are any.
+     *
+     * @param time_ms: Value in milliseconds.
+     */
+    static void AdvanceClockAndRunEventLoop(TestContext * ctx, uint32_t time_ms)
+    {
+        gMockClock.AdvanceMonotonic(System::Clock::Timeout(time_ms));
+        ctx->GetIOContext().DriveIO();
+    }
 
-    nlTestSuite cmSuite = { "TestICDManager", &sTests[0], nullptr, nullptr };
+    static void TestICDModeIntervals(nlTestSuite * aSuite, void * aContext)
+    {
+        TestContext * ctx = static_cast<TestContext *>(aContext);
 
-    nlTestRunner(&cmSuite, nullptr);
-    return (nlTestRunnerStats(&cmSuite));
+        // After the init we should be in active mode
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
+        AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeInterval() + 1);
+        // Active mode interval expired, ICDManager transitioned to the IdleMode.
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::IdleMode);
+        AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetIdleModeInterval() + 1);
+        // Idle mode interval expired, ICDManager transitioned to the ActiveMode.
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
+
+        // Events updating the Operation to Active mode can extend the current active mode time by 1 Active mode threshold.
+        // Kick an active Threshold just before the end of the Active interval and validate that the active mode is extended.
+        AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeInterval() - 1);
+        ctx->mICDManager.UpdateOperationState(ICDManager::OperationalState::ActiveMode);
+        AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeThreshold() / 2);
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
+        AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeThreshold());
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::IdleMode);
+    }
+
+    static void TestKeepActivemodeRequests(nlTestSuite * aSuite, void * aContext)
+    {
+        TestContext * ctx = static_cast<TestContext *>(aContext);
+
+        // Setting a requirement will transition the ICD to active mode.
+        ctx->mICDManager.SetKeepActiveModeRequirements(ICDManager::KeepActiveFlags::kCommissioningWindowOpen, true);
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
+        // Advance time so active mode interval expires.
+        AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeInterval() + 1);
+        // Requirement flag still set. We stay in active mode
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
+
+        // Remove requirement. we should directly transition to idle mode.
+        ctx->mICDManager.SetKeepActiveModeRequirements(ICDManager::KeepActiveFlags::kCommissioningWindowOpen, false);
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::IdleMode);
+
+        ctx->mICDManager.SetKeepActiveModeRequirements(ICDManager::KeepActiveFlags::kFailSafeArmed, true);
+        // Requirement will transition us to active mode.
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
+
+        // Advance time, but by less than the active mode interval and remove the requirement.
+        // We should stay in active mode.
+        AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeInterval() / 2);
+        ctx->mICDManager.SetKeepActiveModeRequirements(ICDManager::KeepActiveFlags::kFailSafeArmed, false);
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
+
+        // Advance time again, The activemode interval is completed.
+        AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeInterval() + 1);
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::IdleMode);
+
+        // Set two requirements
+        ctx->mICDManager.SetKeepActiveModeRequirements(ICDManager::KeepActiveFlags::kExpectingMsgResponse, true);
+        ctx->mICDManager.SetKeepActiveModeRequirements(ICDManager::KeepActiveFlags::kAwaitingMsgAck, true);
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
+        // advance time so the active mode interval expires.
+        AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeInterval() + 1);
+        // A requirement flag is still set. We stay in active mode.
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
+
+        // remove 1 requirement. Active mode is maintained
+        ctx->mICDManager.SetKeepActiveModeRequirements(ICDManager::KeepActiveFlags::kExpectingMsgResponse, false);
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
+        // remove the last requirement
+        ctx->mICDManager.SetKeepActiveModeRequirements(ICDManager::KeepActiveFlags::kAwaitingMsgAck, false);
+        NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::IdleMode);
+    }
+};
+
+} // namespace app
+} // namespace chip
+
+namespace {
+/**
+ *   Test Suite. It lists all the test functions.
+ */
+// clang-format off
+static const nlTest sTests[] =
+{
+    NL_TEST_DEF("TestICDModeIntervals",         TestICDManager::TestICDModeIntervals),
+    NL_TEST_DEF("TestKeepActivemodeRequests",   TestICDManager::TestKeepActivemodeRequests),
+    NL_TEST_SENTINEL()
+};
+// clang-format on
+
+// clang-format off
+nlTestSuite cmSuite =
+{
+    "TestICDManager",
+    &sTests[0],
+    TestContext::Initialize,
+    TestContext::Finalize
+};
+// clang-format on
+} // namespace
+
+int TestSuiteICDManager()
+{
+    return ExecuteTestsWithContext<TestContext>(&cmSuite);
 }
 
-CHIP_REGISTER_TEST_SUITE(TestICDManager)
+CHIP_REGISTER_TEST_SUITE(TestSuiteICDManager)