test: 커버리지 보정

Author: yyuneu

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

@@ -859,6 +859,29 @@ mod tests {
         assert_eq!(out_py, Path::new("src/models/users.py"));
     }
 
+    #[test]
+    fn build_output_path_prisma_uses_prisma_extension() {
+        use std::path::Path;
+        let root = Path::new("src/models");
+        let out = build_output_path(root, Path::new("user.json"), Orm::Prisma);
+        assert_eq!(out, Path::new("src/models/user.prisma"));
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn clean_export_dir_removes_stale_prisma_files() {
+        let tmp = tempdir().unwrap();
+        let root = tmp.path().join("out");
+        std_fs::create_dir_all(&root).unwrap();
+        std_fs::write(root.join("schema.prisma"), "stale").unwrap();
+        std_fs::write(root.join("keep.txt"), "keep").unwrap();
+
+        clean_export_dir(&root, Orm::Prisma).await.unwrap();
+
+        assert!(!root.join("schema.prisma").exists());
+        assert!(root.join("keep.txt").exists());
+    }
+
     #[test]
     fn build_output_path_handles_special_path_components() {
         use std::path::Path;

crates/vespertide-exporter/src/prisma/mod.rs

@@ -201,6 +201,17 @@ mod tests {
         assert!(schema.contains("provider = \"postgresql\""));
     }
 
+    #[test]
+    fn render_schema_emits_shared_enum_block_once() {
+        let config = PrismaConfig::default();
+        let t1 = crate::tests::fixtures::enum_shared();
+        let mut t2 = crate::tests::fixtures::enum_shared();
+        t2.name = "archived_documents".into();
+        let schema = PrismaExporterWithConfig::new(&config).render_schema(&[t1, t2]);
+
+        assert_eq!(schema.matches("enum DocStatus {").count(), 1);
+    }
+
     #[test]
     fn render_schema_emits_relation_mode_when_configured() {
         // `PrismaConfig` is `#[non_exhaustive]` in a different crate, so it can't be

crates/vespertide-exporter/src/prisma/render.rs

@@ -351,10 +351,11 @@ pub(super) fn render_model(
     for c in &table.constraints {
         if let TableConstraint::Index { name, columns } = c {
             let cols = columns.join(", ");
-            if let Some(n) = name {
-                lines.push(format!("  @@index([{cols}], map: \"{n}\")"));
-            } else {
-                lines.push(format!("  @@index([{cols}])"));
+            // `match` instead of `if let Some`: LLVM coverage attributes match
+            // arms reliably where this if/else was misattributed as uncovered.
+            match name {
+                Some(n) => lines.push(format!("  @@index([{cols}], map: \"{n}\")")),
+                None => lines.push(format!("  @@index([{cols}])")),
             }
         }
     }
@@ -467,10 +468,65 @@ fn infer_relation_field_name(fk_col: &str) -> String {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
-    use vespertide_core::schema::column::SimpleColumnType;
+    use vespertide_core::schema::column::{NumValue, SimpleColumnType};
 
     use super::*;
 
+    #[rstest]
+    #[case::cascade(ReferenceAction::Cascade, "Cascade")]
+    #[case::restrict(ReferenceAction::Restrict, "Restrict")]
+    #[case::set_null(ReferenceAction::SetNull, "SetNull")]
+    #[case::set_default(ReferenceAction::SetDefault, "SetDefault")]
+    #[case::no_action(ReferenceAction::NoAction, "NoAction")]
+    fn reference_actions_map_to_prisma(#[case] action: ReferenceAction, #[case] expected: &str) {
+        assert_eq!(reference_action_to_prisma(&action), expected);
+    }
+
+    #[test]
+    fn integer_enum_default_resolves_numeric_value_to_variant_name() {
+        let ty = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "priority".into(),
+            values: EnumValues::Integer(vec![
+                NumValue {
+                    name: "low".into(),
+                    value: 100,
+                },
+                NumValue {
+                    name: "high".into(),
+                    value: 200,
+                },
+            ]),
+        });
+        assert_eq!(
+            prisma_default_attr("100", &ty, PrismaProvider::Postgres),
+            "@default(LOW)"
+        );
+    }
+
+    #[test]
+    fn fk_on_update_action_is_rendered() {
+        let mut table = crate::tests::fixtures::table_with_fk();
+        for c in &mut table.constraints {
+            if let TableConstraint::ForeignKey { on_update, .. } = c {
+                *on_update = Some(ReferenceAction::Cascade);
+            }
+        }
+        let rendered = render_model(
+            &table,
+            std::slice::from_ref(&table),
+            PrismaProvider::default(),
+        );
+        assert!(rendered.contains("onUpdate: Cascade"));
+    }
+
+    #[test]
+    fn named_index_is_rendered_with_map() {
+        let table = crate::tests::fixtures::table_with_indexes();
+        let rendered = render_model(&table, &[], PrismaProvider::default());
+        assert!(rendered.contains("@@index([created_at], map: \"idx_articles_created_at\")"));
+        assert!(rendered.contains("@@index([title])"));
+    }
+
     #[rstest]
     #[case::postgres(PrismaProvider::Postgres, "@default(uuid())")]
     #[case::mysql(PrismaProvider::MySql, "@default(dbgenerated(\"(uuid())\"))")]

crates/vespertide-exporter/src/prisma/types.rs

@@ -52,6 +52,9 @@ pub(super) fn column_type_to_prisma(
                     ("String", None, Some("@db.Text"))
                 }
                 // Unknown/future simple types fall back to a plain String column.
+                // `SimpleColumnType` is #[non_exhaustive]; every current variant is
+                // matched above, so this arm is currently unreachable.
+                #[cfg(not(tarpaulin_include))]
                 _ => ("String", None, None),
             };
             let native = match provider {
@@ -82,6 +85,9 @@ pub(super) fn column_type_to_prisma(
                 (format!("{pascal}{q}"), None)
             }
             // Unknown/future complex types fall back to a plain String column.
+            // `ComplexColumnType` is #[non_exhaustive]; every current variant is
+            // matched above, so this arm is currently unreachable.
+            #[cfg(not(tarpaulin_include))]
             _ => (format!("String{q}"), None),
         },
     }