[Create Test] Creating IDM_3_2 python3 test module

src/app/WriteClient.cpp

@@ -201,7 +201,7 @@ CHIP_ERROR WriteClient::StartNewMessage()
 
     ReturnErrorOnFailure(mWriteRequestBuilder.Init(&mMessageWriter));
     mWriteRequestBuilder.SuppressResponse(mSuppressResponse);
-    mWriteRequestBuilder.TimedRequest(mTimedWriteTimeoutMs.HasValue());
+    mWriteRequestBuilder.TimedRequest(mTimedRequest);
     ReturnErrorOnFailure(mWriteRequestBuilder.GetError());
     mWriteRequestBuilder.CreateWriteRequests();
     ReturnErrorOnFailure(mWriteRequestBuilder.GetError());

src/app/WriteClient.h

@@ -129,7 +129,7 @@ class WriteClient : public Messaging::ExchangeDelegate
                 bool aSuppressResponse = false) :
         mpExchangeMgr(apExchangeMgr),
         mExchangeCtx(*this), mpCallback(apCallback), mTimedWriteTimeoutMs(aTimedWriteTimeoutMs),
-        mSuppressResponse(aSuppressResponse)
+        mSuppressResponse(aSuppressResponse), mTimedRequest(aTimedWriteTimeoutMs.HasValue())
     {
         assertChipStackLockedByCurrentThread();
     }
@@ -138,7 +138,15 @@ class WriteClient : public Messaging::ExchangeDelegate
     WriteClient(Messaging::ExchangeManager * apExchangeMgr, Callback * apCallback, const Optional<uint16_t> & aTimedWriteTimeoutMs,
                 uint16_t aReservedSize) :
         mpExchangeMgr(apExchangeMgr),
-        mExchangeCtx(*this), mpCallback(apCallback), mTimedWriteTimeoutMs(aTimedWriteTimeoutMs), mReservedSize(aReservedSize)
+        mExchangeCtx(*this), mpCallback(apCallback), mTimedWriteTimeoutMs(aTimedWriteTimeoutMs), mReservedSize(aReservedSize),
+        mTimedRequest(aTimedWriteTimeoutMs.HasValue())
+    {
+        assertChipStackLockedByCurrentThread();
+    }
+
+    // TestOnly constructor that allows setting TimedRequest flag without timeout
+    WriteClient(Messaging::ExchangeManager * apExchangeMgr, Callback * apCallback, bool aTimedRequest) :
+        mpExchangeMgr(apExchangeMgr), mExchangeCtx(*this), mpCallback(apCallback), mTimedRequest(aTimedRequest)
     {
         assertChipStackLockedByCurrentThread();
     }
@@ -524,6 +532,7 @@ class WriteClient : public Messaging::ExchangeDelegate
     // #if CONFIG_BUILD_FOR_HOST_UNIT_TEST
     uint16_t mReservedSize = 0;
     // #endif
