use super::{CallError, CallPacket, CallRequest};
use crate::link_handshake::{LinkHandshake, LocalMachine, NOISE_OVERHEAD};
use liminal::protocol::{CausalContext, Frame, MessageEnvelope, ProtocolVersion, SchemaId};
use liminal_protocol::credential::WireCredential;
use lys_core::keys::Ed25519Identity;
use zeroize::Zeroizing;
type TestResult = Result<(), Box<dyn std::error::Error>>;
fn request() -> Result<CallRequest, CallError> {
let frames = [
Frame::Connect {
flags: 0,
min_version: ProtocolVersion::new(1, 0),
max_version: ProtocolVersion::new(1, 3),
auth_token: WireCredential::lys_record(b"private-credential"),
},
Frame::ConversationOpen {
flags: 0,
stream_id: 2,
conversation_id: 7,
subject: "embed.bge".into(),
},
Frame::ConversationMessage {
flags: liminal::protocol::CONVERSATION_REPLY_REQUESTED_FLAG,
stream_id: 2,
conversation_id: 7,
envelope: MessageEnvelope::new(
SchemaId::new([0; 32]),
CausalContext::independent(),
b"private-payload".to_vec(),
),
},
];
CallRequest::new(1, "embed.bge".into(), &frames, 4096)
}
#[test]
fn the_original_request_crosses_the_real_noise_session_and_debug_exposes_no_bytes() -> TestResult {
let first = LocalMachine::new(Ed25519Identity::from_seed(&Zeroizing::new([1; 32])));
let second = LocalMachine::new(Ed25519Identity::from_seed(&Zeroizing::new([2; 32])));
let mut initiator = LinkHandshake::initiator(&first, second.machine())?;
let mut responder = LinkHandshake::responder(&second, first.machine())?;
let mut bytes = [0; NOISE_OVERHEAD];
let length = initiator.write(&mut bytes)?;
responder.read(&bytes[..length])?;
let length = responder.write(&mut bytes)?;
initiator.read(&bytes[..length])?;
let mut sending = initiator.finish()?;
let mut receiving = responder.finish()?;
let original = request()?;
let debug = format!("{original:?}");
assert!(!debug.contains("private-credential") && !debug.contains("private-payload"));
let expected = original.wire_bytes().to_vec();
let sealed = CallPacket::Request(original).seal(&mut sending, 4096)?;
let CallPacket::Request(received) = CallPacket::open(&mut receiving, &sealed, 4096)? else {
return Err("Noise packet changed kind".into());
};
assert!(
received.wire_bytes() == expected,
"original credential or request wire changed"
);
assert_eq!(received.correlation()?, (2, 7));
Ok(())
}
#[test]
fn an_oversize_or_trailing_call_body_is_refused_before_dispatch() -> TestResult {
let packet = CallPacket::Request(request()?);
assert!(matches!(packet.encode(1), Err(CallError::Bound)));
let mut encoded = packet.encode(4096)?;
encoded.push(0);
assert!(matches!(
CallPacket::decode(&encoded, 4096),
Err(CallError::Invalid)
));
Ok(())
}