thing-service 0.5.0

Thing Service - A thing administration microservice that interoperates with the thing-matcher crate
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

use crate::models::identifier::ThingIdentifier;

/// Best-pair identifier similarity.
///
/// Returns 1.0 if any (`property_id`, `value`) pair matches across the
/// two identifier lists; 0.0 otherwise. Empty input on either side
/// returns 0.0.
pub fn identifier_similarity(a: &[ThingIdentifier], b: &[ThingIdentifier]) -> f64 {
    if a.is_empty() || b.is_empty() {
        return 0.0;
    }
    for id_a in a {
        for id_b in b {
            if id_a.property_id == id_b.property_id && id_a.value == id_b.value {
                return 1.0;
            }
        }
    }
    0.0
}

/// True if the two identifier sets share at least one *deterministic*
/// identifier (DOI, ISBN, ISSN, GTIN, MPN, serial number, or UUID).
///
/// Deterministic identifiers are globally unique by construction, so a
/// match short-circuits scoring to 1.0.
pub fn has_deterministic_match(a: &[ThingIdentifier], b: &[ThingIdentifier]) -> bool {
    for id_a in a.iter().filter(|i| i.is_deterministic()) {
        for id_b in b.iter().filter(|i| i.is_deterministic()) {
            if id_a.property_id == id_b.property_id && id_a.value == id_b.value {
                return true;
            }
        }
    }
    false
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::models::identifier::{IdentifierType, ThingIdentifier};

    #[test]
    fn test_matching_isbn() {
        let a = vec![ThingIdentifier::isbn("9780141439518")];
        let b = vec![ThingIdentifier::isbn("9780141439518")];
        assert!((identifier_similarity(&a, &b) - 1.0).abs() < f64::EPSILON);
    }

    #[test]
    fn test_different_isbn() {
        let a = vec![ThingIdentifier::isbn("9780141439518")];
        let b = vec![ThingIdentifier::isbn("9780199536566")];
        assert_eq!(identifier_similarity(&a, &b), 0.0);
    }

    #[test]
    fn test_empty_identifiers() {
        let a: Vec<ThingIdentifier> = vec![];
        let b = vec![ThingIdentifier::isbn("9780141439518")];
        assert_eq!(identifier_similarity(&a, &b), 0.0);
    }

    #[test]
    fn test_mixed_identifiers() {
        let a = vec![
            ThingIdentifier::isbn("9780141439518"),
            ThingIdentifier::new(IdentifierType::Custom("OpenLibrary".into()), "OL1394865W"),
        ];
        let b = vec![ThingIdentifier::new(IdentifierType::Custom("OpenLibrary".into()), "OL1394865W")];
        assert!((identifier_similarity(&a, &b) - 1.0).abs() < f64::EPSILON);
    }

    #[test]
    fn test_has_deterministic_match_isbn() {
        let a = vec![ThingIdentifier::isbn("9780141439518")];
        let b = vec![ThingIdentifier::isbn("9780141439518")];
        assert!(has_deterministic_match(&a, &b));
    }

    #[test]
    fn test_has_deterministic_match_doi() {
        let a = vec![ThingIdentifier::doi("10.1000/xyz123")];
        let b = vec![ThingIdentifier::doi("10.1000/xyz123")];
        assert!(has_deterministic_match(&a, &b));
    }

    #[test]
    fn test_has_deterministic_match_sku_excluded() {
        // SKU is not globally unique, so it must not short-circuit.
        let a = vec![ThingIdentifier::sku("WIDGET-42")];
        let b = vec![ThingIdentifier::sku("WIDGET-42")];
        assert!(!has_deterministic_match(&a, &b));
    }

    #[test]
    fn test_has_deterministic_match_custom_excluded() {
        let a = vec![ThingIdentifier::new(IdentifierType::Custom("Internal".into()), "X1")];
        let b = vec![ThingIdentifier::new(IdentifierType::Custom("Internal".into()), "X1")];
        assert!(!has_deterministic_match(&a, &b));
    }

    #[test]
    fn test_no_match_different_values() {
        let a = vec![ThingIdentifier::isbn("9780141439518")];
        let b = vec![ThingIdentifier::isbn("9780199536566")];
        assert!(!has_deterministic_match(&a, &b));
    }
}