warkanum
495a21b67b
Implements tests/_plans and previously deferred packages; updates plan README with new coverage numbers.
313 lines
11 KiB
Go
313 lines
11 KiB
Go
package main
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.warky.dev/wdevs/relspecgo/pkg/models"
|
|
)
|
|
|
|
const fixturesDir = "../../tests/assets"
|
|
|
|
// readableFormats maps each file-based reader format to an existing fixture.
|
|
var readableFormats = []struct {
|
|
format string
|
|
path string
|
|
}{
|
|
{"dbml", "dbml/simple.dbml"},
|
|
{"json", "json/database.json"},
|
|
{"yaml", "yaml/database.yaml"},
|
|
{"yml", "yaml/database.yaml"},
|
|
{"drawdb", "drawdb/simple.json"},
|
|
{"dctx", "dctx/p1.dctx"},
|
|
{"graphql", "graphql/simple.graphql"},
|
|
{"gql", "graphql/simple.graphql"},
|
|
{"prisma", "prisma/example.prisma"},
|
|
{"typeorm", "typeorm/example.ts"},
|
|
{"drizzle", "drizzle/schema.ts"},
|
|
{"gorm", "gorm/simple.go"},
|
|
{"bun", "bun/simple.go"},
|
|
}
|
|
|
|
func TestReadDatabaseForConvert_FileFormats(t *testing.T) {
|
|
for _, tt := range readableFormats {
|
|
t.Run(tt.format, func(t *testing.T) {
|
|
db, err := readDatabaseForConvert(tt.format, filepath.Join(fixturesDir, tt.path), "")
|
|
if err != nil {
|
|
t.Fatalf("read: %v", err)
|
|
}
|
|
if db == nil || len(db.Schemas) == 0 {
|
|
t.Fatalf("no schemas read: %+v", db)
|
|
}
|
|
// Uppercase format names are accepted.
|
|
if _, err := readDatabaseForConvert(strings.ToUpper(tt.format), filepath.Join(fixturesDir, tt.path), ""); err != nil {
|
|
t.Errorf("uppercase format: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestReadDatabaseForConvert_Errors(t *testing.T) {
|
|
filePathFormats := []string{"dbml", "dctx", "drawdb", "json", "yaml", "gorm", "bun", "drizzle", "prisma", "typeorm", "graphql"}
|
|
for _, f := range filePathFormats {
|
|
t.Run("missing path "+f, func(t *testing.T) {
|
|
_, err := readDatabaseForConvert(f, "", "")
|
|
if err == nil || !strings.Contains(err.Error(), "file path is required") {
|
|
t.Errorf("got %v", err)
|
|
}
|
|
})
|
|
}
|
|
connFormats := []string{"pgsql", "postgres", "postgresql", "mssql", "sqlserver", "mysql", "mariadb"}
|
|
for _, f := range connFormats {
|
|
t.Run("missing conn "+f, func(t *testing.T) {
|
|
_, err := readDatabaseForConvert(f, "", "")
|
|
if err == nil || !strings.Contains(err.Error(), "connection string is required") {
|
|
t.Errorf("got %v", err)
|
|
}
|
|
})
|
|
}
|
|
if _, err := readDatabaseForConvert("sqlite", "", ""); err == nil || !strings.Contains(err.Error(), "required for SQLite") {
|
|
t.Errorf("sqlite: %v", err)
|
|
}
|
|
if _, err := readDatabaseForConvert("nope", "x", ""); err == nil || !strings.Contains(err.Error(), "unsupported source format") {
|
|
t.Errorf("unsupported: %v", err)
|
|
}
|
|
if _, err := readDatabaseForConvert("dbml", filepath.Join(t.TempDir(), "missing.dbml"), ""); err == nil || !strings.Contains(err.Error(), "failed to read database") {
|
|
t.Errorf("missing file: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestReadDatabase_DiffReader(t *testing.T) {
|
|
for _, f := range []string{"dbml", "json", "yaml", "drawdb", "dctx"} {
|
|
for _, tt := range readableFormats {
|
|
if tt.format != f {
|
|
continue
|
|
}
|
|
t.Run(f, func(t *testing.T) {
|
|
db, err := readDatabase(f, filepath.Join(fixturesDir, tt.path), "", "source")
|
|
if err != nil || db == nil || len(db.Schemas) == 0 {
|
|
t.Fatalf("read: %v %+v", err, db)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
for _, f := range []string{"dbml", "dctx", "drawdb", "json", "yaml", "sqldir"} {
|
|
if _, err := readDatabase(f, "", "", "src"); err == nil || !strings.Contains(err.Error(), "src: file path is required") {
|
|
t.Errorf("%s missing path: %v", f, err)
|
|
}
|
|
}
|
|
if _, err := readDatabase("pgsql", "", "", "src"); err == nil || !strings.Contains(err.Error(), "connection string is required") {
|
|
t.Errorf("pgsql: %v", err)
|
|
}
|
|
if _, err := readDatabase("sqlite", "", "", "src"); err == nil {
|
|
t.Error("sqlite without path must fail")
|
|
}
|
|
if _, err := readDatabase("nope", "x", "", "src"); err == nil || !strings.Contains(err.Error(), "unsupported database format") {
|
|
t.Errorf("unsupported: %v", err)
|
|
}
|
|
if _, err := readDatabase("json", filepath.Join(t.TempDir(), "missing.json"), "", "src"); err == nil || !strings.Contains(err.Error(), "src: failed to read database") {
|
|
t.Errorf("missing file: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestMaskPassword(t *testing.T) {
|
|
tests := []struct {
|
|
in, want string
|
|
}{
|
|
{"", ""},
|
|
{"postgres://user:secret@host:5432/db", "postgres://user:***@host:5432/db"},
|
|
{"postgres://user@host:5432/db", "postgres://user@host:5432/db"},
|
|
{"host=h user=u password=secret dbname=d", "host=h user=u password=*** dbname=d"},
|
|
{"host=h user=u", "host=h user=u"},
|
|
{"/tmp/file.db", "/tmp/file.db"},
|
|
}
|
|
for _, tt := range tests {
|
|
if got := maskPassword(tt.in); got != tt.want {
|
|
t.Errorf("maskPassword(%q) = %q, want %q", tt.in, got, tt.want)
|
|
}
|
|
if got := maskPasswordInDiff(tt.in); got != tt.want {
|
|
t.Errorf("maskPasswordInDiff(%q) = %q, want %q", tt.in, got, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGetSchemaNames(t *testing.T) {
|
|
db := models.InitDatabase("d")
|
|
if got := getSchemaNames(db); len(got) != 0 {
|
|
t.Errorf("empty: %v", got)
|
|
}
|
|
db.Schemas = []*models.Schema{{Name: "a"}, {Name: "b"}}
|
|
if got := strings.Join(getSchemaNames(db), ","); got != "a,b" {
|
|
t.Errorf("got %s", got)
|
|
}
|
|
}
|
|
|
|
func TestLoadExtraFields(t *testing.T) {
|
|
dir := t.TempDir()
|
|
write := func(name, body string) string {
|
|
p := filepath.Join(dir, name)
|
|
if err := os.WriteFile(p, []byte(body), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return p
|
|
}
|
|
valid := write("valid.json", `[{"name":"extra"}]`)
|
|
|
|
if got, err := loadExtraFields("bun", valid); err != nil || !strings.Contains(got, "extra") {
|
|
t.Errorf("valid: %q %v", got, err)
|
|
}
|
|
if _, err := loadExtraFields("BUN", valid); err != nil {
|
|
t.Errorf("case-insensitive format: %v", err)
|
|
}
|
|
if _, err := loadExtraFields("gorm", valid); err == nil || !strings.Contains(err.Error(), "only supported for Bun") {
|
|
t.Errorf("non-bun: %v", err)
|
|
}
|
|
if _, err := loadExtraFields("bun", filepath.Join(dir, "missing.json")); err == nil || !strings.Contains(err.Error(), "failed to read") {
|
|
t.Errorf("missing: %v", err)
|
|
}
|
|
if _, err := loadExtraFields("bun", write("bad.json", `{not json`)); err == nil || !strings.Contains(err.Error(), "invalid --extra-fields JSON") {
|
|
t.Errorf("bad json: %v", err)
|
|
}
|
|
if _, err := loadExtraFields("bun", write("empty.json", `[]`)); err == nil || !strings.Contains(err.Error(), "at least one field") {
|
|
t.Errorf("empty: %v", err)
|
|
}
|
|
}
|
|
|
|
func multiSchemaDB() *models.Database {
|
|
db := models.InitDatabase("multi")
|
|
for _, n := range []string{"a", "b"} {
|
|
s := models.InitSchema(n)
|
|
tbl := models.InitTable("t_"+n, n)
|
|
c := models.InitColumn("id", tbl.Name, n)
|
|
c.Type = "integer"
|
|
c.IsPrimaryKey = true
|
|
tbl.Columns["id"] = c
|
|
s.Tables = append(s.Tables, tbl)
|
|
db.Schemas = append(db.Schemas, s)
|
|
}
|
|
return db
|
|
}
|
|
|
|
func TestValidateWriteTarget(t *testing.T) {
|
|
db := multiSchemaDB()
|
|
single := models.InitDatabase("single")
|
|
single.Schemas = []*models.Schema{models.InitSchema("only")}
|
|
|
|
tests := []struct {
|
|
name string
|
|
db *models.Database
|
|
dbType, pkg, schemaFilter, extraFields, wantErrSubstr string
|
|
}{
|
|
{"json ok", db, "json", "", "", "", ""},
|
|
{"pgsql alias ok", db, "sql", "", "", "", ""},
|
|
{"gorm needs package", db, "gorm", "", "", "", "package name is required"},
|
|
{"bun needs package", db, "bun", "", "", "", "package name is required"},
|
|
{"gorm with package", db, "gorm", "models", "", "", ""},
|
|
{"unsupported", db, "nope", "", "", "", "unsupported target format"},
|
|
{"schema filter found", db, "json", "", "a", "", ""},
|
|
{"schema filter missing", db, "json", "", "zzz", "", "not found in database"},
|
|
{"dctx multi schema", db, "dctx", "", "", "", "multiple schemas found"},
|
|
{"dctx multi schema with filter", db, "dctx", "", "a", "", ""},
|
|
{"dctx single schema", single, "dctx", "", "", "", ""},
|
|
{"dctx no schemas", models.InitDatabase("e"), "dctx", "", "", "", "no schemas found"},
|
|
{"extra fields non-bun", db, "json", "", "", "x.json", "only supported for Bun"},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := validateWriteTarget(tt.db, tt.dbType, tt.pkg, tt.schemaFilter, tt.extraFields)
|
|
if tt.wantErrSubstr == "" {
|
|
if err != nil {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
return
|
|
}
|
|
if err == nil || !strings.Contains(err.Error(), tt.wantErrSubstr) {
|
|
t.Errorf("got %v, want substring %q", err, tt.wantErrSubstr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWriteDatabase_Formats(t *testing.T) {
|
|
db := multiSchemaDB()
|
|
formats := []struct{ format, file string }{
|
|
{"json", "out.json"},
|
|
{"yaml", "out.yaml"},
|
|
{"yml", "out.yml"},
|
|
{"dbml", "out.dbml"},
|
|
{"drawdb", "out.drawdb.json"},
|
|
{"pgsql", "out.sql"},
|
|
{"postgres", "out2.sql"},
|
|
{"sql", "out3.sql"},
|
|
{"mssql", "out_ms.sql"},
|
|
{"mysql", "out_my.sql"},
|
|
{"sqlite", "out_lite.sql"},
|
|
{"graphql", "out.graphql"},
|
|
{"gql", "out2.graphql"},
|
|
{"prisma", "out.prisma"},
|
|
{"typeorm", "out.ts"},
|
|
{"drizzle", "out_drizzle.ts"},
|
|
}
|
|
for _, tt := range formats {
|
|
t.Run(tt.format, func(t *testing.T) {
|
|
out := filepath.Join(t.TempDir(), tt.file)
|
|
if err := writeDatabase(db, tt.format, out, "", "", false, "", "", false, ""); err != nil {
|
|
t.Fatalf("write: %v", err)
|
|
}
|
|
info, err := os.Stat(out)
|
|
if err != nil || info.Size() == 0 {
|
|
t.Errorf("output missing or empty: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWriteDatabase_GoFormatsWriteIntoDir(t *testing.T) {
|
|
db := multiSchemaDB()
|
|
for _, f := range []string{"gorm", "bun"} {
|
|
t.Run(f, func(t *testing.T) {
|
|
out := filepath.Join(t.TempDir(), "models.go")
|
|
if err := writeDatabase(db, f, out, "models", "", false, "", "", false, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := os.Stat(out); err != nil {
|
|
t.Errorf("no output: %v", err)
|
|
}
|
|
if err := writeDatabase(db, f, out, "", "", false, "", "", false, ""); err == nil || !strings.Contains(err.Error(), "package name is required") {
|
|
t.Errorf("missing package: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWriteDatabase_SchemaFilterAndDCTX(t *testing.T) {
|
|
db := multiSchemaDB()
|
|
out := filepath.Join(t.TempDir(), "o.json")
|
|
|
|
if err := writeDatabase(db, "json", out, "", "a", false, "", "", false, ""); err != nil {
|
|
t.Errorf("schema filter: %v", err)
|
|
}
|
|
if err := writeDatabase(db, "json", out, "", "zzz", false, "", "", false, ""); err == nil || !strings.Contains(err.Error(), "not found in database") {
|
|
t.Errorf("missing schema: %v", err)
|
|
}
|
|
if err := writeDatabase(db, "dctx", out, "", "", false, "", "", false, ""); err == nil || !strings.Contains(err.Error(), "multiple schemas found") {
|
|
t.Errorf("dctx multi: %v", err)
|
|
}
|
|
single := models.InitDatabase("s")
|
|
single.Schemas = []*models.Schema{db.Schemas[0]}
|
|
if err := writeDatabase(single, "dctx", filepath.Join(t.TempDir(), "o.dctx"), "", "", false, "", "", false, ""); err != nil {
|
|
t.Errorf("dctx single: %v", err)
|
|
}
|
|
if err := writeDatabase(models.InitDatabase("e"), "dctx", out, "", "", false, "", "", false, ""); err == nil || !strings.Contains(err.Error(), "no schemas found") {
|
|
t.Errorf("dctx empty: %v", err)
|
|
}
|
|
if err := writeDatabase(db, "nope", out, "", "", false, "", "", false, ""); err == nil || !strings.Contains(err.Error(), "unsupported target format") {
|
|
t.Errorf("unsupported: %v", err)
|
|
}
|
|
if err := writeDatabase(db, "json", out, "", "", false, "", "", false, filepath.Join(t.TempDir(), "x.json")); err == nil || !strings.Contains(err.Error(), "only supported for Bun") {
|
|
t.Errorf("extra fields with json: %v", err)
|
|
}
|
|
}
|