waitup 1.0.1

Wait for TCP ports and HTTP endpoints to be available. Essential for Docker, K8s, and CI/CD pipelines to ensure services are ready before proceeding.
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

#![allow(
    clippy::unwrap_used,
    clippy::expect_used,
    reason = "test code where panics are acceptable"
)]

use std::process::Command;
use tokio::net::TcpListener;

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn successful_tcp_connection() {
        // Start a test server
        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let addr = listener.local_addr().unwrap();

        // Spawn server task
        tokio::spawn(async move {
            let (_stream, _addr) = listener.accept().await.unwrap();
        });

        // Test waitup
        let output = Command::new("./target/debug/waitup")
            .args([
                &format!("127.0.0.1:{}", addr.port()),
                "--timeout",
                "5s",
                "--quiet",
            ])
            .output()
            .expect("Failed to execute waitup");

        assert!(output.status.success());
    }

    #[tokio::test]
    async fn timeout_failure() {
        let output = Command::new("./target/debug/waitup")
            .args(["127.0.0.1:65534", "--timeout", "1s", "--quiet"])
            .output()
            .expect("Failed to execute waitup");

        assert!(!output.status.success());
        assert_eq!(output.status.code(), Some(1));
    }

    #[tokio::test]
    async fn dns_resolution() {
        let output = Command::new("./target/debug/waitup")
            .args(["google.com:80", "--timeout", "10s", "--quiet"])
            .output()
            .expect("Failed to execute waitup");

        assert!(output.status.success());
    }

    #[tokio::test]
    async fn multiple_targets_any() {
        // Start one test server
        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let addr = listener.local_addr().unwrap();

        tokio::spawn(async move {
            let (_stream, _addr) = listener.accept().await.unwrap();
        });

        let output = Command::new("./target/debug/waitup")
            .args([
                &format!("127.0.0.1:{}", addr.port()),
                "127.0.0.1:65534", // This will fail
                "--any",
                "--timeout",
                "5s",
                "--quiet",
            ])
            .output()
            .expect("Failed to execute waitup");

        assert!(output.status.success());
    }

    #[tokio::test]
    async fn command_execution() {
        // Start a test server
        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let addr = listener.local_addr().unwrap();

        tokio::spawn(async move {
            let (_stream, _addr) = listener.accept().await.unwrap();
        });

        let output = Command::new("./target/debug/waitup")
            .args([
                &format!("127.0.0.1:{}", addr.port()),
                "--timeout",
                "5s",
                "--quiet",
                "--",
                "echo",
                "command executed",
            ])
            .output()
            .expect("Failed to execute waitup");

        assert!(output.status.success());
    }

    #[test]
    fn invalid_target_format() {
        let output = Command::new("./target/debug/waitup")
            .args(["invalid-target", "--quiet"])
            .output()
            .expect("Failed to execute waitup");

        assert!(!output.status.success());
        assert_eq!(output.status.code(), Some(2));
    }

    #[test]
    fn invalid_timeout_format() {
        let output = Command::new("./target/debug/waitup")
            .args(["localhost:8080", "--timeout", "invalid", "--quiet"])
            .output()
            .expect("Failed to execute waitup");

        assert!(!output.status.success());
        assert_eq!(output.status.code(), Some(2));
    }
}