Merge pull request #4 from project-chip/feature/timed_request_tests

Add tests for timed requests

Author: kedars

matter/src/interaction_model/core.rs

@@ -44,7 +44,7 @@ use super::{messages::msg::TimedReq, InteractionConsumer};
 /* Interaction Model ID as per the Matter Spec */
 const PROTO_ID_INTERACTION_MODEL: usize = 0x01;
 
-#[derive(FromPrimitive, Debug, Copy, Clone)]
+#[derive(FromPrimitive, Debug, Copy, Clone, PartialEq)]
 pub enum OpCode {
     Reserved = 0,
     StatusResponse = 1,

matter/src/interaction_model/messages.rs

@@ -71,35 +71,44 @@ pub mod msg {
         tlv::{FromTLV, TLVArray, TLVElement, TLVWriter, TagType, ToTLV},
     };
 
-    use super::ib::{AttrData, AttrPath, AttrResp, CmdData, DataVersionFilter};
+    use super::ib::{self, AttrData, AttrPath, AttrResp, AttrStatus, CmdData, DataVersionFilter};
 
-    #[derive(FromTLV)]
+    #[derive(FromTLV, ToTLV)]
     pub struct TimedReq {
         pub timeout: u16,
     }
 
-    #[derive(ToTLV)]
+    #[derive(FromTLV, ToTLV)]
     pub struct StatusResp {
         pub status: IMStatusCode,
     }
 
-    #[derive(FromTLV)]
+    pub enum InvReqTag {
+        SupressResponse = 0,
+        TimedReq = 1,
+        InvokeRequests = 2,
+    }
+
+    #[derive(FromTLV, ToTLV)]
     #[tlvargs(lifetime = "'a")]
     pub struct InvReq<'a> {
         pub suppress_response: Option<bool>,
         pub timed_request: Option<bool>,
         pub inv_requests: Option<TLVArray<'a, CmdData<'a>>>,
     }
 
+    // This enum is helpful when we are constructing the response
+    // step by step in incremental manner
     pub enum InvRespTag {
         SupressResponse = 0,
         InvokeResponses = 1,
     }
 
-    pub enum InvReqTag {
-        SupressResponse = 0,
-        TimedReq = 1,
-        InvokeRequests = 2,
+    #[derive(FromTLV, ToTLV, Debug)]
+    #[tlvargs(lifetime = "'a")]
+    pub struct InvResp<'a> {
+        pub suppress_response: Option<bool>,
+        pub inv_responses: Option<TLVArray<'a, ib::InvResp<'a>>>,
     }
 
     #[derive(Default, ToTLV, FromTLV)]
@@ -171,6 +180,12 @@ pub mod msg {
     }
 
     // Write Response
+    #[derive(ToTLV, FromTLV)]
+    #[tlvargs(lifetime = "'a")]
+    pub struct WriteResp<'a> {
+        pub write_responses: TLVArray<'a, AttrStatus>,
+    }
+
     pub enum WriteRespTag {
         WriteResponses = 0,
     }
