dpm-engine 0.1.0

Command/query execution engine for DPM
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

//! Which records count as typed in after the fact, and how visible their exclusion is.

use super::*;

/// TEST-A claimed at `claimed`, then started at 5 h and submitted `seconds` later, neither
/// backfilled.
fn quick(claimed: f64, seconds: f64) -> Log {
    let mut log = Log::new();
    log.claim("agent:coder", "TEST-A", claimed);
    log.start("agent:coder", "TEST-A", 5.0, None);
    log.submit("agent:coder", "TEST-A", 5.0 + seconds / 3600.0, None);
    log.verify("human:bob", "TEST-A", 6.0);
    log
}

#[test]
fn quick_work_claimed_well_before_is_measured() {
    // Held for five hours before a two-minute start-to-submit: genuinely short work.
    let report = quick(0.0, 120.0).report(7.0);
    let sample = report.estimates.samples.first().expect("sample");
    close(sample.actual_hours, 2.0 / 60.0);
    assert!(report.estimates.excluded.is_empty());
    assert_eq!(report.flow.cycle_time.count, 1);
}

#[test]
fn claim_start_and_submit_in_one_sitting_are_bulk_recorded() {
    let report = quick(5.0 - 60.0 / 3600.0, 120.0).report(7.0);
    let bulk = report.estimates.excluded.first().expect("excluded");
    assert_eq!(
        (bulk.reason, keys(bulk)),
        (ExclusionReason::BulkRecorded, vec!["TEST-A"])
    );
    assert_eq!(report.flow.cycle_time.count, 0);
}

#[test]
fn without_the_claim_in_history_start_and_submit_alone_decide() {
    let mut log = quick(0.0, 120.0);
    // The claim predates the log the store holds.
    log.history.remove(0);
    let report = log.report(7.0);
    let bulk = report.estimates.excluded.first().expect("excluded");
    assert_eq!(bulk.reason, ExclusionReason::BulkRecorded);
}

#[test]
fn a_backfilled_start_is_never_bulk_recorded() {
    let mut log = Log::new();
    log.claim("agent:coder", "TEST-A", 5.0);
    log.start("agent:coder", "TEST-A", 5.0, Some(5.0));
    log.submit(
        "agent:coder",
        "TEST-A",
        5.0 + 60.0 / 3600.0,
        Some(5.0 + 30.0 / 3600.0),
    );
    log.verify("human:bob", "TEST-A", 6.0);
    let report = log.report(7.0);
    // Honest times, only too short to measure.
    let excluded = report.estimates.excluded.first().expect("excluded");
    assert_eq!(excluded.reason, ExclusionReason::NoWorkingTime);
}

#[test]
fn each_executor_group_counts_what_it_left_out() {
    let report = Log::scenario().report(50.0);
    let groups: Vec<_> = report
        .estimates
        .by_executor
        .iter()
        .map(|g| {
            let excluded: Vec<_> = g.excluded.iter().map(|r| (r.reason, r.count)).collect();
            (g.executor, g.samples, excluded)
        })
        .collect();
    assert_eq!(
        groups,
        [
            (ActorKind::Human, 1, vec![(ExclusionReason::Unestimated, 1)]),
            (
                ActorKind::Agent,
                2,
                vec![(ExclusionReason::BulkRecorded, 1)]
            ),
        ]
    );
    let json = serde_json::to_value(&report.estimates.by_executor).expect("json");
    assert_eq!(
        json[1]["excluded"],
        serde_json::json!([{"reason": "bulk_recorded", "count": 1}])
    );
}