Update Removed value

Author: owjs3901

crates/vespertide-cli/src/commands/revision.rs

@@ -1537,4 +1537,168 @@ mod tests {
     fn test_wrap_if_spaces_multiple_spaces() {
         assert_eq!(wrap_if_spaces("a b c".to_string()), "'a b c'");
     }
+
+    // ── enum fill_with tests ───────────────────────────────────────────
+
+    #[test]
+    fn test_collect_enum_fill_with_values_single_removal() {
+        use vespertide_planner::EnumFillWithRequired;
+
+        let missing = vec![EnumFillWithRequired {
+            action_index: 0,
+            table: "orders".to_string(),
+            column: "status".to_string(),
+            removed_values: vec!["cancelled".to_string()],
+            remaining_values: vec!["pending".to_string(), "shipped".to_string()],
+        }];
+
+        // Mock prompt: always select first remaining value
+        let mock_enum = |_prompt: &str, values: &[String]| -> Result<String> {
+            Ok(format!("'{}'", values[0]))
+        };
+
+        let result = collect_enum_fill_with_values(&missing, mock_enum);
+        assert!(result.is_ok());
+        let collected = result.unwrap();
+        assert_eq!(collected.len(), 1);
+        assert_eq!(collected[0].0, 0); // action_index
+        assert_eq!(collected[0].1.get("cancelled"), Some(&"'pending'".to_string()));
+    }
+
+    #[test]
+    fn test_collect_enum_fill_with_values_multiple_removals() {
+        use vespertide_planner::EnumFillWithRequired;
+
+        let missing = vec![EnumFillWithRequired {
+            action_index: 0,
+            table: "orders".to_string(),
+            column: "status".to_string(),
+            removed_values: vec!["cancelled".to_string(), "draft".to_string()],
+            remaining_values: vec!["pending".to_string(), "shipped".to_string()],
+        }];
+
+        // Mock prompt: always select second remaining value
+        let mock_enum = |_prompt: &str, values: &[String]| -> Result<String> {
+            Ok(format!("'{}'", values[1]))
+        };
+
+        let result = collect_enum_fill_with_values(&missing, mock_enum);
+        assert!(result.is_ok());
+        let collected = result.unwrap();
+        assert_eq!(collected[0].1.len(), 2);
+        assert_eq!(collected[0].1.get("cancelled"), Some(&"'shipped'".to_string()));
+        assert_eq!(collected[0].1.get("draft"), Some(&"'shipped'".to_string()));
+    }
+
+    #[test]
+    fn test_apply_enum_fill_with_to_plan() {
+        use vespertide_core::{ColumnType, ComplexColumnType, EnumValues};
+
+        let mut plan = MigrationPlan {
+            id: String::new(),
+            comment: None,
+            created_at: None,
+            version: 2,
+            actions: vec![MigrationAction::ModifyColumnType {
+                table: "orders".into(),
+                column: "status".into(),
+                new_type: ColumnType::Complex(ComplexColumnType::Enum {
+                    name: "order_status".into(),
+                    values: EnumValues::String(vec!["pending".into(), "shipped".into()]),
+                }),
+                fill_with: None,
+            }],
+        };
+
+        let mut mappings = BTreeMap::new();
+        mappings.insert("cancelled".to_string(), "'pending'".to_string());
+        let collected = vec![(0usize, mappings)];
+
+        apply_enum_fill_with_to_plan(&mut plan, &collected);
+
+        if let MigrationAction::ModifyColumnType { fill_with, .. } = &plan.actions[0] {
+            let fw = fill_with.as_ref().expect("fill_with should be set");
+            assert_eq!(fw.get("cancelled"), Some(&"'pending'".to_string()));
+        } else {
+            panic!("Expected ModifyColumnType");
+        }
+    }
+
+    #[test]
+    fn test_handle_missing_enum_fill_with_collects_and_applies() {
+        use vespertide_core::{ColumnDef, ColumnType, ComplexColumnType, EnumValues};
+
+        let mut plan = MigrationPlan {
+            id: String::new(),
+            comment: None,
+            created_at: None,
+            version: 2,
+            actions: vec![MigrationAction::ModifyColumnType {
+                table: "orders".into(),
+                column: "status".into(),
+                new_type: ColumnType::Complex(ComplexColumnType::Enum {
+                    name: "order_status".into(),
+                    values: EnumValues::String(vec!["pending".into(), "shipped".into()]),
+                }),
+                fill_with: None,
+            }],
+        };
+
+        let baseline = vec![TableDef {
+            name: "orders".into(),
+            description: None,
+            columns: vec![ColumnDef {
+                name: "status".into(),
+                r#type: ColumnType::Complex(ComplexColumnType::Enum {
+                    name: "order_status".into(),
+                    values: EnumValues::String(vec![
+                        "pending".into(),
+                        "shipped".into(),
+                        "cancelled".into(),
+                    ]),
+                }),
+                nullable: false,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            }],
+            constraints: vec![],
+        }];
+
+        // Mock: always select first remaining value
+        let mock_enum = |_prompt: &str, values: &[String]| -> Result<String> {
+            Ok(format!("'{}'", values[0]))
+        };
+
+        let result = handle_missing_enum_fill_with(&mut plan, &baseline, mock_enum);
+        assert!(result.is_ok());
+
+        if let MigrationAction::ModifyColumnType { fill_with, .. } = &plan.actions[0] {
+            let fw = fill_with.as_ref().expect("fill_with should be populated");
+            assert_eq!(fw.get("cancelled"), Some(&"'pending'".to_string()));
+        } else {
+            panic!("Expected ModifyColumnType");
+        }
+    }
+
+    #[test]
+    fn test_handle_missing_enum_fill_with_no_missing() {
+        let mut plan = MigrationPlan {
+            id: String::new(),
+            comment: None,
+            created_at: None,
+            version: 2,
+            actions: vec![],
+        };
+
+        let mock_enum = |_prompt: &str, _values: &[String]| -> Result<String> {
+            panic!("Should not be called when nothing is missing");
+        };
+
+        let result = handle_missing_enum_fill_with(&mut plan, &[], mock_enum);
+        assert!(result.is_ok());
+    }
 }

