proby 1.0.2

Check whether hosts are reachable on certain ports and return result on HTTP
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

mod utils;

use assert_cmd::prelude::*;
use std::io::Read;
use std::process::Command;
use structopt::clap::{crate_name, crate_version};
use surf;

use utils::{Error, ProbyProcess};

/// Show help and exit.
#[test]
fn help_shows() -> Result<(), Error> {
    Command::cargo_bin("proby")?
        .arg("--help")
        .assert()
        .success();

    Ok(())
}

/// Show version and exit.
#[test]
fn version_shows() -> Result<(), Error> {
    Command::cargo_bin("proby")?
        .arg("-V")
        .assert()
        .success()
        .stdout(format!("{} {}\n", crate_name!(), crate_version!()));

    Ok(())
}

/// If provided with no options, we're shown some basic information on stdout.
#[actix_rt::test]
async fn has_some_output_by_default() -> Result<(), Error> {
    let mut dh = ProbyProcess::new(Vec::<String>::new())?;

    let name_and_version = format!("{} {}\n", crate_name!(), crate_version!());

    let resp_body = surf::get(&dh.url).recv_string().await?;
    assert!(resp_body.contains(&name_and_version));

    dh.child.kill()?;
    let mut output = String::new();
    dh.child
        .stdout
        .as_mut()
        .unwrap()
        .read_to_string(&mut output)?;

    assert!(output.contains(&name_and_version));

    Ok(())
}

/// If we pass --quiet, we get no output.
#[actix_rt::test]
async fn has_quiet_output() -> Result<(), Error> {
    let mut dh = ProbyProcess::new(vec!["--quiet"])?;

    println!("{}", dh.selfcheck());
    assert_eq!(surf::get(&dh.selfcheck()).await?.status(), 200);

    dh.child.kill()?;
    let mut output = String::new();
    dh.child
        .stdout
        .as_mut()
        .unwrap()
        .read_to_string(&mut output)?;

    assert!(output.is_empty());

    Ok(())
}

/// If we pass --verbose, we see every single connection.
#[actix_rt::test]
async fn has_verbose_output() -> Result<(), Error> {
    let mut dh = ProbyProcess::new(vec!["--verbose"])?;

    assert_eq!(surf::get(&dh.selfcheck()).await?.status(), 200);

    dh.child.kill()?;
    let mut output = String::new();
    dh.child
        .stdout
        .as_mut()
        .unwrap()
        .read_to_string(&mut output)?;

    assert!(output.contains("requesting check of"));

    Ok(())
}