Hein
5cdec88299
Replace the bare SemanticallyEqual call in every frontend (CLI fmt, LSP
formatting + rangeFormatting) with format.VerifySafe, which runs four
checks before any formatted output is emitted:
- semantic equivalence - the code token stream is unchanged
- comment preservation - no -- or /* */ comment is dropped, merged,
split, reordered, or reworded (line endings / indentation normalised
away; recurses into dollar-quoted bodies)
- structural balance - the () [] and BEGIN/CASE/IF/LOOP...END nesting
profile matches, ignoring anything inside a comment or a string
- idempotence - a second format pass would not change it
On failure the CLI now prints the specific reason and keeps the original.
The comment check surfaced two real formatter bugs, both fixed in
formatBodyStatements:
- multi-line /* */ comments inside a PL/pgSQL body had their interior
lines re-split and reindented as if they were statements; they are
now tracked and carried verbatim with the opening line
- a column-0 -- line was glued onto the preceding line by the
split-line-join, which merged consecutive comment lines into one
Regenerate testdata/corpus/test_mm_proc.pgsql (was carrying the mangled
output). TestCorpusIdempotentAndSafe now runs the full VerifySafe bundle;
add safety_test.go with targeted cases.
92 lines
3.2 KiB
Go
92 lines
3.2 KiB
Go
package format
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.warky.dev/wdevs/pgtidy/pkg/config"
|
|
)
|
|
|
|
func TestCommentsPreserved(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
a, b string
|
|
wantErr bool
|
|
}{
|
|
{"identical", "select 1; -- note", "select 1;\n-- note", false},
|
|
{"reindented block comment", "/* a\n b */ select 1", " /* a\nb */\nselect 1", false},
|
|
{"crlf line comment", "-- note\r\nselect 1", "-- note\nselect 1", false},
|
|
{"dropped comment", "select 1; -- keep me\nselect 2;", "select 1;\nselect 2;", true},
|
|
{"merged comments", "-- one\n-- two\nselect 1", "-- one -- two\nselect 1", true},
|
|
{"reworded comment", "-- alpha\nselect 1", "-- beta\nselect 1", true},
|
|
{"comment inside body preserved", // -- inside a dollar-quoted body
|
|
"do $$ begin\n-- inner\nperform 1;\nend $$;",
|
|
"DO\n$$\nbegin\n -- inner\n perform 1;\nend\n$$;", false},
|
|
}
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
err := CommentsPreserved(c.a, c.b)
|
|
if (err != nil) != c.wantErr {
|
|
t.Fatalf("CommentsPreserved(%q, %q) err = %v, wantErr %v", c.a, c.b, err, c.wantErr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommentsPreservedIgnoresCodeText(t *testing.T) {
|
|
// A ( ; keyword etc. inside a comment must not be read as code by the check.
|
|
a := "select 1; -- ( begin case end ) ;\nselect 2;"
|
|
b := "select 1;\nselect 2;\n-- ( begin case end ) ;"
|
|
if err := CommentsPreserved(a, b); err != nil {
|
|
t.Fatalf("comment content that looks like code tripped the check: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestStructurallyBalanced(t *testing.T) {
|
|
if err := StructurallyBalanced("select f((a+b)*c) from t", "select f( ( a + b ) * c )\nfrom t"); err != nil {
|
|
t.Errorf("whitespace-only reformat flagged: %v", err)
|
|
}
|
|
// Delimiters that live inside a comment or a string must not count.
|
|
if err := StructurallyBalanced("select ')(' as x -- ((((\nfrom t", "select ')(' as x\n-- ((((\nfrom t"); err != nil {
|
|
t.Errorf("comment/string delimiters counted: %v", err)
|
|
}
|
|
if err := StructurallyBalanced("select (a) from t", "select (a from t"); err == nil {
|
|
t.Errorf("dropped ')' not detected")
|
|
}
|
|
}
|
|
|
|
func TestVerifySafeCatchesNonIdempotent(t *testing.T) {
|
|
src := "create function f() returns void language sql as $$ select 1 $$;"
|
|
out := format(src)
|
|
if err := VerifySafe(src, out, config.Default()); err != nil {
|
|
t.Fatalf("clean format rejected: %v", err)
|
|
}
|
|
// A hand-mangled "output" that differs from what the formatter would produce
|
|
// must be rejected (idempotence gate).
|
|
if err := VerifySafe(src, out+"\n\n\n", config.Default()); err == nil {
|
|
t.Errorf("non-idempotent output accepted")
|
|
}
|
|
}
|
|
|
|
func TestVerifySafeBlockCommentInBody(t *testing.T) {
|
|
// Regression: a multi-line /* */ comment inside a PL/pgSQL body was being
|
|
// re-split and reindented as if its lines were statements.
|
|
src := "CREATE FUNCTION f() RETURNS void LANGUAGE plpgsql AS $$\n" +
|
|
"BEGIN\n" +
|
|
" /*\n" +
|
|
" update t u\n" +
|
|
" set x = 1\n" +
|
|
" where u.id = 2\n" +
|
|
" and u.y = 3;\n" +
|
|
" */\n" +
|
|
" perform 1;\n" +
|
|
"END $$;\n"
|
|
out := format(src)
|
|
if err := VerifySafe(src, out, config.Default()); err != nil {
|
|
t.Fatalf("block comment in body mangled: %v", err)
|
|
}
|
|
if !strings.Contains(out, "where u.id = 2") {
|
|
t.Errorf("block comment interior lost a line:\n%s", out)
|
|
}
|
|
}
|