X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fonion_message%2Ffunctional_tests.rs;h=08be1b2c5027d64bdf599faca92f0b2ed510ef5c;hb=a9dcfaf952584ed835d733cb4688d5f96e86349d;hp=fe2b3799e72032524e348776d7d07d28a2f147e0;hpb=7d5dd6b2994752d9f2ae57538a0b25af475ee90d;p=rust-lightning diff --git a/lightning/src/onion_message/functional_tests.rs b/lightning/src/onion_message/functional_tests.rs index fe2b3799..08be1b2c 100644 --- a/lightning/src/onion_message/functional_tests.rs +++ b/lightning/src/onion_message/functional_tests.rs @@ -23,7 +23,7 @@ use super::messenger::{CustomOnionMessageHandler, DefaultMessageRouter, Destinat use super::offers::{OffersMessage, OffersMessageHandler}; use super::packet::{OnionMessageContents, Packet}; -use bitcoin::network::constants::Network; +use bitcoin::network::Network; use bitcoin::hashes::hex::FromHex; use bitcoin::secp256k1::{All, PublicKey, Secp256k1, SecretKey}; @@ -112,16 +112,39 @@ impl Writeable for TestCustomMessage { } struct TestCustomMessageHandler { - expected_messages: Mutex>, + expectations: Mutex>, +} + +struct OnHandleCustomMessage { + expect: TestCustomMessage, + include_reply_path: bool, } impl TestCustomMessageHandler { fn new() -> Self { - Self { expected_messages: Mutex::new(VecDeque::new()) } + Self { expectations: Mutex::new(VecDeque::new()) } } fn expect_message(&self, message: TestCustomMessage) { - self.expected_messages.lock().unwrap().push_back(message); + self.expectations.lock().unwrap().push_back( + OnHandleCustomMessage { + expect: message, + include_reply_path: false, + } + ); + } + + fn expect_message_and_response(&self, message: TestCustomMessage) { + self.expectations.lock().unwrap().push_back( + OnHandleCustomMessage { + expect: message, + include_reply_path: true, + } + ); + } + + fn get_next_expectation(&self) -> OnHandleCustomMessage { + self.expectations.lock().unwrap().pop_front().expect("No expectations remaining") } } @@ -132,25 +155,32 @@ impl Drop for TestCustomMessageHandler { return; } } - assert!(self.expected_messages.lock().unwrap().is_empty()); + assert!(self.expectations.lock().unwrap().is_empty()); } } impl CustomOnionMessageHandler for TestCustomMessageHandler { type CustomMessage = TestCustomMessage; fn handle_custom_message(&self, msg: Self::CustomMessage, responder: Option) -> ResponseInstruction { - match self.expected_messages.lock().unwrap().pop_front() { - Some(expected_msg) => assert_eq!(expected_msg, msg), - None => panic!("Unexpected message: {:?}", msg), - } - let response_option = match msg { - TestCustomMessage::Ping => Some(TestCustomMessage::Pong), - TestCustomMessage::Pong => None, + let expectation = self.get_next_expectation(); + assert_eq!(msg, expectation.expect); + + let response = match msg { + TestCustomMessage::Ping => TestCustomMessage::Pong, + TestCustomMessage::Pong => TestCustomMessage::Ping, }; - if let (Some(response), Some(responder)) = (response_option, responder) { - responder.respond(response) - } else { - ResponseInstruction::NoResponse + + // Sanity check: expecting to include reply path when responder is absent should panic. + if expectation.include_reply_path && responder.is_none() { + panic!("Expected to include a reply_path, but the responder was absent.") + } + + match responder { + Some(responder) if expectation.include_reply_path => { + responder.respond_with_reply_path(response) + }, + Some(responder) => responder.respond(response), + None => ResponseInstruction::NoResponse, } } fn read_custom_message(&self, message_type: u64, buffer: &mut R) -> Result, DecodeError> where Self: Sized { @@ -407,6 +437,73 @@ fn async_response_over_one_blinded_hop() { pass_along_path(&nodes); } +#[test] +fn async_response_with_reply_path_succeeds() { + // Simulate an asynchronous interaction between two nodes, Alice and Bob. + // Create a channel between the two nodes to establish them as announced nodes, + // which allows the creation of the reply_path for successful communication. + + let mut nodes = create_nodes(2); + let alice = &nodes[0]; + let bob = &nodes[1]; + let secp_ctx = Secp256k1::new(); + + add_channel_to_graph(alice, bob, &secp_ctx, 24); + + // Alice receives a message from Bob with an added reply_path for responding back. + let message = TestCustomMessage::Ping; + let path_id = Some([2; 32]); + let reply_path = BlindedPath::new_for_message(&[], bob.node_id, &*bob.entropy_source, &secp_ctx).unwrap(); + + // Alice asynchronously responds to Bob, expecting a response back from him. + let responder = Responder::new(reply_path, path_id); + alice.custom_message_handler.expect_message_and_response(message.clone()); + let response_instruction = alice.custom_message_handler.handle_custom_message(message, Some(responder)); + + assert_eq!( + alice.messenger.handle_onion_message_response(response_instruction), + Ok(Some(SendSuccess::Buffered)), + ); + + // Set Bob's expectation and pass the Onion Message along the path. + bob.custom_message_handler.expect_message(TestCustomMessage::Pong); + pass_along_path(&nodes); + + // Bob responds back to Alice using the reply_path she included with the OnionMessage. + // Set Alice's expectation and reverse the path for the response. + alice.custom_message_handler.expect_message(TestCustomMessage::Ping); + nodes.reverse(); + pass_along_path(&nodes); +} + +#[test] +fn async_response_with_reply_path_fails() { + // Simulate an asynchronous interaction between two unannounced nodes, Alice and Bob. + // Since the nodes are unannounced, attempting to respond using a reply_path + // will fail, leading to an expected failure in communication. + + let nodes = create_nodes(2); + let alice = &nodes[0]; + let bob = &nodes[1]; + let secp_ctx = Secp256k1::new(); + + // Alice receives a message from Bob with an added reply_path for responding back. + let message = TestCustomMessage::Ping; + let path_id = Some([2; 32]); + let reply_path = BlindedPath::new_for_message(&[], bob.node_id, &*bob.entropy_source, &secp_ctx).unwrap(); + + // Alice tries to asynchronously respond to Bob, but fails because the nodes are unannounced. + // Therefore, the reply_path cannot be used for the response. + let responder = Responder::new(reply_path, path_id); + alice.custom_message_handler.expect_message_and_response(message.clone()); + let response_instruction = alice.custom_message_handler.handle_custom_message(message, Some(responder)); + + assert_eq!( + alice.messenger.handle_onion_message_response(response_instruction), + Err(SendError::PathNotFound), + ); +} + #[test] fn too_big_packet_error() { // Make sure we error as expected if a packet is too big to send.