Add case

Author: owjs3901

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

@@ -426,4 +426,24 @@ mod tests {
         let result = cmd_diff();
         assert!(result.is_ok());
     }
+
+    #[test]
+    fn test_constraint_display_unnamed_index() {
+        let constraint = TableConstraint::Index {
+            name: None,
+            columns: vec!["email".into(), "username".into()],
+        };
+        let display = format_constraint_type(&constraint);
+        assert_eq!(display, "INDEX (email, username)");
+    }
+
+    #[test]
+    fn test_constraint_display_named_index() {
+        let constraint = TableConstraint::Index {
+            name: Some("ix_users_email".into()),
+            columns: vec!["email".into()],
+        };
+        let display = format_constraint_type(&constraint);
+        assert_eq!(display, "ix_users_email INDEX (email)");
+    }
 }

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

@@ -228,4 +228,54 @@ mod tests {
         let result = cmd_log(DatabaseBackend::Sqlite);
         assert!(result.is_ok());
     }
+
+    #[test]
+    #[serial_test::serial]
+    fn cmd_log_with_multiple_sql_statements() {
+        use vespertide_core::schema::primary_key::PrimaryKeySyntax;
+        use vespertide_core::{ColumnDef, ColumnType, SimpleColumnType};
+
+        let tmp = tempdir().unwrap();
+        let _guard = CwdGuard::new(&tmp.path().to_path_buf());
+
+        let cfg = VespertideConfig::default();
+        write_config(&cfg);
+        fs::create_dir_all(cfg.migrations_dir()).unwrap();
+
+        // Create a migration with ModifyColumnType for SQLite, which generates multiple SQL statements
+        let plan = MigrationPlan {
+            comment: Some("modify column type".into()),
+            created_at: Some("2024-01-01T00:00:00Z".into()),
+            version: 1,
+            actions: vec![
+                MigrationAction::CreateTable {
+                    table: "users".into(),
+                    columns: vec![ColumnDef {
+                        name: "id".into(),
+                        r#type: ColumnType::Simple(SimpleColumnType::Integer),
+                        nullable: false,
+                        default: None,
+                        comment: None,
+                        primary_key: Some(PrimaryKeySyntax::Bool(true)),
+                        unique: None,
+                        index: None,
+                        foreign_key: None,
+                    }],
+                    constraints: vec![],
+                },
+                MigrationAction::ModifyColumnType {
+                    table: "users".into(),
+                    column: "id".into(),
+                    new_type: ColumnType::Simple(SimpleColumnType::BigInt),
+                },
+            ],
+        };
+        let path = cfg.migrations_dir().join("0001_modify_column_type.json");
+        fs::write(path, serde_json::to_string_pretty(&plan).unwrap()).unwrap();
+
+        // SQLite backend will generate multiple SQL statements for ModifyColumnType (table recreation)
+        // This exercises line 84 where sql_statements.len() > 1
+        let result = cmd_log(DatabaseBackend::Sqlite);
+        assert!(result.is_ok());
+    }
 }

crates/vespertide-core/src/action.rs

@@ -228,6 +228,16 @@ mod tests {
         },
         "AddConstraint: users.ix_users__email (INDEX)"
     )]
+    #[case::add_constraint_index_without_name(
+        MigrationAction::AddConstraint {
+            table: "users".into(),
+            constraint: TableConstraint::Index {
+                name: None,
+                columns: vec!["email".into()],
+            },
+        },
+        "AddConstraint: users.INDEX"
+    )]
     #[case::remove_constraint_index_with_name(
         MigrationAction::RemoveConstraint {
             table: "users".into(),
@@ -238,6 +248,16 @@ mod tests {
         },
         "RemoveConstraint: users.ix_users__email (INDEX)"
     )]
+    #[case::remove_constraint_index_without_name(
+        MigrationAction::RemoveConstraint {
+            table: "users".into(),
+            constraint: TableConstraint::Index {
+                name: None,
+                columns: vec!["email".into()],
+            },
+        },
+        "RemoveConstraint: users.INDEX"
+    )]
     #[case::rename_table(
         MigrationAction::RenameTable {
             from: "old_table".into(),

crates/vespertide-planner/src/apply.rs

@@ -869,4 +869,222 @@ mod tests {
             Some(vespertide_core::StrOrBoolOrArray::Bool(true))
         );
     }
