dpm-interchange 0.1.0

Bounded project-file interchange for reviewed DPM plan proposals
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

use crate::mspdi::tests::{import, link, outline_document, work, workspace};
use crate::{DependencyChange, LinkOutcome};
use dpm_model::DependencyKind;

#[test]
fn duplicate_links_report_the_merged_lag() {
    let plan = workspace();
    // Spec -> Build FS twice: 0 h and 1 h elapsed; one dependency carries the larger lag.
    let result = import(
        &plan,
        &outline_document(&[link(2, 1, 0, 7), link(2, 1, 600, 6)].concat()),
    );
    let spec = work(&result.candidate, "MSP-2").id;
    let build = work(&result.candidate, "MSP-5").id;
    let merged: Vec<_> = result
        .candidate
        .dependencies
        .iter()
        .filter(|d| d.predecessor == spec && d.successor == build)
        .collect();
    assert_eq!(merged.len(), 1);
    assert_eq!(
        (merged[0].kind, merged[0].lag_hours),
        (DependencyKind::FinishStart, 1.0)
    );
    let (smaller, larger) = (&result.report.links[2], &result.report.links[3]);
    assert_eq!(smaller.dependencies, [merged[0].id]);
    assert_eq!(larger.dependencies, [merged[0].id]);
    assert_eq!(smaller.outcome, LinkOutcome::Approximated);
    assert!(
        smaller
            .notes
            .iter()
            .any(|n| n.contains("FS MSP-2 -> MSP-5") && n.contains("1 h")),
        "{smaller:?}"
    );
    assert_eq!(larger.outcome, LinkOutcome::Preserved);
    assert!(
        larger.notes.iter().any(|n| n.contains("another link")),
        "{larger:?}"
    );
}

#[test]
fn changed_local_lags_and_dropped_edges_are_reported() {
    let current = import(&workspace(), &outline_document(&link(2, 1, 0, 7))).candidate;
    // Review -> Approved lag 2 h becomes 1 h; Spec -> Build disappears from the source.
    let edited = outline_document("").replace(&link(3, 1, 1200, 6), &link(3, 1, 600, 6));
    let result = import(&current, &edited);
    let review = &result.report.links[1];
    assert_eq!(review.outcome, LinkOutcome::Changed);
    assert!(
        review
            .notes
            .iter()
            .any(|n| n.contains("changes the local lag 2 h to 1 h")),
        "{review:?}"
    );
    let removed = &result.report.removed_dependencies;
    assert_eq!(removed.len(), 1);
    assert_eq!(
        (
            removed[0].predecessor.0.as_str(),
            removed[0].successor.0.as_str()
        ),
        ("MSP-2", "MSP-5")
    );
    assert!(
        !result
            .candidate
            .dependencies
            .iter()
            .any(|d| d.id == removed[0].id)
    );
    let unchanged = import(&current, &outline_document(&link(2, 1, 0, 7)));
    assert!(unchanged.report.removed_dependencies.is_empty());
    assert!(
        unchanged
            .report
            .links
            .iter()
            .all(|l| l.notes.is_empty() && l.changes.is_empty())
    );
}

#[test]
fn a_link_that_resets_a_local_lag_is_not_preserved() {
    let current = import(&workspace(), &outline_document("")).candidate;
    // Review -> Approved lag 2 h becomes 0 h.
    let edited = outline_document("").replace(&link(3, 1, 1200, 6), &link(3, 1, 0, 6));
    let result = import(&current, &edited);
    let review = &result.report.links[1];
    assert_eq!(review.outcome, LinkOutcome::Changed, "{review:?}");
    let change = &review.changes[..];
    assert_eq!(
        change,
        [DependencyChange {
            dependency: review.dependencies[0],
            relation: "FS MSP-3 -> MSP-4".into(),
            field: "lag".into(),
            before: "2 h".into(),
            after: "0 h".into(),
        }]
    );
}