test: add tests for kvapi data structures

Cover the four previously-untested kvapi data structure modules:
pair.rs, key_codec.rs, message.rs, and item.rs.

Changes:
- `pair.rs`: test BasicPair, Pair, SeqPair construction, accessors,
  unpack, into_pair, and From<SeqPair> conversion
- `key_codec.rs`: test encode/decode round-trips for String (including
  special chars), u64, unit, and composite FooKey
- `message.rs`: test GetKVReq, MGetKVReq, ListKVReq construction,
  Display, and Clone+Eq
- `item.rs`: test Item with/without value and NonEmptyItem construction

Author: Zhang Yanpo

crates/client/kvapi/src/item.rs

@@ -41,3 +41,50 @@ impl<K: Key> NonEmptyItem<K> {
         NonEmptyItem { key, seqv }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use databend_meta_types::SeqV;
+
+    use super::*;
+    use crate::testing::FooKey;
+    use crate::testing::FooValue;
+
+    fn foo_key(a: u64, b: &str, c: u64) -> FooKey {
+        FooKey {
+            a,
+            b: b.to_string(),
+            c,
+        }
+    }
+
+    #[test]
+    fn test_item_with_value() {
+        let k = foo_key(1, "x", 2);
+        let sv = SeqV::new(5, FooValue);
+        let item = Item::new(k.clone(), Some(sv));
+
+        assert_eq!(item.key, k);
+        assert!(item.seqv.is_some());
+        assert_eq!(item.seqv.as_ref().unwrap().seq, 5);
+    }
+
+    #[test]
+    fn test_item_without_value() {
+        let k = foo_key(1, "x", 2);
+        let item = Item::<FooKey>::new(k.clone(), None);
+
+        assert_eq!(item.key, k);
+        assert!(item.seqv.is_none());
+    }
+
+    #[test]
+    fn test_non_empty_item() {
+        let k = foo_key(1, "x", 2);
+        let sv = SeqV::new(10, FooValue);
+        let item = NonEmptyItem::new(k.clone(), sv);
+
+        assert_eq!(item.key, k);
+        assert_eq!(item.seqv.seq, 10);
+    }
+}

crates/client/kvapi/src/key_codec.rs

@@ -66,3 +66,62 @@ mod impls {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::KeyBuilder;
+    use crate::KeyCodec;
+    use crate::KeyParser;
+    use crate::testing::FooKey;
+
+    #[test]
+    fn test_string_round_trip() {
+        let s = "hello world".to_string();
+        let encoded = s.encode_key(KeyBuilder::new()).done();
+        let mut p = KeyParser::new(&encoded);
+        let decoded = String::decode_key(&mut p).unwrap();
+        assert_eq!(s, decoded);
+    }
+
+    #[test]
+    fn test_string_with_special_chars() {
+        let s = "a/b%c".to_string();
+        let encoded = s.encode_key(KeyBuilder::new()).done();
+        let mut p = KeyParser::new(&encoded);
+        let decoded = String::decode_key(&mut p).unwrap();
+        assert_eq!(s, decoded);
+    }
+
+    #[test]
+    fn test_u64_round_trip() {
+        for v in [0u64, 1, 42, u64::MAX] {
+            let encoded = v.encode_key(KeyBuilder::new()).done();
+            let mut p = KeyParser::new(&encoded);
+            let decoded = u64::decode_key(&mut p).unwrap();
+            assert_eq!(v, decoded);
+        }
+    }
+
+    #[test]
+    fn test_unit_round_trip() {
+        let encoded = ().encode_key(KeyBuilder::new()).done();
+        assert_eq!(encoded, "");
+        let mut p = KeyParser::new(&encoded);
+        <()>::decode_key(&mut p).unwrap();
+    }
+
+    #[test]
+    fn test_foo_key_round_trip() {
+        let k = FooKey {
+            a: 1,
+            b: "hello world".to_string(),
+            c: 42,
+        };
+        let encoded = k.encode_key(KeyBuilder::new_prefixed("pref")).done();
+        assert_eq!(encoded, "pref/1/hello%20world/42");
+
+        let mut p = KeyParser::new_prefixed(&encoded, "pref").unwrap();
+        let decoded = FooKey::decode_key(&mut p).unwrap();
+        assert_eq!(k, decoded);
+    }
+}

crates/client/kvapi/src/message.rs

