test: add tests

src/common/meta/src/key/catalog_name.rs

@@ -164,7 +164,7 @@ mod tests {
 
  assert_eq!(key.to_string(), "__catalog_name/my-catalog");
 
- let parsed: CatalogNameKey = "__catalog_name/my-catalog".try_into().unwrap();
+ let parsed = CatalogNameKey::from_bytes(b"__catalog_name/my-catalog").unwrap();
 
  assert_eq!(key, parsed);
  }

src/common/meta/src/key/schema_name.rs

@@ -238,7 +238,8 @@ mod tests {
  let key = SchemaNameKey::new("my-catalog", "my-schema");
  assert_eq!(key.to_string(), "__schema_name/my-catalog/my-schema");
 
- let parsed: SchemaNameKey<'_> = "__schema_name/my-catalog/my-schema".try_into().unwrap();
+ let parsed = SchemaNameKey::from_bytes(b"__schema_name/my-catalog/my-schema").unwrap();
+
  assert_eq!(key, parsed);
 
  let value = SchemaNameValue {

src/common/meta/src/key/table_info.rs

@@ -34,6 +34,7 @@ use crate::table_name::TableName;
 /// The key stores the metadata of the table.
 ///
 /// The layout: `__table_info/{table_id}`.
+#[derive(Debug, PartialEq)]
 pub struct TableInfoKey {
  table_id: TableId,
 }
@@ -281,14 +282,21 @@ mod tests {
  }
 
  #[test]
- fn test_key_serde() {
+ fn test_key_serialization() {
  let key = TableInfoKey::new(42);
  let raw_key = key.to_bytes();
  assert_eq!(raw_key, b"__table_info/42");
  }
 
  #[test]
- fn test_value_serde() {
+ fn test_key_deserialization() {
+ let expected = TableInfoKey::new(42);
+ let key = TableInfoKey::from_bytes(b"__table_info/42").unwrap();
+ assert_eq!(key, expected);
+ }
+
+ #[test]
+ fn test_value_serialization() {
  let value = TableInfoValue {
  table_info: new_table_info(42),
  version: 1,

src/common/meta/src/key/table_name.rs

@@ -50,26 +50,6 @@ impl<'a> TableNameKey<'a> {
  pub fn prefix_to_table(catalog: &str, schema: &str) -> String {
  format!("{}/{}/{}", TABLE_NAME_KEY_PREFIX, catalog, schema)
  }
-
- fn strip_table_name(raw_key: &[u8]) -> Result<String> {
- let key = String::from_utf8(raw_key.to_vec()).map_err(|e| {
- InvalidTableMetadataSnafu {
- err_msg: format!(
- "TableNameKey '{}' is not a valid UTF8 string: {e}",
- String::from_utf8_lossy(raw_key)
- ),
- }
- .build()
- })?;
- let captures =
- TABLE_NAME_KEY_PATTERN
- .captures(&key)
- .context(InvalidTableMetadataSnafu {
- err_msg: format!("Invalid TableNameKey '{key}'"),
- })?;
- // Safety: pass the regex check above
- Ok(captures[3].to_string())
- }
 }
 
 impl Display for TableNameKey<'_> {
@@ -116,10 +96,10 @@ impl<'a> MetaKey<'a, TableNameKey<'a>> for TableNameKey<'_> {
 
 /// Decodes `KeyValue` to ({table_name}, TableNameValue)
 pub fn table_decoder(kv: KeyValue) -> Result<(String, TableNameValue)> {
- let table_name = TableNameKey::strip_table_name(kv.key())?;
+ let table_name_key = TableNameKey::from_bytes(&kv.key)?;
  let table_name_value = TableNameValue::try_from_raw_value(&kv.value)?;
 
- Ok((table_name, table_name_value))
+ Ok((table_name_key.table.to_string(), table_name_value))
 }
 
 impl<'a> From<&'a TableName> for TableNameKey<'a> {
@@ -290,8 +270,8 @@ mod tests {
 
  #[test]
  fn test_strip_table_name() {
- fn test_err(raw_key: &[u8]) {
- assert!(TableNameKey::strip_table_name(raw_key).is_err());
+ fn test_err(bytes: &[u8]) {
+ assert!(TableNameKey::from_bytes(bytes).is_err());
  }
 
  test_err(b"");
@@ -308,10 +288,11 @@ mod tests {
  fn test_ok(table_name: &str) {
  assert_eq!(
  table_name,
- TableNameKey::strip_table_name(
+ TableNameKey::from_bytes(
  format!("__table_name/my_catalog/my_schema/{}", table_name).as_bytes()
  )
  .unwrap()
+ .table
  );
  }
  test_ok("my_table");

src/common/meta/src/key/table_region.rs

@@ -32,6 +32,7 @@ pub type RegionDistribution = BTreeMap<DatanodeId, Vec<RegionNumber>>;
  since = "0.4.0",
  note = "Please use the TableRouteManager's get_region_distribution method instead"
 )]
+#[derive(Debug, PartialEq)]
 pub struct TableRegionKey {
  table_id: TableId,
 }
@@ -107,10 +108,12 @@ mod tests {
  use crate::key::TableMetaValue;
 
  #[test]
- fn test_serde() {
- let key = TableRegionKey::new(1);
+ fn test_serialization() {
+ let key = TableRegionKey::new(24);
  let raw_key = key.to_bytes();
- assert_eq!(raw_key, b"__table_region/1");
+ assert_eq!(raw_key, b"__table_region/24");
+ let deserialized = TableRegionKey::from_bytes(b"__table_region/24").unwrap();
+ assert_eq!(key, deserialized);
 
  let value = TableRegionValue {
  region_distribution: RegionDistribution::from([(1, vec![1, 2, 3]), (2, vec![4, 5, 6])]),

src/common/meta/src/key/table_route.rs

@@ -37,6 +37,7 @@ use crate::rpc::store::BatchGetRequest;
 /// The key stores table routes
 ///
 /// The layout: `__table_route/{table_id}`.
+#[derive(Debug, PartialEq)]
 pub struct TableRouteKey {
  pub table_id: TableId,
 }
@@ -628,6 +629,20 @@ mod tests {
  );
  }
 
+ #[test]
+ fn test_key_serialization() {
+ let key = TableRouteKey::new(42);
+ let raw_key = key.to_bytes();
+ assert_eq!(raw_key, b"__table_route/42");
+ }
+
+ #[test]
+ fn test_key_deserialization() {
+ let expected = TableRouteKey::new(42);
+ let key = TableRouteKey::from_bytes(b"__table_route/42").unwrap();
+ assert_eq!(key, expected);
+ }
+
  #[tokio::test]
  async fn test_table_route_storage_get_raw_empty() {
  let kv = Arc::new(MemoryKvBackend::default());