test: 잔여 뮤턴트 정리 (rank 공간 치환 + 심링크/PK 테스트)

cargo-mutants 5개 shard에 남아 있던 미검출 뮤턴트를 정리한다.

- sort_delete_tables: slot 공간 대신 rank 공간(0..k)에서 치환을 적용하도록
  재작성. delete_indices는 오름차순이라 rank r과 slot delete_indices[r]이
  순서 동형이므로 `slot - rank_base` 변환과 delete slot 사이의 gap까지
  포괄하던 희소 역인덱스가 통째로 불필요해진다. 이 산술을 겨냥하던 뮤턴트
  5건이 구조적으로 사라지며, 출력은 이전과 바이트 동일하다. 비연속·비-0
  시작 delete run 3건을 permute하는 테스트로 재작성분을 고정했다.

- string_enum_value_removed: 옛 default가 신·구 enum 어디에도 속하지 않으면
  재정렬이 일어나지 않아야 함을 고정. `any(|v| v == needle)`이 `!=`로 뒤집히면
  모든 비-멤버 default를 "제거된 값"으로 오판해 두 액션을 뒤바꾼다.

- collect_model_paths: models/ 안의 파일 심링크는 따라가고 끊어진 심링크는
  건너뛰는 #[cfg(unix)] 테스트 추가. `is_symlink && ...` 두 연접이 `||`로
  바뀌면 각각 파일을 read_dir 하거나 없는 경로를 read_to_string 해 Err가 된다.

- should_skip_sqlite_auto_increment_pk: auto-increment를 지원하지 않는 타입
  (TEXT)에 auto_increment PK를 걸면 SQLite도 명시적 PRIMARY KEY 절을 유지해야
  함을 3-백엔드 스냅샷으로 고정.

- render_migration_name의 `+=` 뮤턴트는 기존 E18(비종료) 범주에 편입.
  `*= 1` / `/= 1`은 항등이라 커서가 루프의 감소 측도이길 멈춰 스캔이
  bytes.len()에 도달하지 못한다.

검증: 위 4개 뮤턴트를 수동 적용해 CAUGHT 확인(심링크 2건은 WSL Linux에서
실행), fmt / test / clippy -D warnings / line-budget 모두 통과.

Author: owjs3901

.cargo/mutants.toml

