upgate-presentation 0.1.1

Keep globally installed developer tools up to date
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

use upgate_domain::{
    ExecutionSupport, ManagerId, PackageName, PlanItem, PlanItemId, PlanSelection, SelectedItem,
    ToolId, UpdateCandidate, UpdatePlan, UpdateSelectionPolicy, VersionScheme, VersionText,
};
use upgate_execution::{
    ExecutionItemResult, ExecutionReport, ExecutionStatus, ResolvedExecutionTarget,
};
use upgate_presentation::{
    OutputTheme, ThemeOptions, apply_execution_report_table, render_batch_table,
    theme::TerminalCapabilities,
};

fn version(value: &str) -> VersionText {
    VersionText::new(value).expect("valid version")
}

fn manager_id() -> ManagerId {
    ManagerId::new("npm").expect("valid manager id")
}

fn update_item(package: &str) -> PlanItem {
    PlanItem::Update {
        id: PlanItemId::new(format!("npm:{package}")).expect("valid plan item id"),
        candidate: UpdateCandidate::new(
            ToolId::new(package).expect("valid tool id"),
            PackageName::new(package).expect("valid package name"),
            version("1.0.0"),
            version("2.0.0"),
            VersionScheme::SemVer,
            ExecutionSupport::exact_only(),
        ),
    }
}

fn theme(verbose: bool) -> OutputTheme {
    OutputTheme::from_terminal(
        ThemeOptions {
            plain: true,
            verbose,
            ..ThemeOptions::default()
        },
        TerminalCapabilities {
            stdout_is_tty: false,
            no_color_env: false,
            term_is_dumb: false,
        },
    )
}

#[test]
fn apply_output_only_shows_selected_results_unless_verbose() {
    let plan = UpdatePlan::new(
        manager_id(),
        vec![
            update_item("applied"),
            update_item("failed"),
            update_item("not-selected"),
        ],
    )
    .expect("valid plan");
    let selection = PlanSelection::new(
        &plan,
        vec![
            SelectedItem::recommended(PlanItemId::new("npm:applied").expect("valid plan item id")),
            SelectedItem::recommended(PlanItemId::new("npm:failed").expect("valid plan item id")),
        ],
        UpdateSelectionPolicy::include_all(),
    )
    .expect("valid selection");
    let report = ExecutionReport {
        manager_id: manager_id(),
        items: vec![
            ExecutionItemResult {
                plan_item_id: PlanItemId::new("npm:applied").expect("valid plan item id"),
                package_name: PackageName::new("applied").expect("valid package name"),
                installed_version: version("1.0.0"),
                target: ResolvedExecutionTarget::Known(version("2.0.0")),
                status: ExecutionStatus::Succeeded {
                    command: "npm update applied".to_owned(),
                    skipped_mutation: false,
                },
            },
            ExecutionItemResult {
                plan_item_id: PlanItemId::new("npm:failed").expect("valid plan item id"),
                package_name: PackageName::new("failed").expect("valid package name"),
                installed_version: version("1.0.0"),
                target: ResolvedExecutionTarget::Known(version("2.0.0")),
                status: ExecutionStatus::Failed {
                    command: "npm update failed".to_owned(),
                    detail: "command failed".to_owned(),
                },
            },
        ],
    };
    let table = apply_execution_report_table(&report, &plan, &selection);

    let normal = render_batch_table(&table, theme(false));
    assert!(normal.contains("applied"));
    assert!(normal.contains("failed"));
    assert!(!normal.contains("not-selected"));

    let verbose = render_batch_table(&table, theme(true));
    assert!(verbose.contains("applied"));
    assert!(verbose.contains("failed"));
    assert!(verbose.contains("not-selected"));
    assert!(verbose.contains("Skipped"));
}

#[test]
fn apply_output_only_reports_an_empty_selection_when_verbose() {
    let plan = UpdatePlan::new(manager_id(), Vec::new()).expect("valid plan");
    let selection = PlanSelection::new(&plan, Vec::new(), UpdateSelectionPolicy::include_all())
        .expect("valid selection");
    let report = ExecutionReport {
        manager_id: manager_id(),
        items: Vec::new(),
    };
    let table = apply_execution_report_table(&report, &plan, &selection);

    assert!(render_batch_table(&table, theme(false)).is_empty());

    let verbose = render_batch_table(&table, theme(true));
    assert!(verbose.contains("Current"));
    assert!(verbose.contains("no selected updates"));
}