Add testcase

Author: owjs3901

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

@@ -603,6 +603,7 @@ mod tests {
     #[case(OrmArg::Seaorm, Orm::SeaOrm)]
     #[case(OrmArg::Sqlalchemy, Orm::SqlAlchemy)]
     #[case(OrmArg::Sqlmodel, Orm::SqlModel)]
+    #[case(OrmArg::Jpa, Orm::Jpa)]
     fn orm_arg_maps_to_enum(#[case] arg: OrmArg, #[case] expected: Orm) {
         assert_eq!(Orm::from(arg), expected);
     }
@@ -767,6 +768,23 @@ mod tests {
         assert!(!root.join("model.py").exists());
     }
 
+    #[tokio::test]
+    async fn clean_export_dir_removes_java_files_for_jpa() {
+        let tmp = tempdir().unwrap();
+        let root = tmp.path().join("export_dir");
+        std_fs::create_dir_all(&root).unwrap();
+
+        std_fs::write(root.join("User.java"), "// java entity").unwrap();
+        std_fs::write(root.join("Order.java"), "// java entity").unwrap();
+        std_fs::write(root.join("keep.rs"), "// keep this").unwrap();
+
+        clean_export_dir(&root, Orm::Jpa).await.unwrap();
+
+        assert!(!root.join("User.java").exists());
+        assert!(!root.join("Order.java").exists());
+        assert!(root.join("keep.rs").exists());
+    }
+
     #[tokio::test]
     async fn clean_export_dir_handles_missing_directory() {
         let tmp = tempdir().unwrap();
@@ -828,4 +846,44 @@ mod tests {
         let result = clean_dir_recursive(&file_path, "rs").await;
         assert!(result.is_ok());
     }
+
+    #[test]
+    fn build_output_path_jpa_uses_pascal_case_java_extension() {
+        use std::path::Path;
+        let root = Path::new("src/models");
+
+        // snake_case model → PascalCase .java
+        let rel_path = Path::new("order_item.json");
+        let out = build_output_path(root, rel_path, Orm::Jpa);
+        assert_eq!(out, Path::new("src/models/OrderItem.java"));
+
+        // Single word
+        let rel_path2 = Path::new("users.json");
+        let out2 = build_output_path(root, rel_path2, Orm::Jpa);
+        assert_eq!(out2, Path::new("src/models/Users.java"));
+
+        // Nested path
+        let rel_path3 = Path::new("blog/post_comment.yaml");
+        let out3 = build_output_path(root, rel_path3, Orm::Jpa);
+        assert_eq!(out3, Path::new("src/models/blog/PostComment.java"));
+    }
+
+    #[test]
+    fn build_output_path_jpa_strips_vespertide_suffix() {
+        use std::path::Path;
+        let root = Path::new("src/models");
+
+        let rel_path = Path::new("user.vespertide.json");
+        let out = build_output_path(root, rel_path, Orm::Jpa);
+        assert_eq!(out, Path::new("src/models/User.java"));
+    }
+
+    #[rstest]
+    #[case("order_item", "OrderItem")]
+    #[case("users", "Users")]
+    #[case("a", "A")]
+    #[case("user_profile_image", "UserProfileImage")]
+    fn test_to_pascal_case(#[case] input: &str, #[case] expected: &str) {
+        assert_eq!(to_pascal_case(input), expected);
+    }
 }

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

@@ -1059,11 +1059,153 @@ mod tests {
         assert_snapshot!(result);
     }
 
+    #[test]
+    fn test_unnamed_index_and_unique() {
+        let table = TableDef {
+            name: "events".into(),
+            description: None,
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col("venue_id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col("date", ColumnType::Simple(SimpleColumnType::Date)),
+            ],
+            constraints: vec![
+                TableConstraint::PrimaryKey {
+                    auto_increment: false,
+                    columns: vec!["id".into()],
+                },
+                TableConstraint::Index {
+                    name: None,
+                    columns: vec!["venue_id".into(), "date".into()],
+                },
+                TableConstraint::Unique {
+                    name: None,
+                    columns: vec!["venue_id".into(), "date".into()],
+                },
+            ],
+        };
+
+        let result = render_entity(&table).unwrap();
+        assert_snapshot!(result);
+    }
+
+    #[test]
+    fn test_fk_with_comment_and_auto_increment() {
+        let table = TableDef {
+            name: "child".into(),
+            description: None,
+            columns: vec![
+                ColumnDef {
+                    name: "parent_id".into(),
+                    r#type: ColumnType::Simple(SimpleColumnType::Integer),
+                    nullable: false,
+                    default: None,
+                    comment: Some("References parent table".into()),
+                    primary_key: None,
+                    unique: None,
+                    index: None,
+                    foreign_key: None,
+                },
+                col("value", ColumnType::Simple(SimpleColumnType::Text)),
+            ],
+            constraints: vec![
+                TableConstraint::PrimaryKey {
+                    auto_increment: true,
+                    columns: vec!["parent_id".into()],
+                },
+                TableConstraint::ForeignKey {
+                    name: None,
+                    columns: vec!["parent_id".into()],
+                    ref_table: "parent".into(),
+                    ref_columns: vec!["id".into()],
+                    on_delete: None,
+                    on_update: None,
+                },
+            ],
+        };
+
+        let result = render_entity(&table).unwrap();
+        assert_snapshot!(result);
+    }
+
+    #[test]
+    fn test_server_default_and_true_boolean() {
+        let table = TableDef {
+            name: "logs".into(),
+            description: None,
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                ColumnDef {
+                    name: "active".into(),
+                    r#type: ColumnType::Simple(SimpleColumnType::Boolean),
+                    nullable: false,
+                    default: Some(DefaultValue::Bool(true)),
+                    comment: None,
+                    primary_key: None,
+                    unique: None,
+                    index: None,
+                    foreign_key: None,
+                },
+                ColumnDef {
+                    name: "created_at".into(),
+                    r#type: ColumnType::Simple(SimpleColumnType::Timestamptz),
+                    nullable: false,
+                    default: Some(DefaultValue::String("NOW()".into())),
+                    comment: None,
+                    primary_key: None,
+                    unique: None,
+                    index: None,
+                    foreign_key: None,
+                },
+                ColumnDef {
+                    name: "score".into(),
+                    r#type: ColumnType::Simple(SimpleColumnType::Real),
+                    nullable: false,
+                    default: Some(DefaultValue::Float(1.5)),
+                    comment: None,
+                    primary_key: None,
+                    unique: None,
+                    index: None,
+                    foreign_key: None,
+                },
+                ColumnDef {
+                    name: "tag".into(),
+                    r#type: ColumnType::Simple(SimpleColumnType::Text),
+                    nullable: false,
+                    default: Some(DefaultValue::String("UNKNOWN_EXPR".into())),
+                    comment: None,
+                    primary_key: None,
+                    unique: None,
+                    index: None,
+                    foreign_key: None,
+                },
+            ],
+            constraints: vec![TableConstraint::PrimaryKey {
+                auto_increment: true,
+                columns: vec!["id".into()],
+            }],
+        };
+
+        let result = render_entity(&table).unwrap();
+        assert_snapshot!(result);
+    }
+
+    #[test]
+    fn test_column_type_to_java_string_enum() {
+        // Exercises the string enum branch in column_type_to_java
+        let ty = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: EnumValues::String(vec!["a".into()]),
+        });
+        assert_eq!(column_type_to_java(&ty), "String");
+    }
+
     #[rstest]
     #[case("order_item", "OrderItem")]
     #[case("users", "Users")]
     #[case("a", "A")]
     #[case("user_profile_image", "UserProfileImage")]
