cargo-binlist 1.3.1

List all installed binaries with cargo and their versions
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

#![expect(clippy::unwrap_used, reason = "unwrap is used for testing purposes")]
use comfy_table::{Attribute, Cell, Color};
use log::LevelFilter;
use semver::Version;

use crate::{
    cli::{Cli, ListOpts},
    data::{PackageInfo, VersionCheck},
    logic,
};

#[test]
fn test_get_package_infos() {
    let output = r"
cargo-binstall v1.10.18:
    cargo-binstall
cargo-bloat v0.12.1:
    cargo-bloat
cargo-deny v0.16.1:
    cargo-deny
cargo-edit v0.13.0:
    cargo-add
    cargo-rm
    cargo-set-version
    cargo-upgrade
";

    let mut parsed = logic::get_package_infos(output);
    parsed.sort_by(|a, b| a.name.cmp(&b.name));
    assert_eq!(parsed.len(), 4);
    assert_eq!(parsed[0].name, "cargo-binstall");
    assert_eq!(parsed[0].version.to_string(), "1.10.18");
    assert_eq!(parsed[1].name, "cargo-bloat");
    assert_eq!(parsed[1].version.to_string(), "0.12.1");
    assert_eq!(parsed[2].name, "cargo-deny");
    assert_eq!(parsed[2].version.to_string(), "0.16.1");
    assert_eq!(parsed[3].name, "cargo-edit");
    assert_eq!(parsed[3].version.to_string(), "0.13.0");
}

#[test]
fn test_parse_package_line() {
    let line = "tester v1.10.18:";
    let parsed = logic::parse_package_line(line).unwrap();
    assert_eq!(parsed.name, "tester");
    assert_eq!(parsed.version.to_string(), "1.10.18");
}

#[test]
fn test_packageinfo() {
    let mut pkg = PackageInfo::new("serde".to_owned(), Version::new(0, 0, 1));
    let latest = pkg.latest_version().unwrap();
    assert!(latest > pkg.version);
    pkg.set_info(&latest);
    assert_eq!(pkg.info, VersionCheck::NewerAvailable(latest));
}

#[test]
fn test_get_installed_bins() {
    logic::get_installed_bins().unwrap();
}

#[test]
fn test_cli_list() {
    Cli::List(ListOpts {
        filter: LevelFilter::Trace,
        outdated: false,
        uncondensed: false,
    })
    .run()
    .unwrap();
}

#[test]
fn test_cli_update() {
    logic::update(&[], true).unwrap();
}

#[test]
fn test_version_occurrences() {
    let pkgs = vec![
        PackageInfo::new("cargo-binstall".to_owned(), Version::new(1, 10, 18)),
        PackageInfo::new("cargo-bloat".to_owned(), Version::new(0, 12, 1)),
        PackageInfo::new("cargo-deny".to_owned(), Version::new(0, 16, 1)),
        PackageInfo::new("cargo-edit".to_owned(), Version::new(0, 13, 0)),
    ];

    logic::version_occurrences(&pkgs);
}

#[test]
fn test_colored_cell() {
    let local_newer_cell = Cell::new("No Update").add_attribute(Attribute::Dim);
    let cell = VersionCheck::LocalNewer.colored_cell();
    assert_eq!(cell.content(), "No Update");
    assert_eq!(cell, local_newer_cell);

    let newer_available_cell = Cell::new("Update Available (2.0.0)")
        .fg(Color::Green)
        .add_attribute(Attribute::Bold);
    let cell = VersionCheck::NewerAvailable(Version::new(2, 0, 0)).colored_cell();
    assert_eq!(cell.content(), "Update Available (2.0.0)");
    assert_eq!(cell, newer_available_cell);

    let unavailable_cell = Cell::new("Not Available").fg(Color::Red);
    let cell = VersionCheck::UnAvailable.colored_cell();
    assert_eq!(cell.content(), "Not Available");
    assert_eq!(cell, unavailable_cell);

    let up_to_date_cell = Cell::new("Up to date").fg(Color::Blue);
    let cell = VersionCheck::UpToDate.colored_cell();
    assert_eq!(cell.content(), "Up to date");
    assert_eq!(cell, up_to_date_cell);
}