@@ -183,6 +183,13 @@ exclude_re = [
     "check_expr_parser[.]rs:[0-9]+:[0-9]+: replace < with (<=|==|>) in tokenize_spanned",
     "check_expr_parser[.]rs:[0-9]+:[0-9]+: replace [+]= with (-=|[*]=|/=) in Parser::parse_predicate",
     "layout[.]rs:[0-9]+:[0-9]+: replace [+]= with (-=|[*]=|/=) in rebalance_groups",
+    # Same non-termination class in the migration-filename byte scanner:
+    # `render_migration_name` walks `i` (and the inner width cursor `j`) forward
+    # by 1 or 2 per step. `*= 1` is the identity, and `-=` walks backwards into
+    # an underflow, so either way the cursor stops being the loop's decreasing
+    # measure and the scan never reaches `bytes.len()`. The scanner's comparison
+    # and slice-bound mutants stay in the gate - `%012` and `%06v` cover those.
+    "cli/src/utils[.]rs:[0-9]+:[0-9]+: replace [+]= with (-=|[*]=|/=) in render_migration_name",
     # E19: `String::with_capacity` / `Vec::reserve` sizing arithmetic. These
     # mutants change only how much the buffer pre-allocates; every one of these
     # functions then pushes the same bytes in the same order, so the returned

crates/vespertide-loader/src/models.rs

@@ -214,6 +214,67 @@ mod tests {
         assert_eq!(models[0].name, "users");
     }
 
+    // `DirEntry::file_type()` describes the LINK, never its target, so symlinked
+    // entries fall back to `Path::is_dir` / `Path::is_file`. Three shapes must be
+    // told apart inside `models/`:
+    //   * `order.json`   -> a real file OUTSIDE models/  => loaded
+    //   * `nowhere.json` -> a missing target (dangling)  => skipped
+    //   * `user.json`    -> a plain file                 => loaded
+    // Misreading a file symlink as a directory would `read_dir` a file, and
+    // misreading a dangling symlink as a file would `read_to_string` a path that
+    // does not exist. Both surface as `Err`, so the successful two-table load
+    // pins each `is_symlink && ...` conjunction.
+    #[cfg(unix)]
+    #[test]
+    #[serial]
+    fn load_models_follows_file_symlinks_and_skips_dangling_ones() {
+        use std::os::unix::fs::symlink;
+
+        let tmp = tempdir().unwrap();
+        let _guard = CwdGuard::new(tmp.path());
+        write_default_config("vespertide.json");
+
+        fs::create_dir_all("models").unwrap();
+        fs::create_dir_all("external").unwrap();
+
+        let write_model = |path: &str, name: &str| {
+            let table = TableDef {
+                name: name.into(),
+                description: None,
+                columns: vec![ColumnDef::new(
+                    "id",
+                    ColumnType::Simple(SimpleColumnType::Integer),
+                    false,
+                )],
+                constraints: vec![TableConstraint::PrimaryKey {
+                    auto_increment: false,
+                    columns: vec!["id".into()],
+                    strategy: vespertide_core::PrimaryKeyAdditionStrategy::default(),
+                }],
+            };
+            fs::write(path, serde_json::to_string(&table).unwrap()).unwrap();
+        };
+
+        write_model("models/user.json", "users");
+        write_model("external/order.json", "orders");
+
+        symlink(tmp.path().join("external/order.json"), "models/order.json").unwrap();
+        symlink(
+            tmp.path().join("external/nowhere.json"),
+            "models/nowhere.json",
+        )
+        .unwrap();
+
+        let mut names: Vec<String> = load_models(&VespertideConfig::default())
+            .unwrap()
+            .into_iter()
+            .map(|t| t.name.into_inner())
+            .collect();
+        names.sort();
+
+        assert_eq!(names, ["orders", "users"]);
+    }
+
     #[test]
     #[serial]
     fn load_models_recursive_processes_subdirectories() {

crates/vespertide-planner/src/diff/ordering.rs

@@ -185,45 +185,44 @@ pub(super) fn sort_delete_tables(
     // Reorder the DeleteTable actions among their existing slots according to
     // `sorted_positions`, WITHOUT cloning each action.
     //
-    // `delete_indices` is ascending (it comes from `.enumerate()`). `order[k]`
-    // holds the ORIGINAL slot whose action belongs at the k-th delete slot; the
-    // stable sort keeps equal-position actions in their original relative order,
-    // matching the previous stable `sort_by` byte-for-byte.
-    let mut order: Vec<usize> = delete_indices.clone();
-    order.sort_by_key(|&i| {
-        let name = extract_delete_table_name(&actions[i]);
+    // Everything below works in RANK space (`0..k` over the delete run) rather
+    // than in raw slot space. `delete_indices` is ascending (it comes from
+    // `.enumerate()`), so rank `r` and slot `delete_indices[r]` are
+    // order-isomorphic — ranks index the bookkeeping arrays directly, with no
+    // `slot - base` translation and no sparse side table spanning the gaps
+    // between delete slots.
+    //
+    // `order[dst]` holds the ORIGINAL rank whose action belongs at rank `dst`;
+    // the stable sort keeps equal-position actions in their original relative
+    // order, matching the previous stable `sort_by` byte-for-byte.
+    let k = delete_indices.len();
+    let mut order: Vec<usize> = (0..k).collect();
+    order.sort_by_key(|&rank| {
+        let name = extract_delete_table_name(&actions[delete_indices[rank]]);
         sorted_positions.get(name).copied().unwrap_or(0)
     });
 
     // Apply the permutation `order` onto the delete slots via selection-style
     // swaps, moving each action into its destination with owned moves and no
-    // clone. We keep two mutually-inverse index arrays and update BOTH in O(1)
-    // per swap, so resolving "which rank currently holds the wanted action" is a
-    // direct array read instead of the previous inner `where_now.position(..)`
-    // linear rescan — making the apply O(k) instead of O(k²):
-    //   * `where_now[rank]`  — original slot currently occupying that delete rank
-    //   * `slot_at_rank`     — its inverse, keyed by rank offset within the run
+    // clone. We keep two mutually-inverse rank arrays and update BOTH in O(1)
+    // per swap, so resolving "which position currently holds the wanted action"
+    // is a direct array read instead of an inner `.position(..)` linear rescan
+    // — making the apply O(k) instead of O(k²):
+    //   * `origin_at[pos]`  — original rank of the action now sitting at `pos`
+    //   * `pos_of[origin]`  — its inverse
     // The reordered `DeleteTable` payloads stay byte-identical to before.
-    //
-    // Delete slots are ascending, so `delete_indices[0]` is the lowest slot;
-    // `rank_base` lets us index the inverse array by `slot - rank_base` cheaply.
-    let mut where_now: Vec<usize> = delete_indices.clone();
-    let rank_base = delete_indices[0];
-    let span = delete_indices[delete_indices.len() - 1] - rank_base + 1;
-    let mut slot_to_rank = vec![usize::MAX; span];
-    for (rank, &slot) in delete_indices.iter().enumerate() {
-        slot_to_rank[slot - rank_base] = rank;
-    }
-    for dst_rank in 0..delete_indices.len() {
-        let want_slot = order[dst_rank];
-        let src_rank = slot_to_rank[want_slot - rank_base];
-        if src_rank != dst_rank {
-            actions.swap(delete_indices[dst_rank], delete_indices[src_rank]);
-            // Swap the two slots' bookkeeping so both arrays stay consistent.
-            let displaced_slot = where_now[dst_rank];
-            where_now.swap(dst_rank, src_rank);
-            slot_to_rank[want_slot - rank_base] = dst_rank;
-            slot_to_rank[displaced_slot - rank_base] = src_rank;
+    let mut origin_at: Vec<usize> = (0..k).collect();
+    let mut pos_of: Vec<usize> = (0..k).collect();
+    for dst in 0..k {
+        let want = order[dst];
+        let src = pos_of[want];
+        if src != dst {
+            actions.swap(delete_indices[dst], delete_indices[src]);
+            // Swap the two positions' bookkeeping so both arrays stay consistent.
+            let displaced = origin_at[dst];
+            origin_at.swap(dst, src);
+            pos_of[want] = dst;
+            pos_of[displaced] = src;
         }
     }
 }

crates/vespertide-planner/src/diff/tests/ordering_sort.rs

@@ -228,6 +228,17 @@ mod topo_and_delete_sort_tests {
         MigrationAction::DeleteTable { table: name.into() }
     }
 
+    // An action `sort_delete_tables` must never touch, tagged by column name so
+    // the assertions can prove it stayed in its original slot.
+    fn marker(column: &str) -> MigrationAction {
+        MigrationAction::ModifyColumnDefault {
+            table: "unrelated".into(),
+            column: column.into(),
+            new_default: None,
+            backfill: None,
+        }
+    }
+
     // A standalone table `a` plus a `b <-> c` FK cycle. The error must list
     // ONLY the cyclic tables (b, c), proving the `!result.iter().any(name ==
     // t.name)` "not-yet-placed" filter. The `delete !` mutant and the `== ->
@@ -329,4 +340,102 @@ mod topo_and_delete_sort_tests {
             MigrationAction::ModifyColumnDefault { .. }
         ));
     }
+
+    // Three FK-chained deletes (c -> b -> a) that neither start at slot 0 nor
+    // occupy contiguous slots: inert actions sit before and between them. The
+    // delete payloads must be permuted among exactly their own slots (1, 3, 4)
+    // into dependent-first order while the inert actions stay put. Pins the
+    // rank-space permutation apply — any confusion between a delete's rank
+    // (0..3) and its slot (1, 3, 4) either displaces an inert action or drops
+    // a delete on the floor.
+    #[test]
+    fn sort_delete_permutes_only_delete_slots_in_a_three_table_chain() {
+        let a = pk_table("a", None);
+        let b = pk_table("b", Some("a"));
+        let c = pk_table("c", Some("b"));
+        let mut all: BTreeMap<&str, &TableDef> = BTreeMap::new();
+        all.insert("a", &a);
+        all.insert("b", &b);
+        all.insert("c", &c);
+
+        let mut actions = vec![
+            marker("first"),
+            delete("a"),
+            marker("middle"),
+            delete("b"),
+            delete("c"),
+        ];
+        sort_delete_tables(&mut actions, &all);
+
+        // Dependents first: c (FK-> b), then b (FK-> a), then a.
+        assert_eq!(extract_delete_table_name(&actions[1]), "c");
+        assert_eq!(extract_delete_table_name(&actions[3]), "b");
+        assert_eq!(extract_delete_table_name(&actions[4]), "a");
+
+        // The non-delete actions never move.
+        assert!(matches!(
+            &actions[0],
+            MigrationAction::ModifyColumnDefault { column, .. } if column.as_str() == "first"
+        ));
+        assert!(matches!(
+            &actions[2],
+            MigrationAction::ModifyColumnDefault { column, .. } if column.as_str() == "middle"
+        ));
+    }
+
+    // The old default ('archived') belongs to NEITHER the old nor the new enum
+    // — a stale default left behind by a hand edit. Dropping 'inactive' does
+    // not remove the *default's* value, so the default change carries no
+    // ordering dependency and the actions must stay as-is. Pins the
+    // `from_values` membership half of `string_enum_value_removed`: an
+    // `any(|v| v != needle)` mutant classifies every non-member default as
+    // removed and reorders the pair.
+    #[test]
+    fn enum_default_reorder_skips_when_old_default_is_not_an_enum_member() {
+        use crate::diff::ordering::sort_enum_default_dependencies;
+        use vespertide_core::{ComplexColumnType, DefaultValue, EnumValues};
+
+        let old_enum = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "e".into(),
+            values: EnumValues::String(vec!["active".into(), "inactive".into()]),
+        });
+        let new_enum = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "e".into(),
+            values: EnumValues::String(vec!["active".into()]),
+        });
+
+        let mut from_col = col("status", old_enum);
+        from_col.default = Some(DefaultValue::String("'archived'".into()));
+        let from_table = table("t", vec![from_col], vec![]);
+        let mut from_map: BTreeMap<&str, &TableDef> = BTreeMap::new();
+        from_map.insert("t", &from_table);
+
+        let mut actions = vec![
+            MigrationAction::ModifyColumnType {
+                table: "t".into(),
+                column: "status".into(),
+                new_type: new_enum,
+                fill_with: None,
+                narrowing_strategy: None,
+                timezone: None,
+            },
+            MigrationAction::ModifyColumnDefault {
+                table: "t".into(),
+                column: "status".into(),
+                new_default: Some("'active'".into()),
+                backfill: None,
+            },
+        ];
+
+        sort_enum_default_dependencies(&mut actions, &from_map);
+
+        assert!(
+            matches!(&actions[0], MigrationAction::ModifyColumnType { .. }),
+            "type change must stay first when the old default is not an enum member"
+        );
+        assert!(matches!(
+            &actions[1],
+            MigrationAction::ModifyColumnDefault { .. }
+        ));
+    }
 }

