safe-migrate 0.6.0

Sync PostgreSQL metadata, then lint migrations offline
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use crate::analysis::mutations::Mutation;
use crate::analysis::state::MutationResult;
use crate::engine::config::Config;
use crate::report::violations::{ObjectKind, OperationKind, Violation, ViolationTier};
use crate::rules::Rule;

pub struct ConflictRule;

impl ConflictRule {
    const ID: &'static str = "chain-conflict";
    const DEFAULT_TIER: ViolationTier = ViolationTier::Tier1;
    const RECIPE: &'static str = "Correct the migration so this statement can execute against the schema state produced by earlier statements. Use an idempotency guard only when a no-op is intended.";

    fn extract_conflict_reason(result: &MutationResult) -> Option<&str> {
        match result {
            MutationResult::Conflict { reason } => Some(reason.as_str()),
            _ => None,
        }
    }
}

impl Rule for ConflictRule {
    fn id(&self) -> &'static str {
        Self::ID
    }

    fn default_tier(&self) -> ViolationTier {
        Self::DEFAULT_TIER
    }

    fn recipe(&self) -> &'static str {
        Self::RECIPE
    }

    fn evaluate(
        &self,
        _mutation: &Mutation,
        result: &MutationResult,
        _pre_state: &crate::analysis::state::PreState,
        _state: &crate::analysis::state::AnalysisState,
        _config: &Config,
        _cascade_closure: Option<&crate::analysis::state::CascadeResult>,
    ) -> Vec<Violation> {
        match Self::extract_conflict_reason(result) {
            Some(reason) => vec![Violation {
                source_range: None,
                rule_id: Self::ID,
                operation_kind: OperationKind::Conflict,
                object_kind: ObjectKind::Unknown,
                object_name: "<migration-state>".to_string(),
                tier: Self::DEFAULT_TIER,
                reason: format!("Migration chain conflict: {}", reason),
                recipe: Self::RECIPE,
                dedup_key: None,
                sql: None,
                fk_dependency_related: false,
            }],
            None => Vec::new(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::analysis::mutations::Mutation;
    use crate::analysis::state::MutationResult;
    use std::collections::HashMap;

    #[test]
    fn test_conflict_rule_emits_tier1_on_conflict() {
        let rule = ConflictRule;
        let result = MutationResult::Conflict {
            reason:
                "column 'x' already added with type int, this file adds it again with type text"
                    .to_string(),
        };
        let violations = rule.evaluate(
            &Mutation::Opaque(crate::analysis::mutations::OpaqueMutation::DynamicSql),
            &result,
            &crate::analysis::state::PreState {
                relations: HashMap::new(),
                functions: HashMap::new(),
                roles: HashMap::new(),
                publications: HashMap::new(),
                subscriptions: HashMap::new(),
                sequences: HashMap::new(),
                types: HashMap::new(),
                indexes: Vec::new(),
            },
            &crate::analysis::state::AnalysisState::new(crate::db::cache::DbCache::new()),
            &Config::default(),
            None,
        );
        assert_eq!(violations.len(), 1);
        assert_eq!(violations[0].rule_id, "chain-conflict");
        assert_eq!(violations[0].tier, ViolationTier::Tier1);
        assert_eq!(violations[0].object_kind, ObjectKind::Unknown);
        assert_eq!(violations[0].object_name, "<migration-state>");
        assert!(violations[0].reason.contains("Migration chain conflict"));
        assert!(violations[0].recipe.contains("schema state"));
        assert!(!violations[0].recipe.contains("each column"));
    }

    #[test]
    fn test_conflict_rule_silent_on_applied() {
        let rule = ConflictRule;
        let result = MutationResult::Applied;
        let violations = rule.evaluate(
            &Mutation::Opaque(crate::analysis::mutations::OpaqueMutation::DynamicSql),
            &result,
            &crate::analysis::state::PreState {
                relations: HashMap::new(),
                functions: HashMap::new(),
                roles: HashMap::new(),
                publications: HashMap::new(),
                subscriptions: HashMap::new(),
                sequences: HashMap::new(),
                types: HashMap::new(),
                indexes: Vec::new(),
            },
            &crate::analysis::state::AnalysisState::new(crate::db::cache::DbCache::new()),
            &Config::default(),
            None,
        );
        assert!(violations.is_empty());
    }
}