test(postgres): stub current_schema() so the provider fixtures pass again

resolveSchema() issues `SELECT current_schema()` on its own Statement before
each method's real query. Seven tests predated that call and broke: those
stubbing only prepareStatement got the unstubbed-mock default null from
createStatement()

  NullPointerException: Cannot invoke "java.sql.Statement.executeQuery(String)"
  because "stmt" is null   at resolveSchema(...:797)

and those stubbing createStatement handed resolveSchema the shared ResultSet,
so its getString(1) tripped strict stubbing against getString("tablename").

resolveSchema() is the first createStatement() caller in every method that
reaches the database, so returning a dedicated schemaStatement first and the
shared statement afterwards routes each to the right place. It answers "public",
keeping these fixtures on the historical schema so they go on asserting the
behaviour they were written for rather than the search_path change itself.

setUp() uses lenient() because the pure-Java tests (getDatabaseType,
getDefaultSchema) never touch the Connection and strict stubbing would fail them
over an unused stub. Three tests re-stub createStatement locally and had to
prepend schemaStatement themselves; getForeignKeys_returnsRelationships is left
alone because getForeignKeys does not call resolveSchema.

11/11 pass.

Author: geekypunk

backend/src/test/java/com/dbaagent/provider/postgres/PostgresIntrospectionProviderTest.java

@@ -35,9 +35,31 @@ class PostgresIntrospectionProviderTest {
     @Mock
     private ResultSet resultSet;
 
+    // resolveSchema() issues `SELECT current_schema()` on its own Statement before
+    // any method's real query. These mocks answer that call so the fixtures below
+    // keep testing what they were written to test.
+    @Mock
+    private Statement schemaStatement;
+
+    @Mock
+    private ResultSet schemaResultSet;
+
     @BeforeEach
-    void setUp() {
+    void setUp() throws SQLException {
         provider = new PostgresIntrospectionProvider();
+
+        // lenient(): the pure-Java tests (getDatabaseType, getDefaultSchema, …) never
+        // touch the Connection, and strict stubbing would fail them over an unused stub.
+        //
+        // resolveSchema() is the FIRST createStatement() caller in every method that
+        // reaches the database, so returning schemaStatement first and the shared
+        // statement afterwards routes each to the right place. Answering "public"
+        // keeps these fixtures on the historical schema, so they go on asserting the
+        // behaviour they were written for rather than the search_path change itself.
+        lenient().when(connection.createStatement()).thenReturn(schemaStatement, statement);
+        lenient().when(schemaStatement.executeQuery(anyString())).thenReturn(schemaResultSet);
+        lenient().when(schemaResultSet.next()).thenReturn(true);
+        lenient().when(schemaResultSet.getString(1)).thenReturn("public");
     }
 
     @Test
@@ -47,7 +69,8 @@ void getDatabaseType_returnsPostgres() {
 
     @Test
     void getDatabaseObjects_returnsTables() throws SQLException {
-        when(connection.createStatement()).thenReturn(statement);
+        // schemaStatement first: resolveSchema() runs before the objects query.
+        when(connection.createStatement()).thenReturn(schemaStatement, statement);
         when(statement.executeQuery(anyString())).thenReturn(resultSet);
         when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);
         when(preparedStatement.executeQuery()).thenReturn(resultSet);
@@ -209,7 +232,8 @@ void getTableStats_bindsEveryPlaceholderInTheStatsQuery() throws SQLException {
 
     @Test
     void scanSchema_returnsSchemaMetadata() throws SQLException {
-        when(connection.createStatement()).thenReturn(statement);
+        // schemaStatement first: resolveSchema() runs before the tables query.
+        when(connection.createStatement()).thenReturn(schemaStatement, statement);
         when(statement.executeQuery(anyString())).thenReturn(resultSet);
 
         when(resultSet.next())
@@ -281,6 +305,7 @@ void scanSchema_fallsBackToExactCountWhenEstimateMissing() throws SQLException {
         ResultSet foreignKeysResultSet = mock(ResultSet.class);
 
         when(connection.createStatement()).thenReturn(
+            schemaStatement,   // resolveSchema() runs before the tables query
             statement,
             exactCountStatement,
             columnsStatement,