dpm-model 0.1.0

Domain model for DPM execution planning
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

use super::{ExternalLinkRole, ExternalObjectKind, ExternalReference, ExternalState, credentials};
use crate::{Plan, ValidationError, validation::invalid};
use std::collections::{BTreeMap, BTreeSet};

pub(crate) fn validate(plan: &Plan) -> Result<(), ValidationError> {
    let mut identities = BTreeMap::new();
    for (id, reference) in &plan.external_references {
        if *id != reference.id {
            return Err(invalid(
                "external reference",
                id,
                format!("map key differs from value id {}", reference.id),
            ));
        }
        reference.identity.validate(*id)?;
        if let Some(previous) = identities.insert(reference.identity.object_key(), id) {
            return Err(invalid(
                "external reference",
                id,
                format!(
                    "identity {} is already recorded as {previous}",
                    reference.identity
                ),
            ));
        }
        validate_display(reference)?;
        validate_links(plan, reference)?;
    }
    Ok(())
}

fn validate_display(reference: &ExternalReference) -> Result<(), ValidationError> {
    let id = reference.id;
    if reference.label.trim().is_empty() {
        return Err(invalid("external reference", id, "label must not be empty"));
    }
    credentials::check_text(&reference.label)
        .map_err(|reason| invalid("external reference label", id, reason))?;
    if let Some(url) = &reference.url {
        credentials::check_url(url, &reference.identity)
            .map_err(|reason| invalid("external reference url", id, reason))?;
    }
    if let Some(observation) = &reference.observation {
        if observation.observed_by.name.trim().is_empty() {
            return Err(invalid("external observation", id, "actor is required"));
        }
        if observation.state == ExternalState::Merged
            && reference.identity.kind != ExternalObjectKind::PullRequest
        {
            return Err(invalid(
                "external observation",
                id,
                "only pull requests can be merged",
            ));
        }
    }
    Ok(())
}

fn validate_links(plan: &Plan, reference: &ExternalReference) -> Result<(), ValidationError> {
    let id = reference.id;
    if reference.links.is_empty() {
        return Err(invalid(
            "external reference",
            id,
            "a reference needs at least one work link; unlinking the last link removes it",
        ));
    }
    let mut works = BTreeSet::new();
    for link in &reference.links {
        if !plan.work_items.contains_key(&link.work) {
            return Err(invalid(
                "external link",
                id,
                format!("missing work {}", link.work),
            ));
        }
        if !works.insert(link.work) {
            return Err(invalid(
                "external link",
                id,
                format!("work {} is linked more than once", link.work),
            ));
        }
    }
    let trackers = reference
        .links
        .iter()
        .filter(|link| link.role == ExternalLinkRole::Tracks)
        .count();
    if trackers > 1 {
        return Err(invalid(
            "external link",
            id,
            format!(
                "{} has {trackers} tracking owners; one work item may track it",
                reference.identity
            ),
        ));
    }
    Ok(())
}