Make field error of LightingError mandatory

[rust-lightning] / src / ln / functional_tests.rs

diff --git a/src/ln/functional_tests.rs b/src/ln/functional_tests.rs
index 611b94f1a42ba26cad27c3d1cd94d2ac8ebe1519..1c1f5d2498741d4253bc4b08b896ab6fabf0883c 100644 (file)
--- a/src/ln/functional_tests.rs
+++ b/src/ln/functional_tests.rs
@@ -70,7 +70,7 @@ fn test_insane_channel_opens() {
        // that supposedly makes the channel open message insane
        let insane_open_helper = |expected_error_str, message_mutator: fn(msgs::OpenChannel) -> msgs::OpenChannel| {
                match nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), LocalFeatures::new(), &message_mutator(open_channel_message.clone())) {
-                       Err(msgs::LightningError{ err: error_str, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) => {
+                       Err(msgs::LightningError{ err: error_str, action: msgs::ErrorAction::SendErrorMessage {..}}) => {
                                assert_eq!(error_str, expected_error_str, "unexpected LightningError string (expected `{}`, actual `{}`)", expected_error_str, error_str)
                        },
                        Err(msgs::LightningError{..}) => {panic!("unexpected LightningError action")},
@@ -952,7 +952,7 @@ fn do_test_shutdown_rebroadcast(recv_count: u8) {
                // transaction.
                assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 
-               if let Err(msgs::LightningError{action: Some(msgs::ErrorAction::SendErrorMessage{msg}), ..}) =
+               if let Err(msgs::LightningError{action: msgs::ErrorAction::SendErrorMessage{msg}, ..}) =
                                nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish) {
                        nodes[0].node.handle_error(&nodes[1].node.get_our_node_id(), &msg);
                        let msgs::ErrorMessage {ref channel_id, ..} = msg;
@@ -3455,7 +3455,7 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() {
        nodes[3].node.peer_connected(&nodes[0].node.get_our_node_id());
        let reestablish = get_event_msg!(nodes[3], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
        nodes[0].node.peer_connected(&nodes[3].node.get_our_node_id());
-       if let Err(msgs::LightningError { action: Some(msgs::ErrorAction::SendErrorMessage { msg }), .. }) = nodes[0].node.handle_channel_reestablish(&nodes[3].node.get_our_node_id(), &reestablish) {
+       if let Err(msgs::LightningError { action: msgs::ErrorAction::SendErrorMessage { msg }, .. }) = nodes[0].node.handle_channel_reestablish(&nodes[3].node.get_our_node_id(), &reestablish) {
                assert_eq!(msg.channel_id, channel_id);
        } else { panic!("Unexpected result"); }
 }
@@ -5101,7 +5101,7 @@ fn test_update_add_htlc_bolt2_receiver_check_amount_received_more_than_min() {
        let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
        updates.update_add_htlcs[0].amount_msat = htlc_minimum_msat-1;
        let err = nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
-       if let Err(msgs::LightningError{err, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) = err {
+       if let Err(msgs::LightningError{err, action: msgs::ErrorAction::SendErrorMessage {..}}) = err {
                assert_eq!(err, "Remote side tried to send less than our minimum HTLC value");
        } else {
                assert!(false);
@@ -5127,7 +5127,7 @@ fn test_update_add_htlc_bolt2_receiver_sender_can_afford_amount_sent() {
        updates.update_add_htlcs[0].amount_msat = 5000000-their_channel_reserve+1;
        let err = nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
 
-       if let Err(msgs::LightningError{err, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) = err {
+       if let Err(msgs::LightningError{err, action: msgs::ErrorAction::SendErrorMessage {..}}) = err {
                assert_eq!(err, "Remote HTLC add would put them over their reserve value");
        } else {
                assert!(false);
@@ -5174,7 +5174,7 @@ fn test_update_add_htlc_bolt2_receiver_check_max_htlc_limit() {
        msg.htlc_id = (super::channel::OUR_MAX_HTLCS) as u64;
        let err = nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
 
-       if let Err(msgs::LightningError{err, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) = err {
+       if let Err(msgs::LightningError{err, action: msgs::ErrorAction::SendErrorMessage {..}}) = err {
                assert_eq!(err, "Remote tried to push more than our max accepted HTLCs");
        } else {
                assert!(false);
@@ -5197,7 +5197,7 @@ fn test_update_add_htlc_bolt2_receiver_check_max_in_flight_msat() {
        updates.update_add_htlcs[0].amount_msat = get_channel_value_stat!(nodes[1], chan.2).their_max_htlc_value_in_flight_msat + 1;
        let err = nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
 
-       if let Err(msgs::LightningError{err, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) = err {
+       if let Err(msgs::LightningError{err, action: msgs::ErrorAction::SendErrorMessage {..}}) = err {
                assert_eq!(err,"Remote HTLC add would put them over our max HTLC value");
        } else {
                assert!(false);
@@ -5220,7 +5220,7 @@ fn test_update_add_htlc_bolt2_receiver_check_cltv_expiry() {
        updates.update_add_htlcs[0].cltv_expiry = 500000000;
        let err = nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
 
-       if let Err(msgs::LightningError{err, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) = err {
+       if let Err(msgs::LightningError{err, action: msgs::ErrorAction::SendErrorMessage {..}}) = err {
                assert_eq!(err,"Remote provided CLTV expiry in seconds instead of block height");
        } else {
                assert!(false);
@@ -5266,7 +5266,7 @@ fn test_update_add_htlc_bolt2_receiver_check_repeated_id_ignore() {
        let _bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 
        let err = nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
-       if let Err(msgs::LightningError{err, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) = err {
+       if let Err(msgs::LightningError{err, action: msgs::ErrorAction::SendErrorMessage {..}}) = err {
                assert_eq!(err, "Remote skipped HTLC ID");
        } else {
                assert!(false);
@@ -5298,7 +5298,7 @@ fn test_update_fulfill_htlc_bolt2_update_fulfill_htlc_before_commitment() {
 
        let err = nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
 
-       if let Err(msgs::LightningError{err, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) = err {
+       if let Err(msgs::LightningError{err, action: msgs::ErrorAction::SendErrorMessage {..}}) = err {
                assert_eq!(err, "Remote tried to fulfill/fail HTLC before it had been committed");
        } else {
                assert!(false);
@@ -5330,7 +5330,7 @@ fn test_update_fulfill_htlc_bolt2_update_fail_htlc_before_commitment() {
 
        let err = nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
 
-       if let Err(msgs::LightningError{err, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) = err {
+       if let Err(msgs::LightningError{err, action: msgs::ErrorAction::SendErrorMessage {..}}) = err {
                assert_eq!(err, "Remote tried to fulfill/fail HTLC before it had been committed");
        } else {
                assert!(false);
@@ -5363,7 +5363,7 @@ fn test_update_fulfill_htlc_bolt2_update_fail_malformed_htlc_before_commitment()
 
        let err = nodes[0].node.handle_update_fail_malformed_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
 
-       if let Err(msgs::LightningError{err, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) = err {
+       if let Err(msgs::LightningError{err, action: msgs::ErrorAction::SendErrorMessage {..}}) = err {
                assert_eq!(err, "Remote tried to fulfill/fail HTLC before it had been committed");
        } else {
                assert!(false);
@@ -5404,7 +5404,7 @@ fn test_update_fulfill_htlc_bolt2_incorrect_htlc_id() {
        update_fulfill_msg.htlc_id = 1;
 
        let err = nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_msg);
-       if let Err(msgs::LightningError{err, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) = err {
+       if let Err(msgs::LightningError{err, action: msgs::ErrorAction::SendErrorMessage {..}}) = err {
                assert_eq!(err, "Remote tried to fulfill/fail an HTLC we couldn't find");
        } else {
                assert!(false);
@@ -5445,7 +5445,7 @@ fn test_update_fulfill_htlc_bolt2_wrong_preimage() {
        update_fulfill_msg.payment_preimage = PaymentPreimage([1; 32]);
 
        let err = nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_msg);
-       if let Err(msgs::LightningError{err, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) = err {
+       if let Err(msgs::LightningError{err, action: msgs::ErrorAction::SendErrorMessage {..}}) = err {
                assert_eq!(err, "Remote tried to fulfill HTLC with an incorrect preimage");
        } else {
                assert!(false);
@@ -5491,7 +5491,7 @@ fn test_update_fulfill_htlc_bolt2_missing_badonion_bit_for_malformed_htlc_messag
        };
        update_msg.failure_code &= !0x8000;
        let err = nodes[0].node.handle_update_fail_malformed_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
-       if let Err(msgs::LightningError{err, action: Some(msgs::ErrorAction::SendErrorMessage {..})}) = err {
+       if let Err(msgs::LightningError{err, action: msgs::ErrorAction::SendErrorMessage {..}}) = err {
                assert_eq!(err, "Got update_fail_malformed_htlc with BADONION not set");
        } else {
                assert!(false);
@@ -5864,14 +5864,12 @@ fn test_upfront_shutdown_script() {
        node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
        // Test we enforce upfront_scriptpbukey if by providing a diffrent one at closing that  we disconnect peer
        if let Err(error) = nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown) {
-               if let Some(error) = error.action {
-                       match error {
-                               ErrorAction::SendErrorMessage { msg } => {
-                                       assert_eq!(msg.data,"Got shutdown request with a scriptpubkey which did not match their previous scriptpubkey");
-                               },
-                               _ => { assert!(false); }
-                       }
-               } else { assert!(false); }
+               match error.action {
+                       ErrorAction::SendErrorMessage { msg } => {
+                               assert_eq!(msg.data,"Got shutdown request with a scriptpubkey which did not match their previous scriptpubkey");
+                       },
+                       _ => { assert!(false); }
+               }
        } else { assert!(false); }
        let events = nodes[2].node.get_and_clear_pending_msg_events();
        assert_eq!(events.len(), 1);
@@ -5981,14 +5979,12 @@ fn test_user_configurable_csv_delay() {
        let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
        accept_channel.to_self_delay = 200;
        if let Err(error) = nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), LocalFeatures::new(), &accept_channel) {
-               if let Some(error) = error.action {
-                       match error {
-                               ErrorAction::SendErrorMessage { msg } => {
-                                       assert_eq!(msg.data,"They wanted our payments to be delayed by a needlessly long period");
-                               },
-                               _ => { assert!(false); }
-                       }
-               } else { assert!(false); }
+               match error.action {
+                       ErrorAction::SendErrorMessage { msg } => {
+                               assert_eq!(msg.data,"They wanted our payments to be delayed by a needlessly long period");
+                       },
+                       _ => { assert!(false); }
+               }
        } else { assert!(false); }
 
        // We test msg.to_self_delay <= config.their_to_self_delay is enforced in Channel::new_from_req()
@@ -6056,14 +6052,12 @@ fn test_data_loss_protect() {
 
        // Check we update monitor following learning of per_commitment_point from B
        if let Err(err) = nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_0[0])  {
-               if let Some(error) = err.action {
-                       match error {
-                               ErrorAction::SendErrorMessage { msg } => {
-                                       assert_eq!(msg.data, "We have fallen behind - we have received proof that if we broadcast remote is going to claim our funds - we can't do any automated broadcasting");
-                               },
-                               _ => panic!("Unexpected event!"),
-                       }
-               } else { assert!(false); }
+               match err.action {
+                       ErrorAction::SendErrorMessage { msg } => {
+                               assert_eq!(msg.data, "We have fallen behind - we have received proof that if we broadcast remote is going to claim our funds - we can't do any automated broadcasting");
+                       },
+                       _ => panic!("Unexpected event!"),
+               }
        } else { assert!(false); }
        check_added_monitors!(nodes[0], 1);
 
@@ -6085,13 +6079,11 @@ fn test_data_loss_protect() {
 
        // Check we close channel detecting A is fallen-behind
        if let Err(err) = nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]) {
-               if let Some(error) = err.action {
-                       match error {
-                               ErrorAction::SendErrorMessage { msg } => {
-                                       assert_eq!(msg.data, "Peer attempted to reestablish channel with a very old local commitment transaction"); },
-                               _ => panic!("Unexpected event!"),
-                       }
-               } else { assert!(false); }
+               match err.action {
+                       ErrorAction::SendErrorMessage { msg } => {
+                               assert_eq!(msg.data, "Peer attempted to reestablish channel with a very old local commitment transaction"); },
+                       _ => panic!("Unexpected event!"),
+               }
        } else { assert!(false); }
 
        let events = nodes[1].node.get_and_clear_pending_msg_events();