crates/vespertide-planner/src/validate.rs

@@ -2186,4 +2186,178 @@ mod tests {
             "Bool primary key should not trigger auto_increment validation"
         );
     }
+
+    // ── find_missing_enum_fill_with tests ──────────────────────────────
+
+    fn string_enum(name: &str, values: Vec<&str>) -> ColumnType {
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: name.into(),
+            values: EnumValues::String(values.into_iter().map(|s| s.to_string()).collect()),
+        })
+    }
+
+    #[test]
+    fn find_missing_enum_fill_with_detects_removed_values() {
+        let plan = MigrationPlan {
+            id: String::new(),
+            comment: None,
+            created_at: None,
+            version: 2,
+            actions: vec![MigrationAction::ModifyColumnType {
+                table: "orders".into(),
+                column: "status".into(),
+                new_type: string_enum("order_status", vec!["pending", "shipped"]),
+                fill_with: None,
+            }],
+        };
+        let baseline = vec![table(
+            "orders",
+            vec![col("status", string_enum("order_status", vec!["pending", "shipped", "cancelled"]))],
+            vec![],
+        )];
+
+        let missing = find_missing_enum_fill_with(&plan, &baseline);
+        assert_eq!(missing.len(), 1);
+        assert_eq!(missing[0].table, "orders");
+        assert_eq!(missing[0].column, "status");
+        assert_eq!(missing[0].removed_values, vec!["cancelled"]);
+        assert_eq!(missing[0].remaining_values, vec!["pending", "shipped"]);
+    }
+
+    #[test]
+    fn find_missing_enum_fill_with_ignores_additions_only() {
+        let plan = MigrationPlan {
+            id: String::new(),
+            comment: None,
+            created_at: None,
+            version: 2,
+            actions: vec![MigrationAction::ModifyColumnType {
+                table: "orders".into(),
+                column: "status".into(),
+                new_type: string_enum("order_status", vec!["pending", "shipped", "delivered"]),
+                fill_with: None,
+            }],
+        };
+        let baseline = vec![table(
+            "orders",
+            vec![col("status", string_enum("order_status", vec!["pending", "shipped"]))],
+            vec![],
+        )];
+
+        let missing = find_missing_enum_fill_with(&plan, &baseline);
+        assert!(missing.is_empty(), "Adding values should not trigger fill_with");
+    }
+
+    #[test]
+    fn find_missing_enum_fill_with_skips_already_covered() {
+        let mut fw = std::collections::BTreeMap::new();
+        fw.insert("cancelled".to_string(), "'pending'".to_string());
+
+        let plan = MigrationPlan {
+            id: String::new(),
+            comment: None,
+            created_at: None,
+            version: 2,
+            actions: vec![MigrationAction::ModifyColumnType {
+                table: "orders".into(),
+                column: "status".into(),
+                new_type: string_enum("order_status", vec!["pending", "shipped"]),
+                fill_with: Some(fw),
+            }],
+        };
+        let baseline = vec![table(
+            "orders",
+            vec![col("status", string_enum("order_status", vec!["pending", "shipped", "cancelled"]))],
+            vec![],
+        )];
+
+        let missing = find_missing_enum_fill_with(&plan, &baseline);
+        assert!(missing.is_empty(), "All removed values are covered by fill_with");
+    }
+
+    #[test]
+    fn find_missing_enum_fill_with_reports_partially_covered() {
+        let mut fw = std::collections::BTreeMap::new();
+        fw.insert("cancelled".to_string(), "'pending'".to_string());
+
+        let plan = MigrationPlan {
+            id: String::new(),
+            comment: None,
+            created_at: None,
+            version: 2,
+            actions: vec![MigrationAction::ModifyColumnType {
+                table: "orders".into(),
+                column: "status".into(),
+                new_type: string_enum("order_status", vec!["pending"]),
+                fill_with: Some(fw),
+            }],
+        };
+        let baseline = vec![table(
+            "orders",
+            vec![col("status", string_enum("order_status", vec!["pending", "shipped", "cancelled"]))],
+            vec![],
+        )];
+
+        let missing = find_missing_enum_fill_with(&plan, &baseline);
+        assert_eq!(missing.len(), 1);
+        assert_eq!(missing[0].removed_values, vec!["shipped"], "Only uncovered value should be reported");
+    }
+
+    #[test]
+    fn find_missing_enum_fill_with_ignores_integer_enums() {
+        let old_type = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "priority".into(),
+            values: EnumValues::Integer(vec![
+                NumValue { name: "low".into(), value: 0 },
+                NumValue { name: "high".into(), value: 1 },
+            ]),
+        });
+        let new_type = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "priority".into(),
+            values: EnumValues::Integer(vec![
+                NumValue { name: "high".into(), value: 1 },
+            ]),
+        });
+
+        let plan = MigrationPlan {
+            id: String::new(),
+            comment: None,
+            created_at: None,
+            version: 2,
+            actions: vec![MigrationAction::ModifyColumnType {
+                table: "tasks".into(),
+                column: "priority".into(),
+                new_type,
+                fill_with: None,
+            }],
+        };
+        let baseline = vec![table("tasks", vec![col("priority", old_type)], vec![])];
+
+        let missing = find_missing_enum_fill_with(&plan, &baseline);
+        assert!(missing.is_empty(), "Integer enum changes should not trigger fill_with");
+    }
+
+    #[test]
+    fn find_missing_enum_fill_with_ignores_non_enum_type_change() {
+        let plan = MigrationPlan {
+            id: String::new(),
+            comment: None,
+            created_at: None,
+            version: 2,
+            actions: vec![MigrationAction::ModifyColumnType {
+                table: "users".into(),
+                column: "age".into(),
+                new_type: ColumnType::Simple(SimpleColumnType::BigInt),
+                fill_with: None,
+            }],
+        };
+        let baseline = vec![table(
+            "users",
+            vec![col("age", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+        )];
+
+        let missing = find_missing_enum_fill_with(&plan, &baseline);
+        assert!(missing.is_empty(), "Non-enum type changes should not trigger fill_with");
+    }
 }