netspd 0.1.7

A beautiful, modern, minimalistic network speed testing terminal application
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

//! Tests for the composite connection score.

mod common;

use netspd::app::score::{CompositeScore, ScoreGrade};

#[test]
fn fast_stable_connection_grades_a_plus() {
    let report = common::ReportBuilder::new()
        .download(200.0)
        .upload(80.0)
        .ping(10.0)
        .jitter(1.0)
        .bufferbloat(10.0, 11.0, 12.0) // A+
        .build();

    let score = CompositeScore::compute(&report);
    assert_eq!(score.grade, ScoreGrade::APlus);
    assert!(score.points >= 90, "expected ≥ 90, got {}", score.points);
}

#[test]
fn slow_high_latency_grades_f() {
    let report = common::ReportBuilder::new()
        .download(1.0)
        .upload(0.5)
        .ping(200.0)
        .jitter(30.0)
        .build();

    let score = CompositeScore::compute(&report);
    assert_eq!(score.grade, ScoreGrade::F);
    assert!(score.points < 50, "expected < 50, got {}", score.points);
}

#[test]
fn mid_tier_scores_between_b_and_c() {
    let report = common::ReportBuilder::new()
        .download(25.0)
        .upload(10.0)
        .ping(60.0)
        .jitter(5.0)
        .build();

    let score = CompositeScore::compute(&report);
    assert!(
        matches!(score.grade, ScoreGrade::B | ScoreGrade::C),
        "expected B or C, got {}",
        score.grade.label()
    );
}

#[test]
fn score_without_bufferbloat_stays_within_range() {
    let report = common::ReportBuilder::new()
        .download(100.0)
        .upload(50.0)
        .ping(20.0)
        .jitter(2.0)
        .build(); // no bufferbloat

    let score = CompositeScore::compute(&report);
    assert!(score.points <= 100);
    assert!(
        score.points >= 60,
        "reasonable connection should score ≥ 60"
    );
}

#[test]
fn grade_labels_are_correct() {
    assert_eq!(ScoreGrade::APlus.label(), "A+");
    assert_eq!(ScoreGrade::A.label(), "A");
    assert_eq!(ScoreGrade::B.label(), "B");
    assert_eq!(ScoreGrade::C.label(), "C");
    assert_eq!(ScoreGrade::D.label(), "D");
    assert_eq!(ScoreGrade::F.label(), "F");
}

#[test]
fn bufferbloat_f_drags_score_down() {
    let without = common::ReportBuilder::new()
        .download(100.0)
        .upload(50.0)
        .ping(20.0)
        .jitter(2.0)
        .build();

    let with_f = common::ReportBuilder::new()
        .download(100.0)
        .upload(50.0)
        .ping(20.0)
        .jitter(2.0)
        .bufferbloat(20.0, 500.0, 600.0) // grade F
        .build();

    let score_without = CompositeScore::compute(&without);
    let score_with = CompositeScore::compute(&with_f);
    assert!(
        score_with.points < score_without.points,
        "F bufferbloat should lower the score"
    );
}