@@ -68,3 +68,58 @@ pub type UpsertKVReply = Change<Vec<u8>>;
 pub type GetKVReply = Option<SeqV<Vec<u8>>>;
 pub type MGetKVReply = Vec<Option<SeqV<Vec<u8>>>>;
 pub type ListKVReply = Vec<(String, SeqV<Vec<u8>>)>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_kv_req() {
+        let r = GetKVReq::new("foo");
+        assert_eq!(r.key, "foo");
+
+        let r2 = GetKVReq::new(format!("bar/{}", 42));
+        assert_eq!(r2.key, "bar/42");
+    }
+
+    #[test]
+    fn test_mget_kv_req() {
+        let r = MGetKVReq::new(["a", "b", "c"]);
+        assert_eq!(r.keys, vec!["a", "b", "c"]);
+    }
+
+    #[test]
+    fn test_mget_kv_req_display() {
+        let r = MGetKVReq::new(["x", "y"]);
+        let s = r.to_string();
+        assert!(s.contains("x"), "{}", s);
+        assert!(s.contains("y"), "{}", s);
+    }
+
+    #[test]
+    fn test_list_kv_req() {
+        let r = ListKVReq::new("prefix/");
+        assert_eq!(r.prefix, "prefix/");
+    }
+
+    #[test]
+    fn test_get_kv_req_clone_eq() {
+        let r = GetKVReq::new("foo");
+        let r2 = r.clone();
+        assert_eq!(r, r2);
+    }
+
+    #[test]
+    fn test_mget_kv_req_clone_eq() {
+        let r = MGetKVReq::new(["a", "b"]);
+        let r2 = r.clone();
+        assert_eq!(r, r2);
+    }
+
+    #[test]
+    fn test_list_kv_req_clone_eq() {
+        let r = ListKVReq::new("prefix/");
+        let r2 = r.clone();
+        assert_eq!(r, r2);
+    }
+}

crates/client/kvapi/src/pair.rs

@@ -111,3 +111,89 @@ where K: kvapi::Key
         sp.into_pair()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use databend_meta_types::SeqV;
+
+    use super::*;
+    use crate::testing::FooKey;
+    use crate::testing::FooValue;
+
+    fn foo_key(a: u64, b: &str, c: u64) -> FooKey {
+        FooKey {
+            a,
+            b: b.to_string(),
+            c,
+        }
+    }
+
+    #[test]
+    fn test_basic_pair() {
+        let k = foo_key(1, "x", 2);
+        let p = BasicPair::new(k.clone(), FooValue);
+
+        assert_eq!(p.key(), &k);
+
+        let (uk, _uv) = p.unpack();
+        assert_eq!(uk, k);
+    }
+
+    #[test]
+    fn test_pair() {
+        let k = foo_key(1, "x", 2);
+        let sv = SeqV::new(5, FooValue);
+        let p = Pair::new(k.clone(), sv);
+
+        assert_eq!(p.key(), &k);
+        assert_eq!(p.seq_value().seq, 5);
+    }
+
+    #[test]
+    fn test_seq_pair() {
+        let k = foo_key(1, "x", 2);
+        let sk = SeqV::new(10, k.clone());
+        let sv = SeqV::new(20, FooValue);
+        let sp = SeqPair::new(sk.clone(), sv);
+
+        assert_eq!(sp.seq_key().seq, 10);
+        assert_eq!(sp.seq_value().seq, 20);
+    }
+
+    #[test]
+    fn test_seq_pair_unpack() {
+        let k = foo_key(1, "x", 2);
+        let sk = SeqV::new(10, k.clone());
+        let sv = SeqV::new(20, FooValue);
+        let sp = SeqPair::new(sk, sv);
+
+        let (uk, uv) = sp.unpack();
+        assert_eq!(uk.seq, 10);
+        assert_eq!(uk.data, k);
+        assert_eq!(uv.seq, 20);
+    }
+
+    #[test]
+    fn test_seq_pair_into_pair() {
+        let k = foo_key(1, "x", 2);
+        let sk = SeqV::new(10, k.clone());
+        let sv = SeqV::new(20, FooValue);
+        let sp = SeqPair::new(sk, sv);
+
+        let p: Pair<FooKey> = sp.into_pair();
+        assert_eq!(p.key(), &k);
+        assert_eq!(p.seq_value().seq, 20);
+    }
+
+    #[test]
+    fn test_seq_pair_from_into() {
+        let k = foo_key(1, "x", 2);
+        let sk = SeqV::new(10, k.clone());
+        let sv = SeqV::new(20, FooValue);
+        let sp = SeqPair::new(sk, sv);
+
+        let p: Pair<FooKey> = sp.into();
+        assert_eq!(p.key(), &k);
+        assert_eq!(p.seq_value().seq, 20);
+    }
+}