chore: update tests

Author: avallete

packages/pg/test/integration/client/max-result-size-tests.js

@@ -1,60 +1,138 @@
 'use strict'
-var helper = require('./test-helper')
-var assert = require('assert')
+const helper = require('../test-helper')
+const pg = helper.pg
+const assert = require('assert')
 
-const pool = new helper.pg.Pool({
-  maxResultSize: 100, // Very small size limit (100 bytes)
-  // Keep other connection parameters from helper
-  ...helper.args,
+process.on('unhandledRejection', function (e) {
+  console.error(e, e.stack)
+  process.exit(1)
 })
 
-// Flag to track if we've seen the first type of error message
-let sizeExceededErrorSeen = false
-
-pool.connect(
-  assert.success(function (client) {
-    // First create a temp table
-    client.query(
-      'CREATE TEMP TABLE large_result_test(id SERIAL, data TEXT)',
-      assert.success(function () {
-        // Insert data that will exceed the size limit when selected
-        const insertPromises = []
-        for (let i = 0; i < 20; i++) {
-          // Each row will have 50 bytes of data
-          const data = 'x'.repeat(50)
-          insertPromises.push(client.query('INSERT INTO large_result_test(data) VALUES($1)', [data]))
+const suite = new helper.Suite()
+
+// Test that result size exceeding maxResultSize properly raises an error
+suite.test('maxResultSize limit triggers error', (cb) => {
+  // Create a pool with a very small result size limit
+  const pool = new pg.Pool({
+    maxResultSize: 100, // Very small limit (100 bytes)
+    ...helper.args,
+  })
+
+  // Track if we've seen the size exceeded error
+  let sizeExceededErrorSeen = false
+
+  // Set up error handler on pool
+  pool.on('error', (err) => {
+    console.log('Pool error:', err.message, err.code)
+  })
+
+  pool
+    .connect()
+    .then((client) => {
+      // Set up client error listener for error events
+      client.on('error', (err) => {
+        console.log('Client error event:', err.message, err.code)
+
+        // If we get the expected error, mark it
+        if (err.message === 'Query result size exceeded the configured limit') {
+          assert.equal(err.code, 'RESULT_SIZE_EXCEEDED', 'Error should have RESULT_SIZE_EXCEEDED code')
+          sizeExceededErrorSeen = true
         }
+      })
 
-        // After inserting all rows, attempt to select them all
-        Promise.all(insertPromises).then(function () {
-          client.on('error', (err) => {
-            // If we see the first error type, mark it
-            if (err.message === 'Query result size exceeded the configured limit') {
-              assert.equal(
-                err.code,
-                'RESULT_SIZE_EXCEEDED',
-                'Size exceeded error should have RESULT_SIZE_EXCEEDED code'
-              )
-              sizeExceededErrorSeen = true
-            }
-
-            // For the second error type, we just verify it happens after we've seen the first type
-            if (err.message === 'Received unexpected commandComplete message from backend.') {
-              assert(sizeExceededErrorSeen, 'Should have seen size exceeded error before commandComplete error')
-            }
-          })
+      // Create a temp table
+      return client
+        .query('CREATE TEMP TABLE large_result_test(id SERIAL, data TEXT)')
+        .then(() => {
+          // Insert data that will exceed the size limit when selected
+          const insertPromises = []
+          for (let i = 0; i < 20; i++) {
+            // Each row will have 50 bytes of data
+            const data = 'x'.repeat(50)
+            insertPromises.push(client.query('INSERT INTO large_result_test(data) VALUES($1)', [data]))
+          }
+          return Promise.all(insertPromises)
+        })
+        .then(() => {
+          console.log('Running query that should exceed size limit...')
 
           // This query should fail due to exceeding size limit
-          client
+          return client
             .query('SELECT * FROM large_result_test')
-            .then(function (_result) {
+            .then(() => {
               throw new Error('Query should have failed due to size limit')
             })
-            .catch(function (err) {
-              assert.equal(err.code, 'RESULT_SIZE_EXCEEDED', 'Query error should have RESULT_SIZE_EXCEEDED code')
+            .catch((err) => {
+              console.log('Query error caught:', err.message, err.code)
+
+              // The error should have the correct code
+              assert.equal(err.code, 'RESULT_SIZE_EXCEEDED', 'Error should have RESULT_SIZE_EXCEEDED code')
+
+              // Give a little time for error events to be processed
+              return new Promise((resolve) => setTimeout(resolve, 100)).then(() => {
+                // Verify we saw the expected error event
+                assert(sizeExceededErrorSeen, 'Should have seen the size exceeded error event')
+
+                // Attempt cleanup but don't fail if it errors
+                return client.query('DROP TABLE IF EXISTS large_result_test').catch(() => {
+                  /* ignore cleanup errors */
+                })
+              })
             })
         })
-      })
-    )
+        .then(() => {
+          client.release()
+          pool.end(cb)
+        })
+        .catch((err) => {
+          client.release()
+          pool.end(() => cb(err))
+        })
+    })
+    .catch((err) => {
+      pool.end(() => cb(err))
+    })
+})
+
+// Test that results under the maxResultSize limit work normally
+suite.test('results under maxResultSize limit work correctly', (cb) => {
+  // Create a pool with a reasonably large limit
+  const pool = new pg.Pool({
+    maxResultSize: 10 * 1024, // 10KB is plenty for small results
+    ...helper.args,
   })
-)
+
+  pool
+    .connect()
+    .then((client) => {
+      // Create a temp table
+      return client
+        .query('CREATE TEMP TABLE small_result_test(id SERIAL, data TEXT)')
+        .then(() => {
+          // Insert a small amount of data
+          return client.query('INSERT INTO small_result_test(data) VALUES($1)', ['small_data'])
+        })
+        .then(() => {
+          // This query should succeed
+          return client.query('SELECT * FROM small_result_test').then((result) => {
+            // Verify the result
+            assert.equal(result.rows.length, 1, 'Should get 1 row')
+            assert.equal(result.rows[0].data, 'small_data', 'Data should match')
+
+            // Clean up
+            return client.query('DROP TABLE small_result_test')
+          })
+        })
+        .then(() => {
+          client.release()
+          pool.end(cb)
+        })
+        .catch((err) => {
+          client.release()
+          pool.end(() => cb(err))
+        })
+    })
+    .catch((err) => {
+      pool.end(() => cb(err))
+    })
+})