@@ -190,7 +205,7 @@ pub mod ib {
     use super::GenericPath;
 
     // Command Response
-    #[derive(Clone, Copy, FromTLV, ToTLV)]
+    #[derive(Clone, Copy, FromTLV, ToTLV, Debug)]
     #[tlvargs(lifetime = "'a")]
     pub enum InvResp<'a> {
         Cmd(CmdData<'a>),

matter/src/tlv/traits.rs

@@ -19,6 +19,7 @@ use super::{ElementType, TLVContainerIterator, TLVElement, TLVWriter, TagType};
 use crate::error::Error;
 use core::slice::Iter;
 use log::error;
+use std::fmt::Debug;
 
 pub trait FromTLV<'a> {
     fn from_tlv(t: &TLVElement<'a>) -> Result<Self, Error>
@@ -282,6 +283,7 @@ impl<T> TLVArrayOwned<T> {
     }
 }
 
+#[derive(Copy, Clone)]
 pub enum TLVArray<'a, T> {
     // This is used for the to-tlv path
     Slice(&'a [T]),
@@ -342,6 +344,27 @@ impl<'a, T: FromTLV<'a> + Copy> Iterator for TLVArrayIter<'a, T> {
     }
 }
 
+impl<'a, T> PartialEq<&[T]> for TLVArray<'a, T>
+where
+    T: ToTLV + FromTLV<'a> + Copy + PartialEq,
+{
+    fn eq(&self, other: &&[T]) -> bool {
+        let mut iter1 = self.iter();
+        let mut iter2 = other.into_iter();
+        loop {
+            match (iter1.next(), iter2.next()) {
+                (None, None) => return true,
+                (Some(x), Some(y)) => {
+                    if x != *y {
+                        return false;
+                    }
+                }
+                _ => return false,
+            }
+        }
+    }
+}
+
 impl<'a, T: ToTLV> ToTLV for TLVArray<'a, T> {
     fn to_tlv(&self, tw: &mut TLVWriter, tag_type: TagType) -> Result<(), Error> {
         match *self {
@@ -364,6 +387,15 @@ impl<'a, T> FromTLV<'a> for TLVArray<'a, T> {
     }
 }
 
+impl<'a, T: Debug + ToTLV + FromTLV<'a> + Copy> Debug for TLVArray<'a, T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for i in self.iter() {
+            writeln!(f, "{:?}", i)?;
+        }
+        writeln!(f, "")
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::{FromTLV, OctetStr, TLVElement, TLVWriter, TagType, ToTLV};

matter/tests/common/attributes.rs

@@ -21,6 +21,7 @@ use matter::interaction_model::{messages::ib::AttrResp, messages::msg::ReportDat
 pub fn assert_attr_report(received: &ReportDataMsg, expected: &[AttrResp]) {
     let mut index = 0;
 
+    // We can't use assert_eq because it will also try to match data-version
     for inv_response in received.attr_reports.as_ref().unwrap().iter() {
         println!("Validating index {}", index);
         match expected[index] {
@@ -34,14 +35,7 @@ pub fn assert_attr_report(received: &ReportDataMsg, expected: &[AttrResp]) {
                     panic!("Invalid response, expected AttrRespIn::Data");
                 }
             },
-            AttrResp::Status(e_s) => match inv_response {
-                AttrResp::Status(s) => {
-                    assert_eq!(e_s, s);
-                }
-                _ => {
-                    panic!("Invalid response, expected AttrRespIn::Status");
-                }
-            },
+            AttrResp::Status(s) => assert_eq!(AttrResp::Status(s), inv_response),
         }
         println!("Index {} success", index);
         index += 1;

matter/tests/common/commands.rs

@@ -0,0 +1,98 @@
+/*
+ *
+ *    Copyright (c) 2023 Project CHIP Authors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+use matter::{
+    data_model::objects::EncodeValue,
+    interaction_model::{
+        messages::ib::{CmdPath, CmdStatus, InvResp},
+        messages::msg,
+    },
+};
+
+pub enum ExpectedInvResp {
+    Cmd(CmdPath, u8),
+    Status(CmdStatus),
+}
+
+pub fn assert_inv_response(resp: &msg::InvResp, expected: &[ExpectedInvResp]) {
+    let mut index = 0;
+    for inv_response in resp.inv_responses.unwrap().iter() {
+        println!("Validating index {}", index);
+        match expected[index] {
+            ExpectedInvResp::Cmd(e_c, e_d) => match inv_response {
+                InvResp::Cmd(c) => {
+                    assert_eq!(e_c, c.path);
+                    match c.data {
+                        EncodeValue::Tlv(t) => {
+                            assert_eq!(e_d, t.find_tag(0).unwrap().u8().unwrap())
+                        }
+                        _ => panic!("Incorrect CmdDataType"),
+                    }
+                }
+                _ => {
+                    panic!("Invalid response, expected InvResponse::Cmd");
+                }
+            },
+            ExpectedInvResp::Status(e_status) => match inv_response {
+                InvResp::Status(status) => {
+                    assert_eq!(e_status, status);
+                }
+                _ => {
+                    panic!("Invalid response, expected InvResponse::Status");
+                }
+            },
+        }
+        println!("Index {} success", index);
+        index += 1;
+    }
+    assert_eq!(index, expected.len());
+}
+
+#[macro_export]
+macro_rules! cmd_data {
+    ($path:ident, $data:literal) => {
+        CmdData::new($path, EncodeValue::Value(&($data as u32)))
+    };
+}
+
+#[macro_export]
+macro_rules! echo_req {
+    ($endpoint:literal, $data:literal) => {
+        CmdData::new(
+            CmdPath::new(
+                Some($endpoint),
+                Some(echo_cluster::ID),
+                Some(echo_cluster::Commands::EchoReq as u16),
+            ),
+            EncodeValue::Value(&($data as u32)),
+        )
+    };
+}
+
+#[macro_export]
+macro_rules! echo_resp {
+    ($endpoint:literal, $data:literal) => {
+        ExpectedInvResp::Cmd(
+            CmdPath::new(
+                Some($endpoint),
+                Some(echo_cluster::ID),
+                Some(echo_cluster::Commands::EchoResp as u16),
+            ),
+            $data,
+        )
+    };
+}