+
+    #[test]
+    fn remove_unique_constraint_clears_inline_unique_array() {
+        // Column with inline unique: ["uq_email", "uq_users_email"]
+        let mut col_with_unique = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        col_with_unique.unique = Some(vespertide_core::StrOrBoolOrArray::Array(vec![
+            "uq_email".to_string(),
+            "uq_users_email".to_string(),
+        ]));
+
+        let mut schema = vec![table(
+            "users",
+            vec![col_with_unique],
+            vec![TableConstraint::Unique {
+                name: Some("uq_email".into()),
+                columns: vec!["email".into()],
+            }],
+        )];
+
+        apply_action(
+            &mut schema,
+            &MigrationAction::RemoveConstraint {
+                table: "users".into(),
+                constraint: TableConstraint::Unique {
+                    name: Some("uq_email".into()),
+                    columns: vec!["email".into()],
+                },
+            },
+        )
+        .unwrap();
+
+        // Constraint removed
+        assert!(schema[0].constraints.is_empty());
+        // "uq_email" removed from array, "uq_users_email" remains
+        assert_eq!(
+            schema[0].columns[0].unique,
+            Some(vespertide_core::StrOrBoolOrArray::Array(vec![
+                "uq_users_email".to_string()
+            ]))
+        );
+    }
+
+    #[test]
+    fn remove_unique_constraint_clears_inline_unique_array_last_item() {
+        // Column with inline unique: ["uq_email"] (only one item in array)
+        let mut col_with_unique = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        col_with_unique.unique = Some(vespertide_core::StrOrBoolOrArray::Array(vec![
+            "uq_email".to_string(),
+        ]));
+
+        let mut schema = vec![table(
+            "users",
+            vec![col_with_unique],
+            vec![TableConstraint::Unique {
+                name: Some("uq_email".into()),
+                columns: vec!["email".into()],
+            }],
+        )];
+
+        apply_action(
+            &mut schema,
+            &MigrationAction::RemoveConstraint {
+                table: "users".into(),
+                constraint: TableConstraint::Unique {
+                    name: Some("uq_email".into()),
+                    columns: vec!["email".into()],
+                },
+            },
+        )
+        .unwrap();
+
+        // Constraint removed
+        assert!(schema[0].constraints.is_empty());
+        // Array becomes empty, so unique should be None
+        assert!(schema[0].columns[0].unique.is_none());
+    }
+
+    #[test]
+    fn remove_unique_constraint_clears_inline_unique_str() {
+        // Column with inline unique: "uq_email"
+        let mut col_with_unique = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        col_with_unique.unique = Some(vespertide_core::StrOrBoolOrArray::Str(
+            "uq_email".to_string(),
+        ));
+
+        let mut schema = vec![table(
+            "users",
+            vec![col_with_unique],
+            vec![TableConstraint::Unique {
+                name: Some("uq_email".into()),
+                columns: vec!["email".into()],
+            }],
+        )];
+
+        apply_action(
+            &mut schema,
+            &MigrationAction::RemoveConstraint {
+                table: "users".into(),
+                constraint: TableConstraint::Unique {
+                    name: Some("uq_email".into()),
+                    columns: vec!["email".into()],
+                },
+            },
+        )
+        .unwrap();
+
+        // Constraint removed
+        assert!(schema[0].constraints.is_empty());
+        // Inline unique cleared
+        assert!(schema[0].columns[0].unique.is_none());
+    }
+
+    #[test]
+    fn remove_foreign_key_constraint_clears_inline_fk() {
+        use vespertide_core::schema::foreign_key::{ForeignKeyDef, ForeignKeySyntax};
+        // Column with inline foreign_key
+        let mut col_with_fk = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
+        col_with_fk.foreign_key = Some(ForeignKeySyntax::Object(ForeignKeyDef {
+            ref_table: "users".into(),
+            ref_columns: vec!["id".into()],
+            on_delete: None,
+            on_update: None,
+        }));
+
+        let mut schema = vec![table(
+            "posts",
+            vec![col_with_fk],
+            vec![TableConstraint::ForeignKey {
+                name: Some("fk_posts_user".into()),
+                columns: vec!["user_id".into()],
+                ref_table: "users".into(),
+                ref_columns: vec!["id".into()],
+                on_delete: None,
+                on_update: None,
+            }],
+        )];
+
+        apply_action(
+            &mut schema,
+            &MigrationAction::RemoveConstraint {
+                table: "posts".into(),
+                constraint: TableConstraint::ForeignKey {
+                    name: Some("fk_posts_user".into()),
+                    columns: vec!["user_id".into()],
+                    ref_table: "users".into(),
+                    ref_columns: vec!["id".into()],
+                    on_delete: None,
+                    on_update: None,
+                },
+            },
+        )
+        .unwrap();
+
+        // Constraint removed
+        assert!(schema[0].constraints.is_empty());
+        // Inline foreign_key cleared
+        assert!(schema[0].columns[0].foreign_key.is_none());
+    }
+
+    #[test]
+    fn remove_check_constraint() {
+        let mut schema = vec![table(
+            "users",
+            vec![col("age", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![TableConstraint::Check {
+                name: "check_age".into(),
+                expr: "age >= 18".into(),
+            }],
+        )];
+
+        apply_action(
+            &mut schema,
+            &MigrationAction::RemoveConstraint {
+                table: "users".into(),
+                constraint: TableConstraint::Check {
+                    name: "check_age".into(),
+                    expr: "age >= 18".into(),
+                },
+            },
+        )
+        .unwrap();
+
+        // Constraint removed
+        assert!(schema[0].constraints.is_empty());
+    }
+
+    #[test]
+    fn remove_unnamed_index_single_column() {
+        // Column with inline index: true
+        let mut col_with_index = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        col_with_index.index = Some(vespertide_core::StrOrBoolOrArray::Bool(true));
+
+        let mut schema = vec![table(
+            "users",
+            vec![col_with_index],
+            vec![TableConstraint::Index {
+                name: None,
+                columns: vec!["email".into()],
+            }],
+        )];
+
+        apply_action(
+            &mut schema,
+            &MigrationAction::RemoveConstraint {
+                table: "users".into(),
+                constraint: TableConstraint::Index {
+                    name: None,
+                    columns: vec!["email".into()],
+                },
+            },
+        )
+        .unwrap();
+
+        // Constraint removed
+        assert!(schema[0].constraints.is_empty());
+        // Inline index cleared
+        assert!(schema[0].columns[0].index.is_none());
+    }
 }