test(plpgsql-deparser): add comprehensive round-trip test for ALL generated fixtures

Add test that runs round-trip assertions on all 176 fixtures from
plpgsql-generated/generated.json. This ensures the deparser produces
semantically equivalent output for all canonical PL/pgSQL test cases.

16 fixtures are in a known-failing allowlist due to pre-existing issues:
- Schema qualification loss (pg_catalog.pg_class%rowtype[] -> pg_class%rowtype[])
- Tagged dollar quote reconstruction ($tag$...$tag$ not supported)
- Exception block handling issues

The test will fail if any NEW fixtures start failing (regression detection)
while allowing the known issues to be tracked and fixed incrementally.

Also improved cleanPlpgsqlTree to normalize 'undefined vs missing' properties
for more accurate AST comparison.

Author: pyramation

packages/plpgsql-deparser/__tests__/plpgsql-deparser.test.ts

@@ -32,14 +32,74 @@ describe('PLpgSQLDeparser', () => {
   });
 
   describe('round-trip tests using generated.json', () => {
-    it('should round-trip plpgsql_domain fixtures', async () => {
-      const entries = fixtureTestUtils.getTestEntries(['plpgsql_domain']);
+    // Known failing fixtures due to pre-existing deparser issues:
+    // - Schema qualification loss (pg_catalog.pg_class%rowtype[] -> pg_class%rowtype[])
+    // - Tagged dollar quote reconstruction ($tag$...$tag$ not supported)
+    // - Exception block handling issues
+    // TODO: Fix these underlying issues and remove from allowlist
+    const KNOWN_FAILING_FIXTURES = new Set([
+      'plpgsql_varprops-13.sql',
+      'plpgsql_trap-1.sql',
+      'plpgsql_trap-2.sql',
+      'plpgsql_trap-3.sql',
+      'plpgsql_trap-4.sql',
+      'plpgsql_trap-5.sql',
+      'plpgsql_trap-6.sql',
+      'plpgsql_trap-7.sql',
+      'plpgsql_transaction-17.sql',
+      'plpgsql_transaction-19.sql',
+      'plpgsql_transaction-20.sql',
+      'plpgsql_transaction-21.sql',
+      'plpgsql_control-15.sql',
+      'plpgsql_control-17.sql',
+      'plpgsql_call-44.sql',
+      'plpgsql_array-20.sql',
+    ]);
+
+    it('should round-trip ALL generated fixtures (excluding known failures)', async () => {
+      // Get all fixtures without any filter - this ensures we test everything
+      const entries = fixtureTestUtils.getTestEntries();
       expect(entries.length).toBeGreaterThan(0);
 
+      const failures: { key: string; error: string }[] = [];
+      const unexpectedPasses: string[] = [];
+      
       for (const [key] of entries) {
-        await fixtureTestUtils.runSingleFixture(key);
+        const isKnownFailing = KNOWN_FAILING_FIXTURES.has(key);
+        try {
+          await fixtureTestUtils.runSingleFixture(key);
+          if (isKnownFailing) {
+            unexpectedPasses.push(key);
+          }
+        } catch (err) {
+          if (!isKnownFailing) {
+            failures.push({
+              key,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        }
       }
-    });
+      
+      // Report unexpected passes (fixtures that should be removed from allowlist)
+      if (unexpectedPasses.length > 0) {
+        console.log(`\nUnexpected passes (remove from KNOWN_FAILING_FIXTURES):\n${unexpectedPasses.join('\n')}`);
+      }
+      
+      // Fail if any non-allowlisted fixtures fail (regression detection)
+      if (failures.length > 0) {
+        const failureReport = failures
+          .map(f => `  - ${f.key}: ${f.error}`)
+          .join('\n');
+        throw new Error(
+          `${failures.length} NEW fixture failures (not in allowlist):\n${failureReport}`
+        );
+      }
+      
+      // Report coverage stats
+      const testedCount = entries.length - KNOWN_FAILING_FIXTURES.size;
+      console.log(`\nRound-trip tested ${testedCount} of ${entries.length} fixtures (${KNOWN_FAILING_FIXTURES.size} known failures skipped)`);
+    }, 120000); // 2 minute timeout for all fixtures
   });
 
   describe('PLpgSQLDeparser class', () => {

packages/plpgsql-deparser/test-utils/index.ts

@@ -178,19 +178,27 @@ export const transform = (obj: any, props: any): any => {
     copy = {};
     for (const attr in obj) {
       if (obj.hasOwnProperty(attr)) {
+        let value: any;
         if (props.hasOwnProperty(attr)) {
           if (typeof props[attr] === 'function') {
-            copy[attr] = props[attr](obj[attr]);
+            value = props[attr](obj[attr]);
           } else if (props[attr].hasOwnProperty(obj[attr])) {
-            copy[attr] = props[attr][obj[attr]];
+            value = props[attr][obj[attr]];
           } else {
-            copy[attr] = transform(obj[attr], props);
+            value = transform(obj[attr], props);
           }
         } else {
-          copy[attr] = transform(obj[attr], props);
+          value = transform(obj[attr], props);
+        }
+        // Skip undefined values to normalize "missing vs present-but-undefined"
+        if (value !== undefined) {
+          copy[attr] = value;
         }
       } else {
-        copy[attr] = transform(obj[attr], props);
+        const value = transform(obj[attr], props);
+        if (value !== undefined) {
+          copy[attr] = value;
+        }
       }
     }
     return copy;