faultline_diff 0.1.0

Diff and change classification contracts for FaultLine.
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

use chrono::{DateTime, Utc};
use faultline_core::{ChangeEvent, DatasetSnapshot};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct DiffRequest {
    pub left: String,
    pub right: String,
    pub layer: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct DiffSummary {
    pub diff_id: Uuid,
    pub added: u64,
    pub removed: u64,
    pub changed: u64,
}

impl DiffSummary {
    pub fn empty() -> Self {
        Self {
            diff_id: Uuid::new_v4(),
            added: 0,
            removed: 0,
            changed: 0,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum DiffClassification {
    Deterministic,
    NoChanges,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct SnapshotState {
    pub snapshot: DatasetSnapshot,
    pub features: Vec<faultline_core::FeatureRef>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct DiffArtifact {
    pub artifact_id: Uuid,
    pub generated_at: DateTime<Utc>,
    pub classification: DiffClassification,
    pub left_snapshot_id: Uuid,
    pub right_snapshot_id: Uuid,
    pub summary: DiffSummary,
    pub change_events: Vec<ChangeEvent>,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn summary_empty_starts_at_zero() {
        let summary = DiffSummary::empty();

        assert_eq!(summary.added, 0);
        assert_eq!(summary.removed, 0);
        assert_eq!(summary.changed, 0);
    }

    #[test]
    fn diff_artifact_round_trip_serialization() {
        let snapshot = DatasetSnapshot::new("roads");
        let summary = DiffSummary::empty();
        let artifact = DiffArtifact {
            artifact_id: Uuid::new_v4(),
            generated_at: Utc::now(),
            classification: DiffClassification::NoChanges,
            left_snapshot_id: snapshot.snapshot_id,
            right_snapshot_id: snapshot.snapshot_id,
            summary,
            change_events: Vec::new(),
        };

        let json = serde_json::to_string(&artifact).expect("serialize artifact");
        let restored: DiffArtifact = serde_json::from_str(&json).expect("deserialize artifact");

        assert_eq!(restored.classification, DiffClassification::NoChanges);
        assert!(restored.change_events.is_empty());
    }
}