add test

Author: yunhanw-google

src/app/tests/TestReadInteraction.cpp

@@ -275,6 +275,14 @@ class MockInteractionModelApp : public chip::app::ReadClient::Callback
         mReadError = true;
     }
 
+    void OnSubscriptionEstablished(SubscriptionId aSubscriptionId) override { mOnSubscriptionEstablishedCount++; }
+
+    CHIP_ERROR OnResubscriptionNeeded(ReadClient * apReadClient, CHIP_ERROR aTerminationCause) override
+    {
+        mOnResubscriptionsAttempted++;
+        return apReadClient->ScheduleResubscription(apReadClient->ComputeTimeTillNextSubscription(), NullOptional, false);
+    }
+
     void OnDone(chip::app::ReadClient *) override {}
 
     void OnDeallocatePaths(chip::app::ReadPrepareParams && aReadPrepareParams) override
@@ -374,6 +382,7 @@ class MockInteractionModelApp : public chip::app::ReadClient::Callback
         mError                             = CHIP_NO_ERROR;
         mReceivedAttributePaths.clear();
         mReceivedListSizes.clear();
+
     }
 
     bool CapturesMatchExactly(chip::Span<const AttributeCaptureAssertion> captures)
@@ -421,6 +430,8 @@ class MockInteractionModelApp : public chip::app::ReadClient::Callback
         return true;
     }
 
+    int32_t mOnSubscriptionEstablishedCount = 0;
+    int32_t mOnResubscriptionsAttempted     = 0;
     int mNumDataElementIndex               = 0;
     bool mGotEventResponse                 = false;
     int mNumReadEventFailureStatusReceived = 0;
@@ -4643,6 +4654,104 @@ void TestReadInteraction::TestSubscribeClientReceiveInvalidSubscribeResponseMess
     CreateSessionBobToAlice();
 }
 