crates/vespertide-query/src/sql/create_table.rs

@@ -695,6 +695,37 @@ mod tests {
         });
     }
 
+    #[rstest]
+    #[case::auto_increment_unsupported_type_postgres(DatabaseBackend::Postgres)]
+    #[case::auto_increment_unsupported_type_mysql(DatabaseBackend::MySql)]
+    #[case::auto_increment_unsupported_type_sqlite(DatabaseBackend::Sqlite)]
+    fn test_create_table_auto_increment_pk_on_non_integer_column(#[case] backend: DatabaseBackend) {
+        // SQLite folds an auto-increment PK into the column definition
+        // (`INTEGER PRIMARY KEY AUTOINCREMENT`) and therefore SKIPS the separate
+        // PRIMARY KEY clause — but only when the PK column's type can actually
+        // carry AUTOINCREMENT. TEXT cannot, so nothing is folded into the column
+        // and the explicit PRIMARY KEY clause must survive on every backend.
+        let columns = vec![col("id", ColumnType::Simple(SimpleColumnType::Text))];
+        let constraints = vec![TableConstraint::PrimaryKey {
+            auto_increment: true,
+            columns: vec!["id".into()],
+            strategy: vespertide_core::PrimaryKeyAdditionStrategy::default(),
+        }];
+
+        let queries = build_create_table(backend, "users", &columns, &constraints).unwrap();
+        let sql = join_queries(&queries, backend, ";\n");
+
+        assert!(
+            sql.to_uppercase().contains("PRIMARY KEY"),
+            "auto-increment PK on a type without auto-increment support must still \
+             emit an explicit PRIMARY KEY, got: {sql}"
+        );
+
+        with_settings!({ snapshot_suffix => format!("create_table_auto_increment_pk_on_non_integer_column_{:?}", backend) }, {
+            assert_snapshot!(sql);
+        });
+    }
+
     #[rstest]
     #[case::inline_auto_increment_postgres(DatabaseBackend::Postgres)]
     #[case::inline_auto_increment_mysql(DatabaseBackend::MySql)]

crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_auto_increment_pk_on_non_integer_column@create_table_auto_increment_pk_on_non_integer_column_MySql.snap

@@ -0,0 +1,5 @@
+---
+source: crates/vespertide-query/src/sql/create_table.rs
+expression: sql
+---
+CREATE TABLE `users` ( `id` text, PRIMARY KEY (`id`) )

crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_auto_increment_pk_on_non_integer_column@create_table_auto_increment_pk_on_non_integer_column_Postgres.snap

@@ -0,0 +1,5 @@
+---
+source: crates/vespertide-query/src/sql/create_table.rs
+expression: sql
+---
+CREATE TABLE "users" ( "id" text, PRIMARY KEY ("id") )

crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_auto_increment_pk_on_non_integer_column@create_table_auto_increment_pk_on_non_integer_column_Sqlite.snap

@@ -0,0 +1,5 @@
+---
+source: crates/vespertide-query/src/sql/create_table.rs
+expression: sql
+---
+CREATE TABLE "users" ( "id" text, PRIMARY KEY ("id") )