zakura 1.0.4

Zakura, an independent, consensus-compatible implementation of a Zcash node
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

//! Testing the end of support feature.

#![allow(clippy::unwrap_in_result)]

use std::time::Duration;

use color_eyre::eyre::Result;

use zakura_chain::{block::Height, chain_tip::mock::MockChainTip, parameters::Network};
use zakurad::components::sync::end_of_support::{
    self, EOS_PANIC_AFTER, EOS_WARN_AFTER, EOS_WARN_MESSAGE_HEADER, ESTIMATED_RELEASE_HEIGHT,
};

// Estimated blocks per day with the current 75 seconds block spacing.
const ESTIMATED_BLOCKS_PER_DAY: u32 = 1152;

/// Test that the `end_of_support` function is working as expected.
#[test]
#[should_panic(expected = "Zakura refuses to run if the release date is older than")]
fn end_of_support_panic() {
    // We are in panic
    let panic = ESTIMATED_RELEASE_HEIGHT + (EOS_PANIC_AFTER * ESTIMATED_BLOCKS_PER_DAY) + 1;

    end_of_support::check(Height(panic), &Network::Mainnet);
}

/// Test that the `end_of_support` function is working as expected.
#[test]
#[tracing_test::traced_test]
fn end_of_support_function() {
    // We are away from warn or panic
    let no_warn = ESTIMATED_RELEASE_HEIGHT + (EOS_PANIC_AFTER * ESTIMATED_BLOCKS_PER_DAY)
        - (30 * ESTIMATED_BLOCKS_PER_DAY);

    end_of_support::check(Height(no_warn), &Network::Mainnet);
    assert!(logs_contain(
        "Checking if Zakura release is inside support range ..."
    ));
    assert!(logs_contain("Zakura release is supported"));

    // We are in warn range
    let warn = ESTIMATED_RELEASE_HEIGHT + (EOS_WARN_AFTER * ESTIMATED_BLOCKS_PER_DAY) + 1;

    end_of_support::check(Height(warn), &Network::Mainnet);
    assert!(logs_contain(
        "Checking if Zakura release is inside support range ..."
    ));
    assert!(logs_contain(
        "Your Zakura release is too old and it will stop running at block"
    ));

    // Panic is tested in `end_of_support_panic`
}

/// Test that we are never in end of support warning or panic.
#[test]
#[tracing_test::traced_test]
fn end_of_support_date() {
    // Get the list of checkpoints.
    let list = Network::Mainnet.checkpoint_list();

    // Get the last one we have and use it as tip.
    let higher_checkpoint = list.max_height();

    end_of_support::check(higher_checkpoint, &Network::Mainnet);
    assert!(logs_contain(
        "Checking if Zakura release is inside support range ..."
    ));
    assert!(!logs_contain(EOS_WARN_MESSAGE_HEADER));
}

/// Check that the end of support task is working.
#[tokio::test(start_paused = true)]
#[tracing_test::traced_test]
async fn end_of_support_task() -> Result<()> {
    let (latest_chain_tip, latest_chain_tip_sender) = MockChainTip::new();
    latest_chain_tip_sender.send_best_tip_height(Height(10));

    let eos_future = end_of_support::start(Network::Mainnet, latest_chain_tip);

    tokio::time::timeout(Duration::from_secs(15), eos_future)
        .await
        .expect_err(
            "end of support task unexpectedly exited: it should keep running until Zakura exits",
        );

    assert!(logs_contain(
        "Checking if Zakura release is inside support range ..."
    ));

    assert!(logs_contain("Zakura release is supported"));

    Ok(())
}