+TEST_F_FROM_FIXTURE_NO_BODY(TestReadInteraction, TestSubscribeClientReceiveInvalidSubscribeResponseMessageResubWhenCheckIn)
+TEST_F_FROM_FIXTURE_NO_BODY(TestReadInteractionSync, TestSubscribeClientReceiveInvalidSubscribeResponseMessageResubWhenCheckIn)
+void TestReadInteraction::TestSubscribeClientReceiveInvalidSubscribeResponseMessageResubWhenCheckIn()
+{
+
+    Messaging::ReliableMessageMgr * rm = GetExchangeManager().GetReliableMessageMgr();
+    // Shouldn't have anything in the retransmit table when starting the test.
+    EXPECT_EQ(rm->TestGetCountRetransTable(), 0);
+
+    MockInteractionModelApp delegate;
+    auto * engine = chip::app::InteractionModelEngine::GetInstance();
+    EXPECT_EQ(engine->Init(&GetExchangeManager(), &GetFabricTable(), gReportScheduler), CHIP_NO_ERROR);
+
+    ReadPrepareParams readPrepareParams(GetSessionBobToAlice());
+
+    chip::app::AttributePathParams attributePathParams[2];
+    readPrepareParams.mpAttributePathParamsList                 = attributePathParams;
+    readPrepareParams.mpAttributePathParamsList[0].mEndpointId  = kTestEndpointId;
+    readPrepareParams.mpAttributePathParamsList[0].mClusterId   = kTestClusterId;
+    readPrepareParams.mpAttributePathParamsList[0].mAttributeId = 1;
+
+    readPrepareParams.mpAttributePathParamsList[1].mEndpointId  = kTestEndpointId;
+    readPrepareParams.mpAttributePathParamsList[1].mClusterId   = kTestClusterId;
+    readPrepareParams.mpAttributePathParamsList[1].mAttributeId = 2;
+
+    readPrepareParams.mAttributePathParamsListSize = 2;
+
+    readPrepareParams.mMinIntervalFloorSeconds   = 2;
+    readPrepareParams.mMaxIntervalCeilingSeconds = 5;
+    readPrepareParams.mIsPeerLIT = true;
+
+    {
+        app::ReadClient readClient(chip::app::InteractionModelEngine::GetInstance(), &GetExchangeManager(), delegate,
+                                   chip::app::ReadClient::InteractionType::Subscribe);
+
+        GetLoopback().mSentMessageCount                 = 0;
+        GetLoopback().mNumMessagesToDrop                = 1;
+        GetLoopback().mNumMessagesToAllowBeforeDropping = 3;
+        GetLoopback().mDroppedMessageCount              = 0;
+
+        EXPECT_EQ(readClient.SendRequest(readPrepareParams), CHIP_NO_ERROR);
+
+        DrainAndServiceIO();
+
+        System::PacketBufferHandle msgBuf = System::PacketBufferHandle::New(kMaxSecureSduLengthBytes);
+        EXPECT_FALSE(msgBuf.IsNull());
+        System::PacketBufferTLVWriter writer;
+        writer.Init(std::move(msgBuf));
+        SubscribeResponseMessage::Builder response;
+        response.Init(&writer);
+        response.SubscriptionId(readClient.mSubscriptionId + 1);
+        response.MaxInterval(1);
+        response.EndOfSubscribeResponseMessage();
+        EXPECT_EQ(writer.Finalize(&msgBuf), CHIP_NO_ERROR);
+        PayloadHeader payloadHeader;
+        payloadHeader.SetExchangeID(0);
+        payloadHeader.SetMessageType(chip::Protocols::InteractionModel::MsgType::SubscribeResponse);
+
+        // Since we are dropping packets, things are not getting acked.  Set up
+        // our MRP state to look like what it would have looked like if the
+        // packet had not gotten dropped.
+        PretendWeGotReplyFromServer(*this, readClient.mExchange.Get());
+
+        EXPECT_EQ(GetLoopback().mSentMessageCount, 4u);
+        EXPECT_EQ(GetLoopback().mDroppedMessageCount, 1u);
+        EXPECT_EQ(engine->GetNumActiveReadHandlers(), 1u);
+        ASSERT_NE(engine->ActiveHandlerAt(0), nullptr);
+
+        GetLoopback().mSentMessageCount                 = 0;
+        GetLoopback().mNumMessagesToDrop                = 0;
+        GetLoopback().mNumMessagesToAllowBeforeDropping = 0;
+        GetLoopback().mDroppedMessageCount              = 0;
+
+        readClient.OnMessageReceived(readClient.mExchange.Get(), payloadHeader, std::move(msgBuf));
+        DrainAndServiceIO();
+
+        // TODO: Need to validate what status is being sent to the ReadHandler
+        // The ReadHandler's exchange is still open when we synthesize the subscribe response.
+        // Since we synthesized the subscribe response to the ReadClient, instead of sending it from the ReadHandler,
+        // the only messages here are the ReadClient's StatusResponse to the unexpected message and an MRP ack.
+        EXPECT_EQ(GetLoopback().mSentMessageCount, 2u);
+
+        EXPECT_EQ(delegate.mOnSubscriptionEstablishedCount, 0);
+        EXPECT_EQ(delegate.mOnResubscriptionsAttempted, 1);
+
+        InteractionModelEngine::GetInstance()->OnActiveModeNotification(
+                ScopedNodeId(readClient.GetPeerNodeId(), readClient.GetFabricIndex()));
+        DrainAndServiceIO();
+        EXPECT_EQ(callback.mOnSubscriptionEstablishedCount, 1);
+    }
+    EXPECT_EQ(engine->GetNumActiveReadClients(), 0u);
+    engine->Shutdown();
+    ExpireSessionAliceToBob();
+    ExpireSessionBobToAlice();
+    CreateSessionAliceToBob();
+    CreateSessionBobToAlice();
+}
+
 // Read Client create the subscription, handler sends unsolicited malformed report with invalid subscription id to client,
 // InteractionModelEngine::OnUnsolicitedReportData would process this malformed report and sends out status report
 TEST_F_FROM_FIXTURE_NO_BODY(TestReadInteraction, TestSubscribeClientReceiveUnsolicitedReportMessageWithInvalidSubscriptionId)

src/controller/tests/data_model/TestRead.cpp

@@ -1424,6 +1424,8 @@ class TestResubscriptionCallback : public ReadClient::Callback
 
     void ClearCounters()
     {
+        mOnSubscriptionEstablishedCount = 0;
+        mOnResubscriptionsAttempted     = 0;
         mOnSubscriptionEstablishedCount = 0;
         mOnDone                         = 0;
         mOnError                        = 0;