revert: use callback-based test for GH#1712

Revert to the original callback-based test style for consistency
with the rest of the test file.

Author: claude

test/integration/prepare-execute-statements-test.ts

@@ -156,81 +156,84 @@ describe('Prepare Execute Statement', function() {
     });
   });
 
-  it('should not persist error state between executions of prepared statement (GH#1712)', async function() {
+  it('should not persist error state between executions of prepared statement (GH#1712)', function(done) {
     const config = getConfig();
 
     const connection = new Connection(config);
     if (process.env.TEDIOUS_DEBUG) {
       connection.on('debug', console.log);
     }
 
-    // Helper to execute the prepared statement and return the result
-    const execute = (divisor: number) => {
-      return new Promise<number>((resolve, reject) => {
-        request.once('requestCompleted', () => {
-          if (request.error) {
-            reject(request.error);
-          } else {
-            resolve(results[results.length - 1]!);
-          }
-        });
-        connection.execute(request, { divisor });
-      });
-    };
-
-    // Connect to the database
-    await new Promise<void>((resolve, reject) => {
-      connection.connect((err) => {
-        if (err) {
-          return reject(err);
-        }
-        resolve();
-      });
-    });
-
     // Prepare a statement that can cause a divide by zero error depending on the parameter
-    const request = new Request('select 1 / @divisor as result', () => {});
+    const request = new Request('select 1 / @divisor as result', function() {});
     request.addParameter('divisor', TYPES.Int);
 
+    let executionCount = 0;
     const results: (number | null)[] = [];
-    request.on('row', (columns) => {
+    const errors: (Error | undefined)[] = [];
+
+    request.on('row', function(columns) {
       results.push(columns[0].value);
     });
 
-    // Prepare the statement
-    await new Promise<void>((resolve) => {
-      request.once('prepared', () => {
-        assert.ok(request.handle);
-        resolve();
+    request.on('prepared', function() {
+      assert.ok(request.handle);
+
+      // First execution: should succeed with divisor = 1
+      request.once('requestCompleted', function() {
+        executionCount++;
+        errors.push(request.error);
+
+        // Second execution: should fail with divisor = 0 (divide by zero)
+        request.once('requestCompleted', function() {
+          executionCount++;
+          errors.push(request.error);
+
+          // Third execution: should succeed with divisor = 2
+          // Before the fix, this would report the error from the second execution
+          request.once('requestCompleted', function() {
+            executionCount++;
+            errors.push(request.error);
+
+            // Unprepare and close
+            connection.unprepare(request);
+            connection.close();
+          });
+
+          connection.execute(request, { divisor: 2 });
+        });
+
+        connection.execute(request, { divisor: 0 });
       });
+
+      connection.execute(request, { divisor: 1 });
+    });
+
+    connection.connect(function(err) {
+      if (err) {
+        return done(err);
+      }
+
       connection.prepare(request);
     });
 
-    // First execution: should succeed with divisor = 1
-    const result1 = await execute(1);
-    assert.strictEqual(result1, 1, 'First execution should return 1');
+    connection.on('end', function() {
+      // Verify the behavior
+      assert.strictEqual(executionCount, 3, 'Should have completed 3 executions');
 
-    // Second execution: should fail with divisor = 0 (divide by zero)
-    try {
-      await execute(0);
-      assert.fail('Second execution should have thrown an error');
-    } catch (err) {
-      assert.include((err as Error).message, 'Divide by zero', 'Error should be divide by zero');
-    }
+      // First execution succeeded
+      assert.isUndefined(errors[0], 'First execution should have no error');
+      assert.strictEqual(results[0], 1, 'First execution should return 1');
 
-    // Third execution: should succeed with divisor = 2
-    // Before the fix, this would throw the error from the second execution
-    // This is the key assertion for GH#1712
-    const result3 = await execute(2);
-    assert.strictEqual(result3, 0, 'Third execution should return 0 (1/2 truncated to int)');
+      // Second execution failed with divide by zero
+      assert.isDefined(errors[1], 'Second execution should have an error');
+      assert.include(errors[1]!.message, 'Divide by zero', 'Error should be divide by zero');
 
-    // Unprepare and close
-    await new Promise<void>((resolve) => {
-      connection.on('end', () => {
-        resolve();
-      });
-      connection.unprepare(request);
-      connection.close();
+      // Third execution succeeded - this is the key assertion for GH#1712
+      assert.isUndefined(errors[2], 'Third execution should have no error (error state should be cleared)');
+      assert.strictEqual(results[1], 0, 'Third execution should return 0 (1/2 truncated to int)');
+
+      done();
     });
   });