decouple simulation test from mycelium

1 files changed, 87 insertions, 0 deletions

diff --git a/src/transport/wire.rs b/src/transport/wire.rs
index fcbee85..53fd460 100644
--- a/src/transport/wire.rs
+++ b/src/transport/wire.rs
@@ -325,6 +325,80 @@ pub(crate) mod codec {
     }
 }
 
+/// One message of every kind, for the codecs' tests (this one's, and each transport's
+/// envelope around it).
+#[cfg(test)]
+pub(crate) fn samples() -> Vec<ParsedMessage> {
+    use crate::document::replica::Epoch;
+    use crate::transport::{
+        BlobBody, BlobId, BlobMessage, DeltaSpec, HeadsSummary, HelloReply, HelloRequest,
+        IdentityProof, ListedPeer, Status, SyncBody, SyncEnvelope,
+    };
+    use automerge::ChangeHash;
+    let epoch = Epoch {
+        generation: 2,
+        id: [3; 32],
+    };
+    let status = Status {
+        heads: HeadsSummary::of(vec![ChangeHash([1; 32])]),
+        epoch,
+        epoch_seq: 1,
+        ready: true,
+        syncs_with_you: true,
+    };
+    let proof = IdentityProof {
+        key: [8; 32],
+        signature: [9; 64],
+    };
+    vec![
+        ParsedMessage::Hello(HelloRequest {
+            swarm_id: Some("swarm".into()),
+            epoch,
+            epoch_seq: 1,
+            auth: vec![1, 2, 3],
+            ready: true,
+            run_id: [4; 16],
+            handshake: 7,
+        }),
+        ParsedMessage::HelloReply(HelloReply {
+            swarm_id: "swarm".into(),
+            peers: vec![ListedPeer {
+                id: "p".into(),
+                addresses: vec!["a".into()],
+            }],
+            epoch,
+            epoch_seq: 1,
+            auth: Vec::new(),
+            ready: false,
+            run_id: [4; 16],
+            away_ms: Some(5),
+            sender_run_id: [6; 16],
+        }),
+        ParsedMessage::Sync(SyncEnvelope {
+            swarm_id: "swarm".into(),
+            epoch,
+            epoch_seq: 1,
+            body: SyncBody::Delta(DeltaSpec {
+                from: Vec::new(),
+                to: vec![ChangeHash([2; 32])],
+            }),
+            ready: true,
+        }),
+        ParsedMessage::Status(status.clone()),
+        ParsedMessage::StatusReply(status),
+        ParsedMessage::Blob(BlobMessage {
+            epoch,
+            epoch_seq: 1,
+            id: BlobId::Content([5; 32]),
+            body: BlobBody::Missing,
+        }),
+        ParsedMessage::Who(proof.clone()),
+        ParsedMessage::Me(proof),
+        ParsedMessage::Ping(7),
+        ParsedMessage::Pong(u64::MAX),
+    ]
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -335,6 +409,19 @@ mod tests {
     };
     use automerge::ChangeHash;
 
+    /// Every kind decodes to what was encoded: re-encoded, the same bytes.
+    #[test]
+    fn every_kind_round_trips() {
+        let samples = samples();
+        assert_eq!(samples.len(), 10, "a kind is missing from `samples`");
+        for message in samples {
+            let bytes = encode(&message).unwrap();
+            let decoded = decode(&bytes).unwrap();
+            assert_eq!(decoded.kind(), message.kind());
+            assert_eq!(encode(&decoded).unwrap(), bytes, "{message:?}");
+        }
+    }
+
     #[test]
     fn handshakes_round_trip() {
         let epoch = Epoch {