sara-core 0.6.0

Core library for Sara - Requirements Knowledge Graph CLI
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

//! Broken reference detection validation rule.

use crate::config::ValidationConfig;
use crate::error::SaraError;
use crate::graph::KnowledgeGraph;
use crate::validation::rule::ValidationRule;

/// Broken reference detection rule.
///
/// Detects broken references in the knowledge graph. A broken reference
/// occurs when an item references another item that does not exist in the graph.
pub struct BrokenReferencesRule;

impl ValidationRule for BrokenReferencesRule {
    fn validate(&self, graph: &KnowledgeGraph, _config: &ValidationConfig) -> Vec<SaraError> {
        let mut errors = Vec::new();

        for item in graph.items() {
            for ref_id in item.all_references() {
                if !graph.contains(ref_id) {
                    errors.push(SaraError::BrokenReference {
                        from: item.id.clone(),
                        to: ref_id.clone(),
                    });
                }
            }
        }

        errors
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::graph::KnowledgeGraphBuilder;
    use crate::model::{ItemId, ItemType, Relationship, RelationshipType};
    use crate::test_utils::{create_test_item, create_test_item_with_relationships};

    #[test]
    fn test_no_broken_refs() {
        let graph = KnowledgeGraphBuilder::new()
            .add_item(create_test_item("SOL-001", ItemType::Solution))
            .add_item(create_test_item_with_relationships(
                "UC-001",
                ItemType::UseCase,
                vec![Relationship::new(
                    ItemId::new_unchecked("SOL-001"),
                    RelationshipType::Refines,
                )],
            ))
            .build()
            .unwrap();

        let rule = BrokenReferencesRule;
        let errors = rule.validate(&graph, &ValidationConfig::default());
        assert!(errors.is_empty());
    }

    #[test]
    fn test_broken_ref_detected() {
        let graph = KnowledgeGraphBuilder::new()
            .add_item(create_test_item_with_relationships(
                "UC-001",
                ItemType::UseCase,
                vec![Relationship::new(
                    ItemId::new_unchecked("SOL-MISSING"),
                    RelationshipType::Refines,
                )],
            ))
            .build()
            .unwrap();

        let rule = BrokenReferencesRule;
        let errors = rule.validate(&graph, &ValidationConfig::default());
        assert_eq!(errors.len(), 1);

        if let SaraError::BrokenReference { from, to, .. } = &errors[0] {
            assert_eq!(from.as_str(), "UC-001");
            assert_eq!(to.as_str(), "SOL-MISSING");
        } else {
            panic!("Expected BrokenReference error");
        }
    }
}