Make codec shape authority compile-time and fixed

crates/lazaret-core/tests/schema_records.rs

@@ -15,9 +15,39 @@ use lazaret_core::identity::{
     SessionAnchorId, SessionId, SourceIdentity, StreamDigest, TrustManifestDigest,
 };
 use lazaret_core::network::readiness_fingerprint as derive_readiness_fingerprint;
+use lazaret_core::protocol::{BootstrapWaitOutcome, BootstrapWaitRequest};
 use lazaret_core::records::*;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+
+#[derive(Default)]
+struct SchemaCorpus {
+    names: HashSet<&'static str>,
+    digest: Sha256,
+}
+
+impl SchemaCorpus {
+    fn insert(&mut self, name: &'static str, encoded: &[u8]) -> bool {
+        self.digest.update(name.len().to_be_bytes());
+        self.digest.update(name.as_bytes());
+        self.digest.update(encoded.len().to_be_bytes());
+        self.digest.update(encoded);
+        self.names.insert(name)
+    }
+
+    fn len(&self) -> usize {
+        self.names.len()
+    }
+
+    fn contains(&self, name: &&str) -> bool {
+        self.names.contains(name)
+    }
+
+    fn digest(&self) -> [u8; 32] {
+        self.digest.clone().finalize().into()
+    }
+}
 
 #[derive(Deserialize, Serialize)]
 struct RawParticipant {
@@ -168,6 +198,39 @@ struct RawTrustedHostConfigurationV1 {
     profiles: BTreeMap<String, ProfileConfigurationV1>,
 }
 
+#[derive(Serialize)]
+struct OversizedRecord(Vec<u8>);
+
+macro_rules! test_schema_types {
+    ($($record:ty),+ $(,)?) => {
+        $(
+            impl SchemaType for $record {
+                const NAME: &'static str = concat!("test::", stringify!($record));
+            }
+        )+
+    };
+}
+
+test_schema_types!(
+    RawParticipant,
+    RawTlsCredential,
+    RawProtocolCredential,
+    RawSandboxCredentialBundle,
+    RawMetadata,
+    MissingVersion,
+    RawDomainStore,
+    RawStorageCatalog,
+    RawTerminalResize,
+    RawSessionTerminal,
+    InvalidSessionExit,
+    RawDerivedNetworkPolicy,
+    RawNetworkReadinessAttestation,
+    RawNetworkReadinessIdentity,
+    RawMailboxRequest,
+    RawTrustedHostConfigurationV1,
+    OversizedRecord,
+);
+
 fn opaque(byte: u8) -> [u8; 32] {
     [byte; 32]
 }
@@ -604,12 +667,16 @@ fn participant_edge_snapshot(
     .unwrap()
 }
 
-fn verify_shape<T>(record: T, seen: &mut HashSet<&'static str>)
+fn verify_shape<T>(record: T, seen: &mut SchemaCorpus)
 where
     T: Clone + Debug + DeserializeOwned + Eq + SchemaType + Serialize,
 {
-    assert!(seen.insert(T::NAME), "duplicate test for {}", T::NAME);
     let encoded = encode(&record).expect("representative record encodes");
+    assert!(
+        seen.insert(T::NAME, &encoded),
+        "duplicate test for {}",
+        T::NAME
+    );
     assert_eq!(encode(&record).unwrap(), encoded);
     assert_eq!(decode::<T>(&encoded).unwrap(), record);