+    bool mTimedRequest = false;
 
     /**
      * Below we define several const variables for encoding overheads.

src/app/tests/suites/manualTests.json

@@ -118,7 +118,6 @@
         "Test_TC_IDM_2_1",
         "Test_TC_IDM_2_2",
         "Test_TC_IDM_3_1",
-        "Test_TC_IDM_3_2",
         "Test_TC_IDM_4_1",
         "Test_TC_IDM_4_3",
         "Test_TC_IDM_4_4",

src/controller/python/matter/ChipDeviceCtrl.py

@@ -1582,6 +1582,43 @@ async def TestOnlySendCommandTimedRequestFlagWithNoTimedInvoke(self, nodeid: int
             ), payload).raise_on_error()
         return await future
 
+    async def TestOnlyWriteAttributeTimedRequestFlagWithNoTimedAction(self, nodeid: int,
+                                                                      attributes: typing.List[typing.Tuple[int, ClusterObjects.ClusterAttributeDescriptor]],
+                                                                      interactionTimeoutMs: typing.Optional[int] = None, busyWaitMs: typing.Optional[int] = None,
+                                                                      payloadCapability: int = TransportPayloadCapability.MRP_PAYLOAD):
+        '''
+        ONLY TO BE USED FOR TEST: Write attributes with TimedRequest flag but no TimedAction transaction.
+        This should result in TIMED_REQUEST_MISMATCH error.
+
+        Please see WriteAttribute for description of parameters.
+
+        Returns:
+            [AttributeStatus] (list - one for each path).
+
+        Raises:
+            InteractionModelError on error (expected: TIMED_REQUEST_MISMATCH)
+        '''
+        self.CheckIsActive()
+
+        eventLoop = asyncio.get_running_loop()
+        future = eventLoop.create_future()
+
+        device = await self.GetConnectedDevice(nodeid, timeoutMs=interactionTimeoutMs, payloadCapability=payloadCapability)
+
+        attrs = []
+        for v in attributes:
+            if len(v) == 2:
+                attrs.append(ClusterAttribute.AttributeWriteRequest(
+                    v[0], v[1], 0, 0, v[1].value))  # type: ignore[attr-defined]
+            else:
+                attrs.append(ClusterAttribute.AttributeWriteRequest(
+                    v[0], v[1], v[2], 1, v[1].value))
+
+        ClusterAttribute.TestOnlyWriteAttributeTimedRequestFlagWithNoTimedAction(
+            future, eventLoop, device.deviceProxy, attrs,
+            interactionTimeoutMs=interactionTimeoutMs, busyWaitMs=busyWaitMs).raise_on_error()
+        return await future
+
     async def SendCommand(self, nodeid: int, endpoint: int, payload: ClusterObjects.ClusterCommand, responseType=None,
                           timedRequestTimeoutMs: typing.Optional[int] = None,
                           interactionTimeoutMs: typing.Optional[int] = None, busyWaitMs: typing.Optional[int] = None,

src/controller/python/matter/clusters/Attribute.py

@@ -1057,6 +1057,49 @@ def WriteAttributes(future: Future, eventLoop, device,
     return res
 
 
+def TestOnlyWriteAttributeTimedRequestFlagWithNoTimedAction(future: Future, eventLoop, device,
+                                                            attributes: List[AttributeWriteRequest],
+                                                            interactionTimeoutMs: Union[None, int] = None,
+                                                            busyWaitMs: Union[None, int] = None) -> PyChipError:
+    ''' ONLY TO BE USED FOR TEST: Writes attributes with TimedRequest flag but no TimedAction transaction
+        This should result in TIMED_REQUEST_MISMATCH error.
+    '''
+    handle = GetLibraryHandle()
+
+    numberOfAttributes = len(attributes)
+    pyWriteAttributesArrayType = PyWriteAttributeData * numberOfAttributes
+    pyWriteAttributes = pyWriteAttributesArrayType()
+
+    for idx, attr in enumerate(attributes):
+        # Note: We skip the timed write check here to allow testing the TIMED_REQUEST_MISMATCH scenario
+        # In normal WriteAttributes, this would check for must_use_timed_write
+
+        tlv = attr.Attribute.ToTLV(None, attr.Data)
+
+        pyWriteAttributes[idx].attributePath.endpointId = c_uint16(attr.EndpointId)
+        pyWriteAttributes[idx].attributePath.clusterId = c_uint32(attr.Attribute.cluster_id)
+        pyWriteAttributes[idx].attributePath.attributeId = c_uint32(attr.Attribute.attribute_id)
+        pyWriteAttributes[idx].attributePath.dataVersion = c_uint32(attr.DataVersion)
+        pyWriteAttributes[idx].attributePath.hasDataVersion = c_uint8(attr.HasDataVersion)
+        pyWriteAttributes[idx].tlvData = cast(ctypes.c_char_p(bytes(tlv)), c_void_p)
+        pyWriteAttributes[idx].tlvLength = c_size_t(len(tlv))
+
+    transaction = AsyncWriteTransaction(future, eventLoop)
+    ctypes.pythonapi.Py_IncRef(ctypes.py_object(transaction))
+
+    # Call the TestOnly C++ function that sets TimedRequest=True but no timed transaction
+    res = builtins.chipStack.Call(
+        lambda: handle.pychip_WriteClient_TestOnlyWriteAttributesTimedRequestNoTimedAction(
+            ctypes.py_object(transaction), device,
+            ctypes.c_size_t(0 if interactionTimeoutMs is None else interactionTimeoutMs),
+            ctypes.c_size_t(0 if busyWaitMs is None else busyWaitMs),
+            pyWriteAttributes, ctypes.c_size_t(numberOfAttributes))
+    )
+    if not res.is_success:
+        ctypes.pythonapi.Py_DecRef(ctypes.py_object(transaction))
+    return res
+
+
 def WriteGroupAttributes(groupId: int, devCtrl: c_void_p, attributes: List[AttributeWriteRequest], busyWaitMs: Union[None, int] = None) -> PyChipError:
     handle = GetLibraryHandle()
 
@@ -1227,6 +1270,9 @@ def Init():
 
         handle.pychip_WriteClient_WriteAttributes.restype = PyChipError
         handle.pychip_WriteClient_WriteGroupAttributes.restype = PyChipError
+        handle.pychip_WriteClient_TestOnlyWriteAttributesTimedRequestNoTimedAction.restype = PyChipError
+        handle.pychip_WriteClient_TestOnlyWriteAttributesTimedRequestNoTimedAction.argtypes = [py_object, c_void_p,
+                                                                                               c_size_t, c_size_t, POINTER(PyWriteAttributeData), c_size_t]
 
         # Both WriteAttributes and WriteGroupAttributes are variadic functions. As per ctype documentation
         # https://docs.python.org/3/library/ctypes.html#calling-varadic-functions, it is critical that we

src/controller/python/matter/clusters/attribute.cpp

@@ -267,6 +267,9 @@ PyChipError pychip_WriteClient_WriteAttributes(void * appContext, DeviceProxy *
                                                size_t interactionTimeoutMsSizeT, size_t busyWaitMsSizeT,
                                                chip::python::PyWriteAttributeData * writeAttributesData, size_t attributeDataLength,
                                                bool forceLegacyListEncoding);
+PyChipError pychip_WriteClient_TestOnlyWriteAttributesTimedRequestNoTimedAction(
+    void * appContext, DeviceProxy * device, size_t interactionTimeoutMsSizeT, size_t busyWaitMsSizeT,
+    chip::python::PyWriteAttributeData * writeAttributesData, size_t attributeDataLength);
 PyChipError pychip_WriteClient_WriteGroupAttributes(size_t groupIdSizeT, chip::Controller::DeviceCommissioner * devCtrl,
                                                     size_t busyWaitMsSizeT,
                                                     chip::python::PyWriteAttributeData * writeAttributesData,
@@ -405,6 +408,68 @@ PyChipError pychip_WriteClient_WriteAttributes(void * appContext, DeviceProxy *
     return ToPyChipError(err);
 }
 
+PyChipError pychip_WriteClient_TestOnlyWriteAttributesTimedRequestNoTimedAction(void * appContext, DeviceProxy * device,
+                                                                                size_t interactionTimeoutMsSizeT,
+                                                                                size_t busyWaitMsSizeT,
+                                                                                python::PyWriteAttributeData * writeAttributesData,
+                                                                                size_t attributeDataLength)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    uint16_t interactionTimeoutMs = static_cast<uint16_t>(interactionTimeoutMsSizeT);
+    uint16_t busyWaitMs           = static_cast<uint16_t>(busyWaitMsSizeT);
+
+    std::unique_ptr<WriteClientCallback> callback = std::make_unique<WriteClientCallback>(appContext);
+
+    // CRITICAL: Use TestOnly constructor to set TimedRequest flag without timeout.
+    // This function intentionally sets TimedRequest=true but does NOT send a TimedRequest action first.
+    // This should result in TIMED_REQUEST_MISMATCH error.
+    std::unique_ptr<WriteClient> client = std::make_unique<WriteClient>(
+        app::InteractionModelEngine::GetInstance()->GetExchangeManager(), callback->GetChunkedCallback(),
+        true); // Set TimedRequest flag to true without timeout
+
+    VerifyOrExit(device != nullptr && device->GetSecureSession().HasValue(), err = CHIP_ERROR_MISSING_SECURE_SESSION);
+
+    for (size_t i = 0; i < attributeDataLength; i++)
+    {
+        python::PyAttributePath path = writeAttributesData[i].attributePath;
+        void * tlv                   = writeAttributesData[i].tlvData;
+        size_t length                = writeAttributesData[i].tlvLength;
+
+        uint8_t * tlvBuffer = reinterpret_cast<uint8_t *>(tlv);
+
+        TLV::TLVReader reader;
+        reader.Init(tlvBuffer, static_cast<uint32_t>(length));
+        reader.Next();
+        Optional<DataVersion> dataVersion;
+        if (path.hasDataVersion == 1)
+        {
+            dataVersion.SetValue(path.dataVersion);
+        }
+
+        SuccessOrExit(
+            err = client->PutPreencodedAttribute(
+                chip::app::ConcreteDataAttributePath(path.endpointId, path.clusterId, path.attributeId, dataVersion), reader));
+    }
+
+    // Send WriteRequest with TimedRequest flag set but no preceding TimedRequest action
+    // This should trigger TIMED_REQUEST_MISMATCH error
+    SuccessOrExit(err = client->SendWriteRequest(device->GetSecureSession().Value(),
+                                                 interactionTimeoutMs != 0 ? System::Clock::Milliseconds32(interactionTimeoutMs)
+                                                                           : System::Clock::kZero));
+
+    client.release();
+    callback.release();
+
+    if (busyWaitMs)
+    {
+        usleep(busyWaitMs * 1000);
+    }
+
+exit:
+    return ToPyChipError(err);
+}
+
 PyChipError pychip_WriteClient_WriteGroupAttributes(size_t groupIdSizeT, chip::Controller::DeviceCommissioner * devCtrl,
                                                     size_t busyWaitMsSizeT, python::PyWriteAttributeData * writeAttributesData,
                                                     size_t attributeDataLength)