+    #[case("", "")]
     fn test_to_pascal_case(#[case] input: &str, #[case] expected: &str) {
         assert_eq!(to_pascal_case(input), expected);
     }
@@ -1072,6 +1214,7 @@ mod tests {
     #[case("created_at", "createdAt")]
     #[case("id", "id")]
     #[case("user_profile_image", "userProfileImage")]
+    #[case("", "")]
     fn test_to_camel_case(#[case] input: &str, #[case] expected: &str) {
         assert_eq!(to_camel_case(input), expected);
     }

crates/vespertide-exporter/src/jpa/snapshots/vespertide_exporter__jpa__tests__fk_with_comment_and_auto_increment.snap

@@ -0,0 +1,23 @@
+---
+source: crates/vespertide-exporter/src/jpa/mod.rs
+expression: result
+---
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "child")
+public class Child {
+
+    /** References parent table */
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "parent_id", nullable = false)
+    private Parent parent;
+
+    @Column(name = "value", nullable = false, columnDefinition = "TEXT")
+    private String value;
+
+    protected Child() {
+    }
+}

crates/vespertide-exporter/src/jpa/snapshots/vespertide_exporter__jpa__tests__server_default_and_true_boolean.snap

@@ -0,0 +1,31 @@
+---
+source: crates/vespertide-exporter/src/jpa/mod.rs
+expression: result
+---
+import jakarta.persistence.*;
+import java.time.OffsetDateTime;
+
+@Entity
+@Table(name = "logs")
+public class Logs {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Integer id;
+
+    @Column(name = "active", nullable = false)
+    private Boolean active = true;
+
+    @Column(name = "created_at", nullable = false)
+    private OffsetDateTime createdAt;
+
+    @Column(name = "score", nullable = false)
+    private Float score = 1.5;
+
+    @Column(name = "tag", nullable = false, columnDefinition = "TEXT")
+    private String tag;
+
+    protected Logs() {
+    }
+}

crates/vespertide-exporter/src/jpa/snapshots/vespertide_exporter__jpa__tests__unnamed_index_and_unique.snap

@@ -0,0 +1,28 @@
+---
+source: crates/vespertide-exporter/src/jpa/mod.rs
+expression: result
+---
+import jakarta.persistence.*;
+import java.time.LocalDate;
+
+@Entity
+@Table(name = "events", indexes = {
+    @Index(columnList = "venue_id, date")
+}, uniqueConstraints = {
+    @UniqueConstraint(columnNames = {"venue_id", "date"})
+})
+public class Events {
+
+    @Id
+    @Column(name = "id")
+    private Integer id;
+
+    @Column(name = "venue_id", nullable = false)
+    private Integer venueId;
+
+    @Column(name = "date", nullable = false)
+    private LocalDate date;
+
+    protected Events() {
+    }
+}