checkpoint

veilid-core/src/tests/common/test_table_store.rs

@@ -122,21 +122,21 @@ pub async fn test_store_delete_load(ts: TableStore) {
     assert_eq!(db.load(2, b"baz").unwrap(), Some(b"QWERTY".to_vec()));
 }
 
-pub async fn test_cbor(ts: TableStore) {
-    trace!("test_cbor");
+pub async fn test_frozen(ts: TableStore) {
+    trace!("test_frozen");
 
     let _ = ts.delete("test");
     let db = ts.open("test", 3).await.expect("should have opened");
     let (dht_key, _) = generate_secret();
 
-    assert!(db.store_cbor(0, b"asdf", &dht_key).is_ok());
+    assert!(db.store_rkyv(0, b"asdf", &dht_key).is_ok());
 
-    assert_eq!(db.load_cbor::<DHTKey>(0, b"qwer").unwrap(), None);
+    assert_eq!(db.load_rkyv::<DHTKey>(0, b"qwer").unwrap(), None);
 
-    let d = match db.load_cbor::<DHTKey>(0, b"asdf") {
+    let d = match db.load_rkyv::<DHTKey>(0, b"asdf") {
         Ok(x) => x,
         Err(e) => {
-            panic!("couldn't decode cbor: {}", e);
+            panic!("couldn't decode: {}", e);
         }
     };
     assert_eq!(d, Some(dht_key), "keys should be equal");
@@ -147,8 +147,8 @@ pub async fn test_cbor(ts: TableStore) {
     );
 
     assert!(
-        db.load_cbor::<DHTKey>(1, b"foo").is_err(),
-        "should fail to load cbor"
+        db.load_rkyv::<DHTKey>(1, b"foo").is_err(),
+        "should fail to unfreeze"
     );
 }
 
@@ -157,7 +157,7 @@ pub async fn test_all() {
     let ts = api.table_store().unwrap();
     test_delete_open_delete(ts.clone()).await;
     test_store_delete_load(ts.clone()).await;
-    test_cbor(ts.clone()).await;
+    test_frozen(ts.clone()).await;
 
     let _ = ts.delete("test").await;
 

veilid-core/src/tests/common/test_veilid_core.rs

@@ -43,7 +43,78 @@ pub async fn test_attach_detach() {
     api.shutdown().await;
 }
 
+pub async fn test_signed_node_info() {
+    info!("--- test_signed_node_info ---");
+
+    let (update_callback, config_callback) = setup_veilid_core();
+    let api = api_startup(update_callback, config_callback)
+        .await
+        .expect("startup failed");
+
+    // Test direct
+    let node_info = NodeInfo {
+        network_class: NetworkClass::InboundCapable,
+        outbound_protocols: ProtocolTypeSet::all(),
+        address_types: AddressTypeSet::all(),
+        min_version: 0,
+        max_version: 0,
+        dial_info_detail_list: vec![DialInfoDetail {
+            class: DialInfoClass::Mapped,
+            dial_info: DialInfo::udp(SocketAddress::default()),
+        }],
+    };
+
+    let (pkey, skey) = generate_secret();
+
+    let sni =
+        SignedDirectNodeInfo::with_secret(NodeId::new(pkey.clone()), node_info.clone(), &skey)
+            .unwrap();
+    let _ = SignedDirectNodeInfo::new(
+        NodeId::new(pkey),
+        node_info.clone(),
+        sni.timestamp,
+        sni.signature,
+    )
+    .unwrap();
+
+    // Test relayed
+    let node_info2 = NodeInfo {
+        network_class: NetworkClass::OutboundOnly,
+        outbound_protocols: ProtocolTypeSet::all(),
+        address_types: AddressTypeSet::all(),
+        min_version: 0,
+        max_version: 0,
+        dial_info_detail_list: vec![DialInfoDetail {
+            class: DialInfoClass::Blocked,
+            dial_info: DialInfo::udp(SocketAddress::default()),
+        }],
+    };
+
+    let (pkey2, skey2) = generate_secret();
+
+    let sni2 = SignedRelayedNodeInfo::with_secret(
+        NodeId::new(pkey2.clone()),
+        node_info2.clone(),
+        NodeId::new(pkey.clone()),
+        sni.clone(),
+        &skey2,
+    )
+    .unwrap();
+    let _ = SignedRelayedNodeInfo::new(
+        NodeId::new(pkey2),
+        node_info2,
+        NodeId::new(pkey),
+        sni,
+        sni2.timestamp,
+        sni2.signature,
+    )
+    .unwrap();
+
+    api.shutdown().await;
+}
+
 pub async fn test_all() {
     test_startup_shutdown().await;
     test_attach_detach().await;
+    test_signed_node_info().await;
 }