tawasuyu/brahman

1//! Tests de roundtrip de serialización para `Message`.
2
3use minga_core::{Attestation, ContentHash, Keypair, NodeProbe, StoredNode};
4use minga_p2p::Message;
5
6fn roundtrip(msg: &Message) {
7    let bytes = msg.encode();
8    let decoded = Message::decode(&bytes).unwrap();
9    assert_eq!(msg, &decoded);
10}
11
12fn kp(seed: u8) -> Keypair {
13    Keypair::from_seed(&[seed; 32])
14}
15
16#[test]
17fn hello_roundtrip() {
18    let k = kp(1);
19    let root = ContentHash([42; 32]);
20    let sig = k.sign(root.as_bytes());
21    let msg = Message::Hello {
22        peer_did: k.did(),
23        root_subtree_hash: root,
24        signature: sig,
25    };
26    roundtrip(&msg);
27}
28
29#[test]
30fn probe_req_roundtrip() {
31    roundtrip(&Message::ProbeReq {
32        subtree_hash: ContentHash([5; 32]),
33    });
34}
35
36#[test]
37fn probe_res_with_probe_roundtrip() {
38    let msg = Message::ProbeRes {
39        subtree_hash: ContentHash([7; 32]),
40        probe: Some(NodeProbe {
41            level: 2,
42            keys: vec![ContentHash([1; 32])],
43            child_hashes: vec![ContentHash([10; 32]), ContentHash([20; 32])],
44        }),
45    };
46    roundtrip(&msg);
47}
48
49#[test]
50fn probe_res_empty_roundtrip() {
51    roundtrip(&Message::ProbeRes {
52        subtree_hash: ContentHash([7; 32]),
53        probe: None,
54    });
55}
56
57#[test]
58fn fetch_roundtrip() {
59    roundtrip(&Message::Fetch {
60        hash: ContentHash([3; 32]),
61    });
62}
63
64#[test]
65fn deliver_roundtrip() {
66    let stored = StoredNode {
67        kind: "function_item".to_string(),
68        field_name: Some("body".to_string()),
69        leaf_text: None,
70        children: vec![ContentHash([1; 32]), ContentHash([2; 32])],
71    };
72    roundtrip(&Message::Deliver {
73        hash: ContentHash([99; 32]),
74        stored,
75    });
76}
77
78#[test]
79fn attest_push_roundtrip() {
80    let alice = kp(10);
81    let bob = kp(20);
82    let attestations = vec![
83        Attestation::create(&alice, ContentHash([1; 32])),
84        Attestation::create(&bob, ContentHash([2; 32])),
85    ];
86    roundtrip(&Message::AttestPush { attestations });
87}
88
89#[test]
90fn done_roundtrip() {
91    roundtrip(&Message::Done);
92}
93
94#[test]
95fn malformed_bytes_decode_to_error() {
96    let bogus = vec![0xFFu8; 100];
97    assert!(Message::decode(&bogus).is_err());
98}
99
100#[test]
101fn empty_bytes_decode_to_error() {
102    assert!(Message::decode(&[]).is_err());
103}
104
105#[test]
106fn message_decode_after_encode_preserves_signatures() {
107    // El roundtrip de un Hello debe preservar la firma de modo que la
108    // verificación criptográfica del receptor siga funcionando.
109    let k = kp(33);
110    let root = ContentHash([55; 32]);
111    let sig = k.sign(root.as_bytes());
112    let original = Message::Hello {
113        peer_did: k.did(),
114        root_subtree_hash: root,
115        signature: sig,
116    };
117    let bytes = original.encode();
118    let decoded = Message::decode(&bytes).unwrap();
119    let Message::Hello {
120        peer_did,
121        root_subtree_hash,
122        signature,
123    } = decoded
124    else {
125        panic!("variante incorrecta tras decode");
126    };
127    assert!(peer_did.verify(root_subtree_hash.as_bytes(), &signature));
128}