test(qwp): scope Invariant-B test exception swallows to close-path noise only (M6)

The broad catch (Exception ignored) around whole test bodies let the
Invariant-B pin tests pass vacuously: fromConfig/builder/first-flush/setup
failures were swallowed, skipping every contract assertion.

- ReconnectTest.testReconnectNeverGivesUpInvariantB: hoist fromConfig out
  of the swallow; confine the catch to sender.close() in a finally.
- InitialConnectAsyncTest: add closeQuietly(Sender) and use it in
  testAsyncDeliversBufferedRowsWhenServerArrivesLate,
  testConnectionLostRetriesForeverNoTerminal, and
  testWasEverConnectedTrueImmediatelyInSyncMode; drop the outer catches.
- testConnectionLostRetriesForeverNoTerminal additionally had a bare
  finally { sender.close(); } whose close-path exception could REPLACE a
  pending AssertionError and get swallowed by the outer catch -- i.e. a
  broken feature (terminal delivered, close() rethrows it) actively
  masked the assertion failure. closeQuietly in the finally closes that
  path too.

Author: bluestreak01

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/InitialConnectAsyncTest.java

@@ -144,7 +144,7 @@ public void testAsyncNoServerRetriesForeverNoTerminal() throws Exception {
     }
 
     @Test
-    public void testAsyncDeliversBufferedRowsWhenServerArrivesLate() {
+    public void testAsyncDeliversBufferedRowsWhenServerArrivesLate() throws Exception {
         // Sender opens before the server is listening. Frames are
         // appended to the cursor SF engine on the producer thread. The
         // I/O thread retries connect in the background; once the server
@@ -158,7 +158,10 @@ public void testAsyncDeliversBufferedRowsWhenServerArrivesLate() {
                     + ";reconnect_initial_backoff_millis=20"
                     + ";reconnect_max_backoff_millis=200"
                     + ";close_flush_timeout_millis=2000;";
-            try (Sender sender = Sender.fromConfig(cfg)) {
+            // fromConfig/flush/setup failures must fail the test -- only
+            // close() teardown noise is tolerated (see closeQuietly).
+            Sender sender = Sender.fromConfig(cfg);
+            try {
                 QwpWebSocketSender wss = (QwpWebSocketSender) sender;
                 // wasEverConnected starts false in async mode — the I/O
                 // thread has not yet completed an upgrade.
@@ -187,9 +190,9 @@ public void testAsyncDeliversBufferedRowsWhenServerArrivesLate() {
                 Assert.assertTrue(
                         "wasEverConnected() must flip to true after the I/O thread connects",
                         ((QwpWebSocketSender) sender).wasEverConnected());
+            } finally {
+                closeQuietly(sender);
             }
-        } catch (Exception ignored) {
-            // already closed
         }
     }
 
@@ -222,7 +225,7 @@ public void testAsyncReturnsImmediatelyWithNoServer() {
     }
 
     @Test
-    public void testConnectionLostRetriesForeverNoTerminal() {
+    public void testConnectionLostRetriesForeverNoTerminal() throws Exception {
         // INVARIANT B: after a successful connect, if the server drops, the
         // mid-stream reconnect must retry FOREVER -- it must NEVER surface a
         // connection-lost terminal on a wall-clock budget. The rows are safe in
@@ -266,15 +269,16 @@ public void testConnectionLostRetriesForeverNoTerminal() {
                         "wasEverConnected() must remain true after the outage",
                         ((QwpWebSocketSender) sender).wasEverConnected());
             } finally {
-                sender.close();
+                // closeQuietly (not a bare close()) so a close-path exception
+                // cannot replace a pending AssertionError from the contract
+                // assertions above and mask a genuine failure.
+                closeQuietly(sender);
             }
-        } catch (Exception ignored) {
-            // already closed
         }
     }
 
     @Test
-    public void testWasEverConnectedTrueImmediatelyInSyncMode() {
+    public void testWasEverConnectedTrueImmediatelyInSyncMode() throws Exception {
         // Default (OFF) and SYNC modes both connect on the user thread
         // before fromConfig returns. wasEverConnected() must therefore
         // already be true the instant the sender becomes visible to the
@@ -287,13 +291,14 @@ public void testWasEverConnectedTrueImmediatelyInSyncMode() {
             Assert.assertTrue(server.awaitStart(5, java.util.concurrent.TimeUnit.SECONDS));
             String cfg = "ws::addr=localhost:" + port
                     + ";close_flush_timeout_millis=0;";
-            try (Sender sender = Sender.fromConfig(cfg)) {
+            Sender sender = Sender.fromConfig(cfg);
+            try {
                 Assert.assertTrue(
                         "wasEverConnected() must be true immediately in OFF/SYNC mode",
                         ((QwpWebSocketSender) sender).wasEverConnected());
+            } finally {
+                closeQuietly(sender);
             }
-        } catch (Exception ignored) {
-            // already closed
         }
     }
 
@@ -316,6 +321,20 @@ private static void awaitAtLeastOneConnectAttempt(QwpWebSocketSender wss) {
         }
     }
 
+    /**
+     * Closes the sender, tolerating close-path teardown noise only. Used
+     * instead of a broad {@code catch (Exception ignored)} around a whole
+     * test body, which would swallow fromConfig/flush/setup failures and
+     * let the contract assertions pass vacuously.
+     */
+    private static void closeQuietly(Sender sender) {
+        try {
+            sender.close();
+        } catch (Exception ignored) {
+            // close() teardown noise only
+        }
+    }
+
     /**
      * Closes the sender and tolerates either outcome:
      * * close() throws -- the latched terminal must mention the expected

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/ReconnectTest.java

@@ -119,7 +119,10 @@ public void testReconnectNeverGivesUpInvariantB() throws Exception {
                     + ";reconnect_max_backoff_millis=50"
                     + ";close_flush_timeout_millis=0;";
             Throwable observed = null;
-            try (Sender sender = Sender.fromConfig(cfg)) {
+            // fromConfig/first-flush/setup failures must fail the test --
+            // only close() teardown noise is tolerated in the finally below.
+            Sender sender = Sender.fromConfig(cfg);
+            try {
                 sender.table("foo").longColumn("v", 1L).atNow();
                 sender.flush();
 
@@ -141,9 +144,13 @@ public void testReconnectNeverGivesUpInvariantB() throws Exception {
                     }
                     Thread.sleep(50);
                 }
-            } catch (Exception ignored) {
-                // close() teardown noise -- the contract under test is the flush
-                // loop above, captured in `observed`.
+            } finally {
+                try {
+                    sender.close();
+                } catch (Exception ignored) {
+                    // close() teardown noise -- the contract under test is the
+                    // flush loop above, captured in `observed`.
+                }
             }
             Assert.assertNull(
                     "mid-stream reconnect must retry forever, not surface a terminal "