qudag-cli 0.5.0

Command-line interface for QuDAG - Manage nodes, peers, dark addresses, rUv token exchange, and business plan payouts
Documentation 
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use proptest::prelude::*;
use qudag_cli::cli::Args;
use std::net::{IpAddr, SocketAddr};
use std::str::FromStr;

fn is_valid_socket_addr(s: &str) -> bool {
    SocketAddr::from_str(s).is_ok()
}

fn is_valid_toml_file(path: &str) -> bool {
    path.ends_with(".toml") && !path.contains("..") && !path.contains('/')
}

fn is_valid_log_level(level: &str) -> bool {
    matches!(level, "error" | "warn" | "info" | "debug" | "trace")
}

proptest! {
    #[test]
    fn test_valid_bind_address(ip in r"[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}", port in 1024u16..65535u16) {
        let addr = format!("{}:{}", ip, port);
        let args = Args::try_parse_from(&[
            "qudag",
            "node",
            "start",
            "--config",
            "config.toml",
            "--bind",
            &addr
        ]);

        // Test will fail until Args struct is implemented
        prop_assert!(args.is_ok());
        let args = args.unwrap();
        prop_assert!(is_valid_socket_addr(&args.bind.unwrap()));
    }

    #[test]
    fn test_valid_peer_addresses(
        peers in prop::collection::vec(
            r"[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}:[0-9]{4,5}",
            1..10
        )
    ) {
        let peer_list = peers.join(",");
        let args = Args::try_parse_from(&[
            "qudag",
            "node",
            "start",
            "--config",
            "config.toml",
            "--peers",
            &peer_list
        ]);

        // Test will fail until Args struct is implemented
        prop_assert!(args.is_ok());
        let args = args.unwrap();
        for peer in args.peers.unwrap() {
            prop_assert!(is_valid_socket_addr(&peer));
        }
    }

    #[test]
    fn test_valid_config_paths(path in r"[a-zA-Z0-9_-]+\.toml") {
        let args = Args::try_parse_from(&[
            "qudag",
            "node",
            "start",
            "--config",
            &path
        ]);

        // Test will fail until Args struct is implemented
        prop_assert!(args.is_ok());
        let args = args.unwrap();
        prop_assert!(is_valid_toml_file(&args.config.unwrap()));
    }

    #[test]
    fn test_valid_log_levels(level in prop::sample::select(&["error", "warn", "info", "debug", "trace"])) {
        let args = Args::try_parse_from(&[
            "qudag",
            "node",
            "start",
            "--config",
            "config.toml",
            "--log-level",
            &level
        ]);

        // Test will fail until Args struct is implemented
        prop_assert!(args.is_ok());
        let args = args.unwrap();
        prop_assert!(is_valid_log_level(&args.log_level.unwrap()));
    }
}

#[test]
fn test_multiple_valid_combinations() {
    proptest!(|(
        bind_addr in r"[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}:[0-9]{4,5}",
        config in r"[a-zA-Z0-9_-]+\.toml",
        level in prop::sample::select(&["error", "warn", "info", "debug", "trace"])
    )| {
        let args = Args::try_parse_from(&[
            "qudag",
            "node",
            "start",
            "--config",
            &config,
            "--bind",
            &bind_addr,
            "--log-level",
            &level
        ]);

        // Test will fail until Args struct is implemented
        prop_assert!(args.is_ok());
        let args = args.unwrap();
        prop_assert!(is_valid_socket_addr(&args.bind.unwrap()));
        prop_assert!(is_valid_toml_file(&args.config.unwrap()));
        prop_assert!(is_valid_log_level(&args.log_level.unwrap()));
    });
}

#[test]
fn test_invalid_combinations() {
    proptest!(|(
        bind_addr in r"[a-zA-Z]+:[0-9]+",  // Invalid IP format
        config in r"[a-zA-Z0-9_-]+\.txt",  // Invalid file extension
        level in r"[A-Z]+"  // Invalid log level
    )| {
        let args = Args::try_parse_from(&[
            "qudag",
            "node",
            "start",
            "--config",
            &config,
            "--bind",
            &bind_addr,
            "--log-level",
            &level
        ]);

        // Test will fail until Args struct is implemented with proper validation
        prop_assert!(args.is